using Framework;
using Framework.Condition;

namespace Gameplay.Level
{
    public partial class Level
    {
        private int _currStageSuccessReactionID;
        private int _currStageFailReactionID;
        private int[] _currLevelStarReactionIDArray = new int[15];

        private void InitStageConditions()
        {
            var currStage = CurrentStage;
            if (currStage == null)
                return;

            if (currStage.successCondition == null)
            {
                DebugUtil.LogError(
                    $"currStage's success condition is null!stageIndex:{currentStageIndex} levelID:{ID}");
                return;
            }

            _currStageSuccessReactionID = ConditionReactor.Instance.AddReaction(currStage.successCondition,
                OnSuccessConditionChanged, null, false);

            if (currStage.failConditions == null || currStage.failConditions.Count == 0)
            {
                DebugUtil.LogError(
                    $"currStage's fail condition is null or 0 elements!stageIndex:{currentStageIndex} levelID:{ID}");
                return;
            }

            _currStageFailReactionID = ConditionReactor.Instance.AddReaction(currStage.failConditions,
                OnFailConditionChanged, null, false, false);

            EventManager.Instance.Register(EventManager.EventName.LevelBattleBegin, CheckSuccessAndFailCondition);
        }

        private void ReleaseStageConditions()
        {
            EventManager.Instance.Unregister(EventManager.EventName.LevelBattleBegin, CheckSuccessAndFailCondition);

            ConditionReactor.Instance.RemoveReaction(_currStageSuccessReactionID);
            ConditionReactor.Instance.RemoveReaction(_currStageFailReactionID);
        }

        private void CheckSuccessAndFailCondition()
        {
            ConditionReactor.Instance.ExecuteReaction(_currStageSuccessReactionID);
            ConditionReactor.Instance.ExecuteReaction(_currStageFailReactionID);
        }

        private void OnSuccessConditionChanged(bool result, object param, int id)
        {
            if (result)
            {
                OnStageSuccess();
            }
        }

        private void OnFailConditionChanged(bool result, object param, int id)
        {
            if (result)
            {
                OnStageFailed();
            }
        }

        private void OnStarConditionChanged(bool result, object param, int id)
        {
            var index = (int)param;
            _starTargets[index] = result;
        }

        private void InitStarConditions()
        {
            if (_levelData.scoreLevel) // 评分关
            {
                for (int i = 0; i < _levelData.scoreTarget.Count; i++)
                {
                    ConditionModifier conditionModifier = _levelData.scoreTarget[i];
                    if (null != conditionModifier)
                        _currLevelStarReactionIDArray[i] = ConditionReactor.Instance.AddReaction(conditionModifier, OnStarConditionChanged, i);
                }
            }
            else // 星级关
            {
                for (int i = 0; i < STAR_TARGET_COUNT; i++)
                {
                    var condition = _levelData.starTarget[i];
                    var index = i;
                    _currLevelStarReactionIDArray[i] =
                        ConditionReactor.Instance.AddReaction(condition, OnStarConditionChanged, index);
                }
            }
        }

        private void ReleaseStarConditions()
        {
            foreach (var reactionID in _currLevelStarReactionIDArray)
            {
                ConditionReactor.Instance.RemoveReaction(reactionID);
            }
        }
    }
}