//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Wednesday, October 25, 2017
//--------------------------------------------------------

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


namespace Snxxz.UI
{
    public class MultipleDifficultyDungeonWin : Window
    {
        [SerializeField] Text m_DungeonTitle;
        [SerializeField] DungeonBreifInfo m_BreifInfo;
        [SerializeField] CyclicScroll m_DifficultyScroll;
        [SerializeField] ButtonEx m_Sweep;
        [SerializeField] Text m_ChallengeButtonTitle;
        [SerializeField] ImageEx m_ChallengeIcon;
        [SerializeField] ButtonEx m_SingleStart;
        [SerializeField] Button m_CloseWin;

        List<Dungeon> dungeons = new List<Dungeon>();

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

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

        protected override void AddListeners()
        {
            m_SingleStart.AddListener(ChallengeDungeon);
            m_Sweep.AddListener(SweepDungeon);
            m_CloseWin.AddListener(CloseClick);
        }

        protected override void OnPreOpen()
        {
            ParseDifficultys();

            if (model.selectedKylinDungeon == default(Dungeon))
            {
                var playerLevel = PlayerDatas.Instance.baseData.LV;
                for (int i = dungeons.Count - 1; i >= 0; i--)
                {
                    var dungeonId = model.GetDungeonId(dungeons[i]);
                    var config = DungeonConfig.Get(dungeonId);

                    var challengable = false;
                    if (playerLevel >= config.LVLimitMin)
                    {
                        challengable = i == 0 || model.GetGrade(dungeons[i - 1]) > 0;
                    }

                    if (challengable)
                    {
                        model.selectedKylinDungeon = dungeons[i];
                        break;
                    }
                }
            }

            DrawDungeonBaseInfo();
        }

        protected override void OnAfterOpen()
        {
            model.kylinDifficultySelectedEvent += OnSelectedDifficulty;
            model.dungeonRecordChangeEvent += OnDungeonRecordChange;
            model.updateDungeonBuyCnt += UpdateDungeonTimes;
        }

        protected override void OnPreClose()
        {
            model.kylinDifficultySelectedEvent -= OnSelectedDifficulty;
            model.dungeonRecordChangeEvent -= OnDungeonRecordChange;
            model.updateDungeonBuyCnt -= UpdateDungeonTimes;
        }

        protected override void OnAfterClose()
        {
            m_DifficultyScroll.Dispose();

        }

        protected override void OnActived()
        {
            base.OnActived();
            OnDungeonRecordChange(31190);
            ShowDifficultys();

            CheckAchievementGuide();
        }

        #endregion

        private void DrawDungeonBaseInfo()
        {
            var dungeonId = model.GetDungeonId(model.selectedKylinDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);

            m_DungeonTitle.text = dungeonConfig.FBName;
            m_BreifInfo.SetDungeonInfo(model.selectedKylinDungeon);
        }

        private void SweepDungeon()
        {
            var error = 0;
            if (TestSweepDungeon(out error))
            {
                model.RequestSweep(model.selectedKylinDungeon);
            }
            else
            {
                var dungeonId = model.GetDungeonId(model.selectedKylinDungeon);
                var dungeonConfig = DungeonConfig.Get(dungeonId);
                switch (error)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("MoppingUpLV", dungeonConfig.SweepLVLimit);
                        break;
                    case 2:
                        SysNotifyMgr.Instance.ShowTip("MoppingUpPass", dungeonConfig.LVLimitMin);
                        break;
                    case 3:
                        model.currentDungeon = model.selectedKylinDungeon;
                        WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                        break;
                    case 4:
                        SysNotifyMgr.Instance.ShowTip("Multiple_Finish");
                        break;
                    case 5:
                        SysNotifyMgr.Instance.ShowTip("SweepFB_1");
                        break;
                }
            }

        }

        private void ChallengeDungeon()
        {
            var error = 0;
            if (TestChallengeDungeon(out error))
            {
                model.SingleChallenge(model.selectedKylinDungeon);
            }
            else
            {
                var dungeonId = model.GetDungeonId(model.selectedKylinDungeon);
                var dungeonConfig = DungeonConfig.Get(dungeonId);
                switch (error)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("Multiple_UpLV", dungeonConfig.LVLimitMin);
                        break;
                    case 2:
                        MessageWin.Inst.ShowFixedTip(Language.Get("InsufficientTL_Z"));
                        break;
                    case 3:
                        var requireLineId = model.selectedKylinDungeon.lineId - 1;
                        var requireGrade = model.GetGrade(new Dungeon(model.selectedKylinDungeon.mapId, requireLineId));
                        var requireDungeonId = model.GetDungeonId(new Dungeon(model.selectedKylinDungeon.mapId, requireLineId));
                        var requireDungeonConfig = DungeonConfig.Get(requireDungeonId);
                        SysNotifyMgr.Instance.ShowTip("NotChallengeMultiple", requireDungeonConfig.LVLimitMin);
                        break;
                    case 4:
                        WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                        break;
                }
            }
        }

        private void ShowDifficultys()
        {
            m_DifficultyScroll.Init(dungeons);

            model.currentDungeon = model.selectedKylinDungeon;
            var index = dungeons.IndexOf(model.selectedKylinDungeon);
            m_DifficultyScroll.MoveToCenter(index);
        }

        private void OnSelectedDifficulty(Dungeon _dungeon)
        {
            DrawDungeonBaseInfo();
        }

        private void UpdateDungeonTimes()
        {
            OnDungeonRecordChange(31190);
        }

        private void OnDungeonRecordChange(int _dataMapId)
        {
            var state = dailyQuestModel.GetQuestState((int)DailyQuestType.Kirin);

            if (state == DailyQuestModel.DailyQuestState.CanBuyTimes)
            {
                m_ChallengeButtonTitle.text = Language.Get("Multiple_BuyCount");
            }
            else
            {
                m_ChallengeButtonTitle.text = Language.Get("Multiple_Challenge");
            }

            m_ChallengeIcon.gray = state == DailyQuestModel.DailyQuestState.Completed;
        }

        private bool TestSweepDungeon(out int _error)
        {
            var dungeonId = model.GetDungeonId(model.selectedKylinDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            var playerLevel = PlayerDatas.Instance.baseData.LV;

            var dataMapId = model.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (dataMapId == model.selectedKylinDungeon.mapId)
            {
                _error = 5;
                return false;
            }

            if (playerLevel < dungeonConfig.SweepLVLimit)
            {
                _error = 1;
                return false;
            }

            var dungeonGrade = model.GetGrade(model.selectedKylinDungeon);
            if (dungeonGrade <= 0)
            {
                _error = 2;
                return false;
            }

            var state = dailyQuestModel.GetQuestState((int)DailyQuestType.Kirin);
            if (state == DailyQuestModel.DailyQuestState.CanBuyTimes)
            {
                _error = 3;
                return false;
            }

            if (state == DailyQuestModel.DailyQuestState.Completed)
            {
                _error = 4;
                return false;
            }

            _error = 0;
            return true;
        }

        private bool TestChallengeDungeon(out int _error)
        {
            var dungeonId = model.GetDungeonId(model.selectedKylinDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            var playerLevel = PlayerDatas.Instance.baseData.LV;

            if (playerLevel < dungeonConfig.LVLimitMin)
            {
                _error = 1;
                return false;
            }

            var jobRank = PlayerDatas.Instance.baseData.ExAttr1;
            if (jobRank < dungeonConfig.JobRankLimit)
            {
                _error = 2;
                return false;
            }

            if (model.selectedKylinDungeon.lineId > 0)
            {
                var requireLineId = model.selectedKylinDungeon.lineId - 1;
                var requireGrade = model.GetGrade(new Dungeon(model.selectedKylinDungeon.mapId, requireLineId));
                if (requireGrade <= 0)
                {
                    _error = 3;
                    return false;
                }
            }

            var enterTimes = model.GetEnterTimes(model.selectedKylinDungeon.mapId);
            var totalTimes = model.GetTotalTimes(model.selectedKylinDungeon.mapId);
            var surplusTimes = totalTimes - enterTimes;
            if (surplusTimes <= 0)
            {
                _error = 4;
                return false;
            }

            _error = 0;
            return true;
        }

        private void ParseDifficultys()
        {
            dungeons.Clear();
            var lineIds = model.GetDugeonLines(model.currentDungeon.mapId);
            for (int i = 0; i < lineIds.Count; i++)
            {
                dungeons.Add(new Dungeon(model.currentDungeon.mapId, lineIds[i]));
            }

            dungeons.Sort(
                (Dungeon a, Dungeon b) =>
                {
                    var dungeonConfigA = DungeonConfig.Get(model.GetDungeonId(a));
                    var dungeonConfigB = DungeonConfig.Get(model.GetDungeonId(b));
                    return dungeonConfigA.LVLimitMin < dungeonConfigB.LVLimitMin ? -1 : 1;
                }
                );
        }

        private void CheckAchievementGuide()
        {
            if (AchievementGoto.guideAchievementId != 0)
            {
                var config = SuccessConfig.Get(AchievementGoto.guideAchievementId);
                var condition = config.Type == 49 && config.Condition[0] == model.selectedKylinDungeon.lineId + 1;

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

    }

}