using UnityEngine;
using UnityEngine.UI;

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

public class BigSkill : Skill
{
    #region Config

    public int BigSkillIndex;
    public Text Text;
    public Image BK0;
    public Image Bk1;
    public Button Button;

    public SkillStatus BarStatus
    {
        get { return barStatus; }
        set
        {
            barStatus = value;

            if (barStatus == SkillStatus.Cool)
            {
                BK0.SetActive(true);
                Bk1.SetActive(false);
            }
            else if (barStatus == SkillStatus.UnLock)
            {
                BK0.SetActive(false);
                Bk1.SetActive(true);
            }
            else if (barStatus == SkillStatus.Buy)
            {
                BK0.SetActive(false);
                Bk1.SetActive(true);
                
                Button.interactable = true;
            }
        }
    }
    public SkillStatus barStatus;

    public override SkillStatus ItemStatus
    {
        get { return itemStatus; }
        set
        {
            itemStatus = value;

            if (SkillTab == SkillTab.Null)
            {
                return;
            }

            if (itemStatus == SkillStatus.Lock)
            {
                LanguageManager.Add(ButtonTitle, new MulLanStr(LanguageLabel.UI__Fe_BtnLab0), "\n", new MulLanStr(LanguageLabel.UI__Fe_BtnLab4), UnlockLv);
            }
            else if (itemStatus == SkillStatus.UnLock)
            {
                LanguageManager.Add(ButtonTitle, new MulLanStr(LanguageLabel.UI__Fe_BtnLab1), "\n", Auxiliary.ImageParse(UnlockCur), UnlockAmt.ToString("0"));
            }
            else if (itemStatus == SkillStatus.Upgrade)
            {
                LanguageManager.Add(ButtonTitle, new MulLanStr(LanguageLabel.UI__Fe_BtnLab2), "\n", Auxiliary.ImageParse(UpgradeCur), Auxiliary.ShrinkNumberStr(NewUpgradeAmt));
            }
        }
    }

    public static int WatchADSkillID = 7;
    public static List<Text> BigSkillTexts = new List<Text>();
    public static List<Image> BigSkillBk0s = new List<Image>();
    public static List<Image> BigSkillBk1s = new List<Image>();

    #endregion

    public BigSkill(XmlAttributeCollection attribute) : base(attribute)
    {
        BigSkillIndex = Auxiliary.StringToInt(attribute[4].Value,0);

        SkillType = SkillType.BigSkill;
    }


    public override void AnnulEffect()
    {
        CoolTimer = CD * CdBuff - 1;

        BarStatus = SkillStatus.Cool;

        Manager.CoolSkillList.Add(this);

        AnnulBuff();
    }

    public override void AnnulBuff()
    {
        Manager.SkillPlus -= NewPlus;
        Manager.SkillPerson -= NewPerson;
        Manager.SkillPersonBuff -= NewPersonBuff;
        Manager.SkillCoinPerson -= NewCoinPerson;
    }


    public override bool DoUpdate()
    {
        UseTimer -= Time.deltaTime;

        TimeSpan timeSpan = new TimeSpan(0, 0, 0, Mathf.CeilToInt(UseTimer));

        if (timeSpan.Hours >= 1)
        {
            Text.text = string.Format("{0} : {1}", timeSpan.Hours.ToString("00"), timeSpan.Minutes.ToString("00"));
        }
        else
        {
            Text.text = string.Format("{0} : {1}", timeSpan.Minutes.ToString("00"), timeSpan.Seconds.ToString("00"));
        }


        if (UseTimer <= 0)
        {
            AnnulEffect();

            return true;
        }
        else
        {
            return false;
        }
    }

    public override bool DoCD()
    {
        CoolTimer -= Time.deltaTime;
        
        TimeSpan timeSpan = new TimeSpan(0, 0, 0, Mathf.CeilToInt(CoolTimer));
        
        if (timeSpan.Hours >= 1)
        {
            Text.text = string.Format("{0} : {1}", timeSpan.Hours.ToString("00"), timeSpan.Minutes.ToString("00"));
        }
        else
        {
            Text.text = string.Format("{0} : {1}", timeSpan.Minutes.ToString("00"), timeSpan.Seconds.ToString("00"));
        }


        BK0.fillAmount = CoolTimer / CD;

        if (CoolTimer <= 0)
        {
            Text.text = "";

            BarStatus = SkillStatus.Buy;

            return true;
        }
        else
        {
            return false;
        }
    }


    public override void Reactive()
    {
        if (BarStatus == SkillStatus.Use)
        {
            AnnulBuff();

            Manager.UsingSkillList.Remove(this);
        }
        else if (BarStatus == SkillStatus.Cool)
        {
            Manager.CoolSkillList.Remove(this);
        }
    }

    public override void Init(bool firstInit, float elapse, List<List<Skill>> useList, XmlAttributeCollection attribute)
    {
        Level = int.Parse(attribute[4].Value);
        UseTimer = float.Parse(attribute[6].Value);
        CoolTimer = float.Parse(attribute[5].Value);
        
        Bk1.material = Lib.GrayMat;

        barStatus = (SkillStatus)Enum.Parse(typeof(SkillStatus), attribute[3].Value);
        itemStatus = (SkillStatus)Enum.Parse(typeof(SkillStatus), attribute[2].Value);
        
        NewPlus = Plus;
        NewPerson = Person;
        NewSkillCD = SkillCD;
        NewDuration = Duration;
        NewCoinOnce = CoinOnce;
        NewSkillCdBuff = SkillCdBuff;
        NewPersonBuff = PersonBuff;
        NewCoinPerson = CoinPerson;
        NewUpgradeAmt = UpgradeAmt;
        NewCoinOnceBuff = CoinOnceBuff;

        Bk1.sprite = Icon;

        Button.onClick.RemoveAllListeners();
        Button.onClick.AddListener(Buy);

        if (SkillTab != SkillTab.Null)
        {
            for (int i = 0; i < Level - 1; i++)
            {
                NewUpgradeAmt = Auxiliary.FmlParse(UpgradeFml, "a", NewUpgradeAmt.ToString());
            }
            
            if (barStatus != SkillStatus.Lock && barStatus != SkillStatus.UnLock)
            {
                SkillIcon.material = null;

                UpgradeValue(ref NewPlus, UpgradePlus, Level - 1);
                UpgradeValue(ref NewPersonBuff, UpgradePerson, Level - 1);
                UpgradeValue(ref NewCoinOnceBuff, UpgradeCoinOnce, Level - 1);
                UpgradeSkillCdBuff(ref NewSkillCdBuff, UpgradeCD, Level - 1);

                UpgradeValue(ref NewPerson, Person, UpgradePerson, Level - 1);
                UpgradeValue(ref NewSkillCD, SkillCD, UpgradeCD, Level - 1);
                UpgradeValue(ref NewDuration, Duration, UpgradeDuration, Level - 1);
                UpgradeValue(ref NewCoinOnce, CoinOnce, UpgradeCoinOnce, Level - 1);
                UpgradeValue(ref NewCoinPerson, CoinPerson, UpgradePlus, Level - 1);
            }
            else
            {
                SkillIcon.material = Lib.GrayMat;
            }

            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(OnClick);

            DescriptionText.text = GetDescription(0);
        }

        if (barStatus == SkillStatus.Use)
        {
            GetBuff();

            if (UseTimer < elapse)
            {
                Manager.UsingSkillList.Remove(this);

                if (useList.Count > 0)
                {
                    if (UseTimer < Manager.IncomeCircleTimer)
                    {
                        useList[0].UniqueAdd(this);
                    }
                    else
                    {
                        int circle = 1 + Mathf.FloorToInt((UseTimer - Manager.IncomeCircleTimer) / Manager.IncomeCircleTime);

                        useList[circle].UniqueAdd(this);
                    }
                }
            }
            else
            {
                UseTimer -= elapse;

                Bk1.SetActive(true);
            }
        }
        else if (barStatus == SkillStatus.Cool)
        {
            CoolTimer -= elapse;

            Manager.CoolSkillList.Add(this);
        }

        if (barStatus != SkillStatus.UnLock)
        {
            Bk1.material = null;
        }

        if (itemStatus == SkillStatus.UnLock)
        {
            UIManager.UpdateManagePanelHint();
        }

        BarStatus = BarStatus;
        ItemStatus = ItemStatus;
    }

    public override void Cool(float amt, bool current, bool buff)
    {
        if (!CoolLock)
        {
            return;
        }
        
        if (current)
        {
            if (BarStatus != SkillStatus.Cool)
            {
                return;
            }

            if (buff)
            {
                CoolTimer -= CD * amt;
            }
            else
            {
                CoolTimer -= amt;
            }
        }
        else
        {
            if (buff)
            {
                CdBuff = 1 - amt;
            }
            else
            {
                CD -= amt;
            }
        }
    }

    public override void UpdateStatus()
    {
        if (!Manager.Inited)
        {
            return;
        }

        if (Manager.GardenLevel >= UnlockLv)
        {
            if (SkillTab == SkillTab.Null)
            {
                if (BarStatus == SkillStatus.UnLock)
                {
                    Unlock();
                }
            }
            else
            {
                if (ItemStatus == SkillStatus.Lock)
                {
                    if (UnlockCur == Current.Free)
                    {
                        Unlock();
                    }
                    else
                    {
                        ItemStatus = SkillStatus.UnLock;

                        UIManager.UpdateManagePanelHint();
                    }
                }
            }
        }
    }

    public override void RegistReference()
    {
        base.RegistReference();

        if (BigSkillBk0s.Count == 0)
        {
            BigSkillTexts.Add(ResourceManager.Get<Text>(CanvasLabel.F_SkillLab1));
            BigSkillTexts.Add(ResourceManager.Get<Text>(CanvasLabel.F_SkillLab2));
            BigSkillTexts.Add(ResourceManager.Get<Text>(CanvasLabel.F_SkillLab3));
            BigSkillTexts.Add(ResourceManager.Get<Text>(CanvasLabel.F_SkillLab4));

            BigSkillBk0s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk10));
            BigSkillBk0s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk20));
            BigSkillBk0s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk30));
            BigSkillBk0s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk40));

            BigSkillBk1s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk11));
            BigSkillBk1s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk21));
            BigSkillBk1s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk31));
            BigSkillBk1s.Add(ResourceManager.Get<Image>(CanvasLabel.F_SkillBk41));
        }

        Text = BigSkillTexts[BigSkillIndex-1];
        BK0 = BigSkillBk0s[BigSkillIndex-1];
        Bk1 = BigSkillBk1s[BigSkillIndex-1];
        Button = Bk1.GetComponent<Button>();
    }


    protected void Unlock()
    {
        Manager.Pay
        (
            FullID,
            UnlockAmt,
            UnlockCur,
            () =>
            {
                AudioManager.PlayClip(AudioLabel.UseSkill);

                BarStatus = SkillStatus.Buy;
                ItemStatus = SkillStatus.Upgrade;

                if (SkillTab != SkillTab.Null)
                {
                    SkillIcon.material = null;
                }

                if (UnlockCur != Current.Free)
                {
                    UIManager.UpdateManagePanelHint();
                }

                Level = 1;

                Bk1.material = null;
            },
            StaticsManager.ItemID.解锁技能,
            StaticsManager.ConsumeModule.Shop
        );
    }

    protected void Upgrade()
    {
        Manager.Pay
        (
            FullID,
            NewUpgradeAmt,
            UpgradeCur,
            () =>
            {
                AudioManager.PlayClip(AudioLabel.UseSkill);

                Level++;

                if (BarStatus == SkillStatus.Use)
                {
                    AnnulBuff();
                    Manager.UsingSkillList.Remove(this);
                }

                NewUpgradeAmt = Auxiliary.FmlParse(UpgradeFml, "a", NewUpgradeAmt.ToString("0.00"));

                UpgradeValue(ref NewPlus, UpgradePlus, 1);
                UpgradeValue(ref NewPersonBuff, UpgradePerson, 1);
                UpgradeValue(ref NewCoinOnceBuff, UpgradeCoinOnce, 1);
                UpgradeSkillCdBuff(ref NewSkillCdBuff, UpgradeCD, 1);

                UpgradeValue(ref NewPerson, Person, UpgradePerson, 1);
                UpgradeValue(ref NewSkillCD, SkillCD, UpgradeCD, 1);
                UpgradeValue(ref NewDuration, Duration, UpgradeDuration, 1);
                UpgradeValue(ref NewCoinOnce, CoinOnce, UpgradeCoinOnce, 1);
                UpgradeValue(ref NewCoinPerson, CoinPerson, UpgradePlus, 1);

                if (BarStatus == SkillStatus.Use)
                {
                    GetBuff();
                }
            },
            StaticsManager.ItemID.升级技能,
            StaticsManager.ConsumeModule.Shop
        );
    }


    protected override void Buy()
    {
        if (ID == WatchADSkillID)
        {
            StaticsManager.GetInstance().AdClicked(0);
        }

        if (!HttpManager.IsConnect)
        {
            ResourceManager.Get(CanvasLabel.Fg_Reconnect).TweenForCG();

            return;
        }

        Manager.Pay
        (
            FullID,
            UseAmt,
            BuyCur,
            () =>
            {
                AudioManager.PlayClip(AudioLabel.UseSkill);

                ResourceManager.GetLightwall();

                Manager.UseSkillAmt++;

                UseTimer = NewDuration - 1;

                GetBuff();
                GetAward();

                InfoBoxManager.GardenInfoBox.Display(string.Format("{0}{1}", Language.GetStr(LanguageLabel.UI__J_Info1), Language.GetStr(LanguageLabel.CombineLanguageLabel(LanguageLabel.SkillName, FullID))), 10f, Color.white, ResourceManager.LoadSprite(ResourceLabel.Atlas, Folder.Atlas));
            },
            StaticsManager.ItemID.使用技能,
            StaticsManager.ConsumeModule.Shop
        );
    }

    protected override void GetBuff()
    {
        Button.interactable = false;

        if (UseTimer.Equal(-1))
        {
            AnnulEffect();
        }
        else
        {
            BarStatus = SkillStatus.Use;

            Manager.UsingSkillList.Add(this);
        }

        Manager.SkillPlus += NewPlus;
        Manager.SkillPerson += NewPerson;
        Manager.SkillPersonBuff += NewPersonBuff;
        Manager.SkillCoinPerson += NewCoinPerson;

        if (!NewSkillCD.Equal(0))
        {
            for (int i = 0; i < Manager.SkillList.Count; i++)
            {
                Manager.SkillList[i].Cool(NewSkillCD, true, false);
            }
        }

        if (!NewSkillCdBuff.Equal(0))
        {
            for (int i = 0; i < Manager.SkillList.Count; i++)
            {
                Manager.SkillList[i].Cool(NewSkillCdBuff, true, true);
            }
        }
    }

    protected override void OnClick()
    {
        AudioManager.PlayClip(AudioLabel.ClickButton);

        ResourceManager.Get(CanvasLabel.Fe_Info).TweenForCG();

        ResourceManager.SetText(CanvasLabel.Fe_Tit, Name);

        ResourceManager.SetSprite(CanvasLabel.Fe_Icon, Icon);

        if (ItemStatus == SkillStatus.Lock)
        {
            ResourceManager.SetText(CanvasLabel.Fe_Lab0, "");
            ResourceManager.SetText(CanvasLabel.Fe_Lab1, GetDescription(0));

            ResourceManager.SetText(CanvasLabel.Fe_BtnLab, string.Format("{0}({1}{2:0})", Language.GetStr(LanguageLabel.UI__Fe_BtnLab0), Auxiliary.ImageParse(UnlockAheadCur), UnlockAheadAmt.ToString("0")));

            ResourceManager.SetButtonEvent
            (
                CanvasLabel.Fe_Btn,
                () =>
                {
                    UnlockAhead();

                    ResourceManager.Get(CanvasLabel.Fe_Info).TweenBacCG();
                }
            );
        }
        else if (ItemStatus == SkillStatus.UnLock)
        {
            ResourceManager.SetText(CanvasLabel.Fe_Lab0, "");
            ResourceManager.SetText(CanvasLabel.Fe_Lab1, GetDescription(0));

            ResourceManager.SetText(CanvasLabel.Fe_BtnLab, string.Format("{0}({1}{2:0})", Language.GetStr(LanguageLabel.UI__Fe_BtnLab1), Auxiliary.ImageParse(UnlockCur), UnlockAmt));

            ResourceManager.SetButtonEvent
            (
                CanvasLabel.Fe_Btn,
                () =>
                {
                    Unlock();

                    ResourceManager.Get(CanvasLabel.Fe_Info).TweenBacCG();
                }
            );
        }
        else if (ItemStatus == SkillStatus.Upgrade)
        {
            ResourceManager.SetText(CanvasLabel.Fe_Lab0, GetDescription(0));
            ResourceManager.SetText(CanvasLabel.Fe_Lab1, GetDescription(1));

            ResourceManager.SetText(CanvasLabel.Fe_BtnLab, string.Format("{0}({1}{2:0})", Language.GetStr(LanguageLabel.UI__Fe_BtnLab2), Auxiliary.ImageParse(UpgradeCur), Auxiliary.ShrinkNumberStr(NewUpgradeAmt)));
            
            ResourceManager.SetButtonEvent
            (
                CanvasLabel.Fe_Btn,
                () =>
                {
                    Upgrade();

                    DescriptionText.text = GetDescription(0);

                    ButtonTitle.text = Language.GetStr(LanguageLabel.UI__Fe_BtnLab2) + "\n" + Auxiliary.ImageParse(UpgradeCur) + Auxiliary.ShrinkNumberStr(NewUpgradeAmt);

                    ResourceManager.SetText(CanvasLabel.Fe_Tit, Name);
                    ResourceManager.SetText(CanvasLabel.Fe_Lab0, GetDescription(0));
                    ResourceManager.SetText(CanvasLabel.Fe_Lab1, GetDescription(1));

                    ResourceManager.SetText(CanvasLabel.Fe_BtnLab, string.Format("{0}({1}{2:0})", Language.GetStr(LanguageLabel.UI__Fe_BtnLab2), Auxiliary.ImageParse(UpgradeCur), Auxiliary.ShrinkNumberStr(NewUpgradeAmt)));
                }
            );
        }
    }

    protected override void UnlockAhead()
    {
        Manager.Pay
        (
            FullID,
            UnlockAheadAmt,
            UnlockAheadCur,
            () =>
            {
                if (UnlockCur == Current.Free)
                {
                    Unlock();
                }
                else
                {
                    AudioManager.PlayClip(AudioLabel.UseSkill);

                    ItemStatus = SkillStatus.UnLock;
                }
            },
            StaticsManager.ItemID.提前解锁技能,
            StaticsManager.ConsumeModule.Shop
        );
    }
}