using LitJson;

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.Analytics;
using UnityEngine.EventSystems;

using System;
using System.Xml;
using System.Collections;
using System.Collections.Generic;

public class Manager : Regist 
{
    #region Config

    #region 成就

    public static double PlayADsAmt
    {
        get { return playADsAmt; }
        set
        {
            playADsAmt = value;

            AchieveManager.UpdateStatus(AchieveType.PlayADsAmt, playADsAmt);
        }
    }
    private static double playADsAmt;

    public static double UseSkillAmt
    {
        get { return useSkillAmt; }
        set
        {
            useSkillAmt = value;

            AchieveManager.UpdateStatus(AchieveType.UseSkillAmt, useSkillAmt);
        }
    }
    private static double useSkillAmt;

    public static double SignAmt
    {
        get { return signAmt; }
        set
        {
            signAmt = value;

            AchieveManager.UpdateStatus(AchieveType.SignAmt, signAmt);
        }
    }
    private static double signAmt;

    public static double CloseAmt
    {
        get { return closeAmt; }
        set
        {
            closeAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CloseAmt, closeAmt);
        }
    }
    private static double closeAmt;

    public static double ShareAmt
    {
        get { return shareAmt; }
        set
        {
            shareAmt = value;

            AchieveManager.UpdateStatus(AchieveType.ShareAmt, shareAmt);
        }
    }
    private static double shareAmt;

    public static double PlayMinigameAmt
    {
        get { return playMinigameAmt; }
        set
        {
            playMinigameAmt = value;

            AchieveManager.UpdateStatus(AchieveType.PlayMinigameAmt, playMinigameAmt);
        }
    }
    private static double playMinigameAmt;

    public static double AllElfLevel
    {
        get { return allElfLevel; }
        set
        {
            allElfLevel = value;

            AchieveManager.UpdateStatus(AchieveType.AllElfLevel, allElfLevel);
        }
    }
    private static double allElfLevel;

    public static double TotalCoin
    {
        get { return totalCoin; }
        set
        {
            totalCoin = value;

            AchieveManager.UpdateStatus(AchieveType.TotalCoin, totalCoin);
        }
    }
    private static double totalCoin;

    public static double TotalFlowerAwardCoin
    {
        get { return totalFlowerAwardCoin; }
        set
        {
            totalFlowerAwardCoin = value;
            
            AchieveManager.UpdateStatus(AchieveType.TotalFlowerAwardCoin, totalFlowerAwardCoin);
        }
    }
    private static double totalFlowerAwardCoin;

    public static double TotalVisitPerson
    {
        get { return totalVisitPerson; }
        set
        {
            totalVisitPerson = value;

            AchieveManager.UpdateStatus(AchieveType.TotalVisitPerson, totalVisitPerson);
        }
    }
    private static double totalVisitPerson;

    public static double TotalSpendDiamond
    {
        get { return totalSpendDiamond; }
        set
        {
            totalSpendDiamond = value;

            AchieveManager.UpdateStatus(AchieveType.TotalSpendDiamond, totalSpendDiamond);
        }
    }
    private static double totalSpendDiamond;

    public static double CreateRoomAmt
    {
        get { return createRoomAmt; }
        set
        {
            createRoomAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CreateRoomAmt, createRoomAmt);
        }
    }
    private static double createRoomAmt;

    public static double CreateChestAmt
    {
        get { return createChestAmt; }
        set
        {
            createChestAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CreateChestAmt, createChestAmt);
        }
    }
    private static double createChestAmt;

    public static double CreateLuckyChestAmt
    {
        get { return createLuckyChestAmt; }
        set
        {
            createLuckyChestAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CreateLuckyChestAmt, createLuckyChestAmt);
        }
    }
    private static double createLuckyChestAmt;

    public static double CreateGuessColorChestAmt
    {
        get { return createGuessColorChestAmt; }
        set
        {
            createGuessColorChestAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CreateGuessColorChestAmt, createGuessColorChestAmt);
        }
    }
    private static double createGuessColorChestAmt;

    public static double CreateGuessNumberChestAmt
    {
        get { return createGuessNumberChestAmt; }
        set
        {
            createGuessNumberChestAmt = value;

            AchieveManager.UpdateStatus(AchieveType.CreateGuessNumberChestAmt, createGuessNumberChestAmt);
        }
    }
    private static double createGuessNumberChestAmt;

    public static double GetChestAwardAmt
    {
        get { return getChestAwardAmt; }
        set
        {
            getChestAwardAmt = value;

            AchieveManager.UpdateStatus(AchieveType.GetChestAwardAmt, getChestAwardAmt);
        }
    }
    private static double getChestAwardAmt;

    #endregion

    public static string LevelTextPrefix = "Lv";
    public static Action<int> OnLevelChange;
    public static Action<double> OnCoinChange;
    public static Action<double> OnDiamondChange;

    public static int GardenLevel
    {
        get { return gardenLevel; }
        set
        {
            gardenLevel = value;

            if (!Inited)
            {
                return;
            }

            ResourceManager.SetText(ObjectLabel.C_LevelText, LevelTextPrefix + gardenLevel);

            VisitManager.UpdateVisitCost();

            AchieveManager.UpdateStatus(AchieveType.GardenLevel, gardenLevel);
            
            for (int i = 0; i < SkillList.Count; i++)
            {
                SkillList[i].UpdateStatus();
            }

            foreach (var kv in PlayerManager.CloseItemDictionary)
            {
                kv.Value.OnLevelChange();
            }

            if (OnLevelChange != null)
            {
                OnLevelChange.Invoke(gardenLevel);
            }

            if (gardenLevel >= TutorialManager.MemoryMinigameTutorialLevel)
            {
                if (TutorialManager.memoryMinigameTutorial)
                {
                    TutorialManager.MemoryMinigameTutorial = true;
                }
            }

            if (GardenLevel < TutorialManager.DressroomTutorialLevel)
            {
                ResourceManager.Get<Image>(ObjectLabel.C_DressRoom).material = Lib.GrayMat;
            }
            else
            {
                ResourceManager.Get<Image>(ObjectLabel.C_DressRoom).material = null;
            }

            if (GardenManager.TotalUnlockFlower >= TutorialManager.MinFlowerForFindGame && gardenLevel >= TutorialManager.FindMinigameTutorialLevel)
            {
                if (TutorialManager.findMinigameTutorial)
                {
                    TutorialManager.PlayFindGame();
                }
            }

            if (gardenLevel >= TutorialManager.CommentTutorialLevel)
            {
                ResourceManager.Get(ObjectLabel.C_CommentParent).TweenForCG();
            }

            if (gardenLevel >= TutorialManager.VisitTutorialLevel)
            {
                if (TutorialManager.visitTutorial)
                {
                    TutorialManager.ClickVisitBtn();
                    return;
                }
                else
                {
                    ResourceManager.SetActive(ObjectLabel.C_Visit, true);
                }
            }

            if (gardenLevel >= TutorialManager.DressroomTutorialLevel)
            {
                if (TutorialManager.dressroomTutorial)
                {
                    TutorialManager.ClickDressroomButton();
                    return;
                }
            }

            if (gardenLevel >= TutorialManager.PlazaRoomTutorialLevel)
            {
                if (TutorialManager.plazaRoomTutorial)
                {
                    TutorialManager.ClickPlazaRoomBtn();
                    return;
                }
                else
                {
                    ResourceManager.SetActive(ObjectLabel.C_EnterPlazaRoom, true);
                }
            }
        }
    }
    private static int gardenLevel;

    public static float Person
    {
        get { return person; }
        set
        {
            person = value;

            ResourceManager.SetText(ObjectLabel.F_PersonLab, (IncomeDisplayTime*(person * (1 + skillPersonBuff) + skillPerson)).ToString("0"));
        }
    }
    private static float person;

    public static float SkillPerson
    {
        get { return skillPerson; }
        set
        {
            skillPerson = value;

            TweenOutline tween = ResourceManager.Get(ObjectLabel.F_PersonLab).GetTweenOutline();

            if (skillPerson.Equal(0))
            {
                tween.Pause();

                tween.Target.enabled = false;
            }
            else
            {
                if (tween.InPause)
                {
                    tween.Resume();

                    tween.Target.enabled = true;
                }
                else
                {
                    tween.StartForward();
                }
            }

            ResourceManager.SetText(ObjectLabel.F_PersonLab, (IncomeDisplayTime * (person * (1 + skillPersonBuff) + skillPerson)).ToString("0"));
        }
    }
    public static float skillPerson;

    public static float CoinPerson
    {
        get { return coinPerson; }
        set
        {
            coinPerson = value;

            ResourceManager.SetText(ObjectLabel.F_CoinPersonLab, (coinPerson + skillCoinPerson).ToString("0"));
        }
    }
    private static float coinPerson;

    public static float SkillPersonBuff
    {
        get { return skillPersonBuff; }
        set
        {
            skillPersonBuff = value;

            ResourceManager.SetText(ObjectLabel.F_PersonLab, (IncomeDisplayTime * (person * (1 + skillPersonBuff) + skillPerson)).ToString("0"));
        }
    }
    public static float skillPersonBuff;

    public static float SkillCoinPerson
    {
        get { return skillCoinPerson; }
        set
        {
            skillCoinPerson = value;

            TweenOutline tween = ResourceManager.Get(ObjectLabel.F_CoinPersonLab).GetTweenOutline();

            if (skillCoinPerson.Equal(0))
            {
                tween.Pause();

                tween.Target.enabled = false;
            }
            else
            {
                if (tween.InPause)
                {
                    tween.Resume();

                    tween.Target.enabled = true;
                }
                else
                {
                    tween.StartForward();
                }
            }

            ResourceManager.SetText(ObjectLabel.F_CoinPersonLab, (coinPerson + skillCoinPerson).ToString("0"));
        }
    }
    public static float skillCoinPerson;

    public static double Coin
    {
        get { return coin; }
        set
        {
            coin = value;
            
            ResourceManager.SetText(ObjectLabel.F_CoinLab, Auxiliary.ShrinkNumberStr(coin));
            ResourceManager.SetText(ObjectLabel.C_CoinLab, Auxiliary.ShrinkNumberStr(coin));
            ResourceManager.SetText(ObjectLabel.P_CoinLab, Auxiliary.ShrinkNumberStr(coin));

            AchieveManager.UpdateStatus(AchieveType.CurrentCoin, coin);

            OnCoinChange.SafeInvoke(coin);
        }
    }
    public static double coin;

    public static double Diamond
    {
        get { return diamond; }
        set
        {
            diamond = value;

            ResourceManager.SetText(ObjectLabel.F_DiamondLab, Auxiliary.ShrinkNumberStr(diamond));
            ResourceManager.SetText(ObjectLabel.P_DiamondLab, Auxiliary.ShrinkNumberStr(diamond));

            OnDiamondChange.SafeInvoke(diamond);
        }
    }
    public static double diamond;

    public static float SkillPlus;
    public static float CurrentPerson;
    public static float CurrentCoinPerson;

    public static bool MinigameFlag;
    public static bool UploadConfigFlag;
    public static bool LoginFlag;
    public static bool OfflineFlag;
    public static bool ReactiveFlag;
    public static bool DownloadConfigFlag;
    public static bool SceneSwitchFlag;

    public static bool Inited;
    public static bool IsFirstFrame = true;
    public static bool InBackground;

    public static float IncomeDisplayTime = 60f;
    public static float IncomeCircleTime = 10;
    public static float IncomeCircleTimer;

    public static float OfflineTime;
    public static string OfflineIncomeFml;
    public static double OfflineMaxCoin;
    public static double OfflineMaxTime;
    public static double OfflineMinTime = 120f;

    public static float InputDetectTime = 60f;
    public static float InputDetectTimer;

    public static float LoginTime = 10f;
    public static float LoginTimer;

    public static float MinigameCDTimer;

    public static float UploadConfigTime = 60f;
    public static float UploadConfigTimer;

    public static Manager Instance;
    public static DateTime LastQuitTime;

    public static List<Skill> UsingSkillList = new List<Skill>();
    public static List<Skill> CoolSkillList = new List<Skill>();
    public static List<Skill> OfflineCoolSkillList = new List<Skill>();
    public static List<List<Skill>> OfflineUsingSkillList = new List<List<Skill>>();

    public static List<SkillRoot> SkillList = new List<SkillRoot>();
    public static Dictionary<string, SkillRoot> SkillDictionary = new Dictionary<string, SkillRoot>();

    #endregion
    
    private void Update()
    {
        LoginThread();

        if (TutorialManager.NewplayerTutorial)
        {
            return;
        }

        InputDetectThread();

        ProcessSkillThread();

        MinigameCDThread();

        UploadConfigThread();

        IncomeCircleThread();
    }

    private void InputDetectThread()
    {
        if (Auxiliary.AnyKeyUp)
        {
            InputDetectTimer = 0;

            ResourceManager.Get(ObjectLabel.C_Group).TweenForCG();
        }
        else
        {
            InputDetectTimer += Time.deltaTime;

            if (InputDetectTimer >= InputDetectTime)
            {
                InputDetectTimer = 0;

                ResourceManager.Get(ObjectLabel.C_Group).TweenBacCG();
            }
        }
    }

    private void ProcessSkillThread()
    {
        for (int i = 0; i < UsingSkillList.Count; i++)
        {
            if (UsingSkillList[i].DoUpdate())
            {
                UsingSkillList.RemoveAt(i--);
            }
        }

        for (int i = 0; i < CoolSkillList.Count; i++)
        {
            if (CoolSkillList[i].DoCD())
            {
                CoolSkillList.RemoveAt(i--);
            }
        }
    }

    private void MinigameCDThread()
    {
        if (!MinigameFlag)
        {
            MinigameCDTimer -= Time.deltaTime;

            ResourceManager.SetText(ObjectLabel.C_MiniGameLab, Mathf.CeilToInt(MinigameCDTimer).ToString());

            if (MinigameCDTimer < 0)
            {
                MinigameFlag = true;

                ResourceManager.Get(ObjectLabel.C_MiniGame).TweenBacRect();

                ResourceManager.SetText(ObjectLabel.C_MiniGameLab, "");

                StaticsManager.GetInstance().RewardItem(StaticsManager.ItemID.获得小游戏, StaticsManager.ItemType.小游戏, "1", StaticsManager.ConsumeModule.None);
            }
        }
    }

    private void UploadConfigThread()
    {
        if (DownloadConfigFlag)
        {
            return;
        }

        UploadConfigTimer += Time.deltaTime;

        if (UploadConfigTimer >= UploadConfigTime)
        {
            UploadConfigTimer = 0;

            HttpManager.UploadConfig();
        }
    }

    private void LoginThread()
    {
        LoginTimer += Time.deltaTime;

        if (LoginTimer >= LoginTime)
        {
            LoginTimer = 0;

            HttpManager.Login();

            StaticsManager.GetInstance().Online();
        }
    }

    private void IncomeCircleThread()
    {
        IncomeCircleTimer -= Time.deltaTime;

        if (IncomeCircleTimer < 0)
        {
            IncomeCircleTimer = IncomeCircleTime;

            CurrentPerson = Person * (1 + SkillPersonBuff) + SkillPerson;
            CurrentCoinPerson = CoinPerson + SkillCoinPerson;

            TotalVisitPerson += CurrentPerson * IncomeCircleTime;

            float temp = (CurrentPerson * CurrentCoinPerson * IncomeCircleTime) * (1 + SkillPlus);

            AddCoin(temp, StaticsManager.ItemID.获得金币, StaticsManager.ConsumeModule.Income);

            ResourceManager.Get(ObjectLabel.C_IncomeLab).TweenReForGra();
            ResourceManager.Get(ObjectLabel.C_IncomeLab).TweenReForVec();
            ResourceManager.SetText(ObjectLabel.C_IncomeLab, "+" + Auxiliary.ShrinkNumberStr(temp, 0));
        }
    }


    public static void AddCoin(double amt, StaticsManager.ItemID itemId, StaticsManager.ConsumeModule consumeModule)
    {
        Coin += amt;

        if (amt > 0)
        {
            TotalCoin += amt;

            StaticsManager.GetInstance().RewardItem(itemId, StaticsManager.ItemType.金币, amt.ToString("0"), consumeModule);
        }
    }

    public static void AddDiamond(double amt, StaticsManager.ItemID itemId, StaticsManager.ConsumeModule consumeModule)
    {
        Diamond += amt;

        if (amt > 0)
        {
            StaticsManager.GetInstance().RewardItem(itemId, StaticsManager.ItemType.钻石, amt.ToString("0"), consumeModule);
        }
    }


    public override void Reactive()
    {
        foreach (var kv in SkillDictionary)
        {
            kv.Value.Reactive();
        }

        InitAllSkill(false);
        GetOfflineIncome();

        SignManager.ShowPanels();
    }

    public override void InstantiatePrefabs()
    {
        #region 生成技能条

        #region 读技能配置

        List<XmlAttributeCollection> attributeList = ConfigManager.GetSkillConfig();

        for (int i = 0; i < attributeList.Count; i++)
        {
            SkillRoot skillRoot;

            #region MyRegion

            if (attributeList[i].Count == 18)
            {
                skillRoot = new Pack(attributeList[i]);
            }
            else if (attributeList[i].Count == 24)
            {
                skillRoot = new Ability(attributeList[i]);
            }
            else if (attributeList[i].Count == 34)
            {
                if (string.IsNullOrEmpty(attributeList[i][4].Value))
                {
                    skillRoot = new Skill(attributeList[i]);
                }
                else
                {
                    skillRoot = new BigSkill(attributeList[i]);
                }
            }
            else
            {
                throw new Exception(attributeList[i].Count.ToString());
            }

            #endregion

            SkillDictionary.Add(skillRoot.FullID, skillRoot);
            SkillList.Add(skillRoot);
        }

        SkillList.Sort(SkillRoot.Sort);

        #endregion

        for (int i = 0; i < SkillList.Count; i++)
        {
            if (SkillList[i].SkillTab != SkillTab.Null)
            {
                ResourceManager.GetSkillItem(SkillList[i]);
            }
        }

        #endregion
    }

    public override void FirstInit()
    {
        ResourceManager.Get<Graphic>(ObjectLabel.F_Elf).material = Lib.GrayMat;
        ResourceManager.Get<Graphic>(ObjectLabel.F_Store).material = Lib.GrayMat;
        ResourceManager.Get<Graphic>(ObjectLabel.F_Magic).material = Lib.GrayMat;

        ResourceManager.Get<Graphic>(ObjectLabel.F_ElfLab).material = Lib.GrayMat;
        ResourceManager.Get<Graphic>(ObjectLabel.F_StoreLab).material = Lib.GrayMat;
        ResourceManager.Get<Graphic>(ObjectLabel.F_MagicLab).material = Lib.GrayMat;

        ResourceManager.Get<Button>(ObjectLabel.F_Elf).interactable = false;
        ResourceManager.Get<Button>(ObjectLabel.F_Store).interactable = false;
        ResourceManager.Get<Button>(ObjectLabel.F_Magic).interactable = false;


        List<XmlAttributeCollection> attributeList = ConfigManager.GetSkillList();

        for (int i = 0; i < attributeList.Count; i++)
        {
            SkillRoot skillRoot = SkillDictionary[attributeList[i][0].Value];

            if (!(skillRoot is Skill))
            {
                skillRoot.RegistReference();

                skillRoot.Init(true, OfflineTime, OfflineUsingSkillList, attributeList[i]);
            }
        }
    }

    public override void SecondInit()
    {
        Instance = this;

        Coin = ConfigManager.GetDoubleFormConfig(PlayerConfigLabel.Coin);
        Diamond = ConfigManager.GetDoubleFormConfig(PlayerConfigLabel.Diamond);
        MinigameCDTimer = ConfigManager.GetFloatFormConfig(PlayerConfigLabel.MiniTimer);
        IncomeCircleTimer = ConfigManager.GetFloatFormConfig(PlayerConfigLabel.CircleTimer);

        if (MinigameCDTimer > 0)
        {
            ResourceManager.Get(ObjectLabel.C_MiniGame).TweenForRect();
        }
        else
        {
            MinigameFlag = true;
        }


        HttpManager.ID = ConfigManager.GetStringFormConfig(PlayerConfigLabel.ID);
        HttpManager.SerialNumber = ConfigManager.GetStringFormConfig(PlayerConfigLabel.SerialNumber);

        List<string> offlineList = ConfigManager.GetOfflineConfig();

        OfflineMaxCoin = Auxiliary.StringToLong(offlineList[1], 999999999999999999);
        OfflineMaxTime = Auxiliary.StringToLong(offlineList[2], 999999999999999999);
        OfflineIncomeFml = offlineList[0];


        List<double> dataList = ConfigManager.GetAchieveValues();

        PlayADsAmt = dataList[0];
        AllElfLevel = dataList[4];
        UseSkillAmt = dataList[1];
        SignAmt = dataList[2];
        ShareAmt = dataList[3];
        TotalFlowerAwardCoin = dataList[6];
        TotalVisitPerson = dataList[7];
        TotalSpendDiamond = dataList[8];
        PlayMinigameAmt = dataList[5];
        CreateRoomAmt = dataList[9];
        CreateChestAmt = dataList[10];
        CreateLuckyChestAmt = dataList[11];
        CreateGuessColorChestAmt = dataList[12];
        CreateGuessNumberChestAmt = dataList[13];
        GetChestAwardAmt = dataList[14];
    }


    public static void InitAllSkill(bool firstRegist)
    {
        OfflineFlag = false;

        ResourceManager.SetActive(ObjectLabel.Ba_Lab2, false);

        if (HttpManager.IsConnect && ConfigManager.GetBoolFormConfig(PlayerConfigLabel.QuitFlag))
        {
            LastQuitTime = DateTime.Parse(ConfigManager.GetStringFormConfig(PlayerConfigLabel.QuitTime));

            OfflineTime = (float)HttpManager.CurrentDateTime.Subtract(LastQuitTime).TotalSeconds;

            MinigameCDTimer -= OfflineTime;

            if (OfflineTime <= OfflineMinTime)
            {
                OfflineTime = 0;
            }
            else
            {
                OfflineFlag = true;
            }

            if (OfflineTime > OfflineMaxTime)
            {
                OfflineTime = (long)OfflineMaxTime;

                ResourceManager.SetText(ObjectLabel.Ba_Lab2, Language.GetStr(LanguageLabel.UI__Ba_Lab2));
                ResourceManager.SetActive(ObjectLabel.Ba_Lab2, true);
            }
        }


        OfflineUsingSkillList = new List<List<Skill>>();
        OfflineCoolSkillList = new List<Skill>();

        if (OfflineTime > IncomeCircleTimer)
        {
            int circle = 1 + Mathf.FloorToInt((OfflineTime - IncomeCircleTimer) / IncomeCircleTime);

            for (int i = 0; i < circle; i++)
            {
                OfflineUsingSkillList.Add(new List<Skill>());
            }
        }


        List<XmlAttributeCollection> attributeList = ConfigManager.GetSkillList();

        for (int i = 0; i < attributeList.Count; i++)
        {
            SkillRoot skillRoot = SkillDictionary[attributeList[i][0].Value];

            if (skillRoot is Skill)
            {
                skillRoot.RegistReference();

                skillRoot.Init(firstRegist, OfflineTime, OfflineUsingSkillList, attributeList[i]);
            }
        }
    }

    public static void GetOfflineIncome()
    {
        double coin = 0;

        for (int i = 0; i < OfflineUsingSkillList.Count; i++)
        {
            for (int j = 0; j < OfflineCoolSkillList.Count; j++)
            {
                OfflineCoolSkillList[j].CoolTimer -= IncomeCircleTime;
            }

            for (int j = 0; j < OfflineUsingSkillList[i].Count; j++)
            {
                OfflineUsingSkillList[i][j].AnnulEffect();

                OfflineCoolSkillList.Add(OfflineUsingSkillList[i][j]);
            }

            CurrentPerson = Person*(1 + skillPersonBuff) + SkillPerson;
            CurrentCoinPerson = CoinPerson + SkillCoinPerson;

            TotalVisitPerson += CurrentPerson*IncomeCircleTime;

            coin += (CurrentPerson*CurrentCoinPerson*IncomeCircleTime)*(1 + SkillPlus);
        }

        IncomeCircleTimer = (OfflineTime - IncomeCircleTimer)%IncomeCircleTime;

        for (int j = 0; j < OfflineCoolSkillList.Count; j++)
        {
            OfflineCoolSkillList[j].CoolTimer -= IncomeCircleTime - IncomeCircleTimer;
        }


        coin = (long) Auxiliary.FmlParse(OfflineIncomeFml, "c", coin.ToString());

        if (coin > OfflineMaxCoin)
        {
            coin = OfflineMaxCoin;

            ResourceManager.SetText(ObjectLabel.Ba_Lab2, Language.GetStr(LanguageLabel.UI__Ba_Lab2));
            ResourceManager.SetActive(ObjectLabel.Ba_Lab2, true);
        }

        AddCoin(coin, StaticsManager.ItemID.获得金币, StaticsManager.ConsumeModule.Income);

        ResourceManager.SetText(ObjectLabel.Ba_IconLab, Auxiliary.ShrinkNumberStr(coin));
    }

    public static void SwitchLanguage()
    {
        Coin = Coin;
        AddDiamond(0, StaticsManager.ItemID.None, StaticsManager.ConsumeModule.None);
    }

    public static void Pay(string id, double amt, Current current, UnityAction succeedCallback, StaticsManager.ItemID itemId, StaticsManager.ConsumeModule consumeModule, bool navigate = true, bool useBubbleTweenNavigate = true, UnityAction navigateCall = null)
    {
        if (TutorialManager.PayExempt)
        {
            succeedCallback.Invoke();

            return;
        }

        amt = Auxiliary.ShrinkNumber(amt);

        if (current == Current.Free)
        {
            succeedCallback.Invoke();
        }
        else if (current == Current.AD)
        {
            IAPManager.PlayAD(succeedCallback);
        }
        else if (current == Current.Cash)
        {
            IAPManager.TryPurchase(id);
        }
        else if (current == Current.Coin)
        {
            #region MyRegion

            if (Coin >= amt)
            {
                Coin -= amt;

                succeedCallback.Invoke();

                StaticsManager.GetInstance().UseItem(itemId, StaticsManager.ItemType.金币, "1", consumeModule);
            }
            else
            {
                ResourceManager.Get(ObjectLabel.Fe_Info).TweenBacCG();

                if (navigate)
                {
                    Bubble.Show
                    (
                        Language.GetStr(LanguageLabel.Common__ShortCoin),
                        Language.GetStr(LanguageLabel.Common__NavigateCoin),
                        null,
                        Lib.GoldSprite,
                        () =>
                        {
                            navigateCall.SafeInvoke();

                            if (useBubbleTweenNavigate)
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.K_Bubble0).GetTweenScale();

                                tween.AddEventOnetime
                                (
                                    EventType.BackwardFinish,
                                    () =>
                                    {
                                        UIManager.NavigateToBuyCoin();
                                    }
                                );
                            }
                            else
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.F_Manage0).GetTweenVec();

                                tween.AddEventOnetime
                                (
                                    EventType.ForwardFinish,
                                    () =>
                                    {
                                        UIManager.NavigateToBuyCoin();
                                    }
                                );
                            }
                        }
                    );
                }
                else
                {
                    Bubble.Show
                    (
                        Language.GetStr(LanguageLabel.Common__ShortCoin),
                        null,
                        null,
                        Lib.GoldSprite
                    );
                }
            }

            #endregion
        }
        else if (current == Current.Diamond)
        {
            #region MyRegion

            if (Diamond >= amt)
            {
                Diamond -= amt;

                TotalSpendDiamond += amt;

                succeedCallback.Invoke();

                StaticsManager.GetInstance().PurchaseItem(itemId, StaticsManager.ItemType.钻石, "1", amt.ToString("0"), consumeModule);
            }
            else
            {
                ResourceManager.Get(ObjectLabel.Fe_Info).TweenBacCG();

                if (navigate)
                {
                    Bubble.Show
                    (
                        Language.GetStr(LanguageLabel.Common__ShortDiamond),
                        Language.GetStr(LanguageLabel.Common__NavigateDiamond),
                        null,
                        Lib.DiamondSprite,
                        () =>
                        {
                            navigateCall.SafeInvoke();

                            if (useBubbleTweenNavigate)
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.K_Bubble0).GetTweenScale();

                                tween.AddEventOnetime
                                (
                                    EventType.BackwardFinish,
                                    () =>
                                    {
                                        UIManager.NavigateToBuyDiamond();
                                    }
                                );
                            }
                            else
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.F_Manage0).GetTweenVec();

                                tween.AddEventOnetime
                                    (
                                        EventType.ForwardFinish,
                                        () =>
                                        {
                                            UIManager.NavigateToBuyDiamond();
                                        }
                                    );
                            }
                        }
                    );
                }
                else
                {
                    Bubble.Show
                    (
                        Language.GetStr(LanguageLabel.Common__ShortDiamond),
                        null,
                        null,
                        Lib.DiamondSprite
                    );
                }
            }

            #endregion
        }
        else
        {
            throw new Exception(current.ToString());
        }
    }


    public static void FirstTimeLoginCallback(JsonData jsonData)
    {
        if (!Initializer.Inited || !HttpManager.Inited || Inited)
        {
            return;
        }

        HttpManager.GetBuyPackLimitFlag();

        if (HttpManager.IsConnect)
        {
            if (ConfigManager.GetStringFormConfig(PlayerConfigLabel.ID) == PlayerConfigLabel.DefaultID)
            {
                HttpManager.ID = HttpManager.LoginCallbackData["o"].ToString();

                ResourceManager.SetText(ObjectLabel.L_UserLab, HttpManager.ID);
            }

            if (ConfigManager.GetStringFormConfig(PlayerConfigLabel.SerialNumber) == PlayerConfigLabel.DefaultSerialNumber)
            {
                HttpManager.SerialNumber = HttpManager.LoginCallbackData["i"].ToString();
            }
        }

        InitAllSkill(true);
        GetOfflineIncome();

        SignManager.ShowPanels();

        Analytics.SetUserId(HttpManager.ID);

        Inited = true;
        
        GardenLevel = GardenLevel;
    }

    public static void ReactiveLoginCallback(JsonData jsonData)
    {
        LoginFlag = false;

        for (int i = 0; i < Initializer.RegistList.Count; i++)
        {
            Initializer.RegistList[i].Reactive();
        }
    }


    public static void SwitchConfig(string id)
    {
        ResourceManager.SetText(ObjectLabel.La_Lab, Language.GetStr(LanguageLabel.UI__L_Downloading));

        ResourceManager.SetActive(ObjectLabel.La_Lab, true);
        ResourceManager.SetActive(ObjectLabel.La_Mask, true);


        HttpManager.GetConfigByID(id, SwitchConfigCallback);
    }
    
    public static void SwitchConfigCallback(JsonData jsonData)
    {
        if (jsonData.Inst_Object.Keys.Contains("l"))
        {
            ResourceManager.Get(ObjectLabel.La_Info).TweenBacCG();

            ResourceManager.SetText(ObjectLabel.La_Lab, Language.GetStr(LanguageLabel.UI__La_Lab0));


            ConfigManager.ConfigDocument.LoadXml(jsonData["l"].ToString());

            ConfigManager.ConfigRootNode = ConfigManager.ConfigDocument.SelectSingleNode(PlayerConfigLabel.RootNode);


            ResourceManager.SetText(ObjectLabel.L_UserLab, ConfigManager.GetStringFormConfig(PlayerConfigLabel.ID));

            HttpManager.ID = ConfigManager.GetStringFormConfig(PlayerConfigLabel.ID);
            HttpManager.SerialNumber = ConfigManager.GetStringFormConfig(PlayerConfigLabel.SerialNumber);


            Bubble.Show(null, Language.GetStr(LanguageLabel.UI__La_Lab0), null, null, () => { Application.Quit(); }, null, false);


            UploadConfigFlag = true;

            DownloadConfigFlag = true;

            ConfigManager.SaveConfigDocumentToDisk();
            PlayerPrefs.SetString(Lib.ConfigPrefs, "");
        }
        else
        {
            ResourceManager.SetText(ObjectLabel.La_Lab, Language.GetStr(LanguageLabel.UI__La_Lab1));

            ResourceManager.SetActive(ObjectLabel.La_Mask, false);
        }
    }


    public void OnApplicationQuit()
    {
        if (!UploadConfigFlag)
        {
            VisitManager.ReverseConfigData();

            ConfigManager.SaveConfigDocument();
            ConfigManager.SaveConfigDocumentToDisk();
        }
    }

    public void OnApplicationPause(bool pause)
    {
        if (pause)
        {
            InBackground = true;

            if (DownloadConfigFlag)
            {
                return;
            }

            VisitManager.ReverseConfigData();

            ConfigManager.SaveConfigDocument();
            ConfigManager.SaveConfigDocumentToDisk();
        }
        else
        {
            StaticsManager.GetInstance().StartSession();

            InBackground = false;

            if (IsFirstFrame)
            {
                IsFirstFrame = false;
            }
            else
            {
                if (TutorialManager.NewplayerTutorial)
                {
                    return;
                }

                if (!Initializer.Inited)
                {
                    return;
                }

                if (DownloadConfigFlag)
                {
                    return;
                }

                VisitManager.RecoverConfigData();

                if (LoginFlag)
                {
                    return;
                }

                if (ReactiveFlag)
                {
                    ReactiveFlag = false;

                    return;
                }

                LoginFlag = true;

                HttpManager.Login(ReactiveLoginCallback);
                HttpManager.GetMailAwardData();
            }
        }
    }
}