using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Emit;
using System.Text;
using System.Threading.Tasks;
using AllEnum;
using PokemonGo.RocketAPI.Enums;
using PokemonGo.RocketAPI.Exceptions;
using PokemonGo.RocketAPI.Extensions;
using PokemonGo.RocketAPI.GeneratedCode;
using PokemonGo.RocketAPI.Logic.Utils;
using System.Diagnostics;
using Google;
using Google.Protobuf;

namespace PokemonGo.RocketAPI.Logic
{
    public class Logic
    {
        private readonly Client _client;
        private readonly ISettings _clientSettings;
        private readonly Inventory _inventory;
        public static int xPGained;
        public Stopwatch stopWatch = new Stopwatch();
        public static int sniper = 0;
        public static string SnipedPokemon;
        public static int AmISoftBanned = 0;
        public Logic(ISettings clientSettings)
        {
            _clientSettings = clientSettings;
            _client = new Client(_clientSettings);
            _inventory = new Inventory(_client);
        }

        public async Task Execute()
        {
            Logger.Write($"Starting Execute on login server: {_clientSettings.AuthType}", LogLevel.Info);
            stopWatch.Start();
            while (true)
            {
                try
                {
                    if (_clientSettings.AuthType == AuthType.Ptc)
                        await _client.DoPtcLogin(_clientSettings.PtcUsername, _clientSettings.PtcPassword);
                    else if (_clientSettings.AuthType == AuthType.Google)
                        await _client.DoGoogleLogin();

                    await PostLoginExecute();
                }
                catch (AccessTokenExpiredException)
                {
                    Logger.Write($"Access token expired", LogLevel.Info);
                }
                await Task.Delay(10000);
            }
        }

        public async Task PostLoginExecute()
        {
            while (true)
            {
                try
                {
                    await _client.SetServer();
                    var inventory = await _client.GetInventory();
                    await DisplayPlayerLevelInTitle();
                    var playerStats = inventory.InventoryDelta.InventoryItems.Select(i => i.InventoryItemData).FirstOrDefault(i => i.PlayerStats != null);

                    //await EvolveAllPokemonWithEnoughCandy();
                    await TransferDuplicatePokemon();
                    await RecycleItems();
                    await ExecuteFarmingPokestopsAndPokemons();

                    /*
            * Example calls below
            *
            var profile = await _client.GetProfile();
            var settings = await _client.GetSettings();
            var mapObjects = await _client.GetMapObjects();
            var inventory = await _client.GetInventory();
            var pokemons = inventory.InventoryDelta.InventoryItems.Select(i => i.InventoryItemData?.Pokemon).Where(p => p != null && p?.PokemonId > 0);
            */
                }
                catch (AccessTokenExpiredException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    Logger.Write($"Exception: {ex}", LogLevel.Error);
                }

                await Task.Delay(10000);
            }
        }

        public async Task RepeatAction(int repeat, Func<Task> action)
        {
            for (int i = 0; i < repeat; i++)
                await action();
        }

        private async Task ExecuteFarmingPokestopsAndPokemons()
        {

            var mapObjects = await _client.GetMapObjects();

            var pokeStops = mapObjects.MapCells.SelectMany(i => i.Forts).Where(i => i.Type == FortType.Checkpoint && i.CooldownCompleteTimestampMs < DateTime.UtcNow.ToUnixTime());

            foreach (var pokeStop in pokeStops)
            {
                var distance = Navigation.DistanceBetween2Coordinates(_client.CurrentLat, _client.CurrentLng, pokeStop.Latitude, pokeStop.Longitude);
                if (Math.Round(distance) > 300)
                {
                    continue;
                }
                var update = await _client.UpdatePlayerLocation(pokeStop.Latitude, pokeStop.Longitude, _clientSettings.DefaultAltitude);
                    var fortInfo = await _client.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
                    var fortSearch = await _client.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
                    Logger.Write($"Using Pokestop: {fortInfo.Name} in {Math.Round(distance)}m distance");
                    Logger.Write($"Farmed XP: {fortSearch.ExperienceAwarded}, Gems: { fortSearch.GemsAwarded}, Eggs: {fortSearch.PokemonDataEgg} Items: {StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded)}", LogLevel.Info);
                    if (fortSearch.ExperienceAwarded == 0)
                        AmISoftBanned = 1;
                    else
                    {
                        AmISoftBanned = 0;
                    }
                    if (AmISoftBanned==1)
                     {
                        Logger.Write($"Still softbanned trying to unban", LogLevel.Warning);
                        for (int i = 0; i < 40; i++)
                            fortSearch = await _client.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
                     }

                    xPGained = xPGained + fortSearch.ExperienceAwarded;
                    await Task.Delay(1000);
                if (sniper == 1)
                {
                    await snipePokemon(SnipedPokemon);
                    sniper = 0;
                }
                    await RecycleItems();
                if (sniper == 1)
                {
                    await snipePokemon(SnipedPokemon);
                    sniper = 0;
                }
                await ExecuteCatchAllNearbyPokemons();
                if (sniper == 1)
                {
                    await snipePokemon(SnipedPokemon);
                    sniper = 0;
                }
                await TransferDuplicatePokemon();
                if (sniper == 1)
                {
                    await snipePokemon(SnipedPokemon);
                    sniper = 0;
                }
            }
        }
        private async Task ExecuteCatchAllNearbyPokemons()
        {
            var mapObjects = await _client.GetMapObjects();

            var pokemons = mapObjects.MapCells.SelectMany(i => i.CatchablePokemons);

            foreach (var pokemon in pokemons)
            {
                var distance = Navigation.DistanceBetween2Coordinates(_client.CurrentLat, _client.CurrentLng, pokemon.Latitude, pokemon.Longitude);
                if (distance > 100)
                    await Task.Delay(15000);
                else
                    await Task.Delay(500);

                await _client.UpdatePlayerLocation(pokemon.Latitude, pokemon.Longitude, _clientSettings.DefaultAltitude);

                var encounter = await _client.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnpointId);
                await CatchEncounter(encounter, pokemon);
            }
            await Task.Delay(10000);
        }

        private async Task CatchEncounter(EncounterResponse encounter, MapPokemon pokemon)
        {

            CatchPokemonResponse caughtPokemonResponse;
            do
            {
                if (encounter?.CaptureProbability.CaptureProbability_.First() < 0.35 && encounter?.WildPokemon?.PokemonData?.Cp > 800)
                {
                    //Throw berry is we can
                    await UseBerry(pokemon.EncounterId, pokemon.SpawnpointId);
                }

                var pokeball = await GetBestBall(encounter?.WildPokemon);
                var distance = Navigation.DistanceBetween2Coordinates(_client.CurrentLat, _client.CurrentLng, pokemon.Latitude, pokemon.Longitude);
                caughtPokemonResponse = await _client.CatchPokemon(pokemon.EncounterId, pokemon.SpawnpointId, pokemon.Latitude, pokemon.Longitude, pokeball);
                Logger.Write(caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess ? $"We caught a {pokemon.PokemonId} with CP {encounter?.WildPokemon?.PokemonData?.Cp} and {Math.Round(CalculatePokemonPerfection(encounter?.WildPokemon?.PokemonData))} IV and CaptureProbability: {encounter?.CaptureProbability.CaptureProbability_.First()} using a {pokeball} in {Math.Round(distance)}m distance" : $"{pokemon.PokemonId} with {encounter?.WildPokemon?.PokemonData?.Cp} CP and {Math.Round(CalculatePokemonPerfection(encounter?.WildPokemon?.PokemonData))} IV and CaptureProbability: {encounter?.CaptureProbability.CaptureProbability_.First()} in {Math.Round(distance)}m distance {caughtPokemonResponse.Status} while using a {pokeball}..", LogLevel.Info);
                if(caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
                    xPGained = xPGained + 100;
                await Task.Delay(2000);
            }
            while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed || caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape) ;
        }

        public async Task EvolveAllPokemonWithEnoughCandy()
        {
            var pokemonToEvolve = await _inventory.GetPokemonToEvolve();
            foreach (var pokemon in pokemonToEvolve)
            {
                if (pokemon.PokemonId == PokemonId.Pidgey || pokemon.PokemonId == PokemonId.Caterpie || pokemon.PokemonId == PokemonId.Weedle)
                {
                    var evolvePokemonOutProto = await _client.EvolvePokemon((ulong)pokemon.Id);

                    if (evolvePokemonOutProto.Result == EvolvePokemonOut.Types.EvolvePokemonStatus.PokemonEvolvedSuccess)
                        Logger.Write($"Evolved {pokemon.PokemonId} successfully for {evolvePokemonOutProto.ExpAwarded}xp", LogLevel.Info);
                    else
                        Logger.Write($"Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}, stopping evolving {pokemon.PokemonId}", LogLevel.Info);
                    await Task.Delay(500);
                }

            }
        }

        private async Task TransferDuplicatePokemon(bool keepPokemonsThatCanEvolve = false)
        {
            var duplicatePokemons = await _inventory.GetDuplicatePokemonToTransfer(keepPokemonsThatCanEvolve, _clientSettings.PokemonsNotToTransfer);

            foreach (var duplicatePokemon in duplicatePokemons)
            {
                if (CalculatePokemonPerfection(duplicatePokemon) >= 95 || duplicatePokemon.Cp > 1500)
                {
                    Logger.Write($"Kept pokemon {duplicatePokemon.PokemonId} with {Math.Round(CalculatePokemonPerfection(duplicatePokemon))} IV and {duplicatePokemon.Cp} CP", LogLevel.Warning);
                    continue;
                }
                var transfer = await _client.TransferPokemon(duplicatePokemon.Id);
                Logger.Write($"Transfer {duplicatePokemon.PokemonId} with {duplicatePokemon.Cp} CP", LogLevel.Info);
                await Task.Delay(500);
            }
        }

        public struct BaseStats
        {
            public int BaseAttack, BaseDefense, BaseStamina;
            public BaseStats(int baseStamina, int baseAttack, int baseDefense)
            {
                this.BaseAttack = baseAttack;
                this.BaseDefense = baseDefense;
                this.BaseStamina = baseStamina;
            }
            public override string ToString()
            {
                return (String.Format("({0} atk,{1} def,{2} sta)", BaseAttack, BaseDefense, BaseStamina));
            }
        }
        private async Task snipePokemon(string Coordinate)
        {
            string[] word = Coordinate.Split(' ');
            if (word.Length > 2) {
                word[1] = word[1] + word[2];
                }
            string[] word2 = word[1].Split(',');
            var startLat = _client.CurrentLat;
            var startLng = _client.CurrentLng;
            var update = await _client.UpdatePlayerLocation(Double.Parse(word2[0]), Double.Parse(word2[1]), _clientSettings.DefaultAltitude);
            await Task.Delay(1500);
            Logger.Write("Changed Location", LogLevel.Warning);
            var foundpoki = 0;
            var mapObjects = await _client.GetMapObjects();

            var pokemons = mapObjects.MapCells.SelectMany(i => i.CatchablePokemons);

            var pokeTarg = Enum.Parse(typeof(PokemonId), word[0], true);

            foreach (var pokemon in pokemons)
            {
                if (pokemon.PokemonId != (PokemonId)pokeTarg)
                    continue;
                var distance = Navigation.DistanceBetween2Coordinates(_client.CurrentLat, _client.CurrentLng, pokemon.Latitude, pokemon.Longitude);
                await Task.Delay(distance > 100 ? 15000 : 500);

                var encounter = await _client.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnpointId);


                if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
                {
                    Logger.Write($"Found {word[0]}",LogLevel.Warning);
                    await _client.UpdatePlayerLocation(startLat, startLng, 10);
                    await CatchEncounter(encounter, pokemon);
                    foundpoki = 1;
                }
                else
                    Logger.Write($"Encounter problem: {encounter?.Status}",LogLevel.Warning);
                break;

        }
            if (foundpoki != 1)
            {
                Logger.Write($"Could not find {word[2]}", LogLevel.Warning);
                await Task.Delay(5000);
            }
            else
            {
                await Task.Delay(10000);
            }
        }

        public static double CalculatePokemonPerfection(PokemonData poke)
        {
            if (poke.CpMultiplier + poke.AdditionalCpMultiplier == 0)
                return (poke.IndividualAttack * 2 + poke.IndividualDefense + poke.IndividualStamina) / (4.0 * 15.0) * 100.0;

            BaseStats baseStats = GetBaseStats(poke.PokemonId);
            var max_cp = CalculateMaxCPMultiplier(poke);
            var min_cp = CalculateMinCPMultiplier(poke);
            var cur_cp = CalculateCPMultiplier(poke);

            return ((cur_cp - min_cp) / (max_cp - min_cp)) * 100.0;
        }

        public static double CalculateMaxCPMultiplier(PokemonData poke)
        {
            BaseStats baseStats = GetBaseStats(poke.PokemonId);
            return (baseStats.BaseAttack + 15) * Math.Sqrt(baseStats.BaseDefense + 15) * Math.Sqrt(baseStats.BaseStamina + 15);
        }

        public static double CalculateMinCPMultiplier(PokemonData poke)
        {
            BaseStats baseStats = GetBaseStats(poke.PokemonId);
            return (baseStats.BaseAttack) * Math.Sqrt(baseStats.BaseDefense) * Math.Sqrt(baseStats.BaseStamina);
        }

        public static double CalculateCPMultiplier(PokemonData poke)
        {
            BaseStats baseStats = GetBaseStats(poke.PokemonId);
            return (baseStats.BaseAttack + poke.IndividualAttack) * Math.Sqrt(baseStats.BaseDefense + poke.IndividualDefense) * Math.Sqrt(baseStats.BaseStamina + poke.IndividualStamina);
        }


        private async Task RecycleItems()
        {
            var items = await _inventory.GetItemsToRecycle(_clientSettings);
            await DisplayPlayerLevelInTitle();
            foreach (var item in items)
            {
                var transfer = await _client.RecycleItem((AllEnum.ItemId)item.Item_, item.Count);
                Logger.Write($"Recycled {item.Count}x {(AllEnum.ItemId)item.Item_}", LogLevel.Info);
                await Task.Delay(500);
            }
        }

        private async Task<MiscEnums.Item> GetBestBall(WildPokemon pokemon)
        {
            var pokemonCp = pokemon?.PokemonData?.Cp;

            var pokeBallsCount = await _inventory.GetItemAmountByType(MiscEnums.Item.ITEM_POKE_BALL);
            var greatBallsCount = await _inventory.GetItemAmountByType(MiscEnums.Item.ITEM_GREAT_BALL);
            var ultraBallsCount = await _inventory.GetItemAmountByType(MiscEnums.Item.ITEM_ULTRA_BALL);
            var masterBallsCount = await _inventory.GetItemAmountByType(MiscEnums.Item.ITEM_MASTER_BALL);

            if (masterBallsCount > 0 && pokemonCp >= 1000)
                return MiscEnums.Item.ITEM_MASTER_BALL;
            else if (ultraBallsCount > 0 && pokemonCp >= 1000)
                return MiscEnums.Item.ITEM_ULTRA_BALL;
            else if (greatBallsCount > 0 && pokemonCp >= 1000)
                return MiscEnums.Item.ITEM_GREAT_BALL;

            if (ultraBallsCount > 0 && pokemonCp >= 600)
                return MiscEnums.Item.ITEM_ULTRA_BALL;
            else if (greatBallsCount > 0 && pokemonCp >= 600)
                return MiscEnums.Item.ITEM_GREAT_BALL;

            if (greatBallsCount > 0 && pokemonCp >= 350)
                return MiscEnums.Item.ITEM_GREAT_BALL;

            if (pokeBallsCount > 0)
                return MiscEnums.Item.ITEM_POKE_BALL;
            if (greatBallsCount > 0)
                return MiscEnums.Item.ITEM_GREAT_BALL;
            if (ultraBallsCount > 0)
                return MiscEnums.Item.ITEM_ULTRA_BALL;
            if (masterBallsCount > 0)
                return MiscEnums.Item.ITEM_MASTER_BALL;

            return MiscEnums.Item.ITEM_POKE_BALL;
        }

        public async Task UseBerry(ulong encounterId, string spawnPointId)
        {
            var inventoryBalls = await _inventory.GetItems();
            var berries = inventoryBalls.Where(p => (ItemId) p.Item_ == ItemId.ItemRazzBerry);
            var berry = berries.FirstOrDefault();

            if (berry == null)
                return;

            var useRaspberry = await _client.UseCaptureItem(encounterId, AllEnum.ItemId.ItemRazzBerry, spawnPointId);
            Logger.Write($"Use Rasperry. Remaining: {berry.Count}", LogLevel.Info);
            await Task.Delay(3000);
        }

        private async Task DisplayPlayerLevelInTitle()
        {
            var playerStats = await _inventory.GetPlayerStats();
            var playerStat = playerStats.FirstOrDefault();
            if (playerStat != null)
            {
                var time = int.Parse(stopWatch.ElapsedMilliseconds.ToString());
                var message = $"Player level {playerStat.Level:0} - ({(playerStat.Experience - playerStat.PrevLevelXp):0} / {(playerStat.NextLevelXp - playerStat.PrevLevelXp):0}) - Xp/Hour = {3600 * xPGained / (time/1000)}";
                System.Console.Title = message;
            }
            await Task.Delay(500);
        }
        public static BaseStats GetBaseStats(PokemonId id)
        {
            switch ((int)id)
            {
                case 1: return new BaseStats(90, 126, 126);
                case 2: return new BaseStats(120, 156, 158);
                case 3: return new BaseStats(160, 198, 200);
                case 4: return new BaseStats(78, 128, 108);
                case 5: return new BaseStats(116, 160, 140);
                case 6: return new BaseStats(156, 212, 182);
                case 7: return new BaseStats(88, 112, 142);
                case 8: return new BaseStats(118, 144, 176);
                case 9: return new BaseStats(158, 186, 222);
                case 10: return new BaseStats(90, 62, 66);
                case 11: return new BaseStats(100, 56, 86);
                case 12: return new BaseStats(120, 144, 144);
                case 13: return new BaseStats(80, 68, 64);
                case 14: return new BaseStats(90, 62, 82);
                case 15: return new BaseStats(130, 144, 130);
                case 16: return new BaseStats(80, 94, 90);
                case 17: return new BaseStats(126, 126, 122);
                case 18: return new BaseStats(166, 170, 166);
                case 19: return new BaseStats(60, 92, 86);
                case 20: return new BaseStats(110, 146, 150);
                case 21: return new BaseStats(80, 102, 78);
                case 22: return new BaseStats(130, 168, 146);
                case 23: return new BaseStats(70, 112, 112);
                case 24: return new BaseStats(120, 166, 166);
                case 25: return new BaseStats(70, 124, 108);
                case 26: return new BaseStats(120, 200, 154);
                case 27: return new BaseStats(100, 90, 114);
                case 28: return new BaseStats(150, 150, 172);
                case 29: return new BaseStats(110, 100, 104);
                case 30: return new BaseStats(140, 132, 136);
                case 31: return new BaseStats(180, 184, 190);
                case 32: return new BaseStats(92, 110, 94);
                case 33: return new BaseStats(122, 142, 128);
                case 34: return new BaseStats(162, 204, 170);
                case 35: return new BaseStats(140, 116, 124);
                case 36: return new BaseStats(190, 178, 178);
                case 37: return new BaseStats(76, 106, 118);
                case 38: return new BaseStats(146, 176, 194);
                case 39: return new BaseStats(230, 98, 54);
                case 40: return new BaseStats(280, 168, 108);
                case 41: return new BaseStats(80, 88, 90);
                case 42: return new BaseStats(150, 164, 164);
                case 43: return new BaseStats(90, 134, 130);
                case 44: return new BaseStats(120, 162, 158);
                case 45: return new BaseStats(150, 202, 190);
                case 46: return new BaseStats(70, 122, 120);
                case 47: return new BaseStats(120, 162, 170);
                case 48: return new BaseStats(120, 108, 118);
                case 49: return new BaseStats(140, 172, 154);
                case 50: return new BaseStats(20, 108, 86);
                case 51: return new BaseStats(70, 148, 140);
                case 52: return new BaseStats(80, 104, 94);
                case 53: return new BaseStats(130, 156, 146);
                case 54: return new BaseStats(100, 132, 112);
                case 55: return new BaseStats(160, 194, 176);
                case 56: return new BaseStats(80, 122, 96);
                case 57: return new BaseStats(130, 178, 150);
                case 58: return new BaseStats(110, 156, 110);
                case 59: return new BaseStats(180, 230, 180);
                case 60: return new BaseStats(80, 108, 98);
                case 61: return new BaseStats(130, 132, 132);
                case 62: return new BaseStats(180, 180, 202);
                case 63: return new BaseStats(50, 110, 76);
                case 64: return new BaseStats(80, 150, 112);
                case 65: return new BaseStats(110, 186, 152);
                case 66: return new BaseStats(140, 118, 96);
                case 67: return new BaseStats(160, 154, 144);
                case 68: return new BaseStats(180, 198, 180);
                case 69: return new BaseStats(100, 158, 78);
                case 70: return new BaseStats(130, 190, 110);
                case 71: return new BaseStats(160, 222, 152);
                case 72: return new BaseStats(80, 106, 136);
                case 73: return new BaseStats(160, 170, 196);
                case 74: return new BaseStats(80, 106, 118);
                case 75: return new BaseStats(110, 142, 156);
                case 76: return new BaseStats(160, 176, 198);
                case 77: return new BaseStats(100, 168, 138);
                case 78: return new BaseStats(130, 200, 170);
                case 79: return new BaseStats(180, 110, 110);
                case 80: return new BaseStats(190, 184, 198);
                case 81: return new BaseStats(50, 128, 138);
                case 82: return new BaseStats(100, 186, 180);
                case 83: return new BaseStats(104, 138, 132);
                case 84: return new BaseStats(70, 126, 96);
                case 85: return new BaseStats(120, 182, 150);
                case 86: return new BaseStats(130, 104, 138);
                case 87: return new BaseStats(180, 156, 192);
                case 88: return new BaseStats(160, 124, 110);
                case 89: return new BaseStats(210, 180, 188);
                case 90: return new BaseStats(60, 120, 112);
                case 91: return new BaseStats(100, 196, 196);
                case 92: return new BaseStats(60, 136, 82);
                case 93: return new BaseStats(90, 172, 118);
                case 94: return new BaseStats(120, 204, 156);
                case 95: return new BaseStats(70, 90, 186);
                case 96: return new BaseStats(120, 104, 140);
                case 97: return new BaseStats(170, 162, 196);
                case 98: return new BaseStats(60, 116, 110);
                case 99: return new BaseStats(110, 178, 168);
                case 100: return new BaseStats(80, 102, 124);
                case 101: return new BaseStats(120, 150, 174);
                case 102: return new BaseStats(120, 110, 132);
                case 103: return new BaseStats(190, 232, 164);
                case 104: return new BaseStats(100, 102, 150);
                case 105: return new BaseStats(120, 140, 202);
                case 106: return new BaseStats(100, 148, 172);
                case 107: return new BaseStats(100, 138, 204);
                case 108: return new BaseStats(180, 126, 160);
                case 109: return new BaseStats(80, 136, 142);
                case 110: return new BaseStats(130, 190, 198);
                case 111: return new BaseStats(160, 110, 116);
                case 112: return new BaseStats(210, 166, 160);
                case 113: return new BaseStats(500, 40, 60);
                case 114: return new BaseStats(130, 164, 152);
                case 115: return new BaseStats(210, 142, 178);
                case 116: return new BaseStats(60, 122, 100);
                case 117: return new BaseStats(110, 176, 150);
                case 118: return new BaseStats(90, 112, 126);
                case 119: return new BaseStats(160, 172, 160);
                case 120: return new BaseStats(60, 130, 128);
                case 121: return new BaseStats(120, 194, 192);
                case 122: return new BaseStats(80, 154, 196);
                case 123: return new BaseStats(140, 176, 180);
                case 124: return new BaseStats(130, 172, 134);
                case 125: return new BaseStats(130, 198, 160);
                case 126: return new BaseStats(130, 214, 158);
                case 127: return new BaseStats(130, 184, 186);
                case 128: return new BaseStats(150, 148, 184);
                case 129: return new BaseStats(40, 42, 84);
                case 130: return new BaseStats(190, 192, 196);
                case 131: return new BaseStats(260, 186, 190);
                case 132: return new BaseStats(96, 110, 110);
                case 133: return new BaseStats(110, 114, 128);
                case 134: return new BaseStats(260, 186, 168);
                case 135: return new BaseStats(130, 192, 174);
                case 136: return new BaseStats(130, 238, 178);
                case 137: return new BaseStats(130, 156, 158);
                case 138: return new BaseStats(70, 132, 160);
                case 139: return new BaseStats(140, 180, 202);
                case 140: return new BaseStats(60, 148, 142);
                case 141: return new BaseStats(120, 190, 190);
                case 142: return new BaseStats(160, 182, 162);
                case 143: return new BaseStats(320, 180, 180);
                case 144: return new BaseStats(180, 198, 242);
                case 145: return new BaseStats(180, 232, 194);
                case 146: return new BaseStats(180, 242, 194);
                case 147: return new BaseStats(82, 128, 110);
                case 148: return new BaseStats(122, 170, 152);
                case 149: return new BaseStats(182, 250, 212);
                case 150: return new BaseStats(212, 284, 202);
                case 151: return new BaseStats(200, 220, 220);
                default: return new BaseStats();
            }
        }
    }
}