using System.Collections.Generic;
using UnityEngine;
using Ability;
using TMPro;
using UnityEngine.UI;

public class AddInGameAbilityDialog : BaseDialog
{
    [SerializeField] TextMeshProUGUI m_headerText;
    [SerializeField] TextMeshProUGUI m_labelChoose;
    [SerializeField] TextMeshProUGUI m_labelLearned;

    [SerializeField] GameObject m_learnedAbilityHeader;

    List<InGameAbType> m_inGameAbTypes = new List<InGameAbType>();
    List<InGameAbType> m_generatedAb = new List<InGameAbType>();
    List<GameObject> m_learnedAbContainer = new List<GameObject>();

    GameObject m_learnedAbObj;

    //-----------------------------------------------------------------------------------------
    void Start ()
    {
        SoundsManager.Instance.PlaySound("level_up");
        m_type = DialogType.ADD_IN_GAME_ABILITY_DIALOG;
    }

    //-----------------------------------------------------------------------------------------
    public void Init()
    {
        Transform learnedAbTrans = transform.Find("learned_abilities");
        if (learnedAbTrans)
            m_learnedAbObj = learnedAbTrans.gameObject;
        else
            CommonFunctions.myassert(false);

        GenerateInGameAb();
        InitAbIcons();
        InitTexts();
        InitLearnedAbilities();
    }

    //-----------------------------------------------------------------------------------------
    void InitLearnedAbilities()
    {
        MainCharacter mainChar = GameBoard.Instance.MainCharacter;
        int idx = 0;

        if (mainChar.InGameAb.Count == 0)
            m_learnedAbilityHeader.SetActive(false);

        foreach (InGameAbType type in mainChar.InGameAb.Keys)
        {
            AddIconToLearnedAbField(type, idx);
            idx++;
            if (idx > 4)
                idx = 0;
        }
    }

    //-----------------------------------------------------------------------------------------
    string GetAbNameByType(InGameAbType type)
    {
        string abName = "";
        if (type == InGameAbType.ADD_ATTACK_SPEED)
            abName = "attackspeed";
        else if (type == InGameAbType.ADD_BULLET_45)
            abName = "bullet45";
        else if (type == InGameAbType.ADD_BULLET_AFTER)
            abName = "bulletafter";
        else if (type == InGameAbType.ADD_BULLET_PARALLEL)
            abName = "bulletparallel";
        else if (type == InGameAbType.ADD_BULLET_RICOCHET)
            abName = "bulletricocket";
        else if (type == InGameAbType.ADD_DAMAGE)
            abName = "damage";
        else if (type == InGameAbType.ADD_DROP_GOLD)
            abName = "dropgold";
        else if (type == InGameAbType.ADD_HEADSHOT)
            abName = "headshot";
        else if (type == InGameAbType.ADD_HEALTH)
            abName = "health";
        else if (type == InGameAbType.ADD_XP)
            abName = "exp";
        else if (type == InGameAbType.ADD_MINOR_DAMAGE)
            abName = "minordamage";
        else if (type == InGameAbType.ADD_MINOR_SPEED)
            abName = "minorattackspeed";

        return abName;
    }

    //-----------------------------------------------------------------------------------------
    void AddIconToLearnedAbField(InGameAbType type, int idx)
    {
        string prefabName = "Prefabs/UI/InGameAbIcons/" + GetAbNameByType(type);
        GameObject iconObj = Instantiate(Resources.Load(prefabName) as GameObject);
        iconObj.transform.SetParent(m_learnedAbObj.transform);
        iconObj.transform.localScale = Vector3.one;
        iconObj.GetComponent<InGameAbilityIcon>().DisableAbName();
        iconObj.GetComponent<Button>().interactable = false;
        CommonFunctions.SetDisableButtonColor(iconObj.GetComponent<Button>());

        int yStep = m_learnedAbContainer.Count / 4;

        iconObj.transform.localPosition = new Vector3(-360 + 240 * idx, -240 * yStep, 0);
        m_learnedAbContainer.Add(iconObj);
    }

    //-----------------------------------------------------------------------------------------
    void InitTexts()
    {
        if (m_headerText)
            m_headerText.text = GlobalsVar.gGameTextMng.GetGameText(6).ToUpper();

        if (m_labelChoose)
            m_labelChoose.text = GlobalsVar.gGameTextMng.GetGameText(7).ToUpper();

        if (m_labelLearned)
            m_labelLearned.text = GlobalsVar.gGameTextMng.GetGameText(8).ToUpper();
    }

    //-----------------------------------------------------------------------------------------
    void GenerateInGameAb()
    {
        MainCharacter character = GameBoard.Instance.MainCharacter;
        if (!character.InGameAb.ContainsKey(InGameAbType.ADD_BULLET_45))
            m_inGameAbTypes.Add(InGameAbType.ADD_BULLET_45);
        if (!character.InGameAb.ContainsKey(InGameAbType.ADD_BULLET_AFTER))
            m_inGameAbTypes.Add(InGameAbType.ADD_BULLET_AFTER);
        if (!character.InGameAb.ContainsKey(InGameAbType.ADD_BULLET_PARALLEL))
            m_inGameAbTypes.Add(InGameAbType.ADD_BULLET_PARALLEL);
        if (!character.InGameAb.ContainsKey(InGameAbType.ADD_BULLET_RICOCHET))
            m_inGameAbTypes.Add(InGameAbType.ADD_BULLET_RICOCHET);
        if (!character.InGameAb.ContainsKey(InGameAbType.ADD_HEADSHOT))
            m_inGameAbTypes.Add(InGameAbType.ADD_HEADSHOT);

        if (character.NeedRollAb(InGameAbType.ADD_ATTACK_SPEED))
            m_inGameAbTypes.Add(InGameAbType.ADD_ATTACK_SPEED);
        if (character.NeedRollAb(InGameAbType.ADD_DAMAGE))
            m_inGameAbTypes.Add(InGameAbType.ADD_DAMAGE);
        if (character.NeedRollAb(InGameAbType.ADD_DROP_GOLD))
            m_inGameAbTypes.Add(InGameAbType.ADD_DROP_GOLD);        
        if (character.NeedRollAb(InGameAbType.ADD_HEALTH))
            m_inGameAbTypes.Add(InGameAbType.ADD_HEALTH);
        if (character.NeedRollAb(InGameAbType.ADD_XP))
            m_inGameAbTypes.Add(InGameAbType.ADD_XP);

        for (int i = 0; i < 3; ++i)
        {
            InGameAbType type = GetRandomAbType();
            m_generatedAb.Add(type);
        }
    }

    //-----------------------------------------------------------------------------------------
    InGameAbType GetRandomAbType()
    {
        RandomProb rand = new RandomProb();
        for (int i = 0; i < m_inGameAbTypes.Count; ++i)
        {
            InGameAbInfo info = GlobalsVar.gInGameAbilities.GetAbilityInfoByType(m_inGameAbTypes[i]);
            rand.AddValue(m_inGameAbTypes[i].ToString(), info.m_weight);
        }

        string randValStr = rand.GetRandomValue();
        InGameAbType randType = GlobalsVar.gInGameAbilities.GetAbilityTypeByName(randValStr);
        m_inGameAbTypes.Remove(randType);
        return randType;
    }

    //-----------------------------------------------------------------------------------------
    void InitAbIcons()
    {
        Transform icons = transform.Find("icons");
        if (icons)
        {
            int idx = 1;
            foreach (Transform child in icons)
            {
                InGameAbilityIcon inGameAbIcon = child.GetComponent<InGameAbilityIcon>();
                if (m_generatedAb.Contains(inGameAbIcon.Type))
                {
                    AddIcon(child.gameObject, idx);
                    idx++;
                }

                child.gameObject.SetActive(false);
            }
        }
    }

    //-----------------------------------------------------------------------------------------
    void AddIcon(GameObject iconObj, int idx)
    {
        Transform generatedIconTrans = transform.Find("generated_icons");
        if (generatedIconTrans)
        {
            GameObject icon = Instantiate(iconObj);
            icon.name = iconObj.name;
            icon.transform.SetParent(generatedIconTrans);
            icon.transform.localPosition = GetIconPosByIdx(idx);
            icon.transform.localScale = Vector3.one;
        }
        else
            CommonFunctions.myassert(false);
    }

    //-----------------------------------------------------------------------------------------
    Vector3 GetIconPosByIdx(int idx)
    {
        if (idx == 1)
            return new Vector3(-250, 0, 0);
        else if (idx == 2)
            return new Vector3(0, 0, 0);
        else if (idx == 3)
            return new Vector3(250, 0, 0);

        CommonFunctions.myassert(false);
        return Vector3.zero;
    }

    //-----------------------------------------------------------------------------------------
    public override void Update ()
    {
        base.Update();	
	}
}