//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, November 09, 2017
//--------------------------------------------------------

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


namespace vnxbqy.UI
{

    public class RuneTowerWin : Window
    {
        public static bool guideChallenge = false;
        public static bool guideSweep = false;

        [SerializeField] RuneTowerBehaviour m_Tower;
        [SerializeField] Transform m_ContainerBossInfo;
        [SerializeField] PositionTween m_BossShowTween;
        [SerializeField] Image m_BossRealm;
        [SerializeField] Text m_BossName;
        [SerializeField] Text m_BossLevel;
        [SerializeField] RawImage m_BossPortrait;
        [SerializeField] Transform m_ContainerReward;
        [SerializeField] PositionTween m_RewardShowTween;
        [SerializeField] Text m_FigthPower;
        [SerializeField] Text m_FloorRewardTitle;
        [SerializeField] ItemBehaviour m_ProductRune;
        [SerializeField] Button m_ViewProductRune;
        [SerializeField] ItemBehaviour m_Essence;
        [SerializeField] ItemBehaviour m_MagicEssence;
        [SerializeField] RunePreviewGroup m_RunePreviewGroup;
        [SerializeField] Button m_ViewBoss;
        [SerializeField] UIEffect m_ViewBossEffect;
        [SerializeField] UIEffect m_ChangableBossEffect;
        [SerializeField] Button m_ViewReward;
        [SerializeField] UIEffect m_ViewRewardEffect;
        [SerializeField] RuneTowerPassedInfoPanel m_PassedInfoPanel;
        [SerializeField] PositionTween m_PassInfoTween;
        [SerializeField] Button m_ViewPassedInfo;
        [SerializeField] UIEffect m_ViewPassedInfoEffect;
        [SerializeField] Button m_Challenge;
        [SerializeField] ImageEx m_ChallengeIcon;
        [SerializeField] Button m_Sweep;
        [SerializeField] Text m_SweepButtonDescription;
        [SerializeField] Text m_SweepTip;

        ShowType showType = ShowType.RewardInfo;
        int runeSweepActionId = 0;

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

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

        protected override void AddListeners()
        {
            m_ViewBoss.AddListener(PopupBossInfo);
            m_ViewReward.AddListener(PopupRewardInfo);
            m_ViewPassedInfo.AddListener(PopupTowerPassInfo);
            m_Challenge.AddListener(ChallengeTower);
            m_Sweep.AddListener(SweepTower);
            m_ViewProductRune.AddListener(ViewRuneProduct);
        }

        protected override void OnPreOpen()
        {
            WindowCenter.Instance.uiRoot.eventSystem.enabled = true;
            model.selectedFloor = model.currentFloor;
            var challengable = !model.allTowerCompleted && model.selectedFloor == model.currentFloor;
            m_ChallengeIcon.gray = !challengable;
            m_PassedInfoPanel.Display();

            UpdateBossInfo();
            UpdateFloorRewardInfo();
            UpdateFightPower();

            runeSweepActionId = DailyQuestConfig.Get((int)DailyQuestType.RuneTowerSweep).RelatedID;
            OnRuneTowerSweepResult(runeSweepActionId);

            model.selectedFloorEvent += OnSelectedFloorChange;
            dailyQuestModel.dailyQuestProgressUpdateEvent += OnRuneTowerSweepResult;
        }

        protected override void OnAfterOpen()
        {

        }

        protected override void OnPreClose()
        {
            guideChallenge = false;
            guideSweep = false;
            WindowCenter.Instance.uiRoot.eventSystem.enabled = true;
            m_Tower.Dispose();
            UI3DModelExhibition.Instance.StopShow();
            model.selectedFloorEvent -= OnSelectedFloorChange;
            dailyQuestModel.dailyQuestProgressUpdateEvent -= OnRuneTowerSweepResult;
        }

        protected override void OnAfterClose()
        {
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

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

            PopupRewardInfo();

            if (model.wannaShowUnlockTower > 0)
            {
                WindowCenter.Instance.uiRoot.eventSystem.enabled = false;
                m_Tower.TowerCollapseShow(model.wannaShowUnlockTower, model.currentTower, OnTowerCollapseCompleted);
            }
            else
            {
                m_Tower.Display(model.currentTower);
            }

            CheckTaskGuide();
            CheckSweepGuide();
            CheckAchievementGuide();
        }


        public override void CloseClick()
        {
            base.CloseClick();
        }

        #endregion

        private void ChallengeTower()
        {
            if (!model.allTowerCompleted && model.currentFloor == model.selectedFloor)
            {
                var config = RuneTowerFloorConfig.Get(model.selectedFloor);
                if (PlayerDatas.Instance.baseData.FightPoint >= (ulong)NPCExConfig.Get(config.BossId).SuppressFightPower)
                {
                    model.RequestChallengeTower();
                }
                else
                {
                    ConfirmCancel.ShowPopConfirm(
                        Language.Get("Mail101"),
                        Language.Get("RuneTower25", NPCExConfig.Get(config.BossId).SuppressFightPower),
                        (bool ok) =>
                        {
                            if (ok)
                            { model.RequestChallengeTower(); }
                        }
                        );
                }
            }
        }

        private void SweepTower()
        {
            var latestPassedFloor = model.yesterdayPassFloor;
            if (latestPassedFloor > 0)
            {
                var completedTime = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.RuneTowerSweep);
                if (completedTime > 0)
                {
                    WindowCenter.Instance.Open<RuneTowerSweepBuyWin>();
                }
                else
                {
                    dungeonModel.RequestSweep(new Dungeon(RuneTowerModel.RUNETOWER_MAPID, 0));
                }
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("RuneTowerNoChalleng");
            }
        }

        private void UpdateBossInfo()
        {
            var towerFloorConfig = RuneTowerFloorConfig.Get(model.selectedFloor);
            var npcConfig = NPCConfig.Get(towerFloorConfig.BossId);

            if (npcConfig.Realm > 0 && RealmConfig.Has(npcConfig.Realm))
            {
                m_BossRealm.SetActive(true);
                var realmConfig = RealmConfig.Get(npcConfig.Realm);
                m_BossRealm.SetSprite(realmConfig.Img);
            }
            else
            {
                m_BossRealm.SetActive(false);
            }

            m_BossName.text = npcConfig.charName;
            m_BossLevel.text = Language.Get("HeadUpName_Monster", npcConfig.NPCLV);

            UI3DModelExhibition.Instance.ShowNPC(towerFloorConfig.BossId, new Vector3(0, 30, 0), m_BossPortrait);

            var challengable = !model.allTowerCompleted && model.selectedFloor == model.currentFloor;
            if (challengable)
            {
                m_ChangableBossEffect.Play();
            }
            else
            {
                m_ChangableBossEffect.Stop();
            }
        }

        private void UpdateFloorRewardInfo()
        {
            var towerConfig = RuneTowerConfig.Get(model.currentTower);
            var towerFloorConfig = RuneTowerFloorConfig.Get(model.selectedFloor);

            m_FloorRewardTitle.text = towerFloorConfig.RewardTitle;
            m_ProductRune.SetItem(towerConfig.ProductRune, 0);

            if (towerFloorConfig.RuneEssence > 0)
            {
                m_Essence.SetActive(true);
                m_Essence.SetItem(2106, towerFloorConfig.RuneEssence);
            }
            else
            {
                m_Essence.SetActive(false);
            }

            if (towerFloorConfig.RuneMagicEssence > 0)
            {
                m_MagicEssence.SetActive(true);
                m_MagicEssence.SetItem(4307, towerFloorConfig.RuneMagicEssence);
            }
            else
            {
                m_MagicEssence.SetActive(false);
            }

            var nextUnLockFloor = model.GetNextUnLockFloor(model.selectedFloor);
            m_RunePreviewGroup.Display(model.selectedFloor, nextUnLockFloor);
        }

        private void UpdateFightPower()
        {
            var towerConfig = RuneTowerConfig.Get(model.currentTower);
            var towerFloorConfig = RuneTowerFloorConfig.Get(model.selectedFloor);
            m_FigthPower.text = NPCExConfig.Get(towerFloorConfig.BossId).SuppressFightPower.ToString();

            var reached = PlayerDatas.Instance.baseData.FightPoint >= (ulong)NPCExConfig.Get(towerFloorConfig.BossId).SuppressFightPower;
            m_FigthPower.color = UIHelper.GetUIColor(reached ? TextColType.Green : TextColType.Red);
        }

        private void PopupBossInfo()
        {
            showType = ShowType.BossInfo;
            UpdateUIElement(showType);
            UpdateBossInfo();
            m_BossShowTween.Play();
        }

        private void PopupRewardInfo()
        {
            showType = ShowType.RewardInfo;
            UpdateUIElement(showType);
            UpdateFloorRewardInfo();
            UpdateFightPower();
            m_RewardShowTween.Play();
        }

        private void PopupTowerPassInfo()
        {
            showType = ShowType.PassedInfo;
            UpdateUIElement(showType);
            m_PassInfoTween.Play();
        }

        private void OnSelectedFloorChange(int _floor)
        {
            var challengable = !model.allTowerCompleted && model.selectedFloor == model.currentFloor;
            m_ChallengeIcon.gray = !challengable;
            switch (showType)
            {
                case ShowType.BossInfo:
                    UpdateBossInfo();
                    break;
                case ShowType.RewardInfo:
                    UpdateFloorRewardInfo();
                    UpdateFightPower();
                    break;
            }
        }

        private void OnRuneTowerSweepResult(int _dailyQuestId)
        {
            if (_dailyQuestId == runeSweepActionId)
            {
                var dailyState = dailyQuestModel.GetQuestState((int)DailyQuestType.RuneTowerSweep);

                if (model.yesterdayPassFloor > 0)
                {
                    m_Sweep.SetActive(true);
                    m_Sweep.interactable = dailyState != DailyQuestModel.DailyQuestState.Completed;

                    if (dailyState == DailyQuestModel.DailyQuestState.Completed)
                    {
                        m_SweepTip.text = Language.Get("RuneTower7");
                        m_SweepButtonDescription.text = Language.Get("RuneTower22");
                    }
                    else
                    {
                        var floorConfig = RuneTowerFloorConfig.Get(model.yesterdayPassFloor);
                        var towerConfig = RuneTowerConfig.Get(floorConfig.TowerId);
                        m_SweepTip.text = Language.Get("RuneTower6", StringUtility.Contact(towerConfig.TowerName, floorConfig.FloorName));
                        var sweepTime = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.RuneTowerSweep);
                        m_SweepButtonDescription.text = Language.Get(sweepTime > 0 ? "RuneTower20" : "RuneTower22");
                    }
                }
                else
                {
                    m_Sweep.SetActive(false);
                    m_SweepTip.text = Language.Get("RuneTower4");
                }
            }
        }

        private void UpdateUIElement(ShowType _showType)
        {
            m_ContainerBossInfo.SetActive(_showType == ShowType.BossInfo);
            m_ContainerReward.SetActive(_showType == ShowType.RewardInfo);
            m_PassedInfoPanel.SetActive(_showType == ShowType.PassedInfo);

            m_ViewBoss.transform.localScale = Vector3.one * (_showType == ShowType.BossInfo ? 1 : 0.8f);
            m_ViewReward.transform.localScale = Vector3.one * (_showType == ShowType.RewardInfo ? 1 : 0.8f);
            m_ViewPassedInfo.transform.localScale = Vector3.one * (_showType == ShowType.PassedInfo ? 1 : 0.8f);

            switch (_showType)
            {
                case ShowType.BossInfo:
                    m_ViewBossEffect.Play();
                    m_ViewPassedInfoEffect.Stop();
                    m_ViewRewardEffect.Stop();
                    break;
                case ShowType.PassedInfo:
                    m_ViewBossEffect.Stop();
                    m_ViewPassedInfoEffect.Play();
                    m_ViewRewardEffect.Stop();
                    break;
                case ShowType.RewardInfo:
                    m_ViewBossEffect.Stop();
                    m_ViewPassedInfoEffect.Stop();
                    m_ViewRewardEffect.Play();
                    break;
            }
        }

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

        private void CheckSweepGuide()
        {
            if (guideSweep && m_Sweep.gameObject.activeInHierarchy)
            {
                var guideEffect = AchievementGuideEffectPool.Require(1);
                guideEffect.transform.SetParentEx(m_Sweep.transform, Vector3.zero, Vector3.zero, Vector3.one);
            }
        }

        private void CheckAchievementGuide()
        {
            if (AchievementGoto.guideAchievementId != 0)
            {
                var config = SuccessConfig.Get(AchievementGoto.guideAchievementId);
                var condition = config.Type == 42;

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

        private void ViewRuneProduct()
        {
            var towerConfig = RuneTowerConfig.Get(model.currentTower);
            RuneInfoWin.runeId = towerConfig.ProductRune;
            WindowCenter.Instance.Open<RuneInfoWin>();
        }

        private void OnTowerCollapseCompleted()
        {
            WindowCenter.Instance.uiRoot.eventSystem.enabled = true;
        }

        public enum ShowType
        {
            BossInfo,
            RewardInfo,
            PassedInfo,
        }

    }

}