using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

namespace Parsing
{
    public static class ConditionDelegateFactory
    {
        // 正则表达式用于解析函数名和参数
        private static readonly Regex _methodCallRegex = new Regex(
            @"^(?<methodName>[a-zA-Z_][a-zA-Z0-9_]*)(?:\((?<args>.*)\))?$",
            RegexOptions.Compiled
        );

        /// <summary>
        /// 解析条件字符串并创建 Func<Entity.Entity, bool> 委托。
        /// </summary>
        /// <param name="conditionString">条件字符串，如 "EntityHealth(20)" 或 "IsTargetAlive"。</param>
        /// <param name="entityType">实体类型，通常是 typeof(Entity.Entity)。</param>
        /// <param name="conditionClassType">包含条件静态方法的类类型，如 typeof(ConditionFunctions)。</param>
        /// <returns>一个 Func<Entity.Entity, bool> 委托。</returns>
        /// <exception cref="ArgumentException">当条件字符串格式不正确时抛出。</exception>
        /// <exception cref="MissingMethodException">当找不到匹配的条件方法时抛出。</exception>
        public static Func<Entity.Entity, bool> CreateConditionDelegate(
            string conditionString,
            Type entityType,
            Type conditionClassType)
        {
            if (string.IsNullOrWhiteSpace(conditionString))
                throw new ArgumentException("条件字符串不能为空。", nameof(conditionString));
            if (entityType == null)
                throw new ArgumentNullException(nameof(entityType));
            if (conditionClassType == null)
                throw new ArgumentNullException(nameof(conditionClassType));

            var match = _methodCallRegex.Match(conditionString);
            if (!match.Success)
            {
                throw new ArgumentException(
                    $"条件字符串 '{conditionString}' 格式不正确。期望格式: MethodName 或 MethodName(arg1, arg2)。");
            }

            var methodName = match.Groups["methodName"].Value;
            var argsString = match.Groups["args"].Success ? match.Groups["args"].Value : null;

            // 逻辑修改：支持多参数解析
            var parsedArgValues = new List<object>(); // 存储解析后的参数值
            var parsedArgTypes = new List<Type>(); // 存储解析后的参数类型

            // 第一个参数始终是实体类型
            parsedArgTypes.Add(entityType);

            if (!string.IsNullOrEmpty(argsString))
            {
                // 使用辅助方法拆分参数字符串
                var argStrings = SplitArguments(argsString); // <-- 新增辅助方法调用
                foreach (var argStr in argStrings)
                {
                    var arg = ParseLiteral(argStr.Trim());
                    parsedArgValues.Add(arg.value);
                    parsedArgTypes.Add(arg.type);
                }
            }

            // 逻辑修改：更健壮的方法查找和参数类型匹配
            MethodInfo bestMatchMethod = null;
            object[] finalInvokeArgs = null; // 存储最终用于 Invoke 的参数值（已转换类型）

            // 获取所有静态、公共或非公共的同名方法，并过滤返回类型为 bool 的
            var methods = conditionClassType
                .GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
                .Where(m => m.Name == methodName && m.ReturnType == typeof(bool))
                .ToList();

            foreach (var method in methods)
            {
                var parameters = method.GetParameters();

                // 检查参数数量是否匹配
                if (parameters.Length != parsedArgTypes.Count)
                    continue;

                var paramsMatch = true;
                var currentInvokeArgs = new object[parameters.Length]; // 临时存储当前方法的参数值

                // 检查第一个参数（实体类型）
                if (!parameters[0].ParameterType.IsAssignableFrom(entityType))
                {
                    paramsMatch = false;
                    continue;
                }
                // 注意：currentInvokeArgs[0] 在这里不赋值，它将在委托执行时由传入的 entity 填充。

                // 检查后续参数（解析出的额外参数）
                for (var i = 1; i < parameters.Length; i++)
                {
                    var methodParamType = parameters[i].ParameterType;
                    var parsedValueType = parsedArgTypes[i];
                    var parsedValue = parsedArgValues[i - 1]; // parsedArgValues 从索引0开始对应第一个额外参数

                    // 尝试直接赋值
                    if (methodParamType.IsInstanceOfType(parsedValue))
                    {
                        currentInvokeArgs[i] = parsedValue;
                    }
                    // 尝试类型转换（例如 int 到 long，float 到 double）
                    else if (CanConvert(parsedValue, methodParamType)) // <-- 新增辅助方法调用
                    {
                        try
                        {
                            currentInvokeArgs[i] = Convert.ChangeType(parsedValue, methodParamType);
                        }
                        catch (Exception) // 捕获所有转换异常
                        {
                            paramsMatch = false;
                            break;
                        }
                    }
                    else
                    {
                        paramsMatch = false;
                        break;
                    }
                }

                if (paramsMatch)
                {
                    bestMatchMethod = method;
                    finalInvokeArgs = currentInvokeArgs; // 存储已转换的参数值
                    break; // 找到第一个匹配项即停止，如果需要更复杂的匹配规则（如最具体匹配），则需要进一步处理
                }
            }

            if (bestMatchMethod == null)
            {
                // 如果没有找到匹配的方法，抛出异常
                var expectedSignature = $"{methodName}({string.Join(", ", parsedArgTypes.Select(t => t.Name))})";
                throw new MissingMethodException(
                    $"在类 '{conditionClassType.FullName}' 中未找到名为 '{methodName}' 的静态方法，" +
                    $"其签名与期望的 '{expectedSignature}' 且返回类型为 'bool' 不兼容。"
                );
            }

            // 如果没有额外参数，直接创建委托以获得最佳性能
            if (parsedArgValues.Count == 0)
            {
                return (Func<Entity.Entity, bool>)Delegate.CreateDelegate(typeof(Func<Entity.Entity, bool>),
                    bestMatchMethod);
            }
            else
            {
                // 创建一个闭包来绑定解析后的参数
                // 闭包捕获 finalInvokeArgs，并在运行时填充第一个参数 (entity)
                return (entity) =>
                {
                    // 复制一份 finalInvokeArgs，因为 Invoke 会修改数组内容（如果参数是 ref/out）
                    // 并且需要将 entity 放入第一个位置
                    var invokeArgs = new object[finalInvokeArgs.Length];
                    invokeArgs[0] = entity;
                    for (var i = 1; i < finalInvokeArgs.Length; i++)
                    {
                        invokeArgs[i] = finalInvokeArgs[i];
                    }

                    return (bool)bestMatchMethod.Invoke(null, invokeArgs);
                };
            }
        }

        /// <summary>
        /// 辅助方法：拆分参数字符串。
        /// 这是一个更健壮的实现，能够正确处理包含逗号的带引号字符串和嵌套括号。
        /// </summary>
        /// <param name="argsString">待拆分的参数字符串。</param>
        /// <returns>拆分后的参数列表。</returns>
        private static IEnumerable<string> SplitArguments(string argsString)
        {
            if (string.IsNullOrEmpty(argsString))
            {
                return Enumerable.Empty<string>();
            }

            var arguments = new List<string>();
            var currentArgument = new StringBuilder();
            var inQuote = false; // 跟踪是否在双引号内部
            var parenLevel = 0;   // 跟踪括号的嵌套层级

            for (var i = 0; i < argsString.Length; i++)
            {
                var c = argsString[i];

                if (c == '"')
                {
                    inQuote = !inQuote; // 切换引号状态
                    currentArgument.Append(c); // 将引号字符保留在参数中
                }
                else if (c == '(')
                {
                    parenLevel++; // 增加括号层级
                    currentArgument.Append(c);
                }
                else if (c == ')')
                {
                    parenLevel--; // 减少括号层级
                    currentArgument.Append(c);
                }
                else if (c == ',' && !inQuote && parenLevel == 0)
                {
                    // 发现一个顶级的逗号分隔符：不在引号内，也不在任何括号内
                    var arg = currentArgument.ToString().Trim();
                    if (!string.IsNullOrEmpty(arg))
                    {
                        arguments.Add(arg);
                    }
                    currentArgument.Clear(); // 重置，开始收集下一个参数
                }
                else
                {
                    // 其他字符，直接添加到当前参数
                    currentArgument.Append(c);
                }
            }

            // 循环结束后，添加最后一个参数（如果有的话）
            var lastArg = currentArgument.ToString().Trim();
            if (!string.IsNullOrEmpty(lastArg))
            {
                arguments.Add(lastArg);
            }

            return arguments;
        }

        /// <summary>
        /// 辅助方法：检查一个值是否可以转换为目标类型。
        /// </summary>
        private static bool CanConvert(object value, Type targetType)
        {
            // 逻辑修改：新增辅助方法，用于检查类型转换可行性
            if (value == null) return !targetType.IsValueType || (Nullable.GetUnderlyingType(targetType) != null);
            if (targetType.IsInstanceOfType(value)) return true;

            try
            {
                // 尝试转换，如果成功则表示可转换
                Convert.ChangeType(value, targetType);
                return true;
            }
            catch (Exception) // 捕获所有可能的转换异常
            {
                return false;
            }
        }

        /// <summary>
        /// 解析字符串字面量为对应的对象和类型。
        /// 支持 int, long, float, double, bool, string。
        /// </summary>
        /// <param name="literalString">要解析的字面量字符串。</param>
        /// <returns>包含解析后的值和类型的元组。</returns>
        private static (object value, Type type) ParseLiteral(string literalString)
        {
            // 逻辑修改：增强 ParseLiteral，增加对 long 和 double 的支持
            // 顺序很重要：先尝试更窄的类型，再尝试更宽的类型，以避免不必要的类型提升。

            // 尝试解析为 int
            if (int.TryParse(literalString, out var intValue))
            {
                return (intValue, typeof(int));
            }

            // 尝试解析为 long
            if (long.TryParse(literalString, out var longValue))
            {
                return (longValue, typeof(long));
            }

            // 尝试解析为 float
            if (float.TryParse(literalString, out var floatValue))
            {
                return (floatValue, typeof(float));
            }

            // 尝试解析为 double
            if (double.TryParse(literalString, out var doubleValue))
            {
                return (doubleValue, typeof(double));
            }

            // 尝试解析为 bool
            if (bool.TryParse(literalString, out var boolValue))
            {
                return (boolValue, typeof(bool));
            }

            // 尝试解析为 string (如果被双引号包围)
            if (literalString.StartsWith("\"") && literalString.EndsWith("\"") && literalString.Length > 1)
            {
                return (literalString.Substring(1, literalString.Length - 2), typeof(string));
            }

            // 默认作为字符串处理
            return (literalString, typeof(string));
        }
    }
}