//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, December 21, 2017
//--------------------------------------------------------

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

namespace Snxxz.UI
{

    public class DemonJarWin : Window
    {
        public static bool guideChallenge = false;

        [SerializeField] CyclicScroll m_Bosses;
        [SerializeField] Text m_RewardDescription;
        [SerializeField] BossIntroduceBehaviour m_BossIntroduce;
        [SerializeField] Button m_KillRecord;
        [SerializeField] Text m_Times;
        [SerializeField] Button m_BuyTimes;
        [SerializeField] TimerBehaviour m_CountRemainTime;
        [SerializeField] Button m_Goto;
        [SerializeField] Transform m_SurpassLevel;
        [SerializeField] ToggleButton m_Subscribe;

        [SerializeField] RectTransform m_ContainerDouble;
        [SerializeField] ToggleButton m_ToggleDouble;

        DemonJarModel model { get { return ModelCenter.Instance.GetModel<DemonJarModel>(); } }
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        int enterTimes = 0;
        int totalTimes = 0;
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Goto.AddListener(GotoKillBoss);
            m_KillRecord.AddListener(ShowSkillRecord);
            m_Subscribe.AddListener(SwitchSubscribeBoss);
            m_BuyTimes.AddListener(BuyTimes);
            m_ToggleDouble.AddListener(SwitchDoubleAward);
        }

        protected override void OnPreOpen()
        {
            totalTimes = dungeonModel.GetDungeonTotalTimes(DemonJarModel.DEMONJAR_MAPID);
            enterTimes = dungeonModel.GetDungeonEnterTimes(DemonJarModel.DEMONJAR_MAPID);
            m_Times.text = StringUtility.Contact(totalTimes - enterTimes, "/", DemonJarModel.TOTALTIME_LIMIT);

            OnRemaintimeUpdate(DemonJarModel.DEMONJAR_MAPID);
            ModelCenter.Instance.GetModel<MapModel>().RequestQueryMapLineState(DemonJarModel.DEMONJAR_MAPID);
        }

        protected override void OnAfterOpen()
        {
            model.bossSelectedEvent += OnBossSelected;
            findPreciousModel.bossSubscribeChangeEvent += OnSubscribeBoss;
            dungeonModel.dungeonRecordChangeEvent += OnRemaintimeUpdate;
            dungeonModel.countRemainTimeChangeEvent += OnRemaintimeUpdate;
            dungeonModel.updateDungeonBuyCnt += OnBuyTimesOk;
            model.doubleAwardChangeEvent += OnDoubleAwardChange;
        }

        protected override void OnPreClose()
        {
            guideChallenge = false;
            model.bossSelectedEvent -= OnBossSelected;
            findPreciousModel.bossSubscribeChangeEvent -= OnSubscribeBoss;
            dungeonModel.dungeonRecordChangeEvent -= OnRemaintimeUpdate;
            dungeonModel.countRemainTimeChangeEvent -= OnRemaintimeUpdate;
            dungeonModel.updateDungeonBuyCnt -= OnBuyTimesOk;
            model.doubleAwardChangeEvent -= OnDoubleAwardChange;
        }

        protected override void OnAfterClose()
        {
        }

        protected override void OnActived()
        {
            base.OnActived();
            ShowBosses();
            model.lockSelectedBoss = false;

            CheckTaskGuide();
            CheckAchievementGuideByTimes();
            CheckAchievementGuideKillBoss();
        }
        #endregion

        private void ShowBosses()
        {
            var bosses = new List<int>();
            bosses.AddRange(model.GetDemonJarBosses());

            if (!model.lockSelectedBoss)
            {
                var targetBoss = model.GetLatestUnLockBoss();
                if (!findPreciousModel.IsBossAlive(targetBoss))
                {
                    var priorConfig = Config.Instance.Get<NPCConfig>(targetBoss);
                    if (priorConfig.NPCLV <= GeneralConfig.Instance.demonJarLevelLimit)
                    {
                        targetBoss = bosses[0];
                        for (int i = bosses.Count - 1; i >= 0; i--)
                        {
                            var bossId = bosses[i];
                            var npcConfig = Config.Instance.Get<NPCConfig>(bossId);
                            if (npcConfig.NPCLV <= priorConfig.NPCLV && findPreciousModel.IsBossAlive(bossId))
                            {
                                targetBoss = bossId;
                                break;
                            }
                        }
                    }
                }

                model.selectedBoss = targetBoss;
            }

            DemonJarBossData bossData;
            model.TryGetBossData(model.selectedBoss, out bossData);
            var npcDropConfig = Config.Instance.Get<NPCDropItemConfig>(bossData.id);
            m_SurpassLevel.gameObject.SetActive(npcDropConfig.MaxLV != 0 && PlayerDatas.Instance.baseData.LV > npcDropConfig.MaxLV);
            m_Subscribe.isOn = findPreciousModel.IsBossSubscribed(model.selectedBoss);

            var demonJarConfig = Config.Instance.Get<DemonJarConfig>(model.selectedBoss);
            var doubleShowable = demonJarConfig.CanEnterTimes == 0;

            m_ContainerDouble.gameObject.SetActive(doubleShowable);
            if (doubleShowable)
            {
                m_ToggleDouble.isOn = model.isDoubleAward;
            }

            m_BossIntroduce.Display(model.selectedBoss, true);
            m_Bosses.Init(bosses);
            m_Bosses.MoveToCenter(bosses.IndexOf(model.selectedBoss));
        }

        private void ShowSkillRecord()
        {
            findPreciousModel.ViewKillRecordsBoss = model.selectedBoss;
            WindowCenter.Instance.Open<DemonJarKillRecordWin>();
        }

        private void BuyTimes()
        {
            if ((totalTimes - enterTimes) >= DemonJarModel.TOTALTIME_LIMIT)
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("DemonJar18"));
            }
            else
            {
                dungeonModel.currentDungeon = new Dungeon(DemonJarModel.DEMONJAR_MAPID, 0);
                WindowCenter.Instance.Open<DungeonBuyTimesWin>();
            }
        }

        private void SwitchSubscribeBoss()
        {
            if (findPreciousModel.IsBossSubscribed(model.selectedBoss))
            {
                findPreciousModel.RequestDeSubscribeBoss(model.selectedBoss);
            }
            else
            {
                findPreciousModel.RequestSubscribeBoss(model.selectedBoss, false);
            }
        }

        private void OnSubscribeBoss(int _bossId)
        {
            m_Subscribe.isOn = findPreciousModel.IsBossSubscribed(model.selectedBoss);
        }

        private void SwitchDoubleAward()
        {
            var vipModel = ModelCenter.Instance.GetModel<VipModel>();
            var privilege = vipModel.GetVipPrivilegeCnt(VipPrivilegeType.DemonJarDouble) == 1;
            if (privilege)
            {
                var dataMapId = dungeonModel.GetDungeonDataIdByMapId(PlayerDatas.Instance.baseData.MapID);
                if (dataMapId == DemonJarModel.DEMONJAR_MAPID)
                {
                    SysNotifyMgr.Instance.ShowTip("CantChangeInDemon");
                }
                else
                {
                    model.RequestSetDoubleAward(!model.isDoubleAward);
                }
            }
            else
            {
                var vipLevel = vipModel.GetPrivilegeVipLv(VipPrivilegeType.DemonJarDouble, 0);
                SysNotifyMgr.Instance.ShowTip("DemonJarDoubleVip", vipLevel);
            }
        }

        private void OnDoubleAwardChange()
        {
            m_ToggleDouble.isOn = model.isDoubleAward;
        }

        private void GotoKillBoss()
        {
            var error = 0;
            if (TestEnterDungeon(out error))
            {
                var config = Config.Instance.Get<DemonJarConfig>(model.selectedBoss);
                if (config.LineID == GeneralConfig.Instance.demonJarHintLineId && PlayerDatas.Instance.baseData.LV < GeneralConfig.Instance.demonJarHintLevelLimit)
                {
                    var grade = dungeonModel.GetDungeonGrade(new Dungeon(DemonJarModel.DEMONJAR_MAPID, config.LineID));
                    if (grade <= 0)
                    {
                        ConfirmCancel.ShowPopConfirm(
                            Language.Get("Mail101"),
                            Language.Get("DemonJarFirstRemind"),
                            (bool ok) =>
                            {
                                if (ok)
                                {
                                    dungeonModel.SingleChallengeDungeon(DemonJarModel.DEMONJAR_MAPID, config.LineID);
                                }
                            }
                            );
                    }
                    else
                    {
                        dungeonModel.SingleChallengeDungeon(DemonJarModel.DEMONJAR_MAPID, config.LineID);
                    }
                }
                else
                {
                    dungeonModel.SingleChallengeDungeon(DemonJarModel.DEMONJAR_MAPID, config.LineID);
                }
            }
            else
            {

                switch (error)
                {
                    case 1:
                        DemonJarBossData bossData = null;
                        if (model.TryGetBossData(model.selectedBoss, out bossData))
                        {
                            SysNotifyMgr.Instance.ShowTip("DemonJarLvChallenge", bossData.unLockLevel);
                        }
                        break;
                    case 2:
                        dungeonModel.currentDungeon = new Dungeon(DemonJarModel.DEMONJAR_MAPID, 0);
                        WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                        break;
                    case 3:
                        SysNotifyMgr.Instance.ShowTip("DemonJar_Text1");
                        break;
                    case 4:
                        dungeonModel.currentDungeon = new Dungeon(DemonJarModel.DEMONJAR_MAPID, 0);
                        WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                        break;
                    case 5:
                        ConfirmCancel.ToggleConfirmCancel(
                            Language.Get("Mail101"),
                            Language.Get("DemonJarDoubleTip"),
                            Language.Get("DontRemindAgain"),
                            (bool _ok, bool _toggle) =>
                            {
                                if (_ok)
                                {
                                    var config = Config.Instance.Get<DemonJarConfig>(model.selectedBoss);
                                    dungeonModel.SingleChallengeDungeon(DemonJarModel.DEMONJAR_MAPID, config.LineID);
                                }

                                if (_toggle)
                                {
                                    model.doubleToKillLowerBossHint = false;
                                }
                            });
                        break;
                }
            }

        }

        private void OnRemaintimeUpdate(int _mapId)
        {
            if (DemonJarModel.DEMONJAR_MAPID != _mapId)
            {
                return;
            }

            totalTimes = dungeonModel.GetDungeonTotalTimes(DemonJarModel.DEMONJAR_MAPID);
            enterTimes = dungeonModel.GetDungeonEnterTimes(DemonJarModel.DEMONJAR_MAPID);

            m_Times.text = StringUtility.Contact(totalTimes - enterTimes, "/", DemonJarModel.TOTALTIME_LIMIT);

            if ((totalTimes - enterTimes) < DemonJarModel.TOTALTIME_LIMIT)
            {
                DateTime endTime;
                if (dungeonModel.TryGetDungeonCountRemainTime(DemonJarModel.DEMONJAR_MAPID, out endTime))
                {
                    m_CountRemainTime.gameObject.SetActive(true);
                    m_CountRemainTime.Begin(endTime);
                }
                else
                {
                    m_CountRemainTime.gameObject.SetActive(false);
                }
            }
            else
            {
                m_CountRemainTime.gameObject.SetActive(false);
            }

        }

        private void OnBuyTimesOk()
        {
            totalTimes = dungeonModel.GetDungeonTotalTimes(DemonJarModel.DEMONJAR_MAPID);
            enterTimes = dungeonModel.GetDungeonEnterTimes(DemonJarModel.DEMONJAR_MAPID);

            m_Times.text = StringUtility.Contact(totalTimes - enterTimes, "/", DemonJarModel.TOTALTIME_LIMIT);
            if (totalTimes - enterTimes >= DemonJarModel.TOTALTIME_LIMIT)
            {
                m_CountRemainTime.gameObject.SetActive(false);
            }
        }

        private bool TestEnterDungeon(out int _error)
        {
            DemonJarBossData bossData = null;
            if (model.TryGetBossData(model.selectedBoss, out bossData))
            {
                if (PlayerDatas.Instance.baseData.LV < bossData.unLockLevel)
                {
                    _error = 1;
                    return false;
                }
            }

            if (enterTimes >= totalTimes)
            {
                _error = 2;
                return false;
            }

            if (!findPreciousModel.IsBossAlive(model.selectedBoss))
            {
                _error = 3;
                return false;
            }

            var config = Config.Instance.Get<DemonJarConfig>(model.selectedBoss);
            if (config.CanEnterTimes == 0 && model.isDoubleAward && totalTimes - enterTimes < 2)
            {
                _error = 4;
                return false;
            }

            if (model.doubleToKillLowerBossHint && model.isDoubleAward
                && model.selectedBoss != model.GetLatestUnLockBoss() && config.CanEnterTimes == 0)
            {
                _error = 5;
                return false;
            }

            _error = 0;
            return true;
        }

        private void OnBossSelected(int _bossId)
        {
            m_BossIntroduce.Display(_bossId, false);
            m_Subscribe.isOn = findPreciousModel.IsBossSubscribed(_bossId);

            var npcConfig = Config.Instance.Get<NPCConfig>(_bossId);
            m_RewardDescription.text = Language.Get(npcConfig.NPCLV >= GeneralConfig.Instance.demonJarLevelLimit ? "FindPrecious_13" : "FindPrecious_18");

            DemonJarBossData bossData;
            model.TryGetBossData(_bossId, out bossData);
            var npcDropConfig = Config.Instance.Get<NPCDropItemConfig>(bossData.id);
            m_SurpassLevel.gameObject.SetActive(npcDropConfig.MaxLV != 0 && PlayerDatas.Instance.baseData.LV > npcDropConfig.MaxLV);

            var demonJarConfig = Config.Instance.Get<DemonJarConfig>(model.selectedBoss);
            var doubleShowable = demonJarConfig.CanEnterTimes == 0;
            m_ContainerDouble.gameObject.SetActive(doubleShowable);
            if (doubleShowable)
            {
                m_ToggleDouble.isOn = model.isDoubleAward;
            }
        }

        private void CheckAchievementGuideByTimes()
        {
            if (AchievementGoto.guideAchievementId != 0)
            {
                var config = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
                var condition = config.Type == 99 && config.Condition[0] == DemonJarModel.DEMONJAR_MAPID;

                if (condition)
                {
                    var guideEffect = AchievementGuideEffectPool.Require(3);
                    guideEffect.transform.SetParentEx(m_BuyTimes.transform, Vector3.zero, Vector3.zero, Vector3.one);
                }
            }
        }

        private void CheckAchievementGuideKillBoss()
        {
            if (AchievementGoto.guideAchievementId != 0)
            {
                var config = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
                var condition = config.Type == 36 && config.Condition[0] == model.selectedBoss;
                condition = condition || config.Type == 81;

                if (condition)
                {
                    var guideEffect = AchievementGuideEffectPool.Require(1);
                    guideEffect.transform.SetParentEx(m_Goto.transform, Vector3.zero, Vector3.zero, Vector3.one);
                }
            }
        }

        private void CheckTaskGuide()
        {
            if (guideChallenge)
            {
                var guideEffect = AchievementGuideEffectPool.Require(1);
                guideEffect.transform.SetParentEx(m_Goto.transform, Vector3.zero, Vector3.zero, Vector3.one);
            }
        }

    }

}