<?php

namespace App\Library\Helpers;

//Internal Libraries
use Log;

//Seat Stuff
use Seat\Eseye\Cache\NullCache;
use Seat\Eseye\Configuration;
use Seat\Eseye\Containers\EsiAuthentication;
use Seat\Eseye\Eseye;
use Seat\Eseye\Exceptions\RequestFailedException;
use App\Library\Esi\Esi;

//Models
use App\Models\Lookups\CharacterLookup;
use App\Models\Lookups\CorporationLookup;
use App\Models\Lookups\AllianceLookup;
use App\Models\Lookups\SolarSystem;
use App\Models\Lookups\ItemLookup;
use App\Models\Lookups\MoonLookup;

class LookupHelper {

    //Variables
    private $esi;

    //Construct
    public function __construct() {
        //Declare a variable for use by the construct
        $esiHelper = new Esi;
        $this->esi = $esiHelper->SetupEsiAuthentication();
    }

    public function StructureTypeIdToName($typeId) {
        $structureTypes = [
            35841 => 'Ansiblex Jump Gate',
            35840 => 'Pharolux Cyno Beacon',
            37534 => 'Tenebrex Cyno Jammer',
            35834 => 'Keepstar',
            35833 => 'Fortizar',
            35832 => 'Astrahus',
            35836 => 'Tatara',
            35835 => 'Athanor',
            35827 => 'Sotiyo',
            35826 => 'Azbel',
            35825 => 'Raitaru',
        ];

        return $structureTypes[$typeId];
    }

    public function StructureNameToTypeId($name) {
        $structureTypes = [
            'Ansiblex Jump Gate' => 35841,
            'Pharolux Cyno Beacon' => 35840,
            'Tenebrex Cyno Jammer' => 37534,
            'Keepstar' => 35834,
            'Fortizar' => 35833,
            'Astrahus' => 35832,
            'Tatara' => 35836,
            'Athanor' => 35835,
            'Sotiyo' => 35827,
            'Azbel' => 35826,
            'Raitaru' => 35825,
        ];

        return $structureTypes[$name];
    }

    public function ItemNameToId($itemName) {
        $item = ItemLookup::where([
            'name' => $itemName,
        ])->first();

        if($item != null) {
            return $item->type_id;
        } else {
            try {
                $response = $this->esi->setBody(array(
                    $itemName,
                ))->invoke('post', '/universe/ids/');
            } catch(RequestFailedException $e) {
                printf("Failed to get the item information");
                Log::warning('Failed to get item information from /universe/');
                return null;
            }

            if(isset($response->inventory_types)) {
                return $response->inventory_types[0]->id;
            } else {
                return null;
            }
        }
    }

    public function ItemIdToName($itemId) {
        //Check if the item is stored in our own database first
        $item = $this->LookupItem($itemId);

        //If the item is found, return it, otherwise, do some esi to find it.
        if($item != null) {
            return $item->name;
        } else {
            try {
                $response = $this->esi->invoke('get', '/universe/types/{type_id}/', [
                    'type_id' => $itemId,
                ]);
            } catch(RequestFailedException $e) {
                printf("Failed to get the item name from the id.\r\n");
                var_dump($e);
                printf("\r\n");
                Log::warning('Failed to get item information from /universe/types/{type_id}/ in LookupHelper.');
                return null;
            }

            if(isset($response->description)) {
                $this->StoreItem($response);

                return $response->name;
            } else {
                return null;
            }
        }
    }

    private function LookupItem($itemId) {
        $item = ItemLookup::where([
            'type_id' => $itemId,
        ])->first();

        return $item;
    }

    private function StoreItem($item) {
        $newItem = new ItemLookup;
        if(isset($item->capacity)) {
            $newItem->capacity = $item->capacity;
        }
        $newItem->description = $item->description;
        if(isset($item->graphic_id)) {
            $newItem->graphic_id = $item->graphic_id;
        }
        $newItem->group_id = $item->group_id;
        if(isset($item->icon_id)) {
            $newItem->icon_id = $item->icon_id;
        }
        if(isset($item->market_group_id)) {
            $newItem->market_group_id = $item->market_group_id;
        }
        if(isset($item->mass)) {
            $newItem->mass = $item->mass;
        }
        $newItem->name = $item->name;
        if(isset($item->packaged_volume)) {
            $newItem->packaged_volume = $item->packaged_volume;
        }
        if(isset($item->portion_size)) {
            $newItem->portion_size = $item->portion_size;
        }
        $newItem->published = $item->published;
        if(isset($item->radius)) {
            $newItem->radius = $item->radius;
        }
        $newItem->type_id = $item->type_id;
        if(isset($item->volume)) {
            $newItem->volume = $item->volume;
        }
        $newItem->save();
    }

    public function SystemIdToName($systemId) {
        //Check if the solar system is stored in our database first
        $solarSystem = $this->LookupSolarSystemId($systemId);

        if($solarSystem != null) {
            return $solarSystem->name;
        } else {
            try {
                $solar = $this->esi->invoke('get', '/universe/systems/{system_id}/', [
                    'system_id' => $systemId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get system id from /universe/systems in Lookup Helper.');
                return null;
            }

            $this->StoreSolarSystem($solar);

            return $solar->name;
        }
    }

    public function SystemNameToId($system) {
        //Check if the solar system is stored in our own database first
        $solarSystem = $this->LookupSolarSystem($system);

        if($solarSystem != null) {
            return $solarSystem->solar_system_id;
        } else {
            try {
                $response = $this->esi->setBody(array(
                    $system,
                ))->invoke('post', '/universe/ids/');
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get system name from /universe/ids/ in lookup helper.');
                return null;
            }
    
            if(isset($response->systems)) {
                $this->StoreSolarSystem($response->systems[0]);

                return $response->systems[0]->id;
            } else {
                return null;
            }
        }
    }

    private function LookupSolarSystemId($systemId) {
        $solar = SolarSystem::where([
            'solar_system_id' => $systemId,
        ])->first();

        return $solar;
    }

    private function LookupSolarSystem($system) {
        $solar = SolarSystem::where([
            'name' => $system,
        ])->first();

        return $solar;
    }

    private function StoreSolarSystem($system) {
        if(isset($system->id)) {
            SolarSystem::insertOrIgnore([
                'name' => $system->name,
                'solar_system_id' => $system->id,
            ]);
        } else if(isset($system->system_id)) {
            SolarSystem::insertOrIgnore([
                'name' => $system->name,
                'solar_system_id' => $system->system_id,
            ]);
        } else {
            $solar = new SolarSystem;
            $solar->name = $system->name;
            $solar->solar_system_id = $system->id;
            $solar->save();
        }
    }

    /**
     * Get moon information from the database, or store it in the database if it's not found
     */
    public function GetMoonInfo($moonId) {
        //Check our own database first
        $moon = $this->LookupMoonInfo($moonId);

        //If no data was found in the database, then save the data, and return what is found through esi
        if( $moon == null) {
            try {
                $response = $this->esi->invoke('get', '/universe/moons/{moon_id}/', [
                    'moon_id' => $moonId,
                ]);
            } catch(RequestFailedException $e) {
                Log::critical("Failed to get moon information in LookupHelper.");
                return null;
            }

            $this->SaveMoonInfo($response);
 
            return $response;
        } else {
            //Return the moon info
            return $moon;
        }
    }

    /**
     * Lookup moon info from the database
     */
    private function LookupMoonInfo($moonId) {
        $moon = MoonLookup::where([
            'moon_id' => $moonId,
        ])->first();

        return $moon;
    }

    /**
     * Save moon info into the lookup database
     */
    private function SaveMoonInfo($moon) {
        $newMoon = new MoonLookup;
        $newMoon->moon_id = $moon->moon_id;
        $newMoon->name = $moon->name;
        $newMoon->position_x = $moon->position->x;
        $newMoon->position_y = $moon->position->y;
        $newMoon->position_z = $moon->position->z;
        $newMoon->system_id = $moon->system_id;
        $newMoon->save();
    }

    public function GetCharacterInfo($charId) {
        //Check our own database first
        $char = $this->LookupCharacter($charId, null);

        //if the character was not found in the database, then get the information and store it in our database for later
        if($char == null) {
            try {
                $response = $this->esi->invoke('get', '/characters/{character_id}/', [
                    'character_id' => $charId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get character information in GetCharacterInfo in Lookup');
                dd($e);
                return null;
            }

            //Store the character in our database
            $this->SaveCharacter($response, $charId);

            //Return the character details to the calling function
            return $response;
        } else {
            //Return what was pulled from the database
            return $char;
        }
    }

    public function GetCorporationInfo($corpId) {
        //Check our own database first
        $corp = $this->LookupCorporation($corpId, null);
        
        //If the corporation was not found in the database, then get the information and store it in our database for later
        if($corp == null) {
            try {
                $response = $this->esi->invoke('get', '/corporations/{corporation_id}/', [
                    'corporation_id' => $corpId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get corporation information in GetCorporationInfo in Lookup');
                return null;
            }

            //Store the corporation in our database
            $this->SaveCorporation($response, $corpId);

            //Return the corporation details to the calling function
            return $response;
        } else {
            //Return what was pulled from the database
            return $corp;
        }
    }

    public function GetAllianceInfo($allianceId) {
        //Check our own database first
        $ally = $this->LookupAlliance($allianceId, null);

        if($ally == null) {
            try {
                $response = $this->esi->invoke('get', '/alliances/{alliance_id}/', [
                    'alliance_id' => $allianceId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get alliance information in GetAllianceInfo in Lookup');
                return null;
            }

            //Store the alliance in our database
            $this->SaveAlliance($response, $allianceId);

            return $response;
        } else {
            return $ally;
        }
    }

    public function CharacterIdToName($charId) {
        //Check if the character is stored in our own database first
        $char = $this->LookupCharacter($charId, null);
        //If the char is null, then we did not find the character in our own database
        if($char != null) {
            return $char->name;
        } else {
            //Get the character id from esi
            try {
                $character = $this->esi->invoke('get', '/characters/{character_id}/', [
                    'character_id' => $charId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get character name from /characters/{character_id}/ in lookup helper.');
                return null;
            }
            
            if(isset($character->name)) {
                //Store the character name for the lookup table
                $this->StoreCharacterLookup(null, $character->name);
                //Return the character name to the calling function
                return $character->name;
            } else {
                //If we don't find any information return null
                return null;
            }
        }
    }

    public function CharacterNameToId($charName) {
        //Check if the character is stored in our own database first
        $char = $this->LookupCharacter(null, $charName);
        
        if($char != null) {
            return $char->character_id;
        } else {
            try {
                $response = $this->esi->setBody(array(
                    $charName,
                ))->invoke('post', '/universe/ids/');
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get character name from /universe/ids/ in lookup helper.');
                return null;
            }
            
            if(isset($response->characters[0]->id)) {
                $this->StoreCharacterLookup($response->characters[0]->id, null);
                
                return $response->characters[0]->id;
            } else {
                return null;
            }            
        }
    }

    public function CorporationIdToName($corpId) {
        //Check if the corporation is stored in our own database first
        $corp = $this->LookupCorporation($corpId, null);
        if($corp != null) {
            return $corp->name;
        } else {
            //Try to get the corporation details from ESI
            try {
                $corporation = $this->esi->invoke('get', '/corporations/{corporation_id}/', [
                    'corporation_id' => $corpId,
                ]);
            } catch(RequestFailedException $e) {
                //Log the issue
                Log::warning('Failed to get corporation name from /corporations/{corporation_id}/ in lookup helper.');
                return null;
            }

            if(isset($corporation->name)) {
                //Store the corporation name for the lookup table
                $this->StoreCorporationLookup(null, $corporation->name);
                //Return the corporation name to the calling function
                return $corporation->name;
            } else {
                //If nothing is found and ESI didn't work, return null to the calling function
                return null;
            }
        }
    }

    public function CorporationNameToId($corpName) {
        //Check if the corporation is stored in our own database first
        $corp = $this->LookupCorporation(null, $corpName);
        
        if($corp != null) {
            return $corp->corporation_id;
        } else {
            //Try to get the corporation details from ESI
            try {
                $response = $this->esi->setBody(array(
                    $corpName,
                ))->invoke('post', '/universe/ids/');
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get the corporation id from /universe/ids/ in lookup helper.');
                return null;
            }

            if(isset($response->corporations[0]->id)) {
                $this->StoreCorporationLookup($response->corporations[0]->id, null);

                return $response->corporations[0]->id;
            } else {
                return null;
            }
        }
    }

    public function AllianceIdToName($allianceId) {
        //Check if the alliance is stored in our own database first
        $alliance = $this->LookupAlliance($allianceId, null);
        if($alliance != null) {
            return $alliance->alliance_id;
        } else {
            //Try to get the alliance details from ESI
            try {
                $alliance = $this->esi->invoke('get', '/alliances/{alliance_id}/', [
                    'alliance_id' => $allianceId,
                ]);
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get the alliance name from /alliances/{alliance_id}/ in lookup helper.');
                return null;
            }

            if(isset($alliance->name)) {
                $this->StoreAllianceLookup(null, $alliance->name);

                return $alliance->name;
            } else {
                return null;
            }
        }
    }

    public function AllianceNameToId($allianceName) {
        //Check if the alliance is stored in our own database first
        $alliance = $this->LookupAlliance(null, $allianceName);
        if($alliance != null) {
            return $alliance->name;
        } else {
            //Try to get the alliance details from ESI
            try {
                $response = $this->esi->setBody(array(
                    $allianceName,
                ))->invoke('post', '/universe/ids/');
            } catch(RequestFailedException $e) {
                Log::warning('Failed to get the alliance id from /universe/ids/ in lookup helper.');
                return null;
            }

            //If the data is pulled from ESI store the data, and send the data back to the calling function
            if(isset($response->alliances[0]->id)) {
                $this->StoreAllianceLookup($response->alliances[0]->id, null);

                return $response->alliances[0]->id;
            } else {
                return null;
            }
        }
    }

    private function LookupCharacter($id = null, $name = null) {
        //If both the id and name are null, then there is nothing to lookup
        if($id == null & $name == null) {
            return null;
        }

        $character = null;

        //If the id is null attempt to lookup the character
        if($id != null) {
            $count = CharacterLookup::where(['character_id' => $id])->count();
            if($count > 0) {
                $character = CharacterLookup::where(['character_id' => $id])->first();
            } else {
                //If we didn't find it in the database, then return null
                return null;
            }
        } else if($name != null) {
            //If the name is not null then attemp to lookup the character
            $count = CharacterLookup::where(['name' => $name])->count();
            if($count > 0) {
                $character = CharacterLookup::where(['name' => $name])->first();
            } else {
                //If we didn't find it in the database, then return null
                return null;
            }
        }

        //Return the character details to the calling function
        return $character;
    }

    private function LookupCorporation($id = null, $name = null) {
        if($id == null && $name == null) {
            return null;
        }

        $corporation = null;

        //If the id is not null attempt to lookup the character
        if($id != null) {
            $count = CorporationLookup::where(['corporation_id' => $id])->count();
            if($count > 0) {
                $corporation = CorporationLookup::where(['corporation_id' => $id])->first();
            } else {
                $corporation = null;
            }
        } else if($name != null) {
            $count = CorporationLookup::where(['name' => $name])->count();
            if($count > 0) {
                $corporation = CorporationLookup::where(['name' => $name])->first();
            } else {
                $corporation = null;
            }
        }

        return $corporation;
    }

    private function LookupAlliance($id = null, $name = null) {
        if($id == null && $name == null) {
            return null;
        }

        $alliance = null;

        if($id != null) {
            $count = AllianceLookup::where(['alliance_id' => $id])->count();
            if($count > 0) {
                $alliance = AllianceLookup::where(['alliance_id' => $id])->first();
            } else {
                $alliance = null;
            }
        } else if($name != null) {
            $count = AllianceLookup::where(['name' => $name])->count();
            if($count > 0) {
                $alliance = AllianceLookup::where(['name' => $name])->first();
            } else {
                $alliance = null;
            }
        }

        return $alliance;
    }

    private function StoreCharacterLookup($id = null, $name = null) {
        //Declare the esi helper
        $esiHelper = new Esi;

        //If the id and name are null, just return
        if($id == null && $name == null) {
            return;
        }

        //If the id isn't null, then get the character information from the esi via the character id
        if($id != null) {
            //See if the character already exists in the lookup table
            $count = CharacterLookup::where(['character_id' => $id])->count();
            if($count == 0) {
                try {
                    $response = $this->esi->invoke('get', '/characters/{character_id}/', [
                        'character_id' => $id,
                    ]);
                } catch(RequestFailedException $e) {
                    return;
                }

                $corpId = $this->SaveCharacter($response, $id);

                if($corpId != null) {
                    //Do a recursive call for the corporation Lookup
                    $this->StoreCorporationLookup($corpId, null);
                }                
            } else {
                return;
            }
        } else {
            return;
        }
        
        //If the name is not null attempt to add the character to the table
        if($name != null) {
            $count = CharacterLookup::where(['name' => $name])->count();
            if($count == 0) {
                try {
                    //Get the character id from the ESI API
                    $responseName = $this->esi->setBody(array(
                        $name,
                    ))->invoke('post', '/universe/ids/');
                } catch(RequestFailedException $e) {
                    return;
                }

                try {
                    $response = $this->esi->invoke('get', '/characters/{character_id}/', [
                        'character_id' => $responseName->characters[0]->id,
                    ]);
                } catch(RequestFailedException $e) {
                    return;
                }

                $corpId = $this->SaveCharacter($response, $responseName->characters[0]->id);
                if($corpId != null) {
                    //Do a recursive call for the corporation Lookup
                    $this->StoreCorporationLookup($corpId, null);
                }
                
            } else {
                return;
            }
        } else {
            return;
        }
    }

    private function SaveCharacter($response, $charId) {
        $esiHelper = new Esi;

        $char = new CharacterLookup;

        $char->character_id = $charId;
        if(isset($response->alliance_id)) {
            $char->alliance_id = $response->alliance_id;
        }
        if(isset($response->ancestry_id)) {
            $char->ancestry_id = $response->ancestry_id;
        }
        $char->birthday = $esiHelper->DecodeDate($response->birthday);
        $char->bloodline_id = $response->bloodline_id;
        $char->corporation_id = $response->corporation_id;
        if(isset($response->description)) {
            $char->description = $response->description;
        }
        if(isset($response->faction_id)) {
            $char->faction_id = $response->faction_id;
        }
        $char->gender = $response->gender;
        $char->name = $response->name;
        $char->race_id = $response->race_id;
        if(isset($response->security_status)) {
            $char->security_status = $response->security_status;
        }
        if(isset($response->title)) {
            $char->title = $response->title;
        }
        $char->save();

        return $response->corporation_id;
    }

    public function UpdateCharacters() {
        $all = CharacterLookup::all();

        foreach($all as $entry) {
            //Attempt to get the data from ESI
            try {
                $response = $this->esi->invoke('get', '/characters/{character_id}/', [
                    'character_id' => $entry->character_id,
                ]);
            } catch(RequestFailedException $e) {

            }

            //Update the data
            if(isset($response->alliance_id)) {
                if($response->alliance_id != $entry->alliance_id) {
                    CharacterLookup::where([
                        'character_id' => $entry->character_id,
                    ])->update([
                        'alliance_id' => $response->alliance_id,
                    ]);
                }
            }
            if(isset($response->description)) {
                if($response->description != $entry->description) {
                    CharacterLookup::where([
                        'character_id' => $entry->character_id,
                    ])->update([
                        'description' => $response->description,
                    ]);
                }
            }
            if(isset($response->security_status)) {
                if($response->security_status != $entry->security_status) {
                    CharacterLookup::where([
                        'character_id' => $entry->character_id,
                    ])->update([
                        'security_status' => $response->security_status,
                    ]);
                }
            }
            if(isset($response->title)) {
                if($response->title != $entry->title) {
                    CharacterLookup::where([
                        'character_id' => $entry->character_id,
                    ])->update([
                        'title' => $response->title,
                    ]);
                }
            }
            if(isset($response->corporation_id)) {
                if($response->corporation_id != $entry->corporation_id) {
                    CharacterLookup::where([
                        'character_id' => $entry->character_id,
                    ])->update([
                        'corporation_id' => $response->corporation_id,
                    ]);
                }
            }
        }
    }

    private function StoreCorporationLookup($id = null, $name = null) {
        //Declare the esi helper
        $esiHelper = new Esi;

        //If the id is null and the name is null, then return
        if($id == null && $name == null) {
            return;
        }

        if($id != null) {
            $count = CorporationLookup::where(['corporation_id' => $id])->count();
            if($count == 0) {
                try {
                    $response = $this->esi->invoke('get', '/corporations/{corporation_id}/', [
                        'corporation_id' => $id,
                    ]);
                } catch(RequestFailedException $e) {
                    return;
                }

                $allianceId = $this->SaveCorporation($response, $id);

                if($allianceId != null) {
                    $this->StoreAllianceLookup($allianceId);
                }
            } else {
                return;
            }
        } else {
            return;
        }

        if($name != null) {
            $count = CorporationLookup::where(['name' => $name])->count();
            if($count == 0) {
                try {
                    //Get the corporation id from the ESI API
                    $responseName = $this->esi->setBody(array(
                        $name,
                    ))->invoke('post', '/universe/ids/');
                } catch(RequestFailedException $e) {
                    return;
                }

                try {
                    $response = $this->esi->invoke('get', '/corporations/{corporation_id}/', [
                        'corporation_id' => $responseName->corporations[0]->id,
                    ]);
                } catch(ReqeustFailedException $e) {
                    return;
                }

                $allianceId = $this->SaveCorporation($response, $responseName->corporations[0]->id);
                if($allianceId != null) {
                    //Do a recursive call for the alliance lookup
                    $this->StoreAllianceLookup($allianceId, null);
                }
            } else {
                return;
            }
        } else {
            return;
        }
    }

    private function SaveCorporation($response, $corpId) {
        $esiHelper = new Esi;

        $corp = new CorporationLookup;
        $corp->corporation_id = $corpId;
        if(isset($response->alliance_id)) {
            $corp->alliance_id = $response->alliance_id;
        }
        $corp->ceo_id = $response->ceo_id;
        $corp->creator_id = $response->creator_id;
        if(isset($response->date_founded)) {
            $corp->date_founded = $esiHelper->DecodeDate($response->date_founded);
        }
        if(isset($response->description)) {
            $corp->description = $response->description;
        }
        if(isset($response->faction_id)) {
            $corp->faction_id = $response->faction_id;
        }
        if(isset($response->home_station_id)) {
            $corp->home_station_id = $response->home_station_id;
        }
        $corp->member_count = $response->member_count;
        $corp->name = $response->name;
        if(isset($response->shares)) {
            $corp->shares = $response->shares;
        }
        $corp->tax_rate = $response->tax_rate;
        $corp->ticker = $response->ticker;
        if(isset($response->url)) {
            $corp->url = $response->url;
        }
        if(isset($response->war_eligible)) {
            $corp->war_eligible = $response->war_eligible;
        }
        $corp->save();

        if(isset($response->alliance_id)) {
            return $response->alliance_id;
        } else {
            return null;
        }

    }

    public function UpdateCorporations() {
        $all = CorporationLookup::all();

        foreach($all as $entry) {
            try {
                $response = $this->esi->invoke('get', '/corporations/{corporation_id}/', [
                    'corporation_id' => $entry->corporation_id,
                ]);
            } catch(RequestFailedException $e) {

            }

            if(isset($response->alliance_id)) {
                if($response->alliance_id != $entry->alliance_id) {
                    CorporationLookup::where([
                        'corporation_id' => $entry->corporation_id,
                    ])->update([
                        'alliance_id' => $response->alliance_id,
                    ]);
                }

                if(isset($response->description)) {
                    if($response->description != $entry->description) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'description' => $response->description,
                        ]);
                    }
                }

                if(isset($response->faction_id)) {
                    if($response->faction_id != $entry->faction_id) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'faction_id' => $response->faction_id,
                        ]);
                    }
                }

                if(isset($response->home_station_id)) {
                    if($response->home_station_id != $entry->home_station_id) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'home_station_id' => $response->home_station_id,
                        ]);
                    }
                }

                if(isset($response->member_count)) {
                    if($response->member_count != $entry->member_count) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'member_count' => $response->member_count,
                        ]);
                    }
                }

                if(isset($response->tax_rate)) {
                    if($response->tax_rate != $entry->tax_rate) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'tax_rate' => $response->tax_rate,
                        ]);
                    }
                }

                if(isset($response->url)) {
                    if($response->url != $entry->url) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'url' => $response->url,
                        ]);
                    }
                }

                if(isset($response->war_eligible)) {
                    if($response->war_eligible != $entry->war_eligible) {
                        CorporationLookup::where([
                            'corporation_id' => $entry->corporation_id,
                        ])->update([
                            'war_eligible' => $response->war_eligible,
                        ]);
                    }
                }
            }
        }
    }

    private function StoreAllianceLookup($id = null, $name = null) {
        //Declare the esi helper
        $esiHelper = new Esi;

        //Check if the passed variables are null
        if($id == null && $name == null) {
            return;
        }

        //If the id isn't null then attempt to populate the table
        if($id != null) {
            //See if the alliance already exists in the table
            $count = AllianceLookup::where(['alliance_id' => $id])->count();
            if($count == 0) {
                try {
                    $response = $this->esi->invoke('get', '/alliances/{alliance_id}/', [
                        'alliance_id' => $id,
                    ]);
                } catch(RequestFailedException $e) {
                    return;
                }

                $this->SaveAlliance($response, $id);
            }
        }

        //If the name isn't null then attempt to populate the table
        if($name != null) {
            $count = AllianceLookup::where(['name' => $name])->count();
            if($count == 0) {
                try {
                    $responseName = $this->esi->setBody(array(
                        $name,
                    ))->invoke('post', '/universe/ids/');
                } catch(RequestFailedException $e) {
                    return;
                }

                try {
                    $response = $this->esi->invoke('get', '/alliances/{alliance_id}/', [
                        'alliance_id' => $responseName->alliances[0]->id,
                    ]);
                } catch(RequestFailedException $e) {
                    return;
                }

                $this->SaveAlliance($response, $responseName->alliances[0]->id);
            }
        }
    }

    private function SaveAlliance($response, $allianceId) {
        $esiHelper = new Esi;

        $alliance = new AllianceLookup;
        $alliance->alliance_id = $allianceId;
        $alliance->creator_corporation_id = $response->creator_corporation_id;
        $alliance->creator_id = $response->creator_id;
        $alliance->date_founded =  $esiHelper->DecodeDate($response->date_founded);
        if(isset($response->executor_corporation_id)) {
            $alliance->executor_corporation_id = $response->executor_corporation_id;
        }
        if(isset($response->faction_id)) {
            $alliance->faction_id = $response->faction_id;
        }
        $alliance->name = $response->name;
        $alliance->ticker = $response->ticker;
        $alliance->save();
    }

    public function UpdateAlliances() {
        $all = AllianceLookup::all();
        
        foreach($all as $entry) {
            try {
                $response = $this->esi->invoke('get', '/alliances/{alliance_id}/', [
                    'alliance_id' => $entry->alliance_id,
                ]);
            } catch(RequestFailedException $e) {

            }

            if(isset($response->executor_corporation_id)) {
                if($response->executor_corporation_id != $entry->executor_corporation_id) {
                    AllianceLookup::where([
                        'alliance_id' => $entry->alliance_id,
                    ])->update([
                        'executor_corporation_id' => $response->executor_corporation_id,
                    ]);
                }
            }

            if(isset($response->faction_id)) {
                if($response->faction_id != $entry->faction_id) {
                    AllianceLookup::where([
                        'alliance_id' => $entry->alliance_id,
                    ])->update([
                        'faction_id' => $response->faction_id,
                    ]);
                }
            }
        }
    }
}

?>