using cfg.GuideCfg;
using Code.Scripts.Gameplay.Game;
using Framework;
using Gameplay.Area;
using Gameplay.Level;
using Gameplay.Skill;
using Gameplay.Unit;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

namespace Gameplay.Guide
{
    /// <summary>
    /// 新手引导步骤完成基类
    /// </summary>
    public abstract class GuideCompleteBase
    {
        /// <summary>
        /// 引导完成回调
        /// </summary>
        private readonly Action completeAction;

        public DataGuideCfg Cfg { get; private set; }

        /// <summary>
        /// 引导完成类型
        /// </summary>
        public E_GuideCompleteType CompleteType
        {
            get; private set;
        }

        public GuideCompleteBase(DataGuideCfg cfg, Action complete)
        {
            Cfg = cfg;

            CompleteType = Cfg.GuideCompleteType;
            completeAction = complete;
        }

        /// <summary>
        /// 添加监听
        /// </summary>
        public abstract void AddListener();

        /// <summary>
        /// 移除监听
        /// </summary>
        public abstract void RemoveListener();

        public virtual void Complete()
        {
            completeAction?.Invoke();
        }
    }

    /// <summary>
    /// 播放视频完成
    /// </summary>
    internal sealed class PlayVideoComplete : GuideCompleteBase
    {
        /// <summary>
        /// 视频路径
        /// </summary>
        private readonly string videoPath;

        public PlayVideoComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.视频路径");

            videoPath = Cfg.CompleteTypeParams[0];
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.PlayVideoComplete, (Action<string>)OnPlayVideoComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.PlayVideoComplete, (Action<string>)OnPlayVideoComplete);
        }

        /// <summary>
        /// 播放视频完成回调
        /// </summary>
        /// <param name="path"></param>
        private void OnPlayVideoComplete(string path)
        {
            if (videoPath != path)
                return;

            Complete();
        }
    }

    #region UI
    /// <summary>
    /// 打开UI完成
    /// </summary>
    internal sealed class OpenUIComplete : GuideCompleteBase
    {
        private readonly string uiName;

        public OpenUIComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.UI名");

            uiName = Cfg.CompleteTypeParams[0];
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UIOpen, (Action<string>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIOpen, (Action<string>)OnComplete);
        }

        private void OnComplete(string uiName)
        {
            if (this.uiName != uiName)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 关闭UI完成
    /// </summary>
    internal sealed class CloseUIComplete : GuideCompleteBase
    {
        private readonly string uiName;

        public CloseUIComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.UI名");

            uiName = Cfg.CompleteTypeParams[0];
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UIClose, (Action<string>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIClose, (Action<string>)OnComplete);
        }

        private void OnComplete(string uiName)
        {
            if (this.uiName != uiName)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 打开UI并且UI动画播放完成
    /// </summary>
    internal sealed class OpenUIAndAnimComplete : GuideCompleteBase
    {
        private readonly string uiName;

        public OpenUIAndAnimComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.UI名");

            uiName = Cfg.CompleteTypeParams[0];
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UIOpenAndAnim, (Action<string>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIOpenAndAnim, (Action<string>)OnComplete);
        }

        private void OnComplete(string uiName)
        {
            if (this.uiName != uiName)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 关闭UI并且UI动画播放完成
    /// </summary>
    internal sealed class CloseUIAndAnimComplete : GuideCompleteBase
    {
        private readonly string uiName;

        public CloseUIAndAnimComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.UI名");

            uiName = Cfg.CompleteTypeParams[0];
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UICloseAndAnim, (Action<string>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UICloseAndAnim, (Action<string>)OnComplete);
        }

        private void OnComplete(string uiName)
        {
            if (this.uiName != uiName)
                return;

            Complete();
        }
    }
    #endregion

    #region 关卡战斗
    /// <summary>
    /// 进入战斗关卡完成
    /// </summary>
    internal sealed class EnterFightLevelComplete : GuideCompleteBase
    {
        /// <summary>
        /// 是否切换关卡状态
        /// </summary>
        private bool isChangeLevelState;
        /// <summary>
        /// 是否加载完成
        /// </summary>
        private bool isLoadingExecutor;
        /// <summary>
        /// 加载界面是否关闭
        /// </summary>
        private bool isLoadingClose;

        public EnterFightLevelComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            isChangeLevelState = false;
            isLoadingExecutor = false;
            isLoadingClose = false;
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_ChangeLevelState, OnChangeLevelState);
            EventManager.Instance.Register(EventManager.EventName.LoadingExecutorComplete, OnLoadingExecutor);
            EventManager.Instance.Register(EventManager.EventName.UIClose, (Action<string>)OnLoadingClose);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIClose, (Action<string>)OnLoadingClose);
            EventManager.Instance.Unregister(EventManager.EventName.LoadingExecutorComplete, OnLoadingExecutor);
            EventManager.Instance.Unregister(EventManager.EventName.Guide_ChangeLevelState, OnChangeLevelState);
        }

        private void OnChangeLevelState()
        {
            isChangeLevelState = true;
            CheckComplete();
        }

        private void OnLoadingExecutor()
        {
            isLoadingExecutor = true;
            CheckComplete();
        }

        private void OnLoadingClose(string uiName)
        {
            if (UINameConst.UI_LoadingInterface != uiName)
                return;

            isLoadingClose = true;
            CheckComplete();
        }

        private void CheckComplete()
        {
            if (!isChangeLevelState)
                return;

            if (!isLoadingExecutor)
                return;

            if (!isLoadingClose)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 进入故事关卡完成
    /// </summary>
    internal sealed class EnterStorylineLevelComplete : GuideCompleteBase
    {
        /// <summary>
        /// 是否切换关卡状态
        /// </summary>
        private bool isChangeStoryState;
        /// <summary>
        /// 是否加载完成
        /// </summary>
        private bool isLoadingExecutor;
        /// <summary>
        /// 加载界面是否关闭
        /// </summary>
        private bool isLoadingClose;

        public EnterStorylineLevelComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            isChangeStoryState = false;
            isLoadingExecutor = false;
            isLoadingClose = false;
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_ChangeStoryState, OnChangeStoryState);
            EventManager.Instance.Register(EventManager.EventName.LoadingExecutorComplete, OnLoadingExecutor);
            EventManager.Instance.Register(EventManager.EventName.UIClose, (Action<string>)OnLoadingClose);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIClose, (Action<string>)OnLoadingClose);
            EventManager.Instance.Unregister(EventManager.EventName.LoadingExecutorComplete, OnLoadingExecutor);
            EventManager.Instance.Unregister(EventManager.EventName.Guide_ChangeStoryState, OnChangeStoryState);
        }

        private void OnChangeStoryState()
        {
            isChangeStoryState = true;
            CheckComplete();
        }

        private void OnLoadingExecutor()
        {
            isLoadingExecutor = true;
            CheckComplete();
        }

        private void OnLoadingClose(string uiName)
        {
            if (UINameConst.UI_LoadingInterface != uiName)
                return;

            isLoadingClose = true;
            CheckComplete();
        }

        private void CheckComplete()
        {
            if (!isChangeStoryState)
                return;

            if (!isLoadingExecutor)
                return;

            if (!isLoadingClose)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 关卡上阵完成
    /// </summary>
    internal sealed class LevelEmbattleComplete : GuideCompleteBase
    {
        /// <summary>
        /// 上阵数量
        /// </summary>
        private readonly int embattleCount;

        public LevelEmbattleComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.上阵角色数量");

            if (int.TryParse(Cfg.CompleteTypeParams[0], out int count))
                embattleCount = count;
            else
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，第1个参数类型错误：应该为int类型");
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.LevelFightStartChange, OnStartChange);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.LevelFightStartChange, OnStartChange);
        }

        private void OnStartChange()
        {
            if (TeamManager.Instance.GetFightList().Count >= embattleCount)
                Complete();
        }
    }

    /// <summary>
    /// 关卡载具上阵完成
    /// </summary>
    internal sealed class LevelVehicleEmbattleComplete : GuideCompleteBase
    {
        /// <summary>
        /// 上阵数量
        /// </summary>
        private readonly int embattleCount;

        public LevelVehicleEmbattleComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.上阵载具数量");

            if (int.TryParse(Cfg.CompleteTypeParams[0], out int count))
                embattleCount = count;
            else
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，第1个参数类型错误：应该为int类型");
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.LevelFightStartChange, OnStartChange);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.LevelFightStartChange, OnStartChange);
        }

        private void OnStartChange()
        {
            if (TeamManager.Instance.GetFightList().Count >= embattleCount)
                Complete();
        }
    }

    /// <summary>
    /// 战斗开始完成
    /// </summary>
    internal sealed class FightBeginComplete : GuideCompleteBase
    {
        public FightBeginComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UIPreLevelBattleBegin, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIPreLevelBattleBegin, Complete);
        }
    }

    /// <summary>
    /// 战斗角色开始移动完成
    /// </summary>
    internal sealed class FightBeginMoveComplete : GuideCompleteBase
    {
        public FightBeginMoveComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.INFIGHT_OP_SET_MOVEPOS, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.INFIGHT_OP_SET_MOVEPOS, Complete);
        }
    }

    /// <summary>
    /// 战斗角色移动完成
    /// </summary>
    internal sealed class FightMoveComplete : GuideCompleteBase
    {
        /// <summary>
        /// 角色配置id
        /// </summary>
        private readonly List<int> listCharacterCfgId;
        /// <summary>
        /// 地板索引
        /// </summary>
        private readonly List<int> listFloorIndex;
        /// <summary>
        /// 完成计数
        /// </summary>
        private int total;

        public FightMoveComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (Cfg.CompleteTypeParams.Length <= 1 && (Cfg.CompleteTypeParams.Length & 1) != 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.角色id，2.地板id;");

            int count = Cfg.CompleteTypeParams.Length / 2;
            listCharacterCfgId = new(count);
            listFloorIndex = new(count);
            total = 0;

            for (int i = 0; i < count; ++i)
            {
                if (int.TryParse(Cfg.CompleteTypeParams[2 * i], out int cId))
                    listCharacterCfgId.Add(cId);
                else
                    throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，第{2 * i}个参数类型错误：应该为int类型");

                if (int.TryParse(Cfg.CompleteTypeParams[2 * i + 1], out int fId))
                    listFloorIndex.Add(fId);
                else
                    throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，第{2 * i + 1}个参数类型错误：应该为int类型");
            }
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.LevelCharacterArriveBlock, (Action<Character.Character>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.LevelCharacterArriveBlock, (Action<Character.Character>)OnComplete);
        }

        public void OnComplete(Character.Character character)
        {
            for (int i = 0; i < listCharacterCfgId.Count; ++i)
            {
                if (listCharacterCfgId[i] != character.runtimeData.configData.cfgId)
                    continue;

                if (listFloorIndex[i] != character.transData.cellIndex)
                    continue;

                ++total;
                break;
            }

            if (total < listCharacterCfgId.Count)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 战斗角色攻击完成
    /// </summary>
    internal sealed class FightAttackComplete : GuideCompleteBase
    {
        public FightAttackComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.INFIGHT_OP_SET_TARGET, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.INFIGHT_OP_SET_TARGET, Complete);
        }
    }
    #endregion

    #region 释放技能
    /// <summary>
    /// 角色准备释放技能完成
    /// </summary>
    internal sealed class FightPreparaUseSkillComplete : GuideCompleteBase
    {
        public FightPreparaUseSkillComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UI_START_USE_SKILL, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UI_START_USE_SKILL, Complete);
        }
    }

    /// <summary>
    /// 准备释放指挥官技能完成
    /// </summary>
    internal sealed class FightPreparaUsePlayerSkillComplete : GuideCompleteBase
    {
        public FightPreparaUsePlayerSkillComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_PreparaPlayerSkill, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_PreparaPlayerSkill, Complete);
        }
    }

    /// <summary>
    /// 角色释放技能完成
    /// </summary>
    internal sealed class FightUseSkillComplete : GuideCompleteBase
    {
        /// <summary>
        /// 返回引导id
        /// </summary>
        private readonly int returnId;

        public FightUseSkillComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            returnId = cfg.Id - 1;
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UI_USE_SKILL, Complete);
            EventManager.Instance.Register(EventManager.EventName.Guide_UseSkill, OnUseSkill);
            EventManager.Instance.Register(EventManager.EventName.UI_SKILL_CANCEL, OnCancelUseSkill);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UI_SKILL_CANCEL, OnCancelUseSkill);
            EventManager.Instance.Unregister(EventManager.EventName.Guide_UseSkill, OnUseSkill);
            EventManager.Instance.Unregister(EventManager.EventName.UI_USE_SKILL, Complete);
        }

        private void OnCancelUseSkill()
        {
            GuideManager.Instance.IsUseSkillSuccess = false;
            LevelManager.Instance.CurrentLevel.SetPause(true);

            AreaManager.instance.LogicUpdate(0);

            GuideManager.Instance.ReturnStep(returnId);
        }

        public void OnUseSkill()
        {
            GuideManager.Instance.IsUseSkillSuccess = true;
            LevelManager.Instance.CurrentLevel.SetPause(false);

            AreaManager.instance.LogicUpdate(0);
        }
    }

    /// <summary>
    /// 指挥官释放技能完成
    /// </summary>
    internal sealed class FightUsePlayerSkillComplete : GuideCompleteBase
    {
        /// <summary>
        /// 返回引导id
        /// </summary>
        private readonly int returnId;

        public FightUsePlayerSkillComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            returnId = cfg.Id - 1;
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_UsePlayerSkill, Complete);
            EventManager.Instance.Register(EventManager.EventName.Guide_UseSkill, OnUseSkill);
            EventManager.Instance.Register(EventManager.EventName.Guide_CancelPlayerSkill, OnCancelUseSkill);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_CancelPlayerSkill, OnCancelUseSkill);
            EventManager.Instance.Unregister(EventManager.EventName.Guide_UseSkill, OnUseSkill);
            EventManager.Instance.Unregister(EventManager.EventName.Guide_UsePlayerSkill, Complete);
        }

        private void OnCancelUseSkill()
        {
            LevelManager.Instance.CurrentLevel.SetPause(true);

            SkillManager.instance.playerSkillManager.LogicUpdate(0);
            AreaManager.instance.LogicUpdate(0);

            GuideManager.Instance.ReturnStep(returnId);
        }

        public void OnUseSkill()
        {
            LevelManager.Instance.CurrentLevel.SetPause(false);

            SkillManager.instance.playerSkillManager.LogicUpdate(0);
            AreaManager.instance.LogicUpdate(0);
        }
    }
    #endregion

    /// <summary>
    /// 关卡完成
    /// </summary>
    internal sealed class LevelComplete : GuideCompleteBase
    {
        public LevelComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.UIOpen, (Action<string>)OnOpenUIPause);
            EventManager.Instance.Register(EventManager.EventName.GuideExitLevel, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.GuideExitLevel, Complete);
            EventManager.Instance.Unregister(EventManager.EventName.UIOpen, (Action<string>)OnOpenUIPause);
        }

        private void OnOpenUIPause(string uiName)
        {
            if (UINameConst.UIPause != uiName)
                return;

            UIWindow uiWindow = UIManager.Instance.GetOpenedWindowByPath<UIWindow>(UINameConst.UIPause);
            if (null == uiWindow)
                return;

            Transform ts = uiWindow.gameObject.transform.Find("UI_MainPause/UIRetreatAndReturn/Button_Retreat");
            if (null == ts)
                return;

            if (!ts.TryGetComponent(out Button btn))
                return;

            btn.interactable = false;
        }
    }

    /// <summary>
    /// 点击引导按钮完成
    /// </summary>
    internal sealed class ClickGuideButtonComplete : GuideCompleteBase
    {
        public ClickGuideButtonComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.GuideClickButton, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.GuideClickButton, Complete);
        }
    }

    /// <summary>
    /// 点击地板完成
    /// </summary>
    internal sealed class ClickGuideFloorComplete : GuideCompleteBase
    {
        public ClickGuideFloorComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register<int>(EventManager.EventName.Guide_ClickFloor, OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister<int>(EventManager.EventName.Guide_ClickFloor, OnComplete);
        }

        private void OnComplete(int cellIndex)
        {
            Complete();
        }
    }

    /// <summary>
    /// 等待战斗开始按钮显示完成
    /// </summary>
    internal sealed class WaitFightStartButtonShowComplete : GuideCompleteBase
    {
        public WaitFightStartButtonShowComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_FightStartShow, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_FightStartShow, Complete);
        }
    }

    /// <summary>
    /// 等待备战区显示完成
    /// </summary>
    internal sealed class WaitPreparatShowComplete : GuideCompleteBase
    {
        public WaitPreparatShowComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_PreparatShow, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_PreparatShow, Complete);
        }
    }

    /// <summary>
    /// 等待敌人撤退
    /// </summary>
    internal sealed class WaitEnemyRetreatComplete : GuideCompleteBase
    {
        public WaitEnemyRetreatComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.INFIGHT_STATUS_CHANGED, (Action<GameUnit>)OnComplete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.INFIGHT_STATUS_CHANGED, (Action<GameUnit>)OnComplete);
        }

        private void OnComplete(GameUnit gameUnit)
        {
            if (!gameUnit.statusData.isRetreat)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 等待起名
    /// </summary>
    internal sealed class WaitChangeNameComplete : GuideCompleteBase
    {
        public WaitChangeNameComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.STORY_OPEN_NAME_PANEL, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.STORY_OPEN_NAME_PANEL, Complete);
        }

        public override async void Complete()
        {
            if (GameStateManager.Instance.GetCurState() is GameStateStory gameStateStory)
                gameStateStory.IsReady = false;

            await UI_WriteNameController.Open();

            base.Complete();
        }
    }

    /// <summary>
    /// 等待编队完成
    /// </summary>
    internal sealed class WaitEditTeamComplete : GuideCompleteBase
    {
        /// <summary>
        /// 队伍人数
        /// </summary>
        private readonly int cCount;

        public WaitEditTeamComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (cfg.CompleteTypeParams.Length <= 0)
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，参数数量错误：1.队伍人数");

            if (int.TryParse(cfg.CompleteTypeParams[0], out int count))
                cCount = count;
            else
                throw new Exception($"引导id：{Cfg.Id}, 引导类型：{Cfg.GuideStepType}，第1个参数类型错误：应该为int类型");
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.TeamModified, (Action<int>)OnTeamModfied);
            EventManager.Instance.Register(EventManager.EventName.UIOpen, (Action<string>)OnUIOpen);
            EventManager.Instance.Register(EventManager.EventName.UIClose, (Action<string>)OnUIClose);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UIClose, (Action<string>)OnUIClose);
            EventManager.Instance.Unregister(EventManager.EventName.UIOpen, (Action<string>)OnUIOpen);
            EventManager.Instance.Unregister(EventManager.EventName.TeamModified, (Action<int>)OnTeamModfied);
        }

        private async void OnUIOpen(string uiName)
        {
            if (UINameConst.UISelectCharacter != uiName)
                return;

            await UI_GuideController.Open(false);
        }

        private async void OnUIClose(string uiName)
        {
            if (UINameConst.UISelectCharacter != uiName)
                return;

            await UI_GuideController.Open(Cfg, false);
        }

        private void OnTeamModfied(int teamIndex)
        {
            Team team = TeamEditManager.Instance.GetTeamByIndex(teamIndex);
            if (null == team)
                return;

            if (team.GetAllCharacterCount() < cCount)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 等待清除队伍完成
    /// </summary>
    internal sealed class ClearTeamComplete : GuideCompleteBase
    {
        public ClearTeamComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.TeamClear, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.TeamClear, Complete);
        }
    }

    /// <summary>
    /// 等待加载完成
    /// </summary>
    internal sealed class WaitLoadingComplete : GuideCompleteBase
    {
        public WaitLoadingComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.LoadingExecutorComplete, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.LoadingExecutorComplete, Complete);
        }
    }

    /// <summary>
    /// 任意点击完成
    /// </summary>
    internal sealed class AnyClickComplete : GuideCompleteBase
    {
        /// <summary>
        /// 点击次数
        /// </summary>
        private int clickCount;

        public AnyClickComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
            if (cfg.CompleteTypeParams.Length <= 0)
            {
                clickCount = 1;
                return;
            }

            if (int.TryParse(cfg.CompleteTypeParams[0], out int num))
                clickCount = num;
        }

        public override void AddListener()
        {
            InputManager.Instance.OnClick += OnClick;
            InputManager.Instance.OnFingerUp += OnClick;
            InputManager.Instance.OnFingerUpUI += OnClick;
        }

        public override void RemoveListener()
        {
            InputManager.Instance.OnFingerUpUI -= OnClick;
            InputManager.Instance.OnFingerUp -= OnClick;
            InputManager.Instance.OnClick -= OnClick;
        }

        private void OnClick(Vector2 screenPos)
        {
            --clickCount;
            if (clickCount > 0)
                return;

            Complete();
        }
    }

    /// <summary>
    /// 保存队伍完成
    /// </summary>
    internal sealed class SaveTeamComplete : GuideCompleteBase
    {
        public SaveTeamComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.TeamUpdate, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.TeamUpdate, Complete);
        }
    }

    /// <summary>
    /// 选择队伍完成
    /// </summary>
    internal sealed class SelectTeamComplete : GuideCompleteBase
    {
        public SelectTeamComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.SetSelectTeam, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.SetSelectTeam, Complete);
        }
    }

    /// <summary>
    /// 上载具
    /// </summary>
    internal sealed class JoinVehicle : GuideCompleteBase
    {
        public JoinVehicle(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_JoinVehicle, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_JoinVehicle, Complete);
        }
    }

    /// <summary>
    /// 上阵完成
    /// </summary>
    internal sealed class GoBattleComplete : GuideCompleteBase
    {
        public GoBattleComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_JoinVehicle, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_JoinVehicle, Complete);
        }
    }

    /// <summary>
    /// 技能冷却完成
    /// </summary>
    internal sealed class SkillCDComplete : GuideCompleteBase
    {
        public SkillCDComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_JoinVehicle, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_JoinVehicle, Complete);
        }
    }

    /// <summary>
    /// 等待完成
    /// </summary>
    internal sealed class WaitComplete : GuideCompleteBase
    {
        public WaitComplete(DataGuideCfg cfg, Action complete) : base(cfg, complete)
        {
        }

        public override void AddListener()
        {
            EventManager.Instance.Register(EventManager.EventName.Guide_Wait, Complete);
        }

        public override void RemoveListener()
        {
            EventManager.Instance.Unregister(EventManager.EventName.Guide_Wait, Complete);
        }
    }
}