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

namespace Snxxz.UI
{
    public class FairyBoss : Window
    {
        [SerializeField] Text textAtkCnt;
        [SerializeField] Text textFairyFoodNum;
        [SerializeField] Text textBossName;
        [SerializeField] Text textChallengeTime;
        [SerializeField] Text textBossState;
        [SerializeField] Text textFoodChallengeCnt;
        [SerializeField] Text m_TimeTip;
        [SerializeField] Text m_TimeCoolDown;
        [SerializeField] Button beginBtn;
        [SerializeField] Button previewBtn;
        [SerializeField] Button m_GetWayBtn;
        [SerializeField] Button closeBtn;
        [SerializeField] RawImage model;
        [SerializeField] GameObject enterText;
        [SerializeField] GameObject openText;
        [SerializeField] ItemCell m_FairyFood;
        [SerializeField] Button m_HandIn;
        [SerializeField] Text m_WeekCntRemind;

        FairyBossModel m_Model;
        FairyBossModel fairyBossModel {
            get {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<FairyBossModel>());
            }
        }

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        FairyBossTime m_TimeStage;
        DateTime m_StartTime;

        private void OnClose()
        {
            Close();
        }

        private void OnPreviewAward()
        {
            WindowCenter.Instance.Open<FairyBossAwardWin>();
        }

        private void OnBeginBtn()
        {
            if (PlayerDatas.Instance.fairyData.IsBossOpen == 0)
            {
                PlayerFairyData fairyData = PlayerDatas.Instance.fairyData;
                if (fairyData.mine != null)
                {
                    if (!PlayerDatas.Instance.fairyData.IsCanFunc(PlayerFairyData.LimitFunc.CanOpenBoss))
                    {
                        ServerTipDetails.DisplayNormalTip(Language.Get("L1019"));
                        return;
                    }
                }
                if (TimeUtility.Hour < fairyBossModel.FairyBossStartHour || TimeUtility.Hour >= fairyBossModel.FairyBossEndHour)
                {
                    ServerTipDetails.DisplayNormalTip(Language.Get("L1020"));
                    return;
                }
                if (PlayerDatas.Instance.fairyData.weekBossOpenCnt >= fairyBossModel.GetFairyBossWeekCount())
                {
                    SysNotifyMgr.Instance.ShowTip("FairyBossOpenCntError");
                    return;
                }
                if (PlayerDatas.Instance.fairyData.fairy.FamilyHornor < fairyBossModel.OpenFairyBossNeed)
                {
                    ServerTipDetails.DisplayNormalTip(Language.Get("L1124"));
                    OnFoodGetWay();
                    return;
                }
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("L1125", fairyBossModel.OpenFairyBossNeed), (bool isOk) =>
                {
                    if (isOk)
                    {
                        CA405_tagCGOpenFamilyBossFB openPack = new CA405_tagCGOpenFamilyBossFB();
                        GameNetSystem.Instance.SendInfo(openPack);
                    }
                });
            }
            else
            {
                if (TimeUtility.Hour < fairyBossModel.FairyBossStartHour || TimeUtility.Hour >= fairyBossModel.FairyBossEndHour)
                {
                    ServerTipDetails.DisplayNormalTip(Language.Get("L1020"));
                    return;
                }
                ModelCenter.Instance.GetModel<DungeonModel>().SingleChallenge(fairyBossModel.MapId);
            }

        }

        private void OnRefreshFairyBoss()
        {
            m_StartTime = new DateTime(TimeUtility.Year, TimeUtility.Month, TimeUtility.Day,
                fairyBossModel.FairyBossStartHour, 0, 0);
            UpdateInfo();
            CheckFairyBossTime();
            UpdateTimeTip();
            UpdateCoolDown();
        }

        private void OnRefreshFairyMine()
        {
            if (!PlayerDatas.Instance.fairyData.HasFairy)
            {
                CloseImmediately();
            }
        }

        private void UpdateInfo()
        {
            beginBtn.interactable = true;
            if (PlayerDatas.Instance.fairyData.IsBossOpen > 0)
            {
                openText.gameObject.SetActive(false);
                enterText.gameObject.SetActive(true);
                if (PlayerDatas.Instance.baseData.MapID == fairyBossModel.MapId)
                {
                    beginBtn.interactable = false;
                }
            }
            else
            {
                openText.gameObject.SetActive(true);
                enterText.gameObject.SetActive(false);
                if (!PlayerDatas.Instance.fairyData.IsCanFunc(PlayerFairyData.LimitFunc.CanOpenBoss))
                {
                    beginBtn.interactable = false;
                }
            }
            textFairyFoodNum.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.fairyData.fairy.FamilyHornor);
            textAtkCnt.text = string.Format("{0}/{1}", Mathf.Max(0, fairyBossModel.GetFairyBossWeekCount() - PlayerDatas.Instance.fairyData.weekBossOpenCnt), fairyBossModel.GetFairyBossWeekCount());

            var nextWeekCnt = 0;
            var familyLv = PlayerDatas.Instance.fairyData.fairy.FamilyLV;
            m_WeekCntRemind.gameObject.SetActive(fairyBossModel.TryGetWeekCnt(familyLv + 1, out nextWeekCnt));
            if (nextWeekCnt != 0)
            {
                m_WeekCntRemind.text = Language.Get("FairyBossCountRemind", familyLv + 1, nextWeekCnt);
            }
        }

        void InitData()
        {
            textBossName.text = fairyBossModel.fairyBossInfo;
            textChallengeTime.text = Language.Get("L1105", fairyBossModel.FairyBossStartHour, fairyBossModel.FairyBossEndHour);
            textFoodChallengeCnt.text = fairyBossModel.OpenFairyBossNeed.ToString();
        }

        void OnShowFairyBossModel()
        {
            UI3DModelExhibition.Instance.ShowNPC(fairyBossModel.fairyBossNpcId, Vector3.zero, model);
        }

        private void OnFoodGetWay()
        {
            ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(fairyBossModel.fairyBossFood);
        }

        void UpdateTimeTip()
        {
            m_TimeTip.gameObject.SetActive(true);
            switch (m_TimeStage)
            {
                case FairyBossTime.None:
                case FairyBossTime.PrepareClose:
                    m_TimeTip.gameObject.SetActive(false);
                    break;
                case FairyBossTime.BeforeOpen:
                    m_TimeTip.text = Language.Get("FairyBossOpenCoolDown");
                    break;
                case FairyBossTime.PrepareOpen:
                case FairyBossTime.Open:
                    m_TimeTip.text = Language.Get("FairyBossEndCoolDown");
                    break;
            }
        }

        void UpdateCoolDown()
        {
            if (!m_TimeCoolDown.gameObject.activeSelf)
            {
                m_TimeCoolDown.gameObject.SetActive(true);
            }
            switch (m_TimeStage)
            {
                case FairyBossTime.None:
                case FairyBossTime.PrepareClose:
                    m_TimeCoolDown.gameObject.SetActive(false);
                    break;
                case FairyBossTime.BeforeOpen:
                    {
                        var _surplusTime = (m_StartTime - TimeUtility.ServerNow).TotalSeconds;
                        m_TimeCoolDown.text = TimeUtility.SecondsToDHMSCHS((int)_surplusTime);
                    }
                    break;
                case FairyBossTime.PrepareOpen:
                    m_TimeCoolDown.gameObject.SetActive(true);
                    m_TimeCoolDown.text = TimeUtility.SecondsToDHMSCHS(fairyBossModel.fairyBossContinueTime);
                    break;
                case FairyBossTime.Open:
                    {
                        var _overTime = PlayerDatas.Instance.fairyData.bossOpenTime.AddSeconds(
                            fairyBossModel.fairyBossContinueTime+fairyBossModel.fairyBossPrepareTime);
                        var _surplusTime = (_overTime - TimeUtility.ServerNow).TotalSeconds;
                        m_TimeCoolDown.text = TimeUtility.SecondsToDHMSCHS((int)_surplusTime);
                    }
                    break;
            }
        }

        void CheckFairyBossTime()
        {
            m_TimeStage = FairyBossTime.None;
            var _fairyData = PlayerDatas.Instance.fairyData;
            if (_fairyData == null)
            {
                return;
            }
            if (PlayerDatas.Instance.fairyData.weekBossOpenCnt >= fairyBossModel.GetFairyBossWeekCount()
                && _fairyData.IsBossOpen == 0)
            {
                return;
            }
            if (TimeUtility.Hour < fairyBossModel.FairyBossStartHour)
            {
                m_TimeStage = FairyBossTime.BeforeOpen;
            }
            else if (_fairyData.IsBossOpen == 2)
            {
                m_TimeStage = FairyBossTime.PrepareClose;
            }
            else if (_fairyData.IsBossOpen > 1)
            {
                m_TimeStage = FairyBossTime.Open;
            }
            else if (_fairyData.IsBossOpen == 1 && TimeUtility.Hour < fairyBossModel.FairyBossEndHour)
            {
                m_TimeStage = FairyBossTime.PrepareOpen;
            }
            else if (TimeUtility.Hour >= fairyBossModel.FairyBossEndHour)
            {
                m_TimeStage = FairyBossTime.None;
            }
        }

        private void RefreshItemCountAct(PackType packType, int arg2, int id)
        {
            if (packType == PackType.Item && id == fairyBossModel.fairyBossFood)
            {
                DisplayFairyFood();
            }
        }

        void DisplayFairyFood()
        {
            var singlepack = packModel.GetSinglePack(PackType.Item);
            var count = 0;
            if (singlepack != null)
            {
                count = singlepack.GetCountById(fairyBossModel.fairyBossFood);
            }
            ItemCellModel itemCellModel = new ItemCellModel(fairyBossModel.fairyBossFood, true, (ulong)count);
            m_FairyFood.Init(itemCellModel);
            m_FairyFood.countText.color = UIHelper.GetUIColor(count > 0 ? TextColType.Green : TextColType.Red);
            m_FairyFood.countText.gameObject.SetActive(true);
        }

        private void HandIn()
        {
            fairyBossModel.HandInFairyFood();
        }

        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            closeBtn.onClick.AddListener(OnClose);
            previewBtn.onClick.AddListener(OnPreviewAward);
            beginBtn.onClick.AddListener(OnBeginBtn);
            m_GetWayBtn.onClick.AddListener(OnFoodGetWay);
            m_HandIn.onClick.AddListener(HandIn);
            m_FairyFood.button.AddListener(OnFoodGetWay);
        }

        protected override void OnPreOpen()
        {
            PlayerDatas.Instance.fairyData.OnRefreshFairyBoss += OnRefreshFairyBoss;
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += OnRefreshFairyBoss;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine += OnRefreshFairyMine;
            TimeMgr.Instance.OnHourEvent += OnRefreshFairyBoss;
            packModel.refreshItemCountEvent += RefreshItemCountAct;
            InitData();
            OnRefreshFairyBoss();
            OnShowFairyBossModel();
            DisplayFairyFood();
        }



        protected override void OnAfterOpen()
        {

        }

        protected override void OnPreClose()
        {

        }

        protected override void OnAfterClose()
        {
            UI3DModelExhibition.Instance.StopShow();
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= OnRefreshFairyBoss;
            PlayerDatas.Instance.fairyData.OnRefreshFairyBoss -= OnRefreshFairyBoss;
            TimeMgr.Instance.OnHourEvent -= OnRefreshFairyBoss;
            packModel.refreshItemCountEvent -= RefreshItemCountAct;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= OnRefreshFairyMine;
        }

        float m_Time = 0;
        float m_DelayTime = 0.5f;
        protected override void LateUpdate()
        {
            base.LateUpdate();
            m_Time += Time.deltaTime;
            if (m_Time < m_DelayTime)
            {
                return;
            }
            m_Time = 0;
            switch (m_TimeStage)
            {
                case FairyBossTime.BeforeOpen:
                case FairyBossTime.Open:
                    UpdateCoolDown();
                    break;
            }
        }

        enum FairyBossTime
        {
            None,
            BeforeOpen,
            PrepareOpen,
            Open,
            PrepareClose,
        }
    }
}