//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, October 10, 2017
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;
using Snxxz.UI;
using EnhancedUI.EnhancedScroller;

namespace Snxxz.UI
{

    public class RealmUpWin : Window
    {
        #region built-in
        [SerializeField] RectTransform m_ContainerNow;
        [SerializeField] RectTransform m_ContainerNowHasRealm;
        [SerializeField] RectTransform m_ContainerNext;
        [SerializeField] RectTransform m_ContainerProgress;
        [SerializeField] RectTransform m_ContainerModel;

        [SerializeField] RectTransform m_ContainerNoHighestBottom;
        [SerializeField] RectTransform m_ContainerHighestBottom;

        [SerializeField] Image m_RealmTitleNext;
        [SerializeField] RealmIcon m_RealmIconNow;
        [SerializeField] RealmIcon m_RealmIconNowHighest;
        [SerializeField] RealmIcon m_RealmIconNext;
        [SerializeField] RealmPropertyCell m_RealmPropertyNow;
        [SerializeField] RealmPropertyCell m_RealmPropertyNext;

        [SerializeField] RawImage m_RawBoss;
        [SerializeField] RawImage m_RawPlayer;

        [SerializeField] RealmProgressBehaviour m_RealmProgress;

        [SerializeField] UIEffect m_RealmDungeonSfx;

        [SerializeField] Button m_FuncButton;
        [SerializeField] Text m_FuncButtonTxt;
        [SerializeField] Text m_RealmStageTip;

        [SerializeField] RectTransform m_ContainerFightPower;
        [SerializeField] Text m_FightPower;

        [SerializeField] Button m_RealmPreview;

        [SerializeField, Header("Boss初始朝向")] Vector3 direction = Vector3.zero;
        [SerializeField, Header("模型位置")] Vector3[] m_ModelPositions;
        [SerializeField, Header("当前境界位置")] Vector3[] m_RealmNowPositions;
        [SerializeField, Header("下一境界位置")] Vector3[] m_RealmNextwPositions;
        [SerializeField, Header("Boss位置")] Vector3[] m_BossPositions;
        [SerializeField, Header("Boss出现延长")] float m_DelayEnterTime = 1f;
        [SerializeField, Header("出场总时长")] float m_BossEnterDuration = 3f;
        int cacheRealmPoint = 0;
        Coroutine cacheCoroutine = null;
        const string State_EnterHash = "Show";
        const string State_IdleHash = "Idle";
        DateTime overdueTime = DateTime.Now;

        RealmModel realmModel { get { return ModelCenter.Instance.GetModel<RealmModel>(); } }



        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_FuncButton.onClick.AddListener(OnFunctionClick);
            m_RealmPreview.onClick.AddListener(OnRealmPreview);
        }

        protected override void OnPreOpen()
        {
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
            cacheRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
            m_RawBoss.gameObject.SetActive(false);
            m_RawPlayer.gameObject.SetActive(false);
            overdueTime = DateTime.Now;
            Display();
        }

        protected override void OnActived()
        {
            base.OnActived();
            if (realmModel.realmDungeonState)
            {
                StopBoss();
                m_RawBoss.gameObject.SetActive(false);
                m_RawPlayer.gameObject.SetActive(true);
                UI3DModelExhibition.Instance.BeginShowSitDownPlayer(m_RawPlayer, PlayerDatas.Instance.baseData.Job);
            }
        }

        protected override void OnAfterOpen()
        {
            HandleAchievement();
            if (realmModel.openByDungeonStep)
            {
                m_RawBoss.gameObject.SetActive(false);
                m_RawPlayer.gameObject.SetActive(false);
                ActivateShow.RealmActivate(PlayerDatas.Instance.baseData.realmLevel);
            }
            realmModel.openByDungeonStep = false;
            if (realmModel.realmDungeonState)
            {
                m_RealmDungeonSfx.Play();
                overdueTime = DateTime.Now.AddSeconds(m_BossEnterDuration);
                StartCoroutine(Co_DisplayBossShow());
            }
            realmModel.realmDungeonState = false;
        }

        protected override void OnPreClose()
        {
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
            StopBoss();
            UI3DModelExhibition.Instance.StopShowPlayer();
            realmModel.realmDungeonState = false;
            if (cacheCoroutine != null)
            {
                StopCoroutine(cacheCoroutine);
                cacheCoroutine = null;
            }
        }

        protected override void OnAfterClose()
        {
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            if (!realmModel.IsRealmHighest && _realmPoint >= config.NeedPoint
                && realmModel.realmRedpoint.state == RedPointState.Simple)
            {
                realmModel.openedRealmUpWin = true;
                realmModel.UpdateRedpoint();
            }
        }
        #endregion

        IEnumerator Co_DisplayBossShow()
        {
            yield return WaitingForSecondConst.WaitMS800;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            m_RawPlayer.gameObject.SetActive(false);
            UI3DModelExhibition.Instance.StopShowPlayer();
            yield return WaitingForSecondConst.GetWaitForSeconds(m_DelayEnterTime > 0 ? m_DelayEnterTime : 1f);
            StartBoss(config, true);
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
        {
            if (refreshType == PlayerDataRefresh.OfficialRank)
            {
                DisplayRealmNow();
                DisplayRealmNext();
                DisplayModel();
                DisplayButton();
                DisplayProgress();
                DisplayContainer();
            }
            else if (refreshType == PlayerDataRefresh.RealmPoint)
            {
                m_RealmProgress.DisplayProgress(true);
                DisplayRemind();
                DisplayModel();
                DisplayButton();

                cacheRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
            }
        }

        private void Display()
        {
            DisplayRealmNow();
            DisplayRealmNext();
            DisplayModel();
            DisplayProgress();
            DisplayButton();
            DisplayContainer();
        }

        private void DisplayRealmNow()
        {
            var _realmLv = PlayerDatas.Instance.baseData.realmLevel;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            m_ContainerNow.gameObject.SetActive(_realmLv > 0);
            m_ContainerNoHighestBottom.gameObject.SetActive(!realmModel.IsRealmHighest);
            m_ContainerHighestBottom.gameObject.SetActive(realmModel.IsRealmHighest);
            if (_realmLv > 0)
            {
                m_RealmPropertyNow.Display(_realmLv, false);
                m_RealmIconNow.Display(_realmLv);
                m_RealmIconNowHighest.Display(_realmLv);
            }
        }

        private void DisplayRealmNext()
        {
            var _realmLv = PlayerDatas.Instance.baseData.realmLevel + 1;
            var config = Config.Instance.Get<RealmConfig>(_realmLv);
            m_ContainerNext.gameObject.SetActive(config != null);
            if (config != null)
            {
                m_RealmPropertyNext.Display(_realmLv, false);
                m_RealmIconNext.Display(_realmLv);
                var fightPower = PlayerDatas.Instance.baseData.FightPoint;

                var presentConfig = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
                if (presentConfig != null && presentConfig.IsBigRealm == 1)
                {
                    m_FightPower.text = Language.Get("RealmRecommendTip", UIHelper.ReplaceLargeNum(config.FightPower));
                }
                else
                {
                    m_FightPower.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Green, Language.Get("RolePromoteBetterFight")),
                    UIHelper.GetTextColorByItemColor(fightPower >= config.FightPower ? TextColType.Green : TextColType.Red, fightPower.ToString())
                    , "/", config.FightPower);
                }
            }
        }

        private void DisplayProgress()
        {

            if (!realmModel.IsRealmHighest)
            {
                m_RealmProgress.Display();
            }
            DisplayRemind();
        }

        private void DisplayRemind()
        {
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            m_ContainerFightPower.gameObject.SetActive(!realmModel.IsRealmHighest && _realmPoint >= config.NeedPoint);
            if (_realmPoint < config.NeedPoint)
            {
                m_RealmStageTip.text = Language.Get("RealmWin_Bewrite_39");
            }
            else
            {
                if (config.IsBigRealm == 1)
                {
                    m_RealmStageTip.text = Language.Get("RealmWin_Bewrite_2");
                }
                else
                {
                    m_RealmStageTip.text = Language.Get("RealmWin_Bewrite_11");
                }
            }
            if (realmModel.IsRealmHighest)
            {
                m_RealmStageTip.text = string.Empty;
            }
        }

        private void DisplayModel()
        {
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            if (realmModel.IsRealmHighest || _realmPoint < config.NeedPoint)
            {
                m_RawPlayer.gameObject.SetActive(true);
                StopBoss();
                m_RawBoss.gameObject.SetActive(false);
                UI3DModelExhibition.Instance.BeginShowSitDownPlayer(m_RawPlayer, PlayerDatas.Instance.baseData.Job);
            }
            else if (_realmPoint >= config.NeedGood)
            {
                m_RawBoss.gameObject.SetActive(true);
                m_RawPlayer.gameObject.SetActive(false);
                UI3DModelExhibition.Instance.StopShowPlayer();
                StartBoss(config);
            }
        }

        private void StopBoss()
        {
            UI3DModelExhibition.Instance.StopShowNPC();
        }

        private void StartBoss(RealmConfig config, bool act = false)
        {
            StopBoss();
            m_RawBoss.gameObject.SetActive(true);
            UI3DModelExhibition.Instance.StopShowPlayer();
            UI3DModelExhibition.Instance.BeginShowNPC(config.BossID, config.IsBigRealm == 1 ? Vector3.zero : direction, m_RawBoss, false);
            var npcConfig = Config.Instance.Get<NPCConfig>(config.BossID);
            var npcModel = UI3DModelExhibition.Instance.NpcModelPet;
            m_RawBoss.transform.localPosition = config.IsBigRealm == 1 ? m_BossPositions[1] : m_BossPositions[0];
            if (npcModel != null)
            {
                var animator = npcModel.GetComponentInChildren<Animator>();
                if (animator != null)
                {
                    var runtimeController = AnimatorControllerLoader.LoadMobController(AnimatorControllerLoader.controllerRealmSuffix, npcConfig.MODE);
                    animator.runtimeAnimatorController = runtimeController;
                    animator.Play(act ? State_EnterHash : State_IdleHash, 0);
                }
            }
        }

        private void DisplayContainer()
        {
            int _state = PlayerDatas.Instance.baseData.realmLevel == 0 ? 0 : realmModel.IsRealmHighest ? 2 : 1;
            m_ContainerProgress.gameObject.SetActive(_state != 2);
            m_ContainerNow.transform.localPosition = _state == 2 ? m_RealmNowPositions[1] : m_RealmNowPositions[0];
            m_ContainerNext.transform.localPosition = _state == 0 ? m_RealmNextwPositions[1] : m_RealmNextwPositions[0];
            m_ContainerModel.transform.localPosition = m_ModelPositions[_state];
            m_RealmTitleNext.SetSprite(_state == 0 ? "TB_JJ_10" : "TB_JJ_7");
        }

        private void DisplayButton()
        {
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            m_FuncButton.gameObject.SetActive(!realmModel.IsRealmHighest);
            if (_realmPoint >= config.NeedPoint)
            {
                m_FuncButtonTxt.text = Language.Get(config.IsBigRealm == 1 ? "RealmWin_Bewrite_13" : "RealmWin_Bewrite_12");
            }
            else
            {
                m_FuncButtonTxt.text = Language.Get("RealmWin_Bewrite_1");
            }
        }

        private void OnFunctionClick()
        {
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            if (_realmPoint >= config.NeedPoint)
            {
                if (DateTime.Now < overdueTime)
                {
                    return;
                }
                PlayerDatas.Instance.realm.realmHelpList.Clear();
                if (config.IsBigRealm == 1)
                {
                    var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
                    if (teamModel.myTeam.inTeam && teamModel.myTeam.iamCaptainer)
                    {
                        ModelCenter.Instance.GetModel<DungeonModel>().GroupChallengeDungeon(RealmModel.REALM_DUNGEON_ID, 1);
                    }
                    else
                    {
                        teamModel.missionBuf = teamModel.currentMission = new TeamMission(31110, 1);
                        WindowCenter.Instance.Open<TeamFrameWin>(false, teamModel.myTeam.inTeam ? 1 : 0);
                    }
                }
                else
                {
                    ModelCenter.Instance.GetModel<DungeonModel>().SingleChallengeDungeon(RealmModel.REALM_DUNGEON_ID);
                }
            }
            else
            {
                WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.DailyQuestFunc1);
            }
        }

        private void OnRealmPreview()
        {
            WindowCenter.Instance.Open<RealmPreviewWin>();
        }

        void HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.RealmDungeon)
            {
                if (!realmModel.IsRealmHighest)
                {
                    var _effect = AchievementGuideEffectPool.Require(1);
                    _effect.transform.SetParentEx(m_FuncButton.transform, Vector3.zero, Vector3.zero, Vector3.one);
                    AchievementGoto.achievementType = 0;
                }
            }
            else if (AchievementGoto.achievementType == AchievementGoto.RealmDungeonHelp)
            {
                var _level = PlayerDatas.Instance.baseData.realmLevel;
                var _realmCfg = Config.Instance.Get<RealmConfig>(_level);
                if (_realmCfg != null && _realmCfg.IsBigRealm == 1 && realmModel.IsDungeonState)
                {
                    var _effect = AchievementGuideEffectPool.Require(1);
                    _effect.transform.SetParentEx(m_FuncButton.transform, Vector3.zero, Vector3.zero, Vector3.one);
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("Achievement_79");
                }
                AchievementGoto.achievementType = 0;
            }
            AchievementGoto.achievementType = 0;
        }

        private void WindowAfterCloseEvent(Window _win)
        {
            if (_win is RealmPropertyUpWin)
            {
                DisplayModel();
            }
        }
    }
}