using Newtonsoft.Json.Linq;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using YLErp.Commons;
using YLErp.DBModels;
using YLErp.Modules.RiskEngine.Dto;

namespace YLErp.Modules.RiskEngine
{
    /// <summary>
    /// 结构化规则执行器。
    /// 用于执行现有 ConditionJson：变量取值、按 DataType 转换并比较阈值；复杂业务计算放在变量表达式中完成。
    /// </summary>
    public static class StructuredRuleExecutor
    {
        private static readonly ConcurrentDictionary<string, Func<RiskContext, object>> VariableCompiledCache = new ConcurrentDictionary<string, Func<RiskContext, object>>();

        private static readonly HashSet<string> ComparableOperators = new HashSet<string>(StringComparer.Ordinal)
        {
            "gt", "lt", "gte", "lte", "eq", "ne", "between", "notBetween"
        };

        private static readonly HashSet<string> BooleanOperators = new HashSet<string>(StringComparer.Ordinal)
        {
            "isTrue", "isFalse"
        };

        public static StructuredRuleExecuteResult Execute(
            IReadOnlyList<RuleCondition> conditions,
            IReadOnlyDictionary<long, glms_risk_variable> variables,
            RiskContext context)
        {
            try
            {
                if (conditions == null || conditions.Count == 0)
                    return StructuredRuleExecuteResult.Fail("公式条件列表不能为空");
                if (variables == null)
                    return StructuredRuleExecuteResult.Fail("变量列表不能为空");

                for (var i = 0; i < conditions.Count; i++)
                {
                    var conditionResult = ExecuteCondition(conditions[i], variables, context, i + 1);
                    if (!conditionResult.Success)
                        return conditionResult;
                    if (!conditionResult.Triggered)
                        return StructuredRuleExecuteResult.Ok(false);
                }

                return StructuredRuleExecuteResult.Ok(true);
            }
            catch (Exception ex)
            {
                return StructuredRuleExecuteResult.Fail(ex.Message);
            }
        }

        private static StructuredRuleExecuteResult ExecuteCondition(
            RuleCondition condition,
            IReadOnlyDictionary<long, glms_risk_variable> variables,
            RiskContext context,
            int conditionIndex)
        {
            var label = $"条件{conditionIndex}";
            if (condition == null)
                return StructuredRuleExecuteResult.Fail($"{label}不能为空");
            if (!variables.TryGetValue(condition.VariableId, out var variable))
                return StructuredRuleExecuteResult.Fail($"{label}：变量 ID '{condition.VariableId}' 不存在");

            if (variable.DataType == RiskVariableDataType.Boolean)
                return ExecuteBooleanCondition(condition, variable, context, label);

            if (variable.DataType != RiskVariableDataType.Numeric && variable.DataType != RiskVariableDataType.Date)
                return StructuredRuleExecuteResult.Fail($"{label}：不支持的数据类型");
            if (!ComparableOperators.Contains(condition.Operator))
                return StructuredRuleExecuteResult.Fail($"{label}：操作符 '{condition.Operator}' 不适用于{GetDataTypeName(variable.DataType)}类型变量");

            var left = GetVariableValue(variable, variable.DataType, context, label, "条件变量");
            if (!left.Success)
                return StructuredRuleExecuteResult.Fail(left.ErrorMessage);

            if (condition.Operator == "between" || condition.Operator == "notBetween")
                return ExecuteRangeCondition(condition, variable, left.Value, variables, context, label);

            var rangeFieldCheck = EnsureNoRangeFields(condition, label);
            if (!rangeFieldCheck.Success)
                return rangeFieldCheck;

            var right = GetThresholdValue(
                condition.ThresholdType,
                condition.Value,
                condition.ThresholdVariableId,
                variable,
                variables,
                context,
                label,
                "阈值");
            if (!right.Success)
                return StructuredRuleExecuteResult.Fail(right.ErrorMessage);

            var compareResult = Compare(left.Value, right.Value, variable.DataType, condition.Operator, label);
            if (!compareResult.Success)
                return compareResult;

            return StructuredRuleExecuteResult.Ok(compareResult.Triggered);
        }

        private static StructuredRuleExecuteResult ExecuteBooleanCondition(
            RuleCondition condition,
            glms_risk_variable variable,
            RiskContext context,
            string label)
        {
            if (!BooleanOperators.Contains(condition.Operator))
                return StructuredRuleExecuteResult.Fail($"{label}：操作符 '{condition.Operator}' 不适用于布尔类型变量");
            var thresholdFieldCheck = EnsureNoThresholdFields(condition, label);
            if (!thresholdFieldCheck.Success)
                return thresholdFieldCheck;

            var value = GetVariableValue(variable, RiskVariableDataType.Boolean, context, label, "条件变量");
            if (!value.Success)
                return StructuredRuleExecuteResult.Fail(value.ErrorMessage);

            var expected = condition.Operator == "isTrue";
            return StructuredRuleExecuteResult.Ok((bool)value.Value == expected);
        }

        private static StructuredRuleExecuteResult ExecuteRangeCondition(
            RuleCondition condition,
            glms_risk_variable variable,
            object leftValue,
            IReadOnlyDictionary<long, glms_risk_variable> variables,
            RiskContext context,
            string label)
        {
            if (condition.ThresholdType != null || HasValue(condition.Value) || condition.ThresholdVariableId.HasValue)
                return StructuredRuleExecuteResult.Fail($"{label}：区间条件不得携带普通阈值字段");
            if (!condition.IncludeLower.HasValue || !condition.IncludeUpper.HasValue)
                return StructuredRuleExecuteResult.Fail($"{label}：区间开闭配置不完整");

            var fixedRangeCheck = ValidateFixedRangeOrder(condition, variable.DataType, label);
            if (!fixedRangeCheck.Success)
                return fixedRangeCheck;

            var lower = GetThresholdValue(condition.LowerThresholdType, condition.LowerValue, condition.LowerThresholdVariableId, variable, variables, context, label, "下限");
            if (!lower.Success)
                return StructuredRuleExecuteResult.Fail(lower.ErrorMessage);

            var upper = GetThresholdValue(condition.UpperThresholdType, condition.UpperValue, condition.UpperThresholdVariableId, variable, variables, context, label, "上限");
            if (!upper.Success)
                return StructuredRuleExecuteResult.Fail(upper.ErrorMessage);

            var lowerOperator = condition.IncludeLower == true ? "gte" : "gt";
            var upperOperator = condition.IncludeUpper == true ? "lte" : "lt";
            var lowerCompare = Compare(leftValue, lower.Value, variable.DataType, lowerOperator, label);
            if (!lowerCompare.Success)
                return lowerCompare;
            var upperCompare = Compare(leftValue, upper.Value, variable.DataType, upperOperator, label);
            if (!upperCompare.Success)
                return upperCompare;

            var inRange = lowerCompare.Triggered && upperCompare.Triggered;
            return StructuredRuleExecuteResult.Ok(condition.Operator == "notBetween" ? !inRange : inRange);
        }

        private static ValueExecuteResult GetThresholdValue(
            string thresholdType,
            object fixedValue,
            long? thresholdVariableId,
            glms_risk_variable conditionVariable,
            IReadOnlyDictionary<long, glms_risk_variable> variables,
            RiskContext context,
            string label,
            string thresholdLabel)
        {
            if (string.Equals(thresholdType, "Fixed", StringComparison.Ordinal))
            {
                if (thresholdVariableId.HasValue)
                    return ValueExecuteResult.Fail($"{label}：固定{thresholdLabel}不得携带变量 ID");
                var fixedResult = ConvertValue(fixedValue, conditionVariable.DataType, label, $"固定{thresholdLabel}");
                if (!fixedResult.Success)
                    return ValueExecuteResult.Fail($"{fixedResult.ErrorMessage}，原始值：{FormatRawValue(fixedValue)}");
                return fixedResult;
            }

            if (string.Equals(thresholdType, "Variable", StringComparison.Ordinal))
            {
                if (HasValue(fixedValue))
                    return ValueExecuteResult.Fail($"{label}：变量{thresholdLabel}不得携带固定值");
                if (!thresholdVariableId.HasValue)
                    return ValueExecuteResult.Fail($"{label}：{thresholdLabel}变量 ID 不能为空");
                if (!variables.TryGetValue(thresholdVariableId.Value, out var thresholdVariable))
                    return ValueExecuteResult.Fail($"{label}：{thresholdLabel}变量 ID '{thresholdVariableId.Value}' 不存在");
                if (thresholdVariable.DataType != conditionVariable.DataType)
                    return ValueExecuteResult.Fail($"{label}：{thresholdLabel}变量与条件变量的数据类型不一致");
                if (conditionVariable.DataType == RiskVariableDataType.Numeric && !UnitsMatch(conditionVariable.Unit, thresholdVariable.Unit))
                    return ValueExecuteResult.Fail($"{label}：{thresholdLabel}变量与条件变量的单位不一致");

                return GetVariableValue(thresholdVariable, conditionVariable.DataType, context, label, thresholdLabel);
            }

            return ValueExecuteResult.Fail($"{label}：{thresholdLabel}类型 '{thresholdType}' 不合法，仅支持 Fixed/Variable");
        }

        private static ValueExecuteResult GetVariableValue(
            glms_risk_variable variable,
            RiskVariableDataType dataType,
            RiskContext context,
            string label,
            string valueLabel)
        {
            if (string.IsNullOrWhiteSpace(variable.VariableExpr))
                return ValueExecuteResult.Fail($"{label}：变量'{variable.VariableName}'(ID:{variable.id})的取值表达式为空");

            var compiled = GetCompiledVariableExpression(variable, out var errorMessage);
            if (compiled == null)
                return ValueExecuteResult.Fail($"{label}：变量'{variable.VariableName}'(ID:{variable.id})编译失败：{errorMessage}");

            object rawValue;
            try
            {
                rawValue = compiled(context);
            }
            catch (Exception ex)
            {
                return ValueExecuteResult.Fail($"{label}：变量'{variable.VariableName}'(ID:{variable.id})执行失败：{ex.Message}");
            }

            var converted = ConvertValue(rawValue, dataType, label, valueLabel);
            if (!converted.Success)
                return ValueExecuteResult.Fail($"{label}：变量'{variable.VariableName}'(ID:{variable.id}){converted.ErrorMessage}，原始值：{FormatRawValue(rawValue)}");

            return converted;
        }

        private static Func<RiskContext, object> GetCompiledVariableExpression(glms_risk_variable variable, out string errorMessage)
        {
            var cacheKey = $"{variable.id}:{variable.Version}:{variable.UpdateDate?.Ticks ?? 0}:{StringComparer.Ordinal.GetHashCode(variable.VariableExpr ?? string.Empty)}";
            if (VariableCompiledCache.TryGetValue(cacheKey, out var compiled))
            {
                errorMessage = null;
                return compiled;
            }

            // 变量表达式只负责取原始值，类型转换统一在结构化执行器中处理；这里缓存编译结果，避免每次执行重复 Roslyn 编译。
            compiled = RuleCompiler.CompileValueExpression(variable.VariableExpr, out errorMessage);
            if (compiled != null)
                VariableCompiledCache[cacheKey] = compiled;
            return compiled;
        }

        private static ValueExecuteResult ConvertValue(object value, RiskVariableDataType dataType, string label, string valueLabel)
        {
            if (!HasValue(value))
                return ValueExecuteResult.Fail($"{valueLabel}为空");

            if (dataType == RiskVariableDataType.Numeric)
            {
                if (value is decimal decimalValue)
                    return ValueExecuteResult.Ok(decimalValue);
                if (decimal.TryParse(GetRawValue(value), NumberStyles.Float, CultureInfo.InvariantCulture, out var numericValue))
                    return ValueExecuteResult.Ok(numericValue);
                return ValueExecuteResult.Fail($"{valueLabel}必须为数字");
            }

            if (dataType == RiskVariableDataType.Date)
            {
                if (value is DateTime dateValue)
                    return ValueExecuteResult.Ok(dateValue.Date);
                if (DateTime.TryParseExact(GetRawValue(value), "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var fixedDate))
                    return ValueExecuteResult.Ok(fixedDate.Date);
                return ValueExecuteResult.Fail($"{valueLabel}必须为 yyyy-MM-dd 格式的合法日期");
            }

            if (dataType == RiskVariableDataType.Boolean)
            {
                if (value is bool boolValue)
                    return ValueExecuteResult.Ok(boolValue);
                if (bool.TryParse(GetRawValue(value), out var parsedBool))
                    return ValueExecuteResult.Ok(parsedBool);
                return ValueExecuteResult.Fail($"{valueLabel}必须为布尔值");
            }

            return ValueExecuteResult.Fail($"{label}：不支持的数据类型");
        }

        private static StructuredRuleExecuteResult Compare(object left, object right, RiskVariableDataType dataType, string ruleOperator, string label)
        {
            var compare = dataType switch
            {
                RiskVariableDataType.Numeric => ((decimal)left).CompareTo((decimal)right),
                RiskVariableDataType.Date => ((DateTime)left).CompareTo((DateTime)right),
                _ => throw new ServiceException($"{label}：不支持的数据类型")
            };

            var result = ruleOperator switch
            {
                "gt" => compare > 0,
                "lt" => compare < 0,
                "gte" => compare >= 0,
                "lte" => compare <= 0,
                "eq" => compare == 0,
                "ne" => compare != 0,
                _ => throw new ServiceException($"{label}：不支持的操作符'{ruleOperator}'")
            };

            return StructuredRuleExecuteResult.Ok(result);
        }

        private static StructuredRuleExecuteResult EnsureNoRangeFields(RuleCondition condition, string label)
        {
            if (condition.LowerThresholdType != null || HasValue(condition.LowerValue) || condition.LowerThresholdVariableId.HasValue ||
                condition.UpperThresholdType != null || HasValue(condition.UpperValue) || condition.UpperThresholdVariableId.HasValue ||
                condition.IncludeLower.HasValue || condition.IncludeUpper.HasValue)
            {
                return StructuredRuleExecuteResult.Fail($"{label}：非区间条件不得携带区间字段");
            }

            return StructuredRuleExecuteResult.Ok(false);
        }

        private static StructuredRuleExecuteResult EnsureNoThresholdFields(RuleCondition condition, string label)
        {
            if (condition.ThresholdType != null || HasValue(condition.Value) || condition.ThresholdVariableId.HasValue ||
                condition.LowerThresholdType != null || HasValue(condition.LowerValue) || condition.LowerThresholdVariableId.HasValue ||
                condition.UpperThresholdType != null || HasValue(condition.UpperValue) || condition.UpperThresholdVariableId.HasValue ||
                condition.IncludeLower.HasValue || condition.IncludeUpper.HasValue)
            {
                return StructuredRuleExecuteResult.Fail($"{label}：布尔条件不得携带阈值字段");
            }

            return StructuredRuleExecuteResult.Ok(false);
        }

        private static StructuredRuleExecuteResult ValidateFixedRangeOrder(RuleCondition condition, RiskVariableDataType dataType, string label)
        {
            if (condition.LowerThresholdType != "Fixed" || condition.UpperThresholdType != "Fixed")
                return StructuredRuleExecuteResult.Ok(false);

            var lower = GetRawValue(condition.LowerValue);
            var upper = GetRawValue(condition.UpperValue);
            if (dataType == RiskVariableDataType.Numeric &&
                decimal.TryParse(lower, NumberStyles.Float, CultureInfo.InvariantCulture, out var lowerNumber) &&
                decimal.TryParse(upper, NumberStyles.Float, CultureInfo.InvariantCulture, out var upperNumber) &&
                lowerNumber > upperNumber)
            {
                return StructuredRuleExecuteResult.Fail($"{label}：下限不能大于上限");
            }

            if (dataType == RiskVariableDataType.Date &&
                DateTime.TryParseExact(lower, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var lowerDate) &&
                DateTime.TryParseExact(upper, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var upperDate) &&
                lowerDate > upperDate)
            {
                return StructuredRuleExecuteResult.Fail($"{label}：下限不能晚于上限");
            }

            return StructuredRuleExecuteResult.Ok(false);
        }

        private static bool HasValue(object value)
        {
            if (value == null) return false;
            if (value is JValue jsonValue)
            {
                if (jsonValue.Type == JTokenType.Null || jsonValue.Type == JTokenType.Undefined) return false;
                if (jsonValue.Type == JTokenType.String) return !string.IsNullOrWhiteSpace(jsonValue.Value<string>());
                return true;
            }
            return value is not string text || !string.IsNullOrWhiteSpace(text);
        }

        private static string GetRawValue(object value)
        {
            return value is JValue jsonValue
                ? Convert.ToString(jsonValue.Value, CultureInfo.InvariantCulture)
                : Convert.ToString(value, CultureInfo.InvariantCulture);
        }

        private static string FormatRawValue(object value)
        {
            if (value == null)
                return "<null>";
            var rawValue = GetRawValue(value);
            return string.IsNullOrWhiteSpace(rawValue) ? "<empty>" : rawValue;
        }

        private static bool UnitsMatch(string left, string right)
        {
            return string.Equals(left?.Trim() ?? string.Empty, right?.Trim() ?? string.Empty, StringComparison.Ordinal);
        }

        private static string GetDataTypeName(RiskVariableDataType dataType)
        {
            return dataType switch
            {
                RiskVariableDataType.Numeric => "数值",
                RiskVariableDataType.Date => "日期",
                RiskVariableDataType.Boolean => "布尔",
                _ => "未知"
            };
        }
    }

    public class StructuredRuleExecuteResult
    {
        public bool Success { get; set; }

        public bool Triggered { get; set; }

        public string ErrorMessage { get; set; }

        public static StructuredRuleExecuteResult Ok(bool triggered)
        {
            return new StructuredRuleExecuteResult
            {
                Success = true,
                Triggered = triggered
            };
        }

        public static StructuredRuleExecuteResult Fail(string errorMessage)
        {
            return new StructuredRuleExecuteResult
            {
                Success = false,
                Triggered = false,
                ErrorMessage = errorMessage
            };
        }
    }

    internal class ValueExecuteResult
    {
        public bool Success { get; set; }

        public object Value { get; set; }

        public string ErrorMessage { get; set; }

        public static ValueExecuteResult Ok(object value)
        {
            return new ValueExecuteResult
            {
                Success = true,
                Value = value
            };
        }

        public static ValueExecuteResult Fail(string errorMessage)
        {
            return new ValueExecuteResult
            {
                Success = false,
                ErrorMessage = errorMessage
            };
        }
    }
}