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

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

namespace vnxbqy.UI
{

    public class RealmWin : Window
    {
        [SerializeField] Transform m_ContainerRealmUp;
        [SerializeField] RealmBriefBehaviour m_RealmBrief;
        [SerializeField] RealmAnimationBehaviour m_RealmAnimation;
        [SerializeField] RealmStageBehaviour[] m_RealmStages;
        [SerializeField] Transform m_ContainerBoss;
        [SerializeField] RealmHeartMagicBehaviour m_RealmHeartMagic;
        [SerializeField] Button m_RealmRestraint;
        [SerializeField] Button m_GotoBoss;
        [SerializeField] Button m_Close;

        [SerializeField] UIEffect m_EffectCover;
        [SerializeField] UIEffect m_EffectBoss;
        [SerializeField] UIEffect m_EffectBase;
        [SerializeField] Button towerBtn;
        [SerializeField] RealmLevelUpBehaviour m_RealmUP;


        int cacheRealmLevel = 0;

        const int REALM_STAGE_COUNT = 5;

        RealmState m_RealmState = RealmState.LevelUp;
        RealmState realmState
        {
            get { return m_RealmState; }
            set
            {
                if (m_RealmState != value)
                {
                    switch (m_RealmState)
                    {
                        case RealmState.LevelUp:
                            HideRealmUp();
                            break;
                        case RealmState.Boss:
                            HideRealmBoss();
                            break;
                    }
                    m_RealmState = value;
                    switch (m_RealmState)
                    {
                        case RealmState.LevelUp:
                            DisplayRealmUp();
                            break;
                        case RealmState.Boss:
                            DisplayRealmBoss();
                            break;
                    }
                }
            }
        }

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

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        PlayerMainDate mainDateModel { get { return ModelCenter.Instance.GetModel<PlayerMainDate>(); } }

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

        protected override void AddListeners()
        {
            m_Close.onClick.AddListener(OnBack);
            m_GotoBoss.AddListener(GotoBoss);
            m_RealmRestraint.AddListener(RealmRestraint);

            towerBtn.AddListener(() => { 
                WindowCenter.Instance.Open<RealmTowerWin>();
            });
        }

        protected override void OnPreOpen()
        {
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            model.selectRealmRefresh += SelectRealmRefresh;
            m_RealmAnimation.onRotateComplete += OnRotateComplete;
            m_RealmAnimation.onLevelUpComplete += OnLevelUpComplete;
            m_RealmAnimation.onBossAppearComplete += OnBossAppearComplete;
            m_RealmAnimation.onCoverChange += OnCoverChange;
            mainDateModel.customDisplayPower += CustomDisplayPower;
            WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
            model.RealmMissionRefreshEvent += Model_RealmMissionRefreshEvent;

            cacheRealmLevel = PlayerDatas.Instance.baseData.realmLevel;
            ShowTower();
        }

        private void Model_RealmMissionRefreshEvent()
        {
            m_RealmBrief.Display();
        }

        protected override void OnActived()
        {
            m_RealmState = RealmState.LevelUp;
            HideRealmBoss();

            DisplayRealmUp();

        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            model.selectRealmRefresh -= SelectRealmRefresh;
            m_RealmAnimation.onRotateComplete -= OnRotateComplete;
            m_RealmAnimation.onLevelUpComplete -= OnLevelUpComplete;
            m_RealmAnimation.onBossAppearComplete -= OnBossAppearComplete;
            mainDateModel.customDisplayPower -= CustomDisplayPower;
            m_RealmAnimation.onCoverChange -= OnCoverChange;
            WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
            model.RealmMissionRefreshEvent -= Model_RealmMissionRefreshEvent;

            HideRealmUp();
        }

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

        void ShowTower()
        {
            if (PlayerDatas.Instance.baseData.realmLevel >= model.realmTowerOpenRealm)
            {
                towerBtn.SetActive(true);
            }
            else
            {
                towerBtn.SetActive(false);
            }
        }

        void DisplayRealmUp()
        {
            m_ContainerRealmUp.SetActive(true);

            model.displayRealms.Clear();
            model.selectRealm = PlayerDatas.Instance.baseData.realmLevel;

            DisplayRealmLevelUp();
            DisplayRealmStages();
            DisplayRealmBrief();
            DisplayCover();

            if (model.SatisfyChallengeBoss())
            {
                if (!model.GetBossEffectShow(model.displayRealmLevel))
                {
                    m_RealmAnimation.StartBossEffectShow();
                    m_GotoBoss.SetActive(false);
                    model.SetBossEffectShow(model.displayRealmLevel);
                    return;
                }
            }
            DisplayEffectBoss();

        }

        void HideRealmUp()
        {
            m_ContainerRealmUp.SetActive(false);
            m_RealmAnimation.Dispose();

            model.displayRealms.Clear();
            foreach (var item in m_RealmStages)
            {
                item.Dispose();
            }
        }

        void DisplayRealmBoss()
        {
            m_ContainerBoss.SetActive(true);
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            m_RealmHeartMagic.Display(realmLevel);
        }

        void HideRealmBoss()
        {
            m_ContainerBoss.SetActive(false);
            m_RealmHeartMagic.Dispose();
        }

        void DisplayRealmStages()
        {
            var stage = model.GetRealmStage(model.displayRealmLevel);
            m_RealmAnimation.SetDefault();
            List<int> realms = null;
            if (model.TryGetRealmStages(stage, out realms))
            {
                for (int i = 0; i < m_RealmStages.Length; i++)
                {
                    var index = m_RealmStages[i].animIndex;
                    m_RealmStages[i].SetActive(index < REALM_STAGE_COUNT);
                    if (realms[0] + index <= model.realmMaxLevel)
                    {
                        m_RealmStages[i].Display(realms[0] + index);
                    }
                }
            }
        }

        void DisplayRealmLevelUp()
        {
            m_GotoBoss.SetActive(model.SatisfyChallengeBoss());
        }

        void DisplayRealmBrief()
        {
            m_RealmBrief.Display();
            m_RealmUP.Display();
        }


        void DisplayCover()
        {
            m_EffectCover.StopImediatly();
            if (model.displayRealmLevel == model.realmMaxLevel)
            {
                var id = model.GetRealmCoverEffect(model.realmMaxLevel);
                m_EffectCover.effect = id;
                m_EffectCover.Play();
            }
            else
            {
                var config = RealmConfig.Get(model.displayRealmLevel);
                var isBossExist = model.SatisfyChallengeBoss();
                if (isBossExist)
                {
                    return;
                }
                var stage = model.GetRealmStage(model.displayRealmLevel);
                List<int> realms = null;
                if (model.TryGetRealmStages(stage, out realms))
                {
                    var id = model.GetRealmCoverEffect(realms[0]);
                    m_EffectCover.effect = id;
                    m_EffectCover.Play();
                }
            }
        }

        void DisplayEffectBoss()
        {
            bool requireBossEffect = false;
            m_EffectBoss.StopImediatly();
            if (model.SatisfyChallengeBoss())
            {
                requireBossEffect = true;
                m_EffectBoss.Play();
                Animator animator = null;
                if (m_EffectBoss.target != null)
                {
                    animator = m_EffectBoss.target.GetAnimator();
                    animator.Play("Effect_JingJieBJ_021", 0, 1);
                }
            }

            if (m_EffectBase.target != null)
            {
                var obj = m_EffectBase.target.transform.Find("GameObject/b/b (3)");
                if (obj != null)
                {
                    obj.SetActive(!requireBossEffect);
                }
            }
        }


        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.RealmLevel)
            {
                var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
                if (!model.displayRealms.Contains(realmLevel))
                {
                    model.displayRealms.Add(realmLevel);
                    //if (model.displayRealms.Count == 1)
                    //{
                    //    TryStartAnimation();
                    //}

                    WindowCenter.Instance.Open<RealmBreakWin>();
                }
                m_RealmBrief.Display();
                
            }
            else if (dataType == PlayerDataType.LV)
            {
                if (m_RealmAnimation.isPlayingAnimation || m_RealmAnimation.rotating)
                {
                    return;
                }
                if (model.SatisfyChallengeBoss()
                    && !model.GetBossEffectShow(model.displayRealmLevel))
                {
                    model.SetBossEffectShow(model.displayRealmLevel);
                    m_RealmAnimation.StartBossEffectShow();
                }
            }
        }

        private void TryStartAnimation()
        {
            var stage = model.GetRealmStage(model.displayRealmLevel);
            var currentStage = model.GetRealmStage(cacheRealmLevel);
            if (cacheRealmLevel > model.displayRealmLevel || stage > currentStage + 1)
            {
                model.displayRealms.Clear();
                model.selectRealm = PlayerDatas.Instance.baseData.realmLevel;
                DisplayRealmStages();
                DisplayCover();
                DisplayEffectBoss();
            }
            else
            {
                if (cacheRealmLevel < model.displayRealmLevel)
                {
                    List<int> realms = null;
                    if (model.TryGetRealmStages(currentStage, out realms))
                    {
                        var index = realms.IndexOf(cacheRealmLevel);
                        m_RealmAnimation.DisplayLevelUp(realms.IndexOf(cacheRealmLevel));
                    }
                }
            }
            cacheRealmLevel = model.displayRealmLevel;
        }

        private void OnRotateComplete()
        {
            var stage = model.GetRealmStage(model.displayRealmLevel);
            List<int> realms = null;
            if (model.TryGetRealmStages(stage, out realms))
            {
                for (int i = 0; i < m_RealmStages.Length; i++)
                {
                    var index = m_RealmStages[i].animIndex;
                    if (index >= REALM_STAGE_COUNT && realms[0] + index <= model.realmMaxLevel)
                    {
                        m_RealmStages[i].Display(realms[0] + index);
                    }
                }
            }

            //RealmPromoteWin.realmLevel = model.displayRealmLevel;
            //WindowCenter.Instance.Open<RealmPromoteWin>();
            if (model.displayRealms.Count > 0)
            {
                model.displayRealms.RemoveAt(0);
            }

        }

        private void OnLevelUpComplete()
        {
            model.selectRealm = model.displayRealmLevel;
            if (model.displayRealmLevel == model.realmMaxLevel)
            {
                DisplayRealmLevelUp();
            }

            DisplayCover();

            if (!m_RealmAnimation.rotating)
            {
                //RealmPromoteWin.realmLevel = model.displayRealmLevel;
                //WindowCenter.Instance.Open<RealmPromoteWin>();
                if (model.displayRealms.Count > 0)
                {
                    model.displayRealms.RemoveAt(0);
                }

            }
        }

        private void WindowAfterCloseEvent(Window window)
        {
            if (window is RealmPromoteWin)
            {
                //var equipLevel = 0;
                //if (model.IsUnlockEquipRealm(RealmPromoteWin.realmLevel, out equipLevel))
                //{
                //    WindowCenter.Instance.Open<RealmNewEquipWin>(false, equipLevel);
                //}
                //else
                //{
                //    if (model.displayRealms.Count > 0)
                //    {
                //        TryStartAnimation();
                //    }
                //}
                if (model.displayRealms.Count > 0)
                {
                    TryStartAnimation();
                }
                if (PlayerDatas.Instance.baseData.realmLevel == model.realmTowerOpenRealm)
                {
                    NewBieCenter.Instance.StartNewBieGuideEx(model.realmTowerGuideID);
                }
                ShowTower();
            }
            //if (window is RealmNewEquipWin)
            //{
            //    if (model.displayRealms.Count > 0)
            //    {
            //        TryStartAnimation();
            //    }
            //}
        }

        public void OnBossAppearComplete()
        {
            m_GotoBoss.SetActive(true);

            if (m_EffectCover.IsPlaying)
            {
                m_EffectCover.StopImediatly();
            }
        }


        private void OnCoverChange()
        {
            var id = model.GetRealmCoverEffect(model.displayRealmLevel + 1);
            m_EffectCover.StopImediatly();
            m_EffectCover.effect = id;
            m_EffectCover.Play();
        }

        private bool CustomDisplayPower()
        {
            return m_RealmAnimation.isPlayingAnimation;
        }

        private void SelectRealmRefresh()
        {
            DisplayRealmBrief();
            DisplayRealmLevelUp();
        }

        private void OnBack()
        {
            if (realmState == RealmState.Boss)
            {
                realmState = RealmState.LevelUp;
                return;
            }
            CloseClick();
        }

        private void GotoBoss()
        {
            if (realmState == RealmState.LevelUp)
            {
                realmState = RealmState.Boss;
            }
        }

        private void RealmRestraint()
        {
            WindowCenter.Instance.Open<RealmRestraintWin>();
        }

        public enum RealmState
        {
            LevelUp,
            Boss,
        }

        
    }

}