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 AdAmt
    {
        get { return AdAmt_; }
        set
        {
            AdAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.PlayADsAmt, AdAmt_);
        }
    }
    public static double SkillAmt
    {
        get { return SkillAmt_; }
        set
        {
            SkillAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.UseSkillAmt, SkillAmt_);
        }
    }
    public static double SignAmt
    {
        get { return SignAmt_; }
        set
        {
            SignAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.SignAmt, SignAmt_);
        }
    }
    public static double CloseAmt
    {
        get { return CloseAmt_; }
        set
        {
            CloseAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CloseAmt, CloseAmt_);
        }
    }
    public static double ShareAmt
    {
        get { return ShareAmt_; }
        set
        {
            ShareAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.ShareAmt, ShareAmt_);
        }
    }
    public static double MiniGameAmt
    {
        get { return MiniGameAmt_; }
        set
        {
            MiniGameAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.PlayMinigameAmt, MiniGameAmt_);
        }
    }
    public static double ElfLevel
    {
        get { return ElfLevel_; }
        set
        {
            ElfLevel_ = value;

            AchieveManager.UpdateStatus(AchieveType.AllElfLevel, ElfLevel_);
        }
    }
    public static double TotalCoin
    {
        get { return TotalCoin_; }
        set
        {
            TotalCoin_ = value;

            AchieveManager.UpdateStatus(AchieveType.TotalCoin, TotalCoin_);
        }
    }
    public static double FlowerCoin
    {
        get { return FlowerCoin_; }
        set
        {
            FlowerCoin_ = value;
            
            AchieveManager.UpdateStatus(AchieveType.TotalFlowerAwardCoin, FlowerCoin_);
        }
    }
    public static double TotalPerson
    {
        get { return TotalPerson_; }
        set
        {
            TotalPerson_ = value;

            AchieveManager.UpdateStatus(AchieveType.TotalVisitPerson, TotalPerson_);
        }
    }
    public static double CostDiamond
    {
        get { return CostDiamond_; }
        set
        {
            CostDiamond_ = value;

            AchieveManager.UpdateStatus(AchieveType.SpendDiamond, CostDiamond_);
        }
    }
    public static double CreateRoomAmt
    {
        get { return CreateRoomAmt_; }
        set
        {
            CreateRoomAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CreateRoomAmt, CreateRoomAmt_);
        }
    }
    public static double CreateChestAmt
    {
        get { return CreateChestAmt_; }
        set
        {
            CreateChestAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CreateChestAmt, CreateChestAmt_);
        }
    }
    public static double CreateLuckyChestAmt
    {
        get { return CreateLuckyChestAmt_; }
        set
        {
            CreateLuckyChestAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CreateLuckyChestAmt, CreateLuckyChestAmt_);
        }
    }
    public static double CreateGuessColorChestAmt
    {
        get { return CreateGuessColorChestAmt_; }
        set
        {
            CreateGuessColorChestAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CreateGuessColorChestAmt, CreateGuessColorChestAmt_);
        }
    }
    public static double CreateGuessNumberChestAmt
    {
        get { return CreateGuessNumberChestAmt_; }
        set
        {
            CreateGuessNumberChestAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.CreateGuessNumberChestAmt, CreateGuessNumberChestAmt_);
        }
    }
    public static double GetChestAwardAmt
    {
        get { return GetChestAwardAmt_; }
        set
        {
            GetChestAwardAmt_ = value;

            AchieveManager.UpdateStatus(AchieveType.GetChestAwardAmt, GetChestAwardAmt_);
        }
    }

    private static double AdAmt_;
    private static double SkillAmt_;
    private static double SignAmt_;
    private static double CloseAmt_;
    private static double ShareAmt_;
    private static double MiniGameAmt_;
    private static double ElfLevel_;
    private static double TotalCoin_;
    private static double FlowerCoin_;
    private static double TotalPerson_;
    private static double CostDiamond_;
    private static double CreateRoomAmt_;
    private static double CreateChestAmt_;
    private static double CreateLuckyChestAmt_;
    private static double CreateGuessColorChestAmt_;
    private static double CreateGuessNumberChestAmt_;
    private static double GetChestAwardAmt_;

    #endregion

    public static Action OnLevelChange;

    public static int Level
    {
        get { return Level_; }
        set
        {
            Level_ = value;

            if (!Complete)
            {
                return;
            }

            VisitManager.UpdateCost();

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

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

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

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

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

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

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

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

            if (Level_ >= TutorialManager.PlazaRoomTutorialLevel)
            {
                if (TutorialManager.plazaRoomTutorial)
                {
                    TutorialManager.ClickPlazaRoomBtn();
                    return;
                }
                else
                {
                    ResourceManager.SetActive(ObjectLabel.C_EnterPlazaRoom, true);
                }
            }
        }
    }
    public static float Person
    {
        get { return Person_; }
        set
        {
            Person_ = value;

            ResourceManager.SetText(ObjectLabel.F_PersonLab, (IncomeDisplayTime*(Person_ * (1 + SkillPersonBuff_) + SkillPerson_)).ToString("0"));
        }
    }
    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 CoinPerson
    {
        get { return CoinPerson_; }
        set
        {
            CoinPerson_ = value;

            ResourceManager.SetText(ObjectLabel.F_CoinPersonLab, (CoinPerson_ + SkillCoinPerson_).ToString("0"));
        }
    }
    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 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"));
        }
    }

    private static int Level_;
    private static bool Pause_;
    private static float Person_;
    private static float CoinPerson_;

    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_);
        }
    }
    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_));
        }
    }

    public static double Coin_;
    public static double Diamond_;

    public static bool MiniLock;
    public static bool SaveLock;
    public static bool LoginLock;
    public static bool OfflineLock;
    public static bool ReactiveLock;
    public static bool DownloadLock;
    public static bool SceneSwitchLock;

    public static bool Complete;
    public static bool FirstFrame = true;
    public static bool Background;

    public static float Elapse;
    public static float CircleTime = 10;

    public static float OpTimer;
    public static float MiniTimer;
    public static float SaveTimer;
    public static float LoginTimer;
    public static float CircleTimer;

    public static float NewPerson;
    public static float NewCoinPerson;

    public static string OfflineFml;
    public static double MaxCoin;
    public static double MaxTime;

    public static float SkillPlus;
    public static float SkillPerson_;
    public static float SkillPersonBuff_;
    public static float SkillCoinPerson_;

    public static DateTime QuitTime;
    public static Manager Instance;

    public static List<Skill> UseList = new List<Skill>();
    public static List<Skill> CoolList = new List<Skill>();

    public static List<Skill> TempCoolList = new List<Skill>();
    public static List<List<Skill>> TempUseList = new List<List<Skill>>();

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

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

        if (TutorialManager.NewplayerTutorial)
        {
            return;
        }

        OpThread();

        SkillThread();

        MiniThread();

        SaveThread();

        IncomeCircleThread();
    }


    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);
        }
    }


    private static float InputDetectTime = 60f;
    private void OpThread()
    {
        if (Auxiliary.AnyKeyUp)
        {
            OpTimer = 0;

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

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

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

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

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

    private void MiniThread()
    {
        if (!MiniLock)
        {
            MiniTimer -= Time.deltaTime;

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

            if (MiniTimer < 0)
            {
                MiniLock = true;

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

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

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

    private static float SaveConfigTime = 60f;
    private void SaveThread()
    {
        if (DownloadLock)
        {
            return;
        }

        SaveTimer += Time.deltaTime;

        if (SaveTimer >= SaveConfigTime)
        {
            SaveTimer = 0;

            HttpManager.Save();
        }
    }

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

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

            HttpManager.Login();

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

    private static float IncomeDisplayTime = 60f;
    private void IncomeCircleThread()
    {
        CircleTimer -= Time.deltaTime;
        
        if (CircleTimer < 0)
        {
            CircleTimer = CircleTime;

            NewPerson = Person * (1 + SkillPersonBuff) + SkillPerson;
            NewCoinPerson = CoinPerson + SkillCoinPerson;

            TotalPerson += NewPerson * CircleTime;

            float temp = (NewPerson * NewCoinPerson * CircleTime) * (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 override void Reactive()
    {
        foreach (var kv in SkillDic)
        {
            kv.Value.Reactive();
        }

        RegistSkill(false);
        RegistIncome();

        SignManager.ShowOfflinePanel();
    }

    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

            SkillDic.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 = SkillDic[attributeList[i][0].Value];

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

                skillRoot.Init(true, Elapse, TempUseList, attributeList[i]);
            }
        }
    }

    public override void SecondInit()
    {
        Instance = this;

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

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


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

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

        MaxCoin = Auxiliary.StringToLong(offlineList[1], 999999999999999999);
        MaxTime = Auxiliary.StringToLong(offlineList[2], 999999999999999999);
        OfflineFml = offlineList[0];


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

        AdAmt = dataList[0];
        ElfLevel = dataList[4];
        SkillAmt = dataList[1];
        SignAmt = dataList[2];
        ShareAmt = dataList[3];
        FlowerCoin = dataList[6];
        TotalPerson = dataList[7];
        CostDiamond = dataList[8];
        MiniGameAmt = dataList[5];
        CreateRoomAmt = dataList[9];
        CreateChestAmt = dataList[10];
        CreateLuckyChestAmt = dataList[11];
        CreateGuessColorChestAmt = dataList[12];
        CreateGuessNumberChestAmt = dataList[13];
        GetChestAwardAmt = dataList[14];
    }


    private static float MinOfflineTime = 120f; 
    public static void RegistSkill(bool firstRegist)
    {
        OfflineLock = false;

        ResourceManager.SetActive(ObjectLabel.Ba_Lab2, false);

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

            Elapse = (float)HttpManager.Time.Subtract(QuitTime).TotalSeconds;

            MiniTimer -= Elapse;

            if (Elapse <= MinOfflineTime)
            {
                Elapse = 0;
            }
            else
            {
                OfflineLock = true;
            }

            if (Elapse > MaxTime)
            {
                Elapse = (long)MaxTime;

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


        TempUseList = new List<List<Skill>>();
        TempCoolList = new List<Skill>();

        if (Elapse > CircleTimer)
        {
            int circle = 1 + Mathf.FloorToInt((Elapse - CircleTimer) / CircleTime);

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


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

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

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

                skillRoot.Init(firstRegist, Elapse, TempUseList, attributeList[i]);
            }
        }
    }

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

        for (int i = 0; i < TempUseList.Count; i++)
        {
            for (int j = 0; j < TempCoolList.Count; j++)
            {
                TempCoolList[j].CoolTimer -= CircleTime;
            }

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

                TempCoolList.Add(TempUseList[i][j]);
            }

            NewPerson = Person*(1 + SkillPersonBuff_) + SkillPerson;
            NewCoinPerson = CoinPerson + SkillCoinPerson;

            TotalPerson += NewPerson*CircleTime;

            coin += (NewPerson*NewCoinPerson*CircleTime)*(1 + SkillPlus);
        }

        CircleTimer = (Elapse - CircleTimer)%CircleTime;

        for (int j = 0; j < TempCoolList.Count; j++)
        {
            TempCoolList[j].CoolTimer -= CircleTime - CircleTimer;
        }


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

        if (coin > MaxCoin)
        {
            coin = MaxCoin;

            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);
    }

    private static int DefaultPurchaseAmt = 1;
    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.Purchase(id);
        }
        else if (current == Current.Coin)
        {
            #region MyRegion

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

                succeedCallback.Invoke();

                StaticsManager.GetInstance().UseItem(itemId, StaticsManager.ItemType.金币, DefaultPurchaseAmt.ToString(), 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.NavigateBuyCoin();
                                    }
                                );
                            }
                            else
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.F_Manage0).GetTweenVec();

                                tween.AddEventOnetime
                                (
                                    EventType.ForwardFinish,
                                    () =>
                                    {
                                        UIManager.NavigateBuyCoin();
                                    }
                                );
                            }
                        }
                    );
                }
                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;

                CostDiamond += amt;

                succeedCallback.Invoke();

                StaticsManager.GetInstance().PurchaseItem(itemId, StaticsManager.ItemType.钻石, DefaultPurchaseAmt.ToString(), 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.NavigateBuyDiamond();
                                    }
                                );
                            }
                            else
                            {
                                TweenRoot tween = ResourceManager.Get(ObjectLabel.F_Manage0).GetTweenVec();

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

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


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

        HttpManager.PackTypeRequest();

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

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

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

        RegistSkill(true);
        RegistIncome();

        SignManager.ShowOfflinePanel();

        Analytics.SetUserId(HttpManager.ID);

        Complete = true;
        
        Level = Level;
    }

    public static void LoginCallbackReactive(JsonData jsonData)
    {
        LoginLock = false;

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


    public static void Download(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.DownloadByID(id, DownloadCallback);
    }
    
    public static void DownloadCallback(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);


            SaveLock = true;

            DownloadLock = 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 (!SaveLock)
        {
            VisitManager.DataReverse();

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

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

            if (DownloadLock)
            {
                return;
            }

            VisitManager.DataReverse();

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

            Background = false;

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

                if (!Initializer.Complete)
                {
                    return;
                }

                if (DownloadLock)
                {
                    return;
                }

                VisitManager.DataRecover();

                if (LoginLock)
                {
                    return;
                }

                if (ReactiveLock)
                {
                    ReactiveLock = false;

                    return;
                }

                LoginLock = true;

                HttpManager.Login(LoginCallbackReactive);
                HttpManager.MailRequest();
            }
        }
    }
}