//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, December 10, 2018
//--------------------------------------------------------

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

namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class GatherSoulWin : Window
    {
        [SerializeField] int m_PackLineCount = 5;

        [SerializeField] GatherSoulHoleBehaviour[] m_GatherSoulHoles;
        [SerializeField] ScrollerController m_ScrollerControl;
        [SerializeField] Text m_SoulDust;
        [SerializeField] Text m_SoulSplinters;
        [SerializeField] Text m_SoulCore;
        [SerializeField] Button m_GetSoul;
        [SerializeField] Button m_GotoCompose;
        [SerializeField] Button m_Resolve;
        [SerializeField] Button m_ViewProperty;
        [SerializeField] Image m_DustIcon;
        [SerializeField] Transform m_DustRaycast;
        [SerializeField] Image m_SplintersIcon;
        [SerializeField] Transform m_SplintersRaycast;
        [SerializeField] Image m_CoreIcon;
        [SerializeField] Transform m_CoreRaycast;


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

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

        DailyQuestModel dailyQuestModel
        {
            get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); }
        }

        public static float sync_topsoul_normalized = 0f;
        static float topsoul_duration = 1.067f;
        static float sync_timer = 0f;

        List<UIEffect> flyEffects = new List<UIEffect>();
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_GetSoul.onClick.AddListener(GetSoul);
            m_GotoCompose.onClick.AddListener(GotoCompose);
            m_Resolve.onClick.AddListener(Resolve);
            m_ViewProperty.onClick.AddListener(ViewProperty);
            UIEventTrigger.Get(m_DustRaycast.gameObject).OnDown = (GameObject go) =>
              {
                  ViewMoneyType(GatheringSoulModel.SOULDUST_MONEYTYPE, m_DustIcon.transform as RectTransform);
              };
            UIEventTrigger.Get(m_SplintersRaycast.gameObject).OnDown = (GameObject go) =>
            {
                ViewMoneyType(GatheringSoulModel.SOULSPLINTERS_MONEYTYPE, m_SplintersIcon.transform as RectTransform);
            };
            UIEventTrigger.Get(m_CoreRaycast.gameObject).OnDown = (GameObject go) =>
            {
                ViewMoneyType(GatheringSoulModel.SOULCORE_MONEYTYPE, m_CoreIcon.transform as RectTransform);
            };
            m_ScrollerControl.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            for (int i = 0; i < m_GatherSoulHoles.Length; i++)
            {
                m_GatherSoulHoles[i].Display();
            }
            Display();
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
            model.gatherSoulPackRefresh += GatherSoulPackRefresh;
            GatherSoulItemBehaviour.alreadyResolveEvent += AlreadyResolveEvent;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            for (int i = 0; i < m_GatherSoulHoles.Length; i++)
            {
                m_GatherSoulHoles[i].Dispose();
            }
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
            model.gatherSoulPackRefresh -= GatherSoulPackRefresh;
            GatherSoulItemBehaviour.alreadyResolveEvent -= AlreadyResolveEvent;

            StopAllCoroutines();

            for (int i = 0; i < flyEffects.Count; i++)
            {
                var effect = flyEffects[i];
                if (effect != null)
                {
                    EffectMgr.Instance.RecyleUIEffect(3076, effect.gameObject);
                }
            }
            flyEffects.Clear();
        }

        protected override void OnAfterClose()
        {
        }

        protected override void LateUpdate()
        {
            sync_topsoul_normalized = Mathf.Clamp01(sync_timer / topsoul_duration);
            if (sync_timer >= topsoul_duration)
            {
                sync_timer = 0f;
            }
            else
            {
                sync_timer += Time.deltaTime;
            }
        }
        #endregion

        void Display()
        {
            DisplayPackSouls();
            DisplaySoulCost();
        }

        void DisplayPackSouls()
        {
            if (m_ScrollerControl.GetNumberOfCells(m_ScrollerControl.m_Scorller) == 0)
            {
                m_ScrollerControl.Refresh();
                var capacity = virtualPack.GetPackCapacity(PackType.GatherSoul);
                var line = Mathf.CeilToInt((float)capacity / m_PackLineCount);
                for (int i = 0; i < line; i++)
                {
                    m_ScrollerControl.AddCell(ScrollerDataType.Header, i);
                }
                m_ScrollerControl.Restart();
            }
            else
            {
                m_ScrollerControl.m_Scorller.RefreshActiveCellViews();
            }
        }

        void DisplaySoulCost()
        {
            m_SoulDust.text = UIHelper.ReplaceLargeNum(UIHelper.GetMoneyCnt(28));
            m_SoulSplinters.text = UIHelper.ReplaceLargeNum(UIHelper.GetMoneyCnt(29));
            m_SoulCore.text = UIHelper.ReplaceLargeNum(UIHelper.GetMoneyCnt(30));
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
        {
            if (refreshType == PlayerDataType.CDBPlayerRefresh_SoulDust ||
                refreshType == PlayerDataType.CDBPlayerRefresh_SoulSplinters ||
                refreshType == PlayerDataType.CDBPlayerRefresh_SoulCore)
            {
                DisplaySoulCost();
            }
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            var packCell = cell as GatherSoulPackCell;
            packCell.Display(cell.index);
        }

        private void GatherSoulPackRefresh()
        {
            m_ScrollerControl.m_Scorller.RefreshActiveCellViews();
        }

        private void AlreadyResolveEvent(Transform resolveTransform)
        {
            if (resolveTransform != null)
            {
                var startPoint = resolveTransform.position;
                var endPoint = m_DustIcon.transform.position;
                
                StartCoroutine(Co_DisplayEffect(startPoint, endPoint));
            }
        }

        IEnumerator Co_DisplayEffect(Vector3 start, Vector3 end)
        {
            for (int i = 0; i < 3; i++)
            {
                yield return WaitingForSecondConst.WaitMS100;
                var nl = Vector3.Normalize(end - start);
                var normal = new Vector3(-nl.y, nl.x, 0);
                var distance = Vector3.Distance(start, end);
                var pivot = start + normal * UnityEngine.Random.Range(-distance, distance) * 0.3f + nl * distance * 0.4f;
                var effect = EffectMgr.Instance.PlayUIEffect(3076, 2200, transform, true);
                if (effect != null)
                {
                    flyEffects.Add(effect);
                    var bezierMove = effect.AddMissingComponent<BezierMove>();
                    bezierMove.duration = 1.0f;
                    bezierMove.Begin(start, pivot, end, () =>
                    {
                        if (effect != null)
                        {
                            if (flyEffects.Contains(effect))
                            {
                                flyEffects.Remove(effect);
                            }
                            EffectMgr.Instance.RecyleUIEffect(3076, effect.gameObject);
                        }
                    });
                }
            }
        }

        private void ViewProperty()
        {
            if (WindowCenter.Instance.IsOpen<GatherSoulTotalPropertyWin>())
            {
                WindowCenter.Instance.Close<GatherSoulTotalPropertyWin>();
            }
            else
            {
                WindowCenter.Instance.Open<GatherSoulTotalPropertyWin>();
            }
        }

        private void GetSoul()
        {
            dailyQuestModel.wannaLookDailyQuest = (int)DailyQuestType.GatherSoulDungeon;
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.DailyQuestFunc1);
        }

        private void GotoCompose()
        {
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.GatherSoul271);
        }

        private void Resolve()
        {
            WindowCenter.Instance.Open<GatherSoulResolveWin>();
        }

        void ViewMoneyType(int moneyType, RectTransform rect)
        {
            SystemMoneyRemindWin.moneyType = moneyType;
            var position = rect.TransformPoint(Vector3.zero);
            SystemMoneyRemindWin.position = position;
            WindowCenter.Instance.Open<SystemMoneyRemindWin>(true);
        }
    }

}