//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Wednesday, September 20, 2017
//--------------------------------------------------------

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


namespace Snxxz.UI
{
    public class TrialDungeonEntranceWin : Window
    {
        [SerializeField] Text m_Title;
        [SerializeField] Text m_LevelLimit;
        [SerializeField] Text m_PetHorseLevelLimit;
        [SerializeField] Text m_PreFloorLimit;
        [SerializeField] Text m_ChallengeTimes;
        [SerializeField] Text m_DropItemTxt;

        [SerializeField] Button m_GroupStart;
        [SerializeField] Button m_SingleStart;
        [SerializeField] Button m_AutoGroupStart;
        [SerializeField] Button m_Sweep;
        [SerializeField] Button m_CloseWin;

        [SerializeField] RawImage m_BossPortrayal;

        [SerializeField] Image m_BossRealm;
        [SerializeField] Text m_BossName;

        [SerializeField] RectTransform m_ContainerGroup;
        [SerializeField] Button m_Group;

        [SerializeField] TrialRewardsBehaviour[] m_RewardBehaviours;
        [SerializeField] ScrollRect m_RewardScroller;

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

        TeamModel m_TeamModel;
        TeamModel teamModel {
            get {
                return m_TeamModel ?? (m_TeamModel = ModelCenter.Instance.GetModel<TeamModel>());
            }
        }

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

        TrialDungeonModel trialDungeonModel { get { return ModelCenter.Instance.GetModel<TrialDungeonModel>(); } }

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

        protected override void AddListeners()
        {
            m_GroupStart.AddListener(ChallengeDungeonGroup);
            m_SingleStart.AddListener(ChallengeDungeon);
            m_AutoGroupStart.AddListener(AutoGroupChallenge);
            m_CloseWin.AddListener(CloseClick);
            m_Group.AddListener(OpenGroup);
            m_Sweep.AddListener(Sweep);
        }

        protected override void OnPreOpen()
        {
            model.dungeonRecordChangeEvent += UpdateDungeonTimes;

            DisplayButtonState();
            m_ContainerGroup.gameObject.SetActive(false);

            DrawDungeonBaseInfo();
            DrawRewards();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.dungeonRecordChangeEvent -= UpdateDungeonTimes;
            UI3DModelExhibition.Instance.StopShow();
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void OpenGroup()
        {
            if (!CheckChallenge())
            {
                return;
            }
            var openGroup = m_ContainerGroup.gameObject.activeSelf;
            m_ContainerGroup.gameObject.SetActive(!openGroup);
        }

        private void DrawDungeonBaseInfo()
        {
            var dungeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            m_Title.text = dungeonConfig.FBName;
            m_DropItemTxt.text = Language.Get(StringUtility.Contact("TrialDungeon_Drop", dungeonConfig.LineID));

            var dungeonOpenTimeConfig = DungeonOpenTimeConfig.Get(model.selectedTrialDungeon.mapId);
            var fbType = dungeonOpenTimeConfig.FBType;
            m_GroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);
            m_SingleStart.gameObject.SetActive(fbType == 1 || fbType == 2);
            m_AutoGroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);
            m_Group.gameObject.SetActive(fbType == 2 || fbType == 3);

            var playerLevel = PlayerDatas.Instance.baseData.LV;
            m_LevelLimit.gameObject.SetActive(playerLevel < dungeonConfig.LVLimitMin);

            var requirePetHorseLevel = trialDungeonModel.GetDungeonRequirePetHorseLevel(dungeonConfig.LineID);
            var petHorseLevel = trialDungeonModel.GetPetHorseLevel();
            m_PetHorseLevelLimit.gameObject.SetActive(petHorseLevel < requirePetHorseLevel);

            DungeonRecord dungeonRecord;
            model.TryGetRecord(dungeonConfig.MapID, out dungeonRecord);
            int star = 0;
            if (dungeonConfig.LineID > 0)
            {
                dungeonRecord.lineGrades.TryGetValue(dungeonConfig.LineID - 1, out star);
            }
            else
            {
                star = 5;
            }

            m_PreFloorLimit.gameObject.SetActive(star == 0);

            UpdateDungeonTimes(model.GetTrialMaps()[0]);

            if (dungeonConfig.BossActorID != null && dungeonConfig.BossActorID.Length > 0)
            {
                DisplayBossInfo(dungeonConfig.BossActorID[0]);
            }
            else
            {
                m_BossName.gameObject.SetActive(false);
                m_BossRealm.gameObject.SetActive(false);
            }
        }

        void DisplayBossInfo(int _npcId)
        {
            m_BossName.gameObject.SetActive(true);
            UI3DModelExhibition.Instance.ShowNPC(_npcId, Vector3.zero, m_BossPortrayal);
            var npcConfig = NPCConfig.Get(_npcId);
            if (npcConfig != null)
            {
                if (RealmConfig.Has(npcConfig.ClientRealm))
                {
                    m_BossRealm.gameObject.SetActive(true);
                    var realmConfig = RealmConfig.Get(npcConfig.ClientRealm);
                    if (realmConfig != null)
                    {
                        m_BossRealm.SetSprite(realmConfig.Img);
                    }
                }
                else
                {
                    m_BossRealm.gameObject.SetActive(false);
                }

                m_BossName.text = npcConfig.charName;
            }
        }

        private void UpdateDungeonTimes(int mapID)
        {
            int trialMapID = model.GetTrialMaps()[0];
            if (trialMapID != mapID)
            {
                return;
            }
            DungeonOpenTimeConfig dungeonOpenTimeModel = DungeonOpenTimeConfig.Get(trialMapID);
            var completedTimes = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.Trial);
            var totalTimes = dailyQuestModel.GetDailyQuestTotalTimes((int)DailyQuestType.Trial);
            m_ChallengeTimes.text = Language.Get("TrialChallengeCnt", UIHelper.AppendColor(completedTimes >= totalTimes ?
                TextColType.Red : TextColType.LightYellow, completedTimes.ToString(), true), totalTimes);
            DisplayButtonState();
        }

        private void DisplayButtonState()
        {
            m_GroupStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            m_SingleStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            m_AutoGroupStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            m_Group.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();

            bool requireSweep = RequireDisplaySweep();
            m_Sweep.gameObject.SetActive(requireSweep);
            if (requireSweep)
            {
                var error = 0;
                m_Sweep.image.material = SatisfySweep(out error) ?
                    MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            }
        }

        private void DrawRewards()
        {
            m_RewardScroller.verticalNormalizedPosition = 1;
            var dongeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var config = DungeonConfig.Get(dongeonId);
            for (int i = 0; i < m_RewardBehaviours.Length; i++)
            {
                var behaviour = m_RewardBehaviours[i];
                Item[] rewards = null;
                if (trialDungeonModel.TryGetTrialRewards(config.LineID, m_RewardBehaviours[i].grade, out rewards))
                {
                    behaviour.gameObject.SetActive(true);
                    behaviour.Display(rewards);
                }
                else
                {
                    behaviour.gameObject.SetActive(false);
                }
            }
        }

        private void ChallengeDungeon()
        {
            if (!CheckChallenge(true))
            {
                return;
            }
            model.SingleChallenge(model.selectedTrialDungeon);
        }

        private void AutoGroupChallenge()
        {
            if (!CheckChallenge(true))
            {
                return;
            }
            teamModel.RequestAutoMatchTeam(new TeamMission(model.selectedTrialDungeon.mapId, model.selectedTrialDungeon.lineId));
            WindowCenter.Instance.Open<TeamFrameWin>(false, 1);
        }

        private void ChallengeDungeonGroup()
        {
            if (!CheckChallenge(true))
            {
                return;
            }
            model.GroupChallenge(model.selectedTrialDungeon);
        }

        private bool CheckChallenge(bool requireTip = false)
        {
            var dongeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var config = DungeonConfig.Get(dongeonId);

            DungeonRecord dungeonRecord;
            model.TryGetRecord(config.MapID, out dungeonRecord);
            int star = 0;
            if (config.LineID > 0)
            {
                dungeonRecord.lineGrades.TryGetValue(config.LineID - 1, out star);
            }
            else
            {
                star = 5;
            }
            if (star == 0)
            {
                return false;
            }

            var requirePetHorseLevel = trialDungeonModel.GetDungeonRequirePetHorseLevel(config.LineID);
            var petHorseLevel = trialDungeonModel.GetPetHorseLevel();
            if (petHorseLevel < requirePetHorseLevel)
            {
                return false;
            }

            var completedTimes = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.Trial);
            var totalTimes = dailyQuestModel.GetDailyQuestTotalTimes((int)DailyQuestType.Trial);
            if (completedTimes >= totalTimes)
            {
                if (requireTip)
                {
                    SysNotifyMgr.Instance.ShowTip("GeRen_chenxin_268121", config.MapID);
                }
                return false;
            }

            var error = 0;
            if (!model.TestChallange(model.selectedTrialDungeon, out error))
            {
                if (requireTip)
                {
                    ProcessEnterDungeonError(error);
                }
                return false;
            }
            return true;
        }

        private void ProcessEnterDungeonError(int _error)
        {
            var dungeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            switch (_error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("DungeoninCoolTime");
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("DemonJar_Text2");
                    break;
                case 4:
                    if (dungeonConfig == null)
                    {
                        return;
                    }
                    SysNotifyMgr.Instance.ShowTip("GeRen_chenxin_268121", dungeonConfig.MapID);
                    break;
                case 5:
                    if (dungeonConfig == null)
                    {
                        return;
                    }
                    ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(dungeonConfig.TicketID);
                    break;
                case 6:
                    SysNotifyMgr.Instance.ShowTip("CrossMap10");
                    break;
            }
        }

        bool RequireDisplaySweep()
        {
            var dungeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            return dungeonConfig != null && dungeonConfig.SweepLVLimit > 0;
        }

        private void Sweep()
        {
            var error = 0;
            if (SatisfySweep(out error))
            {
                model.RequestSweep(model.selectedTrialDungeon);
            }
            else
            {
                var dongeonId = model.GetDungeonId(model.selectedTrialDungeon);
                var config = DungeonConfig.Get(dongeonId);
                switch (error)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("TrialDungeonSDLimit", config.SweepLVLimit,
                            Language.Get(StringUtility.Contact("Num_CHS_", config.LineID + 1)),
                            UIHelper.GetGrade(trialDungeonModel.trialSweepGradeLimit));
                        break;
                    case 2:
                        SysNotifyMgr.Instance.ShowTip("Multiple_Finish");
                        break;
                }
            }
        }

        bool SatisfySweep(out int error)
        {
            error = 0;
            var dungeonId = model.GetDungeonId(model.selectedTrialDungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);
            if (dungeonConfig == null || dungeonConfig.SweepLVLimit == 0)
            {
                return false;
            }
            if (PlayerDatas.Instance.baseData.LV < dungeonConfig.SweepLVLimit)
            {
                error = 1;
                return false;
            }
            DungeonRecord dungeonRecord;
            if (!model.TryGetRecord(dungeonConfig.MapID, out dungeonRecord))
            {
                error = 1;
                return false;
            }
            var star = 0;
            dungeonRecord.lineGrades.TryGetValue(dungeonConfig.LineID, out star);
            if (star < trialDungeonModel.trialSweepGradeLimit)
            {
                error = 1;
                return false;
            }
            var completedTimes = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.Trial);
            var totalTimes = dailyQuestModel.GetDailyQuestTotalTimes((int)DailyQuestType.Trial);
            if (completedTimes >= totalTimes)
            {
                error = 2;
                return false;
            }
            return true;
        }
    }

}