//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, March 25, 2019
//--------------------------------------------------------

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

namespace Snxxz.UI
{

    public class ReikiRootWin : Window
    {
        [SerializeField] List<PropertyBehaviour> m_Propertys;
        [SerializeField] List<ReikiRootPointBehaviour> m_ReikiRootPoints;
        [SerializeField] RectTransform m_Container;
        [SerializeField] NumKeyBoard m_NumKeyboard;
        [SerializeField] Text m_FreePoint;
        [SerializeField] Button m_Recommend;
        [SerializeField] Button m_Confirm;
        [SerializeField] Button m_Rule;

        Dictionary<int, int> currentPropertyDict = new Dictionary<int, int>();
        Dictionary<int, int> upPropertyDict = new Dictionary<int, int>();

        int openKeyboardId = 0;

        bool propertyRefreshDirty = false;

        const float refreshInterval = 0.5f;
        float timer = 0f;

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

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Recommend.AddListener(OnRecommend);
            m_Confirm.AddListener(Confirm);
            m_Rule.AddListener(OnRule);

            m_NumKeyboard.onValueChange.AddListener(OnPointValChange);
            m_NumKeyboard.onConfirm.AddListener((bool isOk) =>
            {
                if (isOk)
                {
                    m_NumKeyboard.gameObject.SetActive(false);
                }
            });
        }

        protected override void OnPreOpen()
        {
            model.cacheFreePoint = model.freePoint;
            for (int i = 0; i < m_ReikiRootPoints.Count; i++)
            {
                if (i < model.reikiRoots.Count)
                {
                    m_ReikiRootPoints[i].Display(this, model.reikiRoots[i]);
                }
            }

            m_NumKeyboard.gameObject.SetActive(false);

            model.onCacheFreePointRefresh += OnCacheFreePointRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;

            Display();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.onCacheFreePointRefresh -= OnCacheFreePointRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            for (int i = 0; i < m_ReikiRootPoints.Count; i++)
            {
                m_ReikiRootPoints[i].Dispose();
            }
        }

        protected override void OnAfterClose()
        {
        }

        protected override void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer >= refreshInterval)
            {
                timer = 0f;
                if (propertyRefreshDirty)
                {
                    DisplayProperty();
                }
            }
        }
        #endregion

        void Display()
        {
            DisplayFreePoint();
            DisplayProperty();
        }

        void DisplayFreePoint()
        {
            m_FreePoint.text = model.cacheFreePoint.ToString();
        }

        void DisplayProperty()
        {
            currentPropertyDict.Clear();
            upPropertyDict.Clear();

            foreach (var reikiRootPoint in m_ReikiRootPoints)
            {
                var id = reikiRootPoint.id;
                var point = model.GetReikiRootPoint(id);
                model.GetReikiRootProperty(id, point, ref currentPropertyDict);

                var cachePoint = point + reikiRootPoint.point;
                model.GetReikiRootProperty(id, cachePoint, ref upPropertyDict);
            }

            var index = 0;
            foreach (var property in currentPropertyDict.Keys)
            {
                if (index < m_Propertys.Count)
                {
                    m_Propertys[index].gameObject.SetActive(true);
                    var value = UIHelper.GetPropertyValue((PropertyType)property);
                    var compareValue = currentPropertyDict[property];
                    var add = upPropertyDict.ContainsKey(property) ?
                        (upPropertyDict[property] - compareValue) : 0;
                    m_Propertys[index].DisplayReiki(property, value, add);
                }
                index++;
            }
            for (int i = index; i < m_Propertys.Count; i++)
            {
                m_Propertys[i].gameObject.SetActive(false);
            }
        }

        public void OpenKeyboard(ReikiRootPointBehaviour behaviour)
        {
            openKeyboardId = behaviour.id;
            m_NumKeyboard.gameObject.SetActive(true);
            m_NumKeyboard.max = (uint)model.cacheFreePoint + (uint)behaviour.point;
            m_NumKeyboard.min = 0;
            var trans = behaviour.openKeyboardBottom;

            bool up = m_ReikiRootPoints.IndexOf(behaviour) == m_ReikiRootPoints.Count - 1;

            var worldpos = trans.TransformPoint(new Vector3(0, (up ? 1 : -1) * trans.rect.height / 2, 0));
            var localpos = m_Container.InverseTransformPoint(worldpos);
            m_NumKeyboard.transform.localPosition = localpos;
        }

        private void OnPointValChange()
        {
            var behaviour = m_ReikiRootPoints.Find((x) =>
            {
                return x.id == openKeyboardId;
            });

            var cache = behaviour.point;

            int num = int.Parse(m_NumKeyboard.Value);
            if (model.cacheFreePoint + cache - num < 0)
            {
                num = model.cacheFreePoint + cache;
            }

            behaviour.point = num;
            model.cacheFreePoint = model.cacheFreePoint - num + cache;

            m_NumKeyboard.Value = num.ToString();
        }

        private void OnRecommend()
        {
            var recommends = model.GetReikiRootRecommendPoint(model.freePoint);
            if (recommends != null)
            {
                foreach (var reikiRootPoint in m_ReikiRootPoints)
                {
                    var point = 0;
                    var list = recommends.FindAll((x) =>
                     {
                         return x.id == reikiRootPoint.id;
                     });
                    if (list != null)
                    {
                        foreach (var recommend in list)
                        {
                            point += recommend.value;
                        }
                    }
                    reikiRootPoint.point = point;
                }
                if (model.cacheFreePoint == 0)
                {
                    OnCacheFreePointRefresh();
                }
                model.cacheFreePoint = 0;
            }
        }

        private void Confirm()
        {
            if (model.freePoint != model.cacheFreePoint)
            {
                var ids = new byte[m_ReikiRootPoints.Count];
                var values = new ushort[m_ReikiRootPoints.Count];
                for (int i = 0; i < m_ReikiRootPoints.Count; i++)
                {
                    ids[i] = (byte)m_ReikiRootPoints[i].id;
                    values[i] = (ushort)m_ReikiRootPoints[i].point;
                }
                model.SendAddPoint(ids, values);
            }
        }

        private void OnRule()
        {
            ModelCenter.Instance.GetModel<HowToPlayModel>().ruleId = 44;
            WindowCenter.Instance.Open<ReikiRootRuleWin>();
        }

        private void OnCacheFreePointRefresh()
        {
            DisplayFreePoint();
            DisplayProperty();
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.FreePoint)
            {
                if (model.cacheFreePoint == model.freePoint)
                {
                    OnCacheFreePointRefresh();
                }
                model.cacheFreePoint = model.freePoint;
            }
            else
            {
                propertyRefreshDirty = true;
            }
        }
    }

}