//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, April 12, 2019
//--------------------------------------------------------

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

namespace vnxbqy.UI
{

    public class HazyDemonKingVictoryWin : Window
    {
        [SerializeField] Transform m_ContainerPoivt;
        [SerializeField] Transform m_ContainerBelongTo;
        [SerializeField] Text m_PlayerName;
        [SerializeField] ScrollRect m_RewardsScroll;
        [SerializeField] Text m_ExitTimer;
        [SerializeField] HorizontalLayoutGroup m_RewardLayout;
        [SerializeField] Transform m_ContainerFirst;
        [SerializeField] Transform m_ContainerOther;
        [SerializeField] ButtonEx m_Exit;

        List<DungeonRewardBehavour> m_Items = new List<DungeonRewardBehavour>();

        float timer = 0f;

        private int dungeonType
        {
            get
            {
                var incidentId = hazyRegionModel.GetIncidentId(model.dungeonResult.dataMapID, model.dungeonResult.lineID);
                var config = HazyRegionConfig.Get(incidentId);
                if (config != null)
                {
                    return config.dungeonType;
                }
                return 0;
            }
        }

        DungeonModel model { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        HazyRegionModel hazyRegionModel { get { return ModelCenter.Instance.GetModel<HazyRegionModel>(); } }

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

        protected override void AddListeners()
        {
            m_Exit.AddListener(ExitDungeon);
        }

        protected override void OnPreOpen()
        {
            timer = 0f;
            m_ContainerPoivt.SetActive(false);
            m_ContainerBelongTo.SetActive(dungeonType != 0);
        }

        protected override void OnActived()
        {
            base.OnActived();
            var config = DungeonOpenTimeConfig.Get(PlayerDatas.Instance.baseData.MapID);
            StartCoroutine(Co_DelayDisplay(config.DelayTime * 0.001f));
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
        }

        protected override void OnAfterClose()
        {
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();

            var endTime = model.GetCoolDownEndTime(DungeonCoolDownType.LeaveMap);
            if (endTime > TimeUtility.ServerNow)
            {
                timer -= Time.deltaTime;
                if (timer < 0f)
                {
                    timer = 1f;
                    var seconds = (endTime - TimeUtility.ServerNow).TotalSeconds;
                    m_ExitTimer.text = Language.Get("DungeonVictoryWin_Btn_Exit_1", Mathf.Clamp((int)seconds, 0, int.MaxValue));
                }

                if (!m_ExitTimer.gameObject.activeInHierarchy)
                {
                    m_ExitTimer.SetActive(true);
                }
            }
            else
            {
                if (m_ExitTimer.gameObject.activeInHierarchy)
                {
                    m_ExitTimer.SetActive(false);
                }
            }
        }
        #endregion

        IEnumerator Co_DelayDisplay(float _delay)
        {
            yield return new WaitForSeconds(_delay);

            var endTime = model.GetCoolDownEndTime(DungeonCoolDownType.LeaveMap);
            var seconds = (endTime - TimeUtility.ServerNow).TotalSeconds;
            timer = 0f;
            m_ExitTimer.text = Language.Get("DungeonVictoryWin_Btn_Exit_1", Mathf.Clamp((int)seconds, 0, int.MaxValue));
            m_ExitTimer.SetActive(true);

            bool isFirst = model.dungeonResult.ownerID == PlayerDatas.Instance.PlayerId;
            m_ContainerFirst.SetActive(isFirst);
            m_ContainerOther.SetActive(!isFirst);

            m_ContainerPoivt.SetActive(true);

            DisplayRewards();
            DisplayBelongTo();
        }

        private void DisplayRewards()
        {
            var serverItems = model.dungeonResult.itemInfo;
            var items = new List<Item>();

            var itemCount = 0;

            if (serverItems != null)
            {
                for (int i = 0; i < serverItems.Length; i++)
                {
                    items.Add(new Item(serverItems[i].ItemID, serverItems[i].Count));
                }

                itemCount = serverItems.Length;
            }


            GenerateRewardBehaviour(m_RewardsScroll.content, items.Count);

            if (itemCount < 6)
            {
                m_RewardLayout.childAlignment = TextAnchor.MiddleCenter;
                (m_RewardLayout.transform as RectTransform).pivot = new Vector2(0.5f, 0.5f);
            }
            else
            {
                m_RewardLayout.childAlignment = TextAnchor.MiddleLeft;
                (m_RewardLayout.transform as RectTransform).pivot = new Vector2(0, 0.5f);
            }

            for (int i = 0; i < m_Items.Count; i++)
            {
                var behaviour = m_Items[i];
                if (i < items.Count)
                {
                    behaviour.SetActive(true);
                    behaviour.Display(items[i]);
                }
                else
                {
                    behaviour.SetActive(false);
                }
            }
        }

        void DisplayBelongTo()
        {
            m_PlayerName.text = UIHelper.ServerStringTrim(model.dungeonResult.ownerName);
        }

        private void ExitDungeon()
        {
            //if (PlayerDatas.Instance.baseData.MapID == HazyDemonKingModel.CLIENTDATAMAP)
            //{
            //    ClientDungeonStageUtility.ExitNormalClientDungeon();
            //}
            //else
            //{
            //    ModelCenter.Instance.GetModel<HazyDemonKingModel>().RequestExitDungeon();
            //}
            if (ClientDungeonStageUtility.isClientDungeon)
            {
                ClientDungeonStageUtility.ExitNormalClientDungeon();
            }
            else
            {
                ModelCenter.Instance.GetModel<DungeonModel>().ExitCurrentDungeon();
            }
        }

        private void GenerateRewardBehaviour(RectTransform _parent, int _needCount)
        {
            var nowCount = m_Items.Count;
            var dif = _needCount - nowCount;
            if (dif > 0)
            {
                for (int i = 0; i < dif; i++)
                {
                    var instance = UIUtility.CreateWidget("DungeonRewardBehavour", "DungeonRewardBehavour");
                    var behaviour = instance.GetComponent<DungeonRewardBehavour>();
                    m_Items.Add(behaviour);
                    instance.transform.SetParentEx(_parent, Vector3.zero, Vector3.zero, Vector3.one);
                }
            }
        }
    }

}