using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class GatherSoulItemBehaviour : MonoBehaviour
    {
        [SerializeField] RectTransform m_ContainerItem;
        [SerializeField] Image m_Icon;
        [SerializeField] RectTransform m_ContainerLevel;
        [SerializeField] Text m_Level;
        [SerializeField] Text m_ItemName;
        [SerializeField] Text m_Count;
        [SerializeField] Button m_Func;
        [SerializeField] RectTransform m_Select;
        [SerializeField] UIEffect m_Effect;

        VirtualPackModel model
        {
            get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); }
        }

        GatherSoulComposeModel composeModel
        {
            get { return ModelCenter.Instance.GetModel<GatherSoulComposeModel>(); }
        }

        GatheringSoulModel soulModel
        {
            get { return ModelCenter.Instance.GetModel<GatheringSoulModel>(); }
        }

        VirtualItem displayItem;

        bool requireResolveEffect = false;

        public static event Action<Transform> alreadyResolveEvent;

        private void Awake()
        {
            if (m_Func != null)
            {
                m_Func.onClick.AddListener(OnFunc);
            }
        }

        private void OnEnable()
        {
            soulModel.prepareResolveEvent += PrepareResolveEvent;
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += BeforePlayerDataInitializeEvent;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += MakeItemAnswerEvent;
            RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
        }

        private void OnDisable()
        {
            soulModel.prepareResolveEvent -= PrepareResolveEvent;
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= BeforePlayerDataInitializeEvent;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= MakeItemAnswerEvent;
            RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
            requireResolveEffect = false;
        }

        private void RedpointValueChangeEvent(int id)
        {
            if(id== soulModel.equipRedpoint.id
                || id == soulModel.replaceRedpoint.id)
            {
                DisplayEffect();
            }
        }

        /// <summary>
        /// 背包位置索引
        /// </summary>
        /// <param name="packType"></param>
        /// <param name="index"></param>
        public void Display(int index)
        {
            displayItem = default(VirtualItem);
            GatherSoulItem item;
            bool exist = model.TryGetItem(PackType.GatherSoul, index, out item) && index != -1;
            m_ContainerItem.gameObject.SetActive(exist);
            if (exist)
            {
                displayItem = new VirtualItem()
                {
                    packType = PackType.GatherSoul,
                    index = index,
                    itemId = item.id,
                    level = item.level,
                };
                Display();
            }
        }

        public void Display(int id, int level)
        {
            if (id == 0)
            {
                m_ContainerItem.gameObject.SetActive(false);
                return;
            }
            displayItem = new VirtualItem()
            {
                packType = (PackType)0,
                itemId = id,
                level = level,
            };
            m_ContainerItem.gameObject.SetActive(true);
            Display();
        }

        void Display()
        {
            var config = ItemConfig.Get(displayItem.itemId);
            if (config != null)
            {
                m_Icon.SetSprite(config.IconKey);
                if (m_ContainerLevel != null)
                {
                    m_ContainerLevel.gameObject.SetActive(config.Type != GatheringSoulModel.GATHERSOUL_ESSENCE_TYPE);
                }
                if (m_Level != null)
                {
                    m_Level.text = displayItem.level.ToString();
                }
                if (m_ItemName != null)
                {
                    m_ItemName.text = config.ItemName;
                    m_ItemName.color = UIHelper.GetUIColor(config.ItemColor);
                }
            }
            DisplayEffect();
        }

        public void DisplayCount(int count, int requireCount = 0)
        {
            if (m_Count != null)
            {
                if (requireCount == 0)
                {
                    m_Count.text = count.ToString();
                    m_Count.color = UIHelper.GetUIColor(TextColType.LightYellow);
                }
                else
                {
                    m_Count.text = StringUtility.Contact(
                        UIHelper.AppendStringColor(count >= requireCount ? TextColType.LightYellow : TextColType.Red, count.ToString())
                        , "/", requireCount.ToString());
                }
            }
        }

        void DisplayEffect()
        {
            if (m_Select != null)
            {
                var requireSelect = displayItem.packType == PackType.GatherSoul
                    && soulModel.topBestSoulIndexs.Contains(displayItem.index);
                m_Select.gameObject.SetActive(requireSelect);
                if (requireSelect)
                {
                    if (m_Effect.target != null)
                    {
                        var animator = m_Effect.target.GetAnimator();
                        if (animator != null)
                        {
                            animator.Play(0, 0, GatherSoulWin.sync_topsoul_normalized);
                        }
                    }
                }
            }
        }

        private void PrepareResolveEvent(PackType packType, int index)
        {
            if (displayItem.packType == packType && displayItem.index == index)
            {
                requireResolveEffect = true;
            }
        }

        private void BeforePlayerDataInitializeEvent()
        {
            requireResolveEffect = false;
        }

        private void MakeItemAnswerEvent(H0721_tagMakeItemAnswer package)
        {
            if (package.MakeType == (int)MakeType.Def_mitGatherSoulDecompose)
            {
                if (requireResolveEffect)
                {
                    if (alreadyResolveEvent != null)
                    {
                        alreadyResolveEvent(transform);
                    }
                    requireResolveEffect = false;
                }
            }
        }

        void OnFunc()
        {
            var itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>();
            if (displayItem.packType == PackType.GatherSoul)
            {
                GatherSoulItem item;
                if (model.TryGetItem(displayItem.packType, displayItem.index, out item))
                {
                    var data = new ItemAttrData(item.id);
                    data.SetGatherSoul(item.level, -1, PackType.GatherSoul, displayItem.index);
                    if (item.itemType != GatheringSoulModel.GATHERSOUL_ESSENCE_TYPE)
                    {
                        GatherSoulComposeModel.Compose compose;
                        if (composeModel.TryGetCompose(item.id, out compose)
                            && compose.requireItems.Count > 0)
                        {
                            data.SetTipsFuncBtn(ItemOperateType.dismantle, OnTipFunc);
                        }
                        else
                        {
                            data.SetTipsFuncBtn(ItemOperateType.Resolve, OnTipFunc);
                        }
                        GatherSoulComposeModel.Compose outCompose;
                        bool requireCompose = composeModel.ExistInComposeMat(item.id, out outCompose);
                        if (requireCompose)
                        {
                            data.SetTipsFuncBtn(ItemOperateType.compose, OnTipFunc);
                        }
                        bool existSamePropertyHole = soulModel.IsSamePropertyCompareHoles(-1, item as GatherSoulItem) != -1;
                        bool existCoreHoleItem = false;
                        GatherSoulItem holeItem;
                        if (soulModel.TryGetItem(soulModel.coreHole, out holeItem))
                        {
                            existCoreHoleItem = true;
                        }
                        if (item.itemType == GatheringSoulModel.GATHERSOUL_CORE_TYPE)
                        {
                            data.SetTipsFuncBtn(existCoreHoleItem ? ItemOperateType.Replace : ItemOperateType.Wear, OnTipFunc);
                        }
                        else
                        {
                            data.SetTipsFuncBtn(existSamePropertyHole ? ItemOperateType.Replace : ItemOperateType.Wear, OnTipFunc);
                        }
                    }
                    else
                    {
                        data.SetTipsFuncBtn(ItemOperateType.Resolve, OnTipFunc);
                    }
                    itemTipsModel.SetItemTipsModel(data);
                }
            }
            else
            {
                if (displayItem.itemId != 0)
                {
                    var data = new ItemAttrData(displayItem.itemId);
                    data.SetGatherSoul(displayItem.level, -1);
                    itemTipsModel.SetItemTipsModel(data);
                }
            }
        }

        private void OnTipFunc(ItemOperateType type, string arg2)
        {
            if (displayItem.Equals(default(VirtualItem)))
            {
                WindowCenter.Instance.Close<GatherSoulTipWin>();
                return;
            }
            GatherSoulItem item;
            if (!model.TryGetItem(displayItem.packType, displayItem.index, out item))
            {
                WindowCenter.Instance.Close<GatherSoulTipWin>();
                return;
            }
            soulModel.HandleSoulTipFunc(type, item);
        }
    }
}