#region using directives

using System;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PoGo.PokeMobBot.Logic.Logging;
using PokemonGo.RocketAPI;
using PokemonGo.RocketAPI.Enums;
using POGOProtos.Enums;
using POGOProtos.Inventory.Item;

#endregion

namespace PoGo.PokeMobBot.Logic
{
    internal class AuthSettings
    {
        [JsonIgnore]
        private string _filePath;
        public AuthType AuthType;
        public string GoogleRefreshToken;
        public string GoogleUsername;
        public string GooglePassword;
        public string PtcUsername;
        public string PtcPassword;

        public void Load(string path)
        {
            try
            {
                _filePath = path;

                if (File.Exists(_filePath))
                {
                    //if the file exists, load the settings
                    var input = File.ReadAllText(_filePath);

                    var settings = new JsonSerializerSettings();
                    settings.Converters.Add(new StringEnumConverter { CamelCaseText = true });

                    JsonConvert.PopulateObject(input, this, settings);
                }
                else
                {
                    Save(_filePath);
                }
            }
            catch (JsonReaderException exception)
            {
                if (exception.Message.Contains("Unexpected character") && exception.Message.Contains("PtcUsername"))
                    Logger.Write("JSON Exception: You need to properly configure your PtcUsername using quotations.",
                        LogLevel.Error);
                else if (exception.Message.Contains("Unexpected character") && exception.Message.Contains("PtcPassword"))
                    Logger.Write(
                        "JSON Exception: You need to properly configure your PtcPassword using quotations.",
                        LogLevel.Error);
                else if (exception.Message.Contains("Unexpected character") &&
                         exception.Message.Contains("GoogleUsername"))
                    Logger.Write(
                        "JSON Exception: You need to properly configure your GoogleUsername using quotations.",
                        LogLevel.Error);
                else if (exception.Message.Contains("Unexpected character") &&
                         exception.Message.Contains("GooglePassword"))
                    Logger.Write(
                        "JSON Exception: You need to properly configure your GooglePassword using quotations.",
                        LogLevel.Error);
                else
                    Logger.Write("JSON Exception: " + exception.Message, LogLevel.Error);
            }
        }

        public void Save(string path)
        {
            var output = JsonConvert.SerializeObject(this, Formatting.Indented,
                new StringEnumConverter { CamelCaseText = true });

            var folder = Path.GetDirectoryName(path);
            if (folder != null && !Directory.Exists(folder))
            {
                Directory.CreateDirectory(folder);
            }

            File.WriteAllText(path, output);
        }

        public void Save()
        {
            if (!string.IsNullOrEmpty(_filePath))
            {
                Save(_filePath);
            }
        }
    }

    public class GlobalSettings
    {
  "AmountOfPokemonToDisplayOnStart": 10,
  "AutomaticallyLevelUpPokemon": false,
  "AutoUpdate": false,
  "DefaultAltitude": 10.0,
  "DefaultLatitude": 37.79216,
  "DefaultLongitude": -122.411987,
  "Teleport": true,
  "DelayBetweenPlayerActions": 0,
  "DelayBetweenPokemonCatch": 10,
  "DelayCatchNearbyPokemon": 10,
  "DelayPositionCheckState": 0,
  "DelayCatchIncensePokemon": 10,
  "DelayCatchLurePokemon": 10,
  "DelayCatchPokemon": 10,
  "DelayDisplayPokemon": 0,
  "DelayUseLuckyEgg": 10,
  "DelaySoftbanRetry": 10,
  "DelayPokestop": 10,
  "DelayRecyleItem": 10,
  "DelaySnipePokemon": 10,
  "DelayTransferPokemon": 10,
  "DumpPokemonStats": false,
  "EvolveAboveIvValue": 95.0,
  "EvolveAllPokemonAboveIv": false,
  "EvolveAllPokemonWithEnoughCandy": true,
  "GpxFile": "GPXPath.GPX",
  "ItemRecycleFilter": [
    {
      "Key": "itemUnknown",
      "Value": 0
    },
    {
      "Key": "itemPokeBall",
      "Value": 100
    },
    {
      "Key": "itemGreatBall",
      "Value": 70
    },
    {
      "Key": "itemUltraBall",
      "Value": 60
    },
    {
      "Key": "itemLuckyEgg",
      "Value": 200
    },
    {
      "Key": "itemIncenseOrdinary",
      "Value": 100
    },
    {
      "Key": "itemIncenseSpicy",
      "Value": 100
    },
    {
      "Key": "itemIncenseCool",
      "Value": 100
    },
    {
      "Key": "itemIncenseFloral",
      "Value": 100
    },
    {
      "Key": "itemTroyDisk",
      "Value": 100
    },
    {
      "Key": "itemXAttack",
      "Value": 100
    },
    {
      "Key": "itemXDefense",
      "Value": 100
    },
    {
      "Key": "itemXMiracle",
      "Value": 100
    },
    {
      "Key": "itemRazzBerry",
      "Value": 50
    },
    {
      "Key": "itemBlukBerry",
      "Value": 10
    },
    {
      "Key": "itemNanabBerry",
      "Value": 10
    },
    {
      "Key": "itemWeparBerry",
      "Value": 30
    },
    {
      "Key": "itemPinapBerry",
      "Value": 30
    },
    {
      "Key": "itemSpecialCamera",
      "Value": 100
    },
    {
      "Key": "itemIncubatorBasicUnlimited",
      "Value": 100
    },
    {
      "Key": "itemIncubatorBasic",
      "Value": 100
    },
    {
      "Key": "itemPokemonStorageUpgrade",
      "Value": 100
    },
    {
      "Key": "itemItemStorageUpgrade",
      "Value": 100
    }
  ],
  "KeepMinCp": 2000,
  "KeepMinDuplicatePokemon": 0,
  "KeepMinIvPercentage": 100.0,
  "KeepPokemonsThatCanEvolve": false,
  "LevelUpByCPorIv": "iv",
  "MaxPokeballsPerPokemon": 6,
  "MaxSpawnLocationOffset": 10,
  "MaxTravelDistanceInMeters": 10000,
  "MinDelayBetweenSnipes": 5000,
  "MinPokeballsToSnipe": 10,
  "MinPokeballsWhileSnipe": 0,
  "PokemonsNotToTransfer": [
    "ditto",
    "dragonite",
    "articuno",
    "zapdos",
    "moltres",
    "mewtwo",
    "mew"
  ],
  "PokemonsToEvolve": [
    "caterpie",
    "weedle",
    "pidgey",
    "rattata",
    "spearow",
    "zubat",
    "doduo",
    "goldeen",
    "paras",
    "ekans",
    "staryu",
    "psyduck",
    "krabby",
    "venonat"
  ],
  "PokemonsToIgnore": [
    "caterpie",
    "weedle",
    "pidgey",
    "rattata",
    "spearow",
    "zubat",
    "doduo"
  ],
  "PokemonsTransferFilter": {
    "Golduck": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Dratini": {
      "KeepMinCp": 900,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Eevee": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Chansey": {
      "KeepMinCp": 500,
      "KeepMinIvPercentage": 85.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Farfetchd": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 80.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Krabby": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Kangaskhan": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 60.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Horsea": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Staryu": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "MrMime": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 40.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Scyther": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 80.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Jynx": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Electabuzz": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Magmar": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Pinsir": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Tauros": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Magikarp": {
      "KeepMinCp": 1250,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Gyarados": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Lapras": {
      "KeepMinCp": 2000,
      "KeepMinIvPercentage": 80.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Vaporeon": {
      "KeepMinCp": 2000,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Jolteon": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Flareon": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Porygon": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 95.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Snorlax": {
      "KeepMinCp": 2500,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    },
    "Dragonite": {
      "KeepMinCp": 1800,
      "KeepMinIvPercentage": 90.0,
      "KeepMinDuplicatePokemon": 1
    }
  },
  "PokemonToSnipe": {
    "Locations": [
      {
        "Latitude": 38.556807486461118,
        "Longitude": -121.2383794784546
      },
      {
        "Latitude": -33.859019,
        "Longitude": 151.213098
      },
      {
        "Latitude": 47.5014969,
        "Longitude": -122.0959568
      },
      {
        "Latitude": 51.5025343,
        "Longitude": -0.2055027
      }
    ],
    "Pokemon": [
      "venusaur",
      "charizard",
      "blastoise",
      "beedrill",
      "raichu",
      "sandslash",
      "nidoking",
      "nidoqueen",
      "clefable",
      "ninetales",
      "golbat",
      "vileplume",
      "golduck",
      "primeape",
      "arcanine",
      "poliwrath",
      "alakazam",
      "machamp",
      "golem",
      "rapidash",
      "slowbro",
      "farfetchd",
      "muk",
      "cloyster",
      "gengar",
      "exeggutor",
      "marowak",
      "hitmonchan",
      "lickitung",
      "rhydon",
      "chansey",
      "kangaskhan",
      "starmie",
      "mrMime",
      "scyther",
      "magmar",
      "electabuzz",
      "magmar",
      "jynx",
      "gyarados",
      "lapras",
      "ditto",
      "vaporeon",
      "jolteon",
      "flareon",
      "porygon",
      "kabutops",
      "aerodactyl",
      "snorlax",
      "articuno",
      "zapdos",
      "moltres",
      "dragonite",
      "mewtwo",
      "mew"
    ]
  },
  "PokemonToUseMasterball": [
    "articuno",
    "zapdos",
    "moltres",
    "mew",
    "mewtwo"
  ],
  "PrioritizeIvOverCp": true,
  "RenameOnlyAboveIv": true,
  "RenamePokemon": false,
  "RenameTemplate": "{1}_{0}",
  "SnipeAtPokestops": true,
  "SnipeIgnoreUnknownIv": true,
  "SnipeLocationServer": "localhost",
  "SnipeLocationServerPort": 16969,
  "StartupWelcomeDelay": false,
  "TotalAmountOfPokebalsToKeep": 230,
  "TotalAmountOfPotionsToKeep": 10,
  "TotalAmountOfRevivesToKeep": 10,
  "TransferConfigAndAuthOnUpdate": true,
  "TransferDuplicatePokemon": true,
  "TranslationLanguageCode": "en",
  "UpgradePokemonCpMinimum": 1000.0,
  "UpgradePokemonIvMinimum": 95.0,
  "UseEggIncubators": true,
  "UseGpxPathing": false,
  "UseGreatBallAboveCp": 750,
  "UseLuckyEggsMinPokemonAmount": 30,
  "UseLuckyEggsWhileEvolving": true,
  "UseMasterBallAboveCp": 1500,
  "UsePokemonToNotCatchFilter": false,
  "UseSnipeLocationServer": true,
  "UseTransferIvForSnipe": true,
  "UseUltraBallAboveCp": 1000,
  "WalkingSpeedInKilometerPerHour": 60.0,
  "WebSocketPort": 14251
}


        public static GlobalSettings Default => new GlobalSettings();

        public static GlobalSettings Load(string path)
        {
            GlobalSettings settings;
            var profilePath = Path.Combine(Directory.GetCurrentDirectory(), path);
            var profileConfigPath = Path.Combine(profilePath, "config");
            var configFile = Path.Combine(profileConfigPath, "config.json");

            if (File.Exists(configFile))
            {
                try
                {
                    //if the file exists, load the settings
                    var input = File.ReadAllText(configFile);

                    var jsonSettings = new JsonSerializerSettings();
                    jsonSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
                    jsonSettings.ObjectCreationHandling = ObjectCreationHandling.Replace;
                    jsonSettings.DefaultValueHandling = DefaultValueHandling.Populate;

                    settings = JsonConvert.DeserializeObject<GlobalSettings>(input, jsonSettings);
                }
                catch (JsonReaderException exception)
                {
                    Logger.Write("JSON Exception: " + exception.Message, LogLevel.Error);
                    return null;
                }
            }
            else
            {
                settings = new GlobalSettings();
            }

            if (settings.WebSocketPort == 0)
            {
                settings.WebSocketPort = 14251;
            }

            if (settings.PokemonToSnipe == null)
            {
                settings.PokemonToSnipe = Default.PokemonToSnipe;
            }

            if (settings.RenameTemplate == null)
            {
                settings.RenameTemplate = Default.RenameTemplate;
            }

            if (settings.SnipeLocationServer == null)
            {
                settings.SnipeLocationServer = Default.SnipeLocationServer;
            }

            settings.ProfilePath = profilePath;
            settings.ProfileConfigPath = profileConfigPath;
            settings.GeneralConfigPath = Path.Combine(Directory.GetCurrentDirectory(), "config");

            var firstRun = !File.Exists(configFile);

            settings.Save(configFile);
            settings.Auth.Load(Path.Combine(profileConfigPath, "auth.json"));

            if (firstRun)
            {
                return null;
            }

            return settings;
        }

        public void Save(string fullPath)
        {
            var output = JsonConvert.SerializeObject(this, Formatting.Indented,
                new StringEnumConverter { CamelCaseText = true });

            var folder = Path.GetDirectoryName(fullPath);
            if (folder != null && !Directory.Exists(folder))
            {
                Directory.CreateDirectory(folder);
            }

            File.WriteAllText(fullPath, output);
        }
    }

    public class ClientSettings : ISettings
    {
        // Never spawn at the same position.
        private readonly Random _rand = new Random();
        private readonly GlobalSettings _settings;

        public ClientSettings(GlobalSettings settings)
        {
            _settings = settings;
        }


        public string GoogleUsername => _settings.Auth.GoogleUsername;
        public string GooglePassword => _settings.Auth.GooglePassword;

        public string GoogleRefreshToken
        {
            get { return null; }
            set { GoogleRefreshToken = null; }
        }

        AuthType ISettings.AuthType
        {
            get { return _settings.Auth.AuthType; }

            set { _settings.Auth.AuthType = value; }
        }

        double ISettings.DefaultLatitude
        {
            get
            {
                return _settings.DefaultLatitude + _rand.NextDouble() * ((double)_settings.MaxSpawnLocationOffset / 111111);
            }

            set { _settings.DefaultLatitude = value; }
        }

        double ISettings.DefaultLongitude
        {
            get
            {
                return _settings.DefaultLongitude +
                       _rand.NextDouble() *
                       ((double)_settings.MaxSpawnLocationOffset / 111111 / Math.Cos(_settings.DefaultLatitude));
            }

            set { _settings.DefaultLongitude = value; }
        }

        double ISettings.DefaultAltitude
        {
            get { return _settings.DefaultAltitude; }

            set { _settings.DefaultAltitude = value; }
        }

        string ISettings.PtcPassword
        {
            get { return _settings.Auth.PtcPassword; }

            set { _settings.Auth.PtcPassword = value; }
        }

        string ISettings.PtcUsername
        {
            get { return _settings.Auth.PtcUsername; }

            set { _settings.Auth.PtcUsername = value; }
        }

        string ISettings.GoogleUsername
        {
            get { return _settings.Auth.GoogleUsername; }

            set { _settings.Auth.GoogleUsername = value; }
        }

        string ISettings.GooglePassword
        {
            get { return _settings.Auth.GooglePassword; }

            set { _settings.Auth.GooglePassword = value; }
        }
    }

    public class LogicSettings : ILogicSettings
    {
        private readonly GlobalSettings _settings;

        public LogicSettings(GlobalSettings settings)
        {
            _settings = settings;
        }

        public string ProfilePath => _settings.ProfilePath;
        public string ProfileConfigPath => _settings.ProfileConfigPath;
        public string GeneralConfigPath => _settings.GeneralConfigPath;
        public bool AutoUpdate => _settings.AutoUpdate;
        public bool TransferConfigAndAuthOnUpdate => _settings.TransferConfigAndAuthOnUpdate;
        public float KeepMinIvPercentage => _settings.KeepMinIvPercentage;
        public int KeepMinCp => _settings.KeepMinCp;
        public bool AutomaticallyLevelUpPokemon => _settings.AutomaticallyLevelUpPokemon;
        public string LevelUpByCPorIv => _settings.LevelUpByCPorIv;
        public float UpgradePokemonIvMinimum => _settings.UpgradePokemonIvMinimum;
        public float UpgradePokemonCpMinimum => _settings.UpgradePokemonCpMinimum;
        public double WalkingSpeedInKilometerPerHour => _settings.WalkingSpeedInKilometerPerHour;
        public bool EvolveAllPokemonWithEnoughCandy => _settings.EvolveAllPokemonWithEnoughCandy;
        public bool KeepPokemonsThatCanEvolve => _settings.KeepPokemonsThatCanEvolve;
        public bool TransferDuplicatePokemon => _settings.TransferDuplicatePokemon;
        public bool UseEggIncubators => _settings.UseEggIncubators;
        public int UseGreatBallAboveCp => _settings.UseGreatBallAboveCp;
        public int UseUltraBallAboveCp => _settings.UseUltraBallAboveCp;
        public int UseGreatBallAboveIv => _settings.UseGreatBallAboveIv;
        public int UseUltraBallAboveIv => _settings.UseUltraBallAboveIv;
        public double UseMasterBallBelowCatchProbability => _settings.UseMasterBallBelowCatchProbability;
        public double UseUltraBallBelowCatchProbability => _settings.UseUltraBallBelowCatchProbability;
        public double UseGreatBallBelowCatchProbability => _settings.UseGreatBallBelowCatchProbability;
        public int UseMasterBallAboveCp => _settings.UseMasterBallAboveCp;
        public int DelayBetweenPokemonCatch => _settings.DelayBetweenPokemonCatch;
        public int DelayBetweenPlayerActions => _settings.DelayBetweenPlayerActions;
        public bool UsePokemonToNotCatchFilter => _settings.UsePokemonToNotCatchFilter;
        public int KeepMinDuplicatePokemon => _settings.KeepMinDuplicatePokemon;
        public bool PrioritizeIvOverCp => _settings.PrioritizeIvOverCp;
        public int MaxTravelDistanceInMeters => _settings.MaxTravelDistanceInMeters;
        public string GpxFile => _settings.GpxFile;
        public bool UseGpxPathing => _settings.UseGpxPathing;
        public bool UseLuckyEggsWhileEvolving => _settings.UseLuckyEggsWhileEvolving;
        public int UseLuckyEggsMinPokemonAmount => _settings.UseLuckyEggsMinPokemonAmount;
        public bool EvolveAllPokemonAboveIv => _settings.EvolveAllPokemonAboveIv;
        public float EvolveAboveIvValue => _settings.EvolveAboveIvValue;
        public bool RenamePokemon => _settings.RenamePokemon;
        public bool RenameOnlyAboveIv => _settings.RenameOnlyAboveIv;
        public float FavoriteMinIvPercentage => _settings.FavoriteMinIvPercentage;
        public bool AutoFavoritePokemon => _settings.AutoFavoritePokemon;
        public string RenameTemplate => _settings.RenameTemplate;
        public int AmountOfPokemonToDisplayOnStart => _settings.AmountOfPokemonToDisplayOnStart;
        public bool DumpPokemonStats => _settings.DumpPokemonStats;
        public string TranslationLanguageCode => _settings.TranslationLanguageCode;
        public ICollection<KeyValuePair<ItemId, int>> ItemRecycleFilter => _settings.ItemRecycleFilter;
        public ICollection<PokemonId> PokemonsToEvolve => _settings.PokemonsToEvolve;
        public ICollection<PokemonId> PokemonsNotToTransfer => _settings.PokemonsNotToTransfer;
        public ICollection<PokemonId> PokemonsNotToCatch => _settings.PokemonsToIgnore;
        public ICollection<PokemonId> PokemonToUseMasterball => _settings.PokemonToUseMasterball;
        public Dictionary<PokemonId, TransferFilter> PokemonsTransferFilter => _settings.PokemonsTransferFilter;
        public bool StartupWelcomeDelay => _settings.StartupWelcomeDelay;
        public bool SnipeAtPokestops => _settings.SnipeAtPokestops;
        public int MinPokeballsToSnipe => _settings.MinPokeballsToSnipe;
        public int MinPokeballsWhileSnipe => _settings.MinPokeballsWhileSnipe;
        public int MaxPokeballsPerPokemon => _settings.MaxPokeballsPerPokemon;

        public SnipeSettings PokemonToSnipe => _settings.PokemonToSnipe;
        public string SnipeLocationServer => _settings.SnipeLocationServer;
        public int SnipeLocationServerPort => _settings.SnipeLocationServerPort;
        public bool UseSnipeLocationServer => _settings.UseSnipeLocationServer;
        public bool UseTransferIvForSnipe => _settings.UseTransferIvForSnipe;
        public bool SnipeIgnoreUnknownIv => _settings.SnipeIgnoreUnknownIv;
        public int MinDelayBetweenSnipes => _settings.MinDelayBetweenSnipes;
        public int TotalAmountOfPokeballsToKeep => _settings.TotalAmountOfPokeballsToKeep;
        public int TotalAmountOfPotionsToKeep => _settings.TotalAmountOfPotionsToKeep;
        public int TotalAmountOfRevivesToKeep => _settings.TotalAmountOfRevivesToKeep;

        public bool Teleport => _settings.Teleport;
        public int DelayCatchIncensePokemon => _settings.DelayCatchIncensePokemon;
        public int DelayCatchNearbyPokemon => _settings.DelayCatchNearbyPokemon;
        public int DelayPositionCheckState => _settings.DelayPositionCheckState;
        public int DelayCatchLurePokemon => _settings.DelayCatchLurePokemon;
        public int DelayCatchPokemon => _settings.DelayCatchPokemon;
        public int DelayDisplayPokemon => _settings.DelayDisplayPokemon;
        public int DelayUseLuckyEgg => _settings.DelayUseLuckyEgg;
        public int DelaySoftbanRetry => _settings.DelaySoftbanRetry;
        public int DelayPokestop => _settings.DelayPokestop;
        public int DelayRecyleItem => _settings.DelayRecyleItem;
        public int DelaySnipePokemon => _settings.DelaySnipePokemon;
        public int DelayTransferPokemon => _settings.DelayTransferPokemon;
        public double RecycleInventoryAtUsagePercentage => _settings.RecycleInventoryAtUsagePercentage;
        public bool HumanizeThrows => _settings.HumanizeThrows;
        public double ThrowAccuracyMin => _settings.ThrowAccuracyMin;
        public double ThrowAccuracyMax => _settings.ThrowAccuracyMax;
        public double ThrowSpinFrequency => _settings.ThrowSpinFrequency;
        public int UseBerryMinCp => _settings.UseBerryMinCp;
        public float UseBerryMinIv => _settings.UseBerryMinIv;
        public double UseBerryBelowCatchProbability => _settings.UseBerryBelowCatchProbability;
    }
}