using UnityEngine;
using UnityEngine.UI;

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

using Random = UnityEngine.Random;

public class Ability : SkillRoot 
{
    #region Config

    #region 配置

    public float UnlockAheadAmt
    {
        get { return UnlockAheadBaseAmt + (UnlockLv - Manager.GardenLevel - 1)*UnlockAheadDeltaAmt; }
    }

    public override string FullID
    {
        get { return AbilityFullIDPrefix + ID; }
    }

    public static string ElfAnim = "Elf";
    public static string ItemAnim = "Item";

    public float Person;
    public float SkillCD;
    public float CoinPerson;
    public double UpgradeAmt;

    public float Plus;
    public float PersonBuff;
    public float SkillCdBuff;

    public int UnlockLv;
    public float UnlockAmt;
    public float UnlockAheadBaseAmt;
    public float UnlockAheadDeltaAmt;
    public string UnlockPos;

    public Current UnlockCur;
    public Current UpgradeCur;
    public Current UnlockAheadCur;

    public string Label;
    public string Anim;

    public string UpgradeCD;
    public string UpgradeFml;
    public string UpgradePlus;
    public string UpgradePerson;

    #endregion

    public bool ElfFlag = true;

    public string Elf;
    public string Item;

    public float NewPlus;
    public float NewPerson;
    public float NewSkillCD;
    public float NewSkillCdBuff;
    public float NewPersonBuff;
    public float NewCoinPerson;
    public double NewUpgradeAmt;

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

            if (itemStatus == SkillStatus.Lock)
            {
                if (UnlockAheadCur == Current.Free)
                {
                    button.interactable = false;

                    LanguageManager.Add(ButtonTitle, new MulLanStr(LanguageLabel.UI__Fe_BtnLab1), "\n", new MulLanStr(LanguageLabel.UI__Fe_BtnLab4), UnlockLv.ToString());
                }
                else
                {
                    button.interactable = true;

                    LanguageManager.Add(ButtonTitle, new MulLanStr(LanguageLabel.UI__Fe_BtnLab0), "\n", new MulLanStr(LanguageLabel.UI__Fe_BtnLab4), UnlockLv.ToString());
                }
            }
            else if (itemStatus == SkillStatus.UnLock)
            {
                button.interactable = true;

                ButtonTitle.text = Language.GetStr(LanguageLabel.UI__Fe_BtnLab1) + "\n" + Auxiliary.ImageParse(UnlockCur) + Auxiliary.ShrinkBigNumberStr(UnlockAmt);
            }
            else if (itemStatus == SkillStatus.Upgrade)
            {
                button.interactable = true;

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

    private static int BannedSlotIndexForZoomIn = 4;

    #endregion

    public Ability(XmlAttributeCollection attribute)
    {
        #region 配置

        ID = int.Parse(attribute[0].Value);
        icon = attribute[21].Value;
        Anim = attribute[22].Value;
        Label = attribute[23].Value;

        UnlockPos = attribute[13].Value;
        UpgradeCD = attribute[19].Value;
        UpgradeFml = attribute[16].Value;
        UpgradePlus = attribute[17].Value;
        UpgradePerson = attribute[18].Value;

        UnlockLv = Auxiliary.StringToInt(attribute[7].Value,0);
        ItemIndex = Auxiliary.StringToInt(attribute[3].Value,0);

        UnlockAmt = Auxiliary.StringToFloat(attribute[12].Value,0);
        UnlockAheadBaseAmt = Auxiliary.StringToFloat(attribute[10].Value,0);
        UnlockAheadDeltaAmt = Auxiliary.StringToFloat(attribute[9].Value, 0);

        SkillTab = SkillClassParse(attribute[2].Value);
        UpgradeAmt = GetUpgradeAmt(attribute[15].Value);
        
        UnlockCur = Auxiliary.CurrentParse(attribute[11].Value);
        UpgradeCur = Auxiliary.CurrentParse(attribute[14].Value);
        UnlockAheadCur = Auxiliary.CurrentParse(attribute[8].Value);

        ValueBuffParse(out Person, out PersonBuff, attribute[5].Value);
        ValueBuffParse(out SkillCD, out SkillCdBuff, attribute[6].Value);
        ValueBuffParse(out CoinPerson, out Plus, attribute[4].Value);
        
        #endregion

        SkillType = SkillType.Ability;
    }


    public void UnlockTab()
    {
        ResourceManager.Get<Graphic>(CanvasLabel.F_Elf).material = null;
        ResourceManager.Get<Graphic>(CanvasLabel.F_Store).material = null;
        ResourceManager.Get<Graphic>(CanvasLabel.F_Magic).material = null;

        ResourceManager.Get<Graphic>(CanvasLabel.F_ElfLab).material = null;
        ResourceManager.Get<Graphic>(CanvasLabel.F_StoreLab).material = null;
        ResourceManager.Get<Graphic>(CanvasLabel.F_MagicLab).material = null;

        ResourceManager.Get<Button>(CanvasLabel.F_Elf).interactable = true;
        ResourceManager.Get<Button>(CanvasLabel.F_Store).interactable = true;
        ResourceManager.Get<Button>(CanvasLabel.F_Magic).interactable = true;
    }


    public override void Reactive()
    {
        //if (Level > 0)
        //{
        //    AnnulA();
        //    AnnulB();
        //}
    }

    public override void Init(bool firstInit, float elapse, List<List<Skill>> useList, XmlAttributeCollection attribute)
    {
        if (!firstInit)
        {
            return;
        }

        Level = int.Parse(attribute[3].Value);

        itemStatus = (SkillStatus)Enum.Parse(typeof(SkillStatus), attribute[2].Value);


        NewPlus = Plus;
        NewPerson = Person;
        NewSkillCD = SkillCD;
        NewSkillCdBuff = SkillCdBuff;
        NewPersonBuff = PersonBuff;
        NewCoinPerson = CoinPerson;
        NewUpgradeAmt = UpgradeAmt;

        if (FullID == "Ability1")
        {
            Manager.GardenLevel = Level;

            if (Level > 0)
            {
                UnlockTab();
            }
        }

        if (itemStatus == SkillStatus.Lock || itemStatus == SkillStatus.UnLock)
        {
            SkillIcon.material = Lib.GrayMat;
        }
        else
        {
            SkillIcon.material = null;
        }

        if (itemStatus == SkillStatus.Upgrade)
        {
            for (int i = 0; i < Level - 1; i++)
            {
                NewUpgradeAmt = Auxiliary.FmlParse(UpgradeFml, "a", NewUpgradeAmt.ToString("0.00"));
            }

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

            UpgradeValue(ref NewPerson, Person, UpgradePerson, Level - 1);
            UpgradeValue(ref NewSkillCD, SkillCD, UpgradeCD, Level - 1);
            UpgradeValue(ref NewCoinPerson, CoinPerson, UpgradePlus, Level - 1);

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


        ItemStatus = ItemStatus;

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

        DescriptionText.text = GetDescription(0);
    }

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

        ItemStatus = ItemStatus;
    }

    
    protected void GetAward()
    {
        if (ElfFlag)
        {
            ElfFlag = false;

            if (!string.IsNullOrEmpty(Anim))
            {
                if (Anim.Contains(ElfAnim))
                {
                    string[] strings = Anim.Split(',');

                    for (int i = 1; i < strings.Length; i++)
                    {
                        GardenManager.ElfList.Add(strings[i].ToEnum<ElfType>());
                    }

                    Elf = strings[1];
                }
                else if (Anim.Contains(ItemAnim))
                {
                    string[] strings = Anim.Split(',');

                    for (int i = 1; i < strings.Length; i++)
                    {
                        ResourceManager.Get(strings[i]).TweenForSr();
                    }

                    Item = strings[1];
                }
            }
        }

        Manager.Person += NewPerson;
        Manager.CoinPerson += NewCoinPerson;

        Manager.SkillCoinPersonBuff += NewPlus;
        Manager.SkillPersonBuff += NewPersonBuff;

        if (Math.Abs(NewPerson) > 0.001f || Math.Abs(NewPersonBuff) > 0.001f)
        {
            Manager.ExtraPersonSourceSpritesName.UniqueAdd(icon);
        }
        if (Math.Abs(NewPlus) > 0.001f || Math.Abs(NewCoinPerson) > 0.001f)
        {
            Manager.ExtraCoinPersonSourceSpritesName.UniqueAdd(icon);
        }

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

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

    protected void AddAchieve()
    {
        if (!string.IsNullOrEmpty(Elf))
        {
            Manager.AllElfLevel++;
        }
    }

    protected void GetSlot()
    {
        for (int i = 0; i < Auxiliary.StringToInt(UnlockPos, 0); i++)
        {
            GardenManager.UnlockSlot();
        }
    }

    protected void Zoom()
    {
        if (!string.IsNullOrEmpty(Elf))
        {
            if (GardenManager.PlantSlotList.Count <= Garden.CurrentPage * GardenManager.TotalSlotInOnePage)
            {
                return;
            }
            
            GardenManager.CreateElfTimer = Random.Range(GardenManager.MinCreateElfTime, GardenManager.MaxCreateElfTime);

            Slot zoomSlot = GardenManager.PlantSlotList.Random(1, false, false, slot => { return slot.Index >= Garden.CurrentPage* GardenManager.TotalSlotInOnePage; })[0];

            if (zoomSlot.Index% GardenManager.TotalSlotInOnePage == BannedSlotIndexForZoomIn)
            {
                return;
            }

            Flower flower = zoomSlot.PlantFlower;

            flower.GetElf(GardenManager.ElfList.Back(0), 0, 0, 0, 0);


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

            ResourceManager.Get(CanvasLabel.F_Manage).TweenBacGra();

            TweenRoot tween = ResourceManager.Get(CanvasLabel.F_Manage0).GetTweenVec();

            tween.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    ResourceManager.Get(ResourceLabel.MainCamera).Zoom2D(1.5f, 3f, 1, flower.ElfList.Back(0), Curve.EaseOutQuad);
                }
            );
        }
        else if (!string.IsNullOrEmpty(Item))
        {
            TweenRoot tween = ResourceManager.Get(Item).GetTweenSr();

            Vector3 pos = ResourceManager.Get(Item).position;
            pos.z = -2;

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.GetFirework(pos);
                }
            );


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

            ResourceManager.Get(CanvasLabel.F_Manage).TweenBacGra();

            tween = ResourceManager.Get(CanvasLabel.F_Manage0).GetTweenVec();

            tween.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    ResourceManager.Get(ResourceLabel.MainCamera).Zoom2D(3.5f, 3f, 1, ResourceManager.Get(Item), Curve.EaseOutQuad);
                }
            );
        }
    }


    public void Unlock()
    {
        Manager.Pay
        (
            FullID,
            UnlockAmt,
            UnlockCur,
            () =>
            {
                UnlockSucceed();

                Zoom();

                if (FullID == "Ability1")
                {
                    Manager.GardenLevel = 1;

                    UnlockTab();
                }
            },
            StaticsManager.ItemID.解锁技能, 
            StaticsManager.ConsumeModule.Shop
        );
    }

    public void UnlockSucceed()
    {
        AudioManager.PlayClip(AudioLabel.UseSkill);

        SkillIcon.material = null;
        ItemStatus = SkillStatus.Upgrade;

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

        Level = 1;

        GetAward();
        AddAchieve();
        GetSlot();
    }

    public 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.ToString("0")));
            
            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.ShrinkBigNumberStr(NewUpgradeAmt)));

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

                    DescriptionText.text = GetDescription(0);

                    ButtonTitle.text = Language.GetStr(LanguageLabel.UI__Fe_BtnLab2) + "\n" + Auxiliary.ImageParse(UpgradeCur) + Auxiliary.ShrinkBigNumberStr(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.ShrinkBigNumberStr(NewUpgradeAmt)));
                }
            );
        }
    }

    public void Upgrade()
    {
        Manager.Pay
        (
            FullID,
            NewUpgradeAmt,
            UpgradeCur,
            () =>
            {
               UpgradeSucceed();
            },
            StaticsManager.ItemID.升级技能,
            StaticsManager.ConsumeModule.Shop
        );
    }

    public void UpgradeSucceed()
    {
        AudioManager.PlayClip(AudioLabel.UseSkill);

        Level++;

        AnnulEffect();

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

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

        UpgradeValue(ref NewPerson, Person, UpgradePerson, 1);
        UpgradeValue(ref NewSkillCD, SkillCD, UpgradeCD, 1);
        UpgradeValue(ref NewCoinPerson, CoinPerson, UpgradePlus, 1);

        GetAward();
        AddAchieve();

        if (FullID == "Ability1")
        {
            Manager.GardenLevel++;
        }
    }

    public void UnlockAhead()
    {
        Manager.Pay
        (
            FullID,
            UnlockAheadAmt,
            UnlockAheadCur,
            () =>
            {
                UnlockAheadSucceed();
            },
            StaticsManager.ItemID.提前解锁技能,
            StaticsManager.ConsumeModule.Shop
        );
    }

    public void UnlockAheadSucceed()
    {
        AudioManager.PlayClip(AudioLabel.UseSkill);

        if (UnlockCur == Current.Free)
        {
            Unlock();
        }
        else
        {
            ItemStatus = SkillStatus.UnLock;

            UIManager.UpdateManagePanelHint();
        }
    }


    public override void AnnulEffect()
    {
        Manager.Person -= NewPerson;
        Manager.CoinPerson -= NewCoinPerson;

        Manager.SkillCoinPersonBuff -= NewPlus;
        Manager.SkillPersonBuff -= NewPersonBuff;

        Manager.ExtraPersonSourceSpritesName.Remove(icon);
        Manager.ExtraCoinPersonSourceSpritesName.Remove(icon);

        if (Math.Abs(NewSkillCD) > 0.0005f)
        {
            for (int i = 0; i < Manager.SkillList.Count; i++)
            {
                Manager.SkillList[i].Cool(-NewSkillCD, false, false);
            }
        }

        if (Math.Abs(NewSkillCdBuff) > 0.0005f)
        {
            for (int i = 0; i < Manager.SkillList.Count; i++)
            {
                Manager.SkillList[i].Cool(-NewSkillCdBuff, false, true);
            }
        }
    }

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

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

                    UIManager.UpdateManagePanelHint();
                }
            }
        }
    }


    public ExchangeInfo GetUnlockAheadExchangeValue(float rate, StaticsManager.ConsumeModule consumeModule)
    {
        ExchangeInfo info = ExchangeInfo.GetExchangeInfo(UnlockAheadCur, UnlockAheadAmt, rate);
        ExchangeInfo.GetExchangeValue(info, consumeModule);
        return info;
    }


    protected double GetUpgradeAmt(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return UnlockAmt;
        }
        else
        {
            return double.Parse(str);
        }
    }

    protected override string GetDescription(int offset)
    {
        float temp;
        string[] strings = Desc.Split(TransferLabel.OpenChar, TransferLabel.CloseChar);

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < strings.Length; i++)
        {
            if (strings[i].Contains(TransferLabel.Level))
            {

            }
            else if (strings[i].Contains(TransferLabel.Person))
            {
                #region MyRegion

                if (!Person.Equal(0))
                {
                    temp = NewPerson;

                    UpgradeValue(ref temp, Person, UpgradePerson, offset);

                    UpgradeUnit(ref temp, strings[i]);

                    float remainder = temp % 1;

                    if (remainder > 0)
                    {
                        stringBuilder.Append(temp.ToString("0") + "+");
                    }
                    else
                    {
                        stringBuilder.Append(temp.ToString("0"));
                    }
                }
                else if (!PersonBuff.Equal(0))
                {
                    temp = NewPersonBuff;

                    UpgradeValue(ref temp, UpgradePerson, offset);

                    stringBuilder.Append(string.Format("{0:0}%", temp * 100));
                }

                #endregion
            }
            else if (strings[i].Contains(TransferLabel.SkillCD))
            {
                #region MyRegion

                if (!SkillCD.Equal(0))
                {
                    temp = NewSkillCD;

                    UpgradeValue(ref temp, SkillCD, UpgradeCD, offset);

                    UpgradeUnit(ref temp, strings[i]);

                    stringBuilder.Append(temp.ToString("0"));
                }
                else if (!SkillCdBuff.Equal(0))
                {
                    temp = NewSkillCdBuff;

                    UpgradeSkillCdBuff(ref temp, UpgradeCD, offset);
                    
                    stringBuilder.Append(string.Format("{0:0}%", temp * 100));
                }

                #endregion
            }
            else if (strings[i].Contains(TransferLabel.CoinPerson))
            {
                #region MyRegion

                if (!CoinPerson.Equal(0))
                {
                    temp = NewCoinPerson;

                    UpgradeValue(ref temp, CoinPerson, UpgradePlus, offset);

                    UpgradeUnit(ref temp, strings[i]);

                    float remainder = temp % 1;

                    if (remainder > 0)
                    {
                        stringBuilder.Append(temp.ToString("0") + "+");
                    }
                    else
                    {
                        stringBuilder.Append(temp.ToString("0"));
                    }
                }
                else if (!Plus.Equal(0))
                {
                    temp = NewPlus;

                    UpgradeValue(ref temp, UpgradePlus, offset);

                    stringBuilder.Append(string.Format("{0:0}%", temp * 100));
                }

                #endregion
            }
            else
            {
                stringBuilder.Append(strings[i]);
            }
        }

        return stringBuilder.ToString();
    }
}