using System;
using Core.Economy;
using Core.Health;
using Core.Utilities;
using TowerDefense.Economy;
using TowerDefense.Towers.Data;
using TowerDefense.Towers.Placement;
using UnityEngine;
using KTGMGemClient;
using System.Collections;
using System.Collections.Generic;
using TowerDefense.Nodes;
using TowerDefense.UI.HUD;

namespace TowerDefense.Level
{
    /// <summary>
    /// The level manager - handles the level states and tracks the player's currency
    /// PVE（无尽模式）关卡管理器
    /// </summary>
    [RequireComponent(typeof(EndlessWaveManager))]
    public class EndlessLevelManager : Singleton<EndlessLevelManager>
    {
        /// <summary>
        /// 起始关卡
        /// </summary>'
        /// <value></value>
        protected int startLevel { get; set; } = 1;

        /// <summary>
        /// 当前的关卡等级
        /// </summary>
        public int CurrentLevel { get; set; } = 1;

        private float dropRate;

        /// <summary>
        /// 当前金币掉率
        /// </summary>
        /// <value></value>
        public float DropRate
        {
            get
            {
                return dropRate;
            }
            set
            {
                dropRate = value;
                Debug.Log("设置了掉率" + dropRate);
            }
        }

        private int dropCoin;

        /// <summary>
        /// 当前金币
        /// </summary>
        /// <value></value>
        public int DropCoin
        {
            get
            {
                return dropCoin;
            }
            set
            {
                dropCoin = value;
            }
        }

        protected static readonly int MAX_TOWER = 5;

        /// <summary>
        /// The tower library for level
        /// </summary>
        public TowerLibrary TowerLibrary;

        /// <summary>
        /// The currency that the player starts with
        /// </summary>
        public int StartingCurrency;

        /// <summary>
        /// 自身所在的PlacementArea
        /// </summary>
        public TowerPlacementGridEndless SelfPlacementArea;

        /// <summary>
        /// The controller for gaining currency
        /// </summary>
        public CurrencyGainer CurrencyGainer;

        /// <summary>
        /// Configuration for if the player gains currency even in pre-build phase
        /// </summary>
        [Header("Setting will allow currency gain during the Intro and Pre-Build phase")]
        public bool alwaysGainCurrency;

        /// <summary>
        /// The home bases that the player must defend
        /// </summary>
        public PlayerHomeBase[] HomeBases;

        /// <summary>
        /// The attached wave manager
        /// </summary>
        public EndlessWaveManager WaveManager { get; protected set; }

        /// <summary>
        /// Number of enemies currently in the level
        /// </summary>
        public int NumberOfEnemies { get; protected set; }

        /// <summary>
        /// The current state of the level
        /// </summary>
        public LevelState EndlessLeveltate { get; protected set; }

        /// <summary>
        /// The currency controller
        /// </summary>
        public Currency Currency { get; protected set; }

        /// <summary>
        /// Number of home bases left
        /// </summary>
        public int NumberOfHomeBasesLeft { get; protected set; }

        /// <summary>
        /// Starting number of home bases
        /// </summary>
        public int NumberOfHomeBases { get; protected set; }

        /// <summary>
        /// 每一个Tower对应的AttributeID.
        /// </summary>
        protected int[] towerAttributeID = new int[5];

        protected int[] towerLevel = new int[5];

        /// <summary>
        /// An accessor for the home bases
        /// </summary>
        public PlayerHomeBase[] playerHomeBases
        {
            get { return HomeBases; }
        }

        /// <summary>
        /// Fired when all the waves are done and there are no more enemies left
        /// </summary>
        public event Action LevelCompleted;

        /// <summary>
        /// Fired when the level state is changed - first parameter is the old state, second parameter is the new state
        /// </summary>
        public event Action<LevelState, LevelState> LevelStateChanged;

        /// <summary>
        /// Fired when the number of enemies has changed
        /// </summary>
        public event Action<int> numberOfEnemiesChanged;

        public event Action<int> DecrementEnemies;

        /// <summary>
        /// Event for home base being destroyed
        /// </summary>
        public event Action homeBaseDestroyed;

        /// <summary>
        /// 当前关卡的所有波次是否全部完成
        /// </summary>
        private bool IsAllWaveCompleted;

        /// <summary>
        /// 基地起点集合
        /// </summary>
        public List<Node> StartingNodeList;

        public List<Node> EndNodeList;

        /// <summary>
        /// 已经完成的关卡数量
        /// </summary>
        public int CompletedLevels { get; protected set; }

        /// <summary>
        /// 选择buff需要通过的关卡数量，也就是，通过每通过几关然后开始选buff
        /// </summary>
        /// <value></value>
        public int SelectBuffNeddLevels { get; set; }

        /// <summary>
        /// buff是否选择完成
        /// </summary>
        private bool isBuffSelectCompleted = true;

        /// <summary>
        /// 新手第一关是否完成
        /// </summary>
        private bool isFirstLevelCompleted = false;
        private bool isSecondLevelCompleted = false;
        private bool isThirdLevelCompleted = false;

        private bool isStopSecondWaveCompleted = false;

        /// <summary>
        /// 赛道长度
        /// </summary>
        private float tunelLength;

        private List<Vector3> homeBasePositionList;

        /// <summary>
        /// 根据赛道id（1~5）获得基地坐标
        /// </summary>
        /// <param name="tunelId"></param>
        /// <returns></returns>
        public Vector3 GetHomeBasePosition(int tunelId)
        {
            return homeBasePositionList[tunelId - 1];
        }

        /// <summary>
        /// 根据赛道id（1~5）和赛道类型获得世界坐标
        /// </summary>
        /// <param name="tunelId"></param>
        /// <param name="tunelType"></param>
        public Vector3 GetTunelWorldPosition(int tunelId, EndlessBossSkillTunelType tunelType)
        {
            Vector3 startPos = StartingNodeList[tunelId - 1].transform.position;
            Vector3 ret = new Vector3(startPos.x, startPos.y, startPos.z);
            float add = 0;

            switch (tunelType)
            {
                case EndlessBossSkillTunelType.Top:
                    break;
                case EndlessBossSkillTunelType.Center:
                    add = -(tunelLength / 2);
                    break;
                case EndlessBossSkillTunelType.Bottom:
                    add = -tunelLength;
                    break;
            }

            ret.z += add;

            return ret;
        }

        /// <summary>
        /// 切换基地
        /// </summary>
        /// <param name="index">列索引</param>
        public Node SwitchHomeBase(int index)
        {
            EndlessSwitchHomeBase switchHomeBase = StartingNodeList[index].GetComponent<EndlessSwitchHomeBase>();
            return switchHomeBase.SwitchHomeBase();
        }

        /// <summary>
        /// 设置每一条兵线对应的AttID
        /// </summary>
        /// <param name="waveline"></param>
        /// <param name="id"></param>
        public void SetTowerAttID(int waveline, int id, int lvl)
        {
            towerAttributeID[waveline] = id;
            towerLevel[waveline] = lvl;
        }

        /// <summary>
        /// 重设当前的Currency数据
        /// </summary>
        /// <param name="curnum"></param>
        public void ResetCurrency(int curnum)
        {
            int curChg = curnum - Currency.currentCurrency;
            Currency.AddCurrency(curChg);
        }

        /// <summary>
        /// If the game is over
        /// </summary>
        public bool isGameOver
        {
            get { return EndlessLeveltate == LevelState.Win || EndlessLeveltate == LevelState.Lose; }
        }

        /// <summary>
        /// Increments the number of enemies. Called on Agent spawn
        /// </summary>
        public virtual void IncrementNumberOfEnemies()
        {
            NumberOfEnemies++;
            SafelyCallNumberOfEnemiesChanged();
        }

        /// <summary>
        /// Returns the sum of all HomeBases' health
        /// </summary>
        public float GetAllHomeBasesHealth()
        {
            float health = 0.0f;
            foreach (PlayerHomeBase homebase in HomeBases)
            {
                health += homebase.configuration.currentHealth;
            }
            return health;
        }

        /// <summary>
        /// Decrements the number of enemies. Called on Agent death
        /// </summary>
        public virtual void DecrementNumberOfEnemies()
        {
            NumberOfEnemies--;
            CallDecrementEnemies();
            SafelyCallNumberOfEnemiesChanged();
            if (NumberOfEnemies < 0)
            {
                Debug.LogError("[LEVEL] There should never be a negative number of enemies. Something broke!");
                NumberOfEnemies = 0;
            }

            if (NumberOfEnemies == 0 && EndlessLeveltate == LevelState.AllEnemiesSpawned)
            {
                ChangeLevelState(LevelState.Win);
            }
        }

        /// <summary>
        /// 开始关卡
        /// </summary>
        public virtual void StartLevel()
        {
            EndlessPortData.Init();
            ChangeLevelState(LevelState.SpawningEnemies);
            SelfPlacementArea.startCoinGenMode();
        }

        /// <summary>
        /// Caches the attached wave manager and subscribes to the spawning completed event
        /// Sets the level state to intro and ensures that the number of enemies is set to 0
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            for (int i = 0; i < MAX_TOWER; ++i)
            {
                towerAttributeID[i] = 0;
            }

            WaveManager = GetComponent<EndlessWaveManager>();
            WaveManager.AllWaveCompleted += AllWaveCompleted;

            // Does not use the change state function as we don't need to broadcast the event for default value
            EndlessLeveltate = LevelState.Intro;
            NumberOfEnemies = 0;

            // Ensure currency change listener is assigned
            Currency = new Currency(StartingCurrency);
            CurrencyGainer.Initialize(Currency);

            // Iterate through home bases and subscribe
            NumberOfHomeBases = HomeBases.Length;
            NumberOfHomeBasesLeft = NumberOfHomeBases;
        }

        private void Start()
        {
            EndlessBuffSelect.instance.BuffSelectCompleted += OnBuffSelectCompleted;
            EndlessGameUI.instance.GameOverEvent += SafelyCallLevelCompleted;

            homeBasePositionList = new List<Vector3>();
            tunelLength = Mathf.Abs(StartingNodeList[0].transform.position.z - EndNodeList[0].transform.position.z);

            for (int i = 0; i < StartingNodeList.Count; ++i)
            {
                Vector3 startPos = StartingNodeList[i].transform.position;
                Vector3 pos = new Vector3();
                pos.x = startPos.x;
                pos.y = startPos.y;
                pos.z = startPos.z - tunelLength;
                homeBasePositionList.Add(pos);
            }
        }

        /// <summary>
        /// Updates the currency gain controller
        /// </summary>
        protected virtual void Update()
        {
            if (EndlessGameUI.instance.state == EndlessGameUI.State.GameOver) return;

            if (alwaysGainCurrency || !alwaysGainCurrency && EndlessLeveltate != LevelState.Building && EndlessLeveltate != LevelState.Intro)
            {
                CurrencyGainer.Tick(Time.deltaTime);
            }

            // buff选择完成，开始波次
            if (!isBuffSelectCompleted)
            {
                isBuffSelectCompleted = true;
                if (CurrentLevel > startLevel)
                    WaveManager.InitPort(CurrentLevel);
                EndlessUIStart.instance.Restart();
                WaveManager.StartWaves(CurrentLevel);
            }

            // 本关卡所有波次全部生成完成 && 敌人全部被清理了，然后就去尝试进入下一关
            if (EndlessLeveltate == LevelState.SpawningEnemies && IsAllWaveCompleted && NumberOfEnemies == 0)
            {
                // 新手的话，第一关完了暂停
                if (!GameConfig.IsNewbie)
                {
                    if (!UpdateLevel())
                        ChangeLevelState(LevelState.AllEnemiesSpawned);
                }
                // else if (!isFirstLevelCompleted)
                // {
                //     isFirstLevelCompleted = true;
                //     EndlessUIStart.instance.Pause();
                //     // 第一关的怪全部被杀光
                //     EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.KillDone);
                // }
                // else if (!isSecondLevelCompleted)
                // {
                //     Debug.Log("开始第三关???");
                //     isSecondLevelCompleted = true;
                //     //EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.CreateThirdWave);
                // }
            }
        }

        /// <summary>
        /// Unsubscribes from events
        /// </summary>
        protected override void OnDestroy()
        {
            base.OnDestroy();

            if (WaveManager != null)
                WaveManager.AllWaveCompleted -= AllWaveCompleted;
        }

        /// <summary>
        /// Fired when the WaveManager has finished spawning enemies
        /// </summary>
        protected virtual void AllWaveCompleted()
        {
            IsAllWaveCompleted = true;
            int score = EndlessPortData.GetLevelScore(CurrentLevel);
            Debug.Log($"--------------------- 通过第{CurrentLevel}关，+{score}分 ---------------------");
            // 关卡通过，加分
            EndlessScoreManager.instance.AddScore(score);
            EndlessBossSkillManager.instance.ClearSkillList();
            EndlessBossCtrl.instance.ChangeState(EndlessBossActionState.Death);

            if (GameConfig.IsNewbie)
            {
                if (!isFirstLevelCompleted)
                {
                    isFirstLevelCompleted = true;
                    EndlessUIStart.instance.Pause();
                    // 第一关的怪全部被杀光
                    EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.KillDone);
                }
                else if (!isSecondLevelCompleted)
                {
                    //Debug.Log("开始第三关???");
                    isSecondLevelCompleted = true;
                    EndlessUIStart.instance.Pause();
                    EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.KillSecondDone);
                }
                else if (isFirstLevelCompleted && isSecondLevelCompleted && !isThirdLevelCompleted)
                {
                    isThirdLevelCompleted = true;
                    EndlessUIStart.instance.Pause();
                    EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.KillThirdDone);
                }
            }
        }

        /// <summary>
        /// 更新关卡
        /// </summary>
        private bool UpdateLevel()
        {
            ++CurrentLevel;
            IsAllWaveCompleted = false;

            // 所有关卡全部结束
            if (CurrentLevel > EndlessPortData.MaxLevel)
                return false;

            StartCoroutine(DelayToNextLevel());

            return true;
        }

        /// <summary>
        /// 新手更新关卡
        /// </summary>
        public void NewbieUpdateLevel()
        {
            ++CurrentLevel;
            WaveManager.InitPort(CurrentLevel);
            IsAllWaveCompleted = false;
            EndlessUIStart.instance.Restart();
            WaveManager.StartWaves(CurrentLevel);
        }

        /// <summary>
        /// 延迟进入下一关
        /// </summary>
        /// <returns></returns>
        private IEnumerator DelayToNextLevel()
        {
            yield return new WaitForSeconds(2f);
            BeginLevel();
        }

        /// <summary>
        /// 开始关卡，需要处理选择buff
        /// </summary>
        private void BeginLevel()
        {
            if (EndlessGameUI.instance.state == EndlessGameUI.State.GameOver) return;

            if (CurrentLevel == startLevel)
                WaveManager.InitPort(CurrentLevel);

            if (!GameConfig.IsNewbie)
            {
                // buff池的初始化要从正式关卡算起，不算新手关
                EndlessBuffData.InitEndlessBuffPool(GameConfig.IsNewbieStart ? CurrentLevel - EndlessPortData.NewbieTotalLevel : CurrentLevel);
                ShowSelectBuffUI();
            }
            else
            {
                EndlessUIStart.instance.Restart();
                WaveManager.StartWaves(CurrentLevel);
            }
        }

        /// <summary>
        /// 显示选择buff界面
        /// </summary>
        private void ShowSelectBuffUI()
        {
            // 需要随机一个buff列表出来，然后简单刷新一下界面
            List<EndlessBuffConfig> list = EndlessBuffData.GetRandomBuffList();

            if (list.Count == 0)
            {
                isBuffSelectCompleted = false;
                return;
            }

            EndlessUIStart.instance.Pause();
            EndlessBuffSelect.instance.Refresh(list);
            EndlessBuffSelect.instance.ShowBuffUI();
        }

        /// <summary>
        /// buff选择完成p
        /// </summary>
        /// <param name="index"></param>
        public void OnBuffSelectCompleted(int index)
        {
            isBuffSelectCompleted = false;
            EndlessBuffManager.instance.AddBuff(EndlessBuffData.GetBuffByIndex(index));
            EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.EndlessBuffRefresh);
        }

        /// <summary>
        /// Changes the state and broadcasts the event
        /// </summary>
        /// <param name="newState">The new state to transitioned to</param>
        protected virtual void ChangeLevelState(LevelState newState)
        {
            if (EndlessLeveltate == newState)
                return;

            LevelState oldState = EndlessLeveltate;
            EndlessLeveltate = newState;

            if (LevelStateChanged != null)
                LevelStateChanged(oldState, newState);

            switch (newState)
            {
                case LevelState.SpawningEnemies:
                    BeginLevel();
                    break;
                case LevelState.AllEnemiesSpawned:
                    // if (NumberOfEnemies == 0)
                    ChangeLevelState(LevelState.Win);
                    break;
                case LevelState.Lose:
                    SafelyCallLevelCompleted();
                    break;
                case LevelState.Win:
                    SafelyCallLevelCompleted();
                    Debug.Log("--------------------- you are winner ！！！ ---------------------");
                    break;
            }
        }

        /// <summary>
        /// Fired when a home base is destroyed
        /// </summary>
        protected virtual void OnHomeBaseDestroyed(DamageableBehaviour homeBase)
        {
            // Decrement the number of home bases
            NumberOfHomeBasesLeft--;

            // Call the destroyed event
            if (homeBaseDestroyed != null)
            {
                homeBaseDestroyed();
            }

            // // If there are no home bases left and the level is not over then set the level to lost
            // if ((NumberOfHomeBasesLeft < 3) && !isGameOver)
            // {
            //     ChangeLevelState(LevelState.Lose);
            // }
        }

        /// <summary>
        /// Calls the <see cref="levelCompleted"/> event
        /// </summary>
        protected virtual void SafelyCallLevelCompleted()
        {
            EndlessDropManager.instance.PickUpAllDrop();
            if (LevelCompleted != null)
                LevelCompleted();
        }

        /// <summary>
        /// Calls the <see cref="numberOfEnemiesChanged"/> event
        /// </summary>
        protected virtual void SafelyCallNumberOfEnemiesChanged()
        {
            if (numberOfEnemiesChanged != null)
                numberOfEnemiesChanged(NumberOfEnemies);
        }

        protected virtual void CallDecrementEnemies()
        {
            if (DecrementEnemies != null)
                DecrementEnemies(1);
        }

        /// <summary>
        /// 兵线的所有基地都已经被摧毁，停止某一条兵线的出兵
        /// </summary>
        /// <param name="index"></param>
        public void StopWaveLine(int index)
        {
            if (WaveManager.waves[index].LineState == EndlessWaveLineState.Spawning)
            {
                WaveManager.waves[index].StopWave();
                WaveManager.waves[index].LineState = EndlessWaveLineState.Destroyed;
                --WaveManager.TotalWaveLines;
            }
        }

        /// <summary>
        /// 暂停波次，小怪停止移动，塔停止攻击
        /// </summary>
        public void PauseWave()
        {
            EndlessUIStart.instance.Pause();
            AgentInsManager.instance.SetWaveLineCanMove(-1, false, false);
            WaveManager.PauseAllWave();
            EndlessGameUI.instance.SetAttackingTowerState(false);
        }

        /// <summary>
        /// 恢复波次，小怪
        /// </summary>
        public void RestartWave()
        {
            EndlessUIStart.instance.Restart();
            AgentInsManager.instance.SetWaveLineCanMove(-1, true, false);
            WaveManager.RestartAllWave();
            EndlessGameUI.instance.SetAttackingTowerState(true);
        }

        /// <summary>
        /// 停止第二关波次
        /// </summary>
        public void StopSecondWave()
        {
            if (!isStopSecondWaveCompleted)
            {
                isStopSecondWaveCompleted = true;
                PauseWave();
            }
            //EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.SkillStep);
            EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.DragStep);
        }


    }
}