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

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

namespace vnxbqy.UI
{

    public class ReikiRootWin : Window
    {
        [SerializeField] List<PropertyBehaviour> m_BasePropertys;
        [SerializeField] List<PropertyBehaviour> m_SpecialPropertys;
        [SerializeField] List<ReikiRootPointBehaviour> m_ReikiRootPoints;
        [SerializeField] RectTransform m_Container;
        [SerializeField] NumKeyBoard m_NumKeyboard;
        [SerializeField] UIEffect m_ResetEffect;
        [SerializeField] Text m_FreePoint;
        [SerializeField] Button m_Reset;
        [SerializeField] Text m_ResetLabel;
        [SerializeField] Button m_GetPath;
        [SerializeField] Button m_Confirm;
        [SerializeField] Text m_ConfirmLabel;
        [SerializeField] Button m_Rule;
        [SerializeField] Button m_ViewQuality;
        [SerializeField] Button m_Gift;
        [SerializeField] UIEffect m_GiftEffect;
        [SerializeField] int m_GiftType = 11;
        [SerializeField] int m_JumpGiftType = 224;

        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;

        Clock resetPointClock = null;

        public DateTime m_ResetAnimationTime = DateTime.MinValue;
        public DateTime resetAnimationTime {
            get { return m_ResetAnimationTime; }
            set {
                m_ResetAnimationTime = value;
                resetPointClock = Clock.AlarmAfter(0.7f, () =>
                   {
                       m_ResetEffect.Play();
                       DisplayFreePoint();
                   });
            }
        }

        ReikiRootModel model { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
        TreasureSkillModel treasureSkillModel { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
        OSGiftModel giftModel { get { return ModelCenter.Instance.GetModel<OSGiftModel>(); } }

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

        protected override void AddListeners()
        {
            m_Reset.AddListener(OnReset);
            m_Confirm.AddListener(Confirm);
            m_Rule.AddListener(OnRule);
            m_GetPath.AddListener(GetPath);
            m_ViewQuality.AddListener(ViewQuality);
            m_Gift.AddListener(GotoGift);

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

        protected override void OnPreOpen()
        {
            m_ResetAnimationTime = DateTime.MinValue;

            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_ReikiRootPoints[i].SetActive(!model.displayOpenAnimation);
                    m_ReikiRootPoints[i].DisplaySelectEffect(model.selectReikiRoot == model.reikiRoots[i]);
                }
            }

            model.selectReikiRoot = 0;

            m_NumKeyboard.SetActive(false);

            model.onCacheFreePointRefresh += OnCacheFreePointRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            ReikiFuncOpenWin.onFlyComplete += OnFlyComplete;
            model.onReikiRootPointRefresh += OnReikiRootPointRefresh;
            NewBieCenter.Instance.guideCompletedEvent += GuideCompletedEvent;
            FunctionalGuideCenter.Instance.finishGuideEevent += GuideCompletedEvent;

            m_Gift.SetActive(PlayerDatas.Instance.baseData.VIPLv >= 1 && giftModel.IsGiftExist(m_GiftType));
            DisplayGiftState();

            Display();
        }

        protected override void OnAfterOpen()
        {
            if (model.displayOpenAnimation)
            {
                WindowCenter.Instance.Open<ReikiFuncOpenWin>();
                model.displayOpenAnimation = false;
            }
        }

        protected override void OnPreClose()
        {
            model.onCacheFreePointRefresh -= OnCacheFreePointRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            ReikiFuncOpenWin.onFlyComplete -= OnFlyComplete;
            model.onReikiRootPointRefresh -= OnReikiRootPointRefresh;
            NewBieCenter.Instance.guideCompletedEvent -= GuideCompletedEvent;
            FunctionalGuideCenter.Instance.finishGuideEevent -= GuideCompletedEvent;
            for (int i = 0; i < m_ReikiRootPoints.Count; i++)
            {
                m_ReikiRootPoints[i].Dispose();
            }

            if (resetPointClock != null)
            {
                Clock.Stop(resetPointClock);
                resetPointClock = null;
            }

            treasureSkillModel.newSatisfyActiveExpertDirty = false;
            model.openFromTreasureSkill = false;

            StopAllCoroutines();
        }

        protected override void OnAfterClose()
        {
        }

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

            if (treasureSkillModel.newSatisfyActiveExpertDirty && !model.openFromTreasureSkill)
            {
                if (!WindowCenter.Instance.IsOpen<ReikiRootQualityPromoteWin>())
                {
                    treasureSkillModel.newSatisfyActiveExpertDirty = false;
                    WindowCenter.Instance.Open<ReikiGotoSkillLevelUpWin>();
                }
            }
        }
        #endregion

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

        void DisplayFreePoint()
        {
            if ((DateTime.Now - resetAnimationTime).TotalSeconds < 0.5f)
            {
                return;
            }
            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 baseIndex = 0;
            var specialIndex = 0;
            foreach (var property in currentPropertyDict.Keys)
            {
                var config = PlayerPropertyConfig.Get(property);
                switch (config.type)
                {
                    case 1:
                        if (baseIndex < m_BasePropertys.Count)
                        {
                            m_BasePropertys[baseIndex].SetActive(true);
                            var value = (long)UIHelper.GetPropertyValue((PropertyType)property);
                            var compareValue = currentPropertyDict[property];
                            var add = upPropertyDict.ContainsKey(property) ?
                                (upPropertyDict[property] - compareValue) : 0;
                            m_BasePropertys[baseIndex].DisplayReiki(property, value, add);
                        }
                        baseIndex++;
                        break;
                    default:
                        if (specialIndex < m_SpecialPropertys.Count)
                        {
                            m_SpecialPropertys[specialIndex].SetActive(true);
                            var value = model.GetReikiPropertyValue(property);
                            var compareValue = currentPropertyDict[property];
                            var add = upPropertyDict.ContainsKey(property) ?
                                (upPropertyDict[property] - compareValue) : 0;
                            m_SpecialPropertys[specialIndex].DisplayReiki(property, value, add);
                        }
                        specialIndex++;
                        break;
                }
            }
            for (int i = baseIndex; i < m_BasePropertys.Count; i++)
            {
                m_BasePropertys[i].SetActive(false);
            }
            for (int i = specialIndex; i < m_SpecialPropertys.Count; i++)
            {
                m_SpecialPropertys[i].SetActive(false);
            }
        }

        void DisplayButtonState()
        {
            var isResetOpen = PlayerDatas.Instance.baseData.LV >= model.resetReikiLimitLevel;
            if (isResetOpen)
            {
                m_Reset.image.SetSprite("BlackBtn");
                m_Reset.image.color = Color.white;
            }
            else
            {
                m_Reset.image.SetSprite("SecondBtn1");
                m_Reset.image.color = new Color32(200, 200, 200, 255);
            }
            m_Reset.SetColorful(m_ResetLabel, isResetOpen, 1);
            if (isResetOpen)
                m_ResetLabel.color = UIHelper.GetUIColor(TextColType.NavyBrown);

            m_Confirm.SetInteractable(m_ConfirmLabel, model.freePoint != model.cacheFreePoint);
        }

        void DisplayGiftState()
        {
            if (giftModel.IsGiftExist(m_GiftType))
            {
                m_GiftEffect.SetActive(PlayerDatas.Instance.baseData.LV < model.effectLimitLevel);
            }
        }

        public void OpenKeyboard(ReikiRootPointBehaviour behaviour)
        {
            openKeyboardId = behaviour.id;
            m_NumKeyboard.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 = Vector3.zero;
            if (!up)
            {
                worldpos = trans.TransformPoint(new Vector3(0, -trans.rect.height / 2, 0));
            }
            else
            {
                var keyBoardRect = m_NumKeyboard.transform as RectTransform;
                worldpos = trans.TransformPoint(new Vector3(0, trans.rect.height / 2 + keyBoardRect.rect.height, 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 OnReset()
        {
            if (PlayerDatas.Instance.baseData.LV < model.resetReikiLimitLevel)
            {
                SysNotifyMgr.Instance.ShowTip("FuncLimit_WXLGCZ",
                    Language.Get("OpenFunc2", model.resetReikiLimitLevel));
                return;
            }
            if (model.GetTotalWashPoint() <= 0)
            {
                SysNotifyMgr.Instance.ShowTip("NoneReikiPointCanWash");
                return;
            }
            WindowCenter.Instance.Open<ReikiRootResetWin>();
        }

        private void ViewQuality()
        {
            WindowCenter.Instance.Open<ReikiQualityInfomationWin>();
        }

        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 length = 0;
                for (int i = 0; i < m_ReikiRootPoints.Count; i++)
                {
                    if (m_ReikiRootPoints[i].point > 0)
                    {
                        length++;
                    }
                }

                var ids = new byte[length];
                var values = new uint[length];
                var index = 0;
                for (int i = 0; i < m_ReikiRootPoints.Count; i++)
                {
                    if (m_ReikiRootPoints[i].point > 0)
                    {
                        ids[index] = (byte)m_ReikiRootPoints[i].id;
                        values[index] = (uint)m_ReikiRootPoints[i].point;
                        index++;
                    }
                }
                model.SendAddPoint(ids, values);
            }
        }

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

        private void GetPath()
        {
            RealmRecommandEquipGetWayWin.equipGetWays.Clear();
            RealmRecommandEquipGetWayWin.equipGetWays.AddRange(model.reikiRootGetWays);
            WindowCenter.Instance.Open<RealmRecommandEquipGetWayWin>();
        }

        private void OnFlyComplete()
        {
            StartCoroutine(Co_DisplayReikis());
        }

        IEnumerator Co_DisplayReikis()
        {
            for (int i = 0; i < m_ReikiRootPoints.Count; i++)
            {
                m_ReikiRootPoints[i].SetActive(true);
                yield return WaitingForSecondConst.WaitMS100;
            }
            var job = PlayerDatas.Instance.baseData.Job;
            switch (job)
            {
                case 1:
                    NewBieCenter.Instance.StartNewBieGuideEx(52);
                    break;
                case 2:
                    NewBieCenter.Instance.StartNewBieGuideEx(53);
                    break;
            }
        }

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

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

                DisplayButtonState();
            }
            else if (dataType == PlayerDataType.LV)
            {
                DisplayButtonState();
                DisplayGiftState();
            }
            else
            {
                propertyRefreshDirty = true;
            }
        }

        private void OnReikiRootPointRefresh()
        {
            propertyRefreshDirty = true;
        }

        private void GotoGift()
        {
            WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)m_JumpGiftType);
        }

        private void GuideCompletedEvent(int id)
        {
            if (id == 52 || id == 53)
            {
                FunctionalGuideCenter.Instance.StartGuide(129);
            }
            else if (id == 129)
            {
                FunctionalGuideCenter.Instance.StartGuide(135);
            }
        }
    }

}