//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, September 08, 2017
//--------------------------------------------------------

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

namespace vnxbqy.UI
{

    public class RunePackWin : Window, SecondWindowInterface
    {
        [SerializeField] ScrollerController m_ScrollController;
        [SerializeField] Text m_Capacity;
        [SerializeField] Button m_GetRune;
        [SerializeField] Button m_Compose;

        List<int> itemIndexs = new List<int>();

        public static int selectHole = 0;

        RuneModel runeModel
        {
            get { return ModelCenter.Instance.GetModel<RuneModel>(); }
        }

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

        public Button close { get; set; }

        #region Built-in
        protected override void BindController()
        {
            if (this is SecondWindowInterface)
            {
                var frame = this.GetComponentInChildren<SecondFrameLoader2>();
                frame.Create();
                close = frame.GetComponentInChildren<Button>();
            }
        }

        protected override void AddListeners()
        {
            close.AddListener(CloseClick);
            m_GetRune.AddListener(OnRuneGetBtn);
            m_Compose.AddListener(OnRuneComposeBtn);

            m_ScrollController.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            model.virtualPackRefresh += VirtualPackRefresh;
            Display();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.virtualPackRefresh -= VirtualPackRefresh;
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        void VirtualPackRefresh(PackType packType)
        {
            if (packType == PackType.RunePack)
            {
                Display();
            }
        }

        void Display()
        {
            m_ScrollController.Refresh();

            itemIndexs.Clear();

            List<int> _items = null;
            model.TryGetItems(PackType.RunePack, out _items);
            itemIndexs.AddRange(_items);

            itemIndexs.RemoveAll(ExcludeCream);
            itemIndexs.Sort(Compare);

            int line = Mathf.CeilToInt((float)itemIndexs.Count / 3);
            for (int i = 0; i < line; i++)
            {
                m_ScrollController.AddCell(ScrollerDataType.Normal, i);
            }

            m_ScrollController.Restart();

            m_Capacity.text = StringUtility.Contact(model.GetPackItemCount(PackType.RunePack), "/",
                model.GetPackCapacity(PackType.RunePack));
        }

        private bool ExcludeCream(int index)
        {
            RuneItem item;
            if (model.TryGetItem(PackType.RunePack, index, out item))
            {
                return item.itemType == RuneModel.RUNE_CREAMTYPE;
            }
            return true;
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            var runePackCell = cell as RunePackCell;
            runePackCell.Display(cell.index, itemIndexs);
        }

        private void OnRuneComposeBtn()
        {
            CloseImmediately();
            runeModel.JumpToCompose();
        }

        private void OnRuneGetBtn()
        {
            CloseImmediately();
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneTower);
        }

        int Compare(int lhs, int rhs)
        {
            RuneItem lhsItem;
            RuneItem rhsItem;
            if (model.TryGetItem(PackType.RunePack, lhs, out lhsItem)
                && model.TryGetItem(PackType.RunePack, rhs, out rhsItem))
            {
                var lhsItemConfig = ItemConfig.Get(lhsItem.id);
                var rhsItemConfig = ItemConfig.Get(rhsItem.id);
                bool lhsSame = runeModel.GetMaxSamePropertyHoleCount(lhsItemConfig.ID, selectHole) >= runeModel.samePropertyHoleLimit;
                bool rhsSame = runeModel.GetMaxSamePropertyHoleCount(rhsItemConfig.ID, selectHole) >= runeModel.samePropertyHoleLimit;
                if (lhsSame != rhsSame)
                {
                    return lhsSame.CompareTo(rhsSame);
                }
                if (lhsItemConfig.ItemColor != rhsItemConfig.ItemColor)
                {
                    return -lhsItemConfig.ItemColor.CompareTo(rhsItemConfig.ItemColor);
                }
                if (lhsItem.level != rhsItem.level)
                {
                    return -lhsItem.level.CompareTo(rhsItem.level);
                }
                else if (lhsItem.id != rhsItem.id)
                {
                    return -lhsItem.id.CompareTo(rhsItem.id);
                }
            }
            return 1;
        }
    }

}