using Snxxz.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System;


namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class RuneResolveCell : CellView
    {
        [SerializeField] RuneResolveItem[] m_ResolveItems;

        RuneResolveModel runeResolveModel { get { return ModelCenter.Instance.GetModel<RuneResolveModel>(); } }

        List<int> itemIndexs { get { return runeResolveModel.itemIndexs; } }

        public void Display(int line)
        {
            for (int i = 0; i < m_ResolveItems.Length; i++)
            {
                var index = line * m_ResolveItems.Length + i;
                m_ResolveItems[i].SetActive(index < itemIndexs.Count);
                if (index < itemIndexs.Count)
                {
                    m_ResolveItems[i].Display(line, index);
                }
            }
        }
    }

    [Serializable]
    public class RuneResolveItem
    {
        [SerializeField] Transform m_Container;
        [SerializeField] Image m_Icon;
        [SerializeField] Text m_RuneName;
        [SerializeField] Text m_Property;
        [SerializeField] Transform m_ContainerSelect;
        [SerializeField] Button m_Select;

        RuneModel model { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
        RuneResolveModel runeResolveModel { get { return ModelCenter.Instance.GetModel<RuneResolveModel>(); } }
        VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }

        List<Transform> resolveObjs { get { return runeResolveModel.resolveObjs; } }
        List<int> itemIndexs { get { return runeResolveModel.itemIndexs; } }
        Dictionary<int, bool> resolveSigns { get { return runeResolveModel.resolveSigns; } }

        public void Display(int line, int index)
        {
            if (index < itemIndexs.Count)
            {
                var packIndex = itemIndexs[index];
                RuneItem item;
                if (!virtualPackModel.TryGetItem(PackType.RunePack, packIndex, out item))
                {
                    return;
                }

                m_Select.SetListener(() =>
                {
                    OnSelect(line, index);
                });

                var config = ItemConfig.Get(item.id);

                if (item.itemType == RuneModel.RUNE_TYPE)
                {
                    m_RuneName.text = StringUtility.Contact(config.ItemName, " lv.", item.level);
                    m_Property.text = model.GetRunePropertyDescription(item.id, item.level);
                }
                else if (item.itemType == RuneModel.RUNE_CREAMTYPE)
                {
                    m_RuneName.text = config.ItemName;
                    m_Property.text = Language.Get("L1079", config.EffectValueA1);
                }

                m_RuneName.color = UIHelper.GetUIColor(config.ItemColor, true);
                m_Icon.SetSprite(config.IconKey);

                bool selected = resolveSigns.ContainsKey(index) && resolveSigns[index];
                m_ContainerSelect.gameObject.SetActive(selected);

                if (selected)
                {
                    if (!resolveObjs.Contains(m_Container))
                    {
                        resolveObjs.Add(m_Container);
                    }
                }
                else
                {
                    if (resolveObjs.Contains(m_Container))
                    {
                        resolveObjs.Remove(m_Container);
                    }
                }
            }
        }

        private void OnSelect(int line, int index)
        {
            if (resolveSigns.ContainsKey(index))
            {
                resolveSigns[index] = !resolveSigns[index];
            }
            runeResolveModel.RefreshResolveSelect(line);
        }

        public void SetActive(bool active)
        {
            m_Container.gameObject.SetActive(active);
            if (!active && resolveObjs.Contains(m_Container))
            {
                resolveObjs.Remove(m_Container);
            }
        }
    }
}