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

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

namespace Snxxz.UI
{

    public class RealmWin : Window
    {
        [SerializeField] Transform m_ContainerRealmUp;
        [SerializeField] RealmBriefBehaviour m_RealmBrief;
        [SerializeField] RealmLevelUpBehaviour m_RealmLevelUp;
        [SerializeField] RealmPoolBehaviour m_RealmPool;
        [SerializeField] RealmAnimationBehaviour m_RealmAnimation;
        [SerializeField] RealmStageBehaviour[] m_RealmStages;
        [SerializeField] Transform m_ContainerUnlockEquip;
        [SerializeField] Image m_EquipName;
        [SerializeField] Transform m_ContainerBoss;
        [SerializeField] RealmHeartMagicBehaviour m_RealmHeartMagic;
        [SerializeField] Button m_RealmRestraint;
        [SerializeField] Button m_GotoBoss;
        [SerializeField] Button m_Close;

        [SerializeField] PositionTween m_RealmBriefTween;
        [SerializeField] PositionTween m_RealmLevelUpTween;
        [SerializeField] UIEffect m_EffectCover;
        [SerializeField] UIEffect m_EffectBoss;
        [SerializeField] UIEffect m_EffectBase;

        int cacheRealmLevel = 0;
        long cacheFightPower = 0;
        long customUpPower = 0;
        bool tweenOnStart = false;

        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);
        }

        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;

            cacheRealmLevel = PlayerDatas.Instance.baseData.realmLevel;
            cacheFightPower = PlayerDatas.Instance.baseData.FightPoint;
            customUpPower = 0;
        }

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

            m_RealmState = RealmState.LevelUp;
            HideRealmBoss();

            DisplayRealmUp();

            tweenOnStart = true;
            m_RealmBriefTween.SetStartState();
            m_RealmLevelUpTween.SetStartState();
            if (!m_RealmAnimation.isPlayingBossEffect)
            {
                StartTween();
            }
        }

        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;

            HideRealmUp();
        }

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

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

            model.displayRealms.Clear();
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            if (realmLevel < model.realmMaxLevel)
            {
                model.selectRealm = realmLevel + 1;
            }
            else
            {
                model.selectRealm = realmLevel;
            }

            DisplayRealmLevelUp();
            DisplayRealmStages();
            DisplayRealmBrief();
            DisplayRealmPool();
            DisplayUnlockEquip();
            DisplayCover();

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

        }

        void HideRealmUp()
        {
            m_ContainerRealmUp.gameObject.SetActive(false);
            m_RealmAnimation.Dispose();
            m_RealmBriefTween.Stop();
            m_RealmBriefTween.SetEndState();
            m_RealmLevelUpTween.Stop();
            m_RealmLevelUpTween.SetEndState();
            m_RealmPool.Dispose();
            model.displayRealms.Clear();
            foreach (var item in m_RealmStages)
            {
                item.Dispose();
            }
        }

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

        void HideRealmBoss()
        {
            m_ContainerBoss.gameObject.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].gameObject.SetActive(index < REALM_STAGE_COUNT);
                    if (realms[0] + index <= model.realmMaxLevel)
                    {
                        m_RealmStages[i].Display(realms[0] + index);
                    }
                }
            }
        }

        void DisplayRealmLevelUp()
        {
            var requireLevelUp = model.displayRealmLevel < model.realmMaxLevel
                && model.selectRealm > model.displayRealmLevel;
            m_RealmLevelUp.gameObject.SetActive(requireLevelUp);
            if (requireLevelUp)
            {
                m_RealmLevelUp.Display(model.selectRealm);
            }

            m_GotoBoss.gameObject.SetActive(model.SatisfyChallengeBoss(model.displayRealmLevel));
        }

        void DisplayRealmBrief()
        {
            m_RealmBrief.Display(model.selectRealm);
        }

        void DisplayRealmPool()
        {
            if (model.displayRealmLevel >= model.realmPoolOpenLevel - 1)
            {
                m_RealmPool.gameObject.SetActive(true);
                m_RealmPool.Display(model.displayRealmLevel);
            }
            else
            {
                m_RealmPool.gameObject.SetActive(false);
            }
        }

        void DisplayUnlockEquip()
        {
            m_ContainerUnlockEquip.gameObject.SetActive(false);
            var stage = model.GetRealmStage(model.displayRealmLevel);
            List<int> realms = null;
            if (model.TryGetRealmStages(stage, out realms))
            {
                for (int i = 0; i < REALM_STAGE_COUNT; i++)
                {
                    var level = realms[0] + i;
                    var equipSet = 0;
                    if (model.displayRealmLevel < level && model.selectRealm != level
                        && model.IsUnlockEquipRealm(level, out equipSet))
                    {
                        var index = i;
                        m_ContainerUnlockEquip.gameObject.SetActive(true);
                        foreach (var realmStage in m_RealmStages)
                        {
                            if (realmStage.animIndex == index)
                            {
                                var worldpos = realmStage.transform.TransformPoint(Vector2.zero + Vector2.down * 60);
                                var localpos = m_ContainerRealmUp.InverseTransformPoint(worldpos);
                                m_ContainerUnlockEquip.localPosition = localpos;
                                break;
                            }
                        }
                        var config = RealmConfig.Get(level);
                        m_EquipName.SetSprite(config.equipNameIcon);
                        break;
                    }
                }
            }
        }

        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(model.displayRealmLevel);
                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(model.displayRealmLevel))
            {
                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.gameObject.SetActive(!requireBossEffect);
                }
            }
        }

        void StartTween()
        {
            m_RealmBriefTween.Play();

            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            var requireLevelUp = realmLevel < model.realmMaxLevel && model.selectRealm > realmLevel;
            if (requireLevelUp)
            {
                m_RealmLevelUpTween.Play();
            }

            tweenOnStart = false;
        }

        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();
                    }
                }
            }
            else if (dataType == PlayerDataType.FightPower)
            {
                if (CustomDisplayPower())
                {
                    customUpPower += (PlayerDatas.Instance.baseData.FightPoint - cacheFightPower);
                }
                cacheFightPower = PlayerDatas.Instance.baseData.FightPoint;
            }
            else if (dataType == PlayerDataType.LV)
            {
                m_RealmLevelUp.DisplayCondition();
                if (m_RealmAnimation.isPlayingAnimation || m_RealmAnimation.rotating)
                {
                    return;
                }
                if (model.SatisfyChallengeBoss(model.displayRealmLevel)
                    && !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 + 1;
                DisplayRealmStages();
                DisplayRealmPool();
                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);
                    }
                }
            }
            DisplayUnlockEquip();

            if (model.displayRealms.Count > 0)
            {
                model.displayRealms.RemoveAt(0);
            }
            if (model.displayRealms.Count > 0)
            {
                TryStartAnimation();
            }

            DisplayRealmPool();
        }

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

            DisplayCover();

            if (!m_RealmAnimation.rotating)
            {
                if (model.displayRealms.Count > 0)
                {
                    model.displayRealms.RemoveAt(0);
                }
                if (model.displayRealms.Count > 0)
                {
                    TryStartAnimation();
                }
            }

            DisplayRealmPool();

            if (customUpPower > 0)
            {
                mainDateModel.CustomPowerUp((int)customUpPower);
            }
            customUpPower = 0;
        }

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

            if (tweenOnStart)
            {
                StartTween();
            }

            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();
            if (!m_RealmAnimation.rotating)
            {
                DisplayUnlockEquip();
            }
        }

        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,
        }
    }

}