//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, December 13, 2018
//--------------------------------------------------------

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

namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class GatherSoulComposeWin : Window
    {
        [SerializeField] ScrollerController m_ScrollerControl;
        [SerializeField] GatherSoulItemBehaviour m_ComposeItem;
        [SerializeField] PropertyBehaviour[] m_ComposeItemPropertys;
        [SerializeField] Text m_SuccessRate;
        [SerializeField] Button m_Compose;

        [SerializeField] GatherSoulComposeBehaviour[] m_ComposeBehaviours;
        [SerializeField] Text m_RequireLevel;

        [SerializeField] RectTransform m_ContainerUnCompose;
        [SerializeField] RectTransform m_ContainerCompose;

        [SerializeField] UIEffect m_OneMatEffect;
        [SerializeField] UIEffect m_TwoMatEffect;

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

        GatheringSoulModel soulModel
        {
            get { return ModelCenter.Instance.GetModel<GatheringSoulModel>(); }
        }
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Compose.onClick.AddListener(Compose);
            m_ScrollerControl.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            model.selectCategory = default(GatherSoulComposeModel.ComposeCategory);
            model.selectItemId = 0;

            HandleJumpSelect();

            Display();
            model.onSelectComposeItemChange += OnSelectComposeItemChange;
            model.onSelectCategoryChange += OnSelectCategoryChange;
            soulModel.gatherSoulPackRefresh += GatherSoulPackRefresh;
            soulModel.gatherSoulHolesRefresh += GatherSoulHolesRefresh;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += MakeItemAnswerEvent;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.jumpGatherSoulItem = default(VirtualItem);
            model.onSelectComposeItemChange -= OnSelectComposeItemChange;
            model.onSelectCategoryChange -= OnSelectCategoryChange;
            soulModel.gatherSoulPackRefresh -= GatherSoulPackRefresh;
            soulModel.gatherSoulHolesRefresh -= GatherSoulHolesRefresh;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= MakeItemAnswerEvent;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerDataRefreshInfoEvent;
        }

        protected override void OnAfterClose()
        {
        }
        #endregion
        void HandleJumpSelect()
        {
            if (!model.jumpGatherSoulItem.Equals(default(VirtualItem)))
            {
                var itemId = model.jumpGatherSoulItem.itemId;
                GatherSoulComposeModel.Compose compose;
                if (model.ExistInComposeMat(itemId, out compose))
                {
                    foreach (var category in model.categoryDict.Keys)
                    {
                        if (model.categoryDict[category].Contains(compose.itemId))
                        {
                            model.selectCategory = category;
                            model.selectItemId = compose.itemId;
                            break;
                        }
                    }
                }
            }
        }

        private void GatherSoulHolesRefresh()
        {
            if (!model.jumpGatherSoulItem.Equals(default(VirtualItem))
                && !soulModel.CheckExist(model.jumpGatherSoulItem))
            {
                model.jumpGatherSoulItem = default(VirtualItem);
            }
            DisplayCompose();
        }

        private void GatherSoulPackRefresh()
        {
            if (!model.jumpGatherSoulItem.Equals(default(VirtualItem))
                && !soulModel.CheckExist(model.jumpGatherSoulItem))
            {
                model.jumpGatherSoulItem = default(VirtualItem);
            }
            DisplayCompose();
        }

        private void OnSelectComposeItemChange()
        {
            model.jumpGatherSoulItem = default(VirtualItem);
            m_ScrollerControl.m_Scorller.RefreshActiveCellViews();
            DisplayCompose();
            DisplayRequireLevel();
        }

        private void OnSelectCategoryChange()
        {
            model.jumpGatherSoulItem = default(VirtualItem);
            DisplaySelect();
            if (model.selectCategory.Equals(default(GatherSoulComposeModel.ComposeCategory)))
            {
                model.selectItemId = 0;
            }
            else
            {
                var list = model.categoryDict[model.selectCategory];
                if (list == null || !list.Contains(model.selectItemId))
                {
                    model.selectItemId = 0;
                }
            }
            DisplayCompose();
            DisplayRequireLevel();
        }

        private void MakeItemAnswerEvent(H0721_tagMakeItemAnswer package)
        {
            if (package.MakeType == (byte)MakeType.Def_mitGatherSoulCompound)
            {
                if (model.selectItemId != 0)
                {
                    GatherSoulComposeModel.Compose compose;
                    if (model.TryGetCompose(model.selectItemId, out compose))
                    {
                        if (compose.requireSoulCore > 0 && compose.requireSoulSplinters > 0)
                        {
                            m_TwoMatEffect.Play();
                        }
                        else
                        {
                            m_OneMatEffect.Play();
                        }
                    }
                }
            }
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
        {
            if (refreshType == PlayerDataRefresh.LV)
            {
                DisplayRequireLevel();
            }
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            if (type == ScrollerDataType.Header)
            {
                var categoryCell = cell as GatherSoulComposeCategoryCell;
                categoryCell.Display(model.composeCategories[cell.index]);
            }
            else if (type == ScrollerDataType.Normal)
            {
                var selectCell = cell as GatherSoulComposeSelectCell;
                selectCell.Display(cell.index);
            }
        }

        void Display()
        {
            DisplaySelect();
            DisplayCompose();
            DisplayRequireLevel();
        }

        void DisplaySelect()
        {
            var jumpIndex = 0;
            m_ScrollerControl.Refresh();
            for (int i = 0; i < model.composeCategories.Count; i++)
            {
                var category = model.composeCategories[i];
                var list = model.categoryDict[category];
                m_ScrollerControl.AddCell(ScrollerDataType.Header, i);
                if (model.selectCategory.Equals(category))
                {
                    jumpIndex = i;
                    for (int k = 0; k < list.Count; k++)
                    {
                        m_ScrollerControl.AddCell(ScrollerDataType.Normal, list[k]);
                        if (model.selectItemId != 0 && model.selectItemId == list[k])
                        {
                            jumpIndex += k+1;
                        }
                    }
                }
            }
            m_ScrollerControl.Restart();
            m_ScrollerControl.JumpIndex(jumpIndex);
        }

        void DisplayCompose()
        {
            var matCount = 0;
            GatherSoulComposeModel.Compose compose = null;
            if (model.TryGetCompose(model.selectItemId, out compose))
            {
                if (compose.requireSoulCore != 0)
                {
                    matCount++;
                }
                if (compose.requireSoulSplinters != 0)
                {
                    matCount++;
                }
            }
            for (int i = 0; i < m_ComposeBehaviours.Length; i++)
            {
                m_ComposeBehaviours[i].gameObject.SetActive(i + 1 == matCount);
                if (i + 1 == matCount)
                {
                    m_ComposeBehaviours[i].Display(model.selectItemId);
                }
            }
            m_ComposeItem.gameObject.SetActive(matCount > 0);
            m_ContainerCompose.gameObject.SetActive(matCount > 0);
            m_ContainerUnCompose.gameObject.SetActive(matCount == 0);
            if (matCount > 0)
            {
                var resolveReturn = 0;
                for (int i = 0; i < compose.requireItems.Count; i++)
                {
                    if (compose.requireItems[i] == model.jumpGatherSoulItem.itemId)
                    {
                        resolveReturn += soulModel.GetResolveReturnCost(model.jumpGatherSoulItem.itemId, 
                            model.jumpGatherSoulItem.level, true);
                    }
                    else
                    {
                        GatherSoulItem item;
                        if (!soulModel.TryGetHighestLevelItem(compose.requireItems[i], out item))
                        {
                            resolveReturn = 0;
                            break;
                        }
                        resolveReturn += soulModel.GetResolveReturnCost(item.id, item.level, true);
                    }
                }
                var level = 1;
                if (resolveReturn != 0)
                {
                    level = soulModel.GetLevelByCost(model.selectItemId, (ulong)resolveReturn);
                }
                level = Mathf.Max(1, level);
                m_ComposeItem.Display(model.selectItemId, level);
                var propertys = soulModel.gatherSoulPropertys[model.selectItemId];
                for (int i = 0; i < m_ComposeItemPropertys.Length; i++)
                {
                    m_ComposeItemPropertys[i].gameObject.SetActive(i < propertys.Count);
                    if (i < propertys.Count)
                    {
                        m_ComposeItemPropertys[i].DisplayUpper(propertys[i],
                            soulModel.GetPropertyValue(model.selectItemId, propertys[i], level));
                    }
                }
            }
            else
            {
                m_ComposeItem.Display(0, 1);
            }
        }

        void DisplayRequireLevel()
        {
            GatherSoulComposeModel.Compose compose = null;
            if (model.TryGetCompose(model.selectItemId, out compose))
            {
                m_RequireLevel.gameObject.SetActive(true);
                m_RequireLevel.text = Language.Get("GatherSoulComposeRequireLevel", compose.requireLevel);
                m_RequireLevel.color = UIHelper.GetUIColor(PlayerDatas.Instance.baseData.LV >= compose.requireLevel ?
                    TextColType.NavyBrown : TextColType.Red, true);
            }
            else
            {
                m_RequireLevel.gameObject.SetActive(false);
            }
        }

        private void Compose()
        {
            var error = 0;
            if (!TestCompose(out error))
            {
                DisplayErrorTip(error);
                return;
            }
            else
            {
                GatherSoulComposeModel.Compose compose;
                if (model.TryGetCompose(model.selectItemId, out compose))
                {
                    byte[] packArray = new byte[compose.requireItems.Count];
                    ushort[] indexArray = new ushort[compose.requireItems.Count];

                    for (int i = 0; i < compose.requireItems.Count; i++)
                    {
                        GatherSoulItem item;
                        if (soulModel.TryGetHighestLevelItem(compose.requireItems[i], out item))
                        {
                            packArray[i] = (byte)item.placeType;
                            indexArray[i] = (ushort)item.index;
                        }
                        else
                        {
                            return;
                        }
                    }

                    CA51C_tagCMGatherSoulCompound pak = new CA51C_tagCMGatherSoulCompound();
                    pak.PackList = packArray;
                    pak.IndexList = indexArray;
                    pak.Cnt = (byte)compose.requireItems.Count;
                    pak.TagItemID = (uint)model.selectItemId;
                    GameNetSystem.Instance.SendInfo(pak);
                }
            }
        }

        bool TestCompose(out int error)
        {
            error = 0;
            GatherSoulComposeModel.Compose compose;
            if (!model.TryGetCompose(model.selectItemId, out compose))
            {
                error = 1;
                return false;
            }
            if (PlayerDatas.Instance.baseData.LV < compose.requireLevel)
            {
                error = 2;
                return false;
            }
            if (UIHelper.GetMoneyCnt(GatheringSoulModel.SOULSPLINTERS_MONEYTYPE) < (ulong)compose.requireSoulSplinters)
            {
                error = 3;
                return false;
            }
            if (UIHelper.GetMoneyCnt(GatheringSoulModel.SOULCORE_MONEYTYPE) < (ulong)compose.requireSoulCore)
            {
                error = 4;
                return false;
            }
            for (int i = 0; i < compose.requireItems.Count; i++)
            {
                if (compose.requireItems[i] != model.jumpGatherSoulItem.itemId)
                {
                    GatherSoulItem item;
                    if (!soulModel.TryGetHighestLevelItem(compose.requireItems[i], out item))
                    {
                        error = 5;
                        return false;
                    }
                }
            }
            return true;
        }

        void DisplayErrorTip(int error)
        {
            switch (error)
            {
                case 2:
                    SysNotifyMgr.Instance.ShowTip("GatherSoulComposeError_2");
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("GatherSoulComposeError_3");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("GatherSoulComposeError_4");
                    break;
                case 5:
                    SysNotifyMgr.Instance.ShowTip("GatherSoulComposeError_5");
                    break;
            }
        }

    }

}