using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

namespace AibisDream
{
    [CreateAssetMenu(fileName = "BlockPuzzleValidator", menuName = AibisAssetMenus.BlockPuzzleValidator)]
    public class BlockPuzzleValidator : ScriptableObject
    {
        [Tooltip("基础条件, 不满足无法提交")]
        public ValidateItem[] baseConditions;

        public UnityEvent<ValidateResult> OnValidate = new();

        /// <summary>       
        /// 验证是否可以完成拼图
        /// </summary>
        /// <param name="shapeInGrid"></param>
        /// <returns></returns>
        public ValidateResult Validate(List<BlockShape> shapeInGrid)
        {
            var result = new ValidateResult();

            var propValue = new BlockPuzzleParamValue();
            // 统计每个Shape的属性值
            foreach (var shape in shapeInGrid)
            {
                propValue.power += shape.BlockShapeData.blockShapeInfo.paramValue.power;
                propValue.noise += shape.BlockShapeData.blockShapeInfo.paramValue.noise;
                propValue.heat += shape.BlockShapeData.blockShapeInfo.paramValue.heat;  
            }

            // 保存所有Property的值
            result.propValue = propValue;

            // 校验基础条件
            foreach (var condition in baseConditions)
            {
                int propertyValue = GetPropertyValue(propValue, condition.paramType);
                var itemResult = condition.Validate(propertyValue);
                
                // 保存每个条件的验证结果
                result.conditionResults.Add(new PropertyValidationResult
                {
                    propertyName = condition.paramType.ToString(),
                    propertyValue = propertyValue,
                    conditionName = condition.name,
                    isValid = itemResult
                });

                result.isPass = result.isPass && itemResult;
            }

            OnValidate.Invoke(result);
            return result;
        }

        /// <summary>
        /// 根据参数类型获取对应的属性值
        /// </summary>
        /// <param name="propValue">属性值结构</param>
        /// <param name="paramType">参数类型</param>
        /// <returns>属性值</returns>
        private int GetPropertyValue(BlockPuzzleParamValue propValue, ParamType paramType)
        {
            return paramType switch
            {
                ParamType.Power => propValue.power,
                ParamType.Noise => propValue.noise,
                ParamType.Heat => propValue.heat,
                _ => 0
            };
        }

        /// <summary>
        /// 收集Power, Noise, Heat的阈值，并以BlockPuzzleParamValue的形式返回
        /// </summary>
        /// <returns>包含各参数阈值的BlockPuzzleParamValue结构</returns>
        public BlockPuzzleParamValue CollectThresholds()
        {
            var thresholds = new BlockPuzzleParamValue();

            if (baseConditions == null)
                return thresholds;

            // 遍历所有条件，收集每个参数类型的阈值
            // 如果同一参数类型有多个条件，取第一个匹配的阈值
            bool powerFound = false;
            bool noiseFound = false;
            bool heatFound = false;

            foreach (var condition in baseConditions)
            {
                if (!powerFound && condition.paramType == ParamType.Power)
                {
                    thresholds.power = condition.threshold;
                    powerFound = true;
                }
                else if (!noiseFound && condition.paramType == ParamType.Noise)
                {
                    thresholds.noise = condition.threshold;
                    noiseFound = true;
                }
                else if (!heatFound && condition.paramType == ParamType.Heat)
                {
                    thresholds.heat = condition.threshold;
                    heatFound = true;
                }

                // 如果所有参数类型都已找到，可以提前退出
                if (powerFound && noiseFound && heatFound)
                    break;
            }

            return thresholds;
        }

        [System.Serializable]
        public struct ValidateItem
        {
            [Tooltip("条件名称, 仅用于显示")]
            public string name;

            [Tooltip("要验证的属性类型")]
            public ParamType paramType;

            [Tooltip("比较类型")]
            public ComparisonType comparisonType;

            [Tooltip("阈值")]
            public int threshold;

            public bool Validate(int propertyValue)
            {
                return comparisonType switch
                {
                    ComparisonType.GreaterThan => propertyValue > threshold,
                    ComparisonType.LessThan => propertyValue < threshold,
                    ComparisonType.GreaterThanOrEqual => propertyValue >= threshold,
                    ComparisonType.LessThanOrEqual => propertyValue <= threshold,
                    _ => false
                };
            }
        }

        /// <summary>
        /// 参数类型枚举，用于选择要验证的属性
        /// </summary>
        public enum ParamType
        {
            /// <summary>
            /// 功率
            /// </summary>
            Power,
            /// <summary>
            /// 噪音
            /// </summary>
            Noise,
            /// <summary>
            /// 热量
            /// </summary>
            Heat
        }

        public enum ComparisonType
        {
            /// <summary>
            /// 大于阈值
            /// </summary>
            GreaterThan,
            /// <summary>
            /// 小于阈值
            /// </summary>
            LessThan,
            /// <summary>
            /// 大于等于阈值
            /// </summary>
            GreaterThanOrEqual,
            /// <summary>
            /// 小于等于阈值
            /// </summary>
            LessThanOrEqual
        }
    }
    
    public class ValidateResult
    {
        /// <summary>
        /// 完整的验证结果，所有基础条件都满足时为true
        /// </summary>
        public bool isPass;

        /// <summary>
        /// 所有Shape的属性值
        /// </summary>
        public BlockPuzzleParamValue propValue;

        /// <summary>
        /// 每个条件的验证结果，包含Property的值和验证结果
        /// </summary>
        public List<PropertyValidationResult> conditionResults;

        public ValidateResult()
        {
            isPass = true;
            propValue = new BlockPuzzleParamValue();
            conditionResults = new List<PropertyValidationResult>();
        }
    }

    [System.Serializable]
    public class PropertyValidationResult
    {
        /// <summary>
        /// 属性名称
        /// </summary>
        public string propertyName;

        /// <summary>
        /// 属性值
        /// </summary>
        public int propertyValue;

        /// <summary>
        /// 条件名称
        /// </summary>
        public string conditionName;

        /// <summary>
        /// 是否通过验证
        /// </summary>
        public bool isValid;
    }
}