using AutoMapper;
using CapMachine.Core;
using CapMachine.Model;
using CapMachine.Wpf.Dtos;
using DynamicExpresso;
using FreeSql;
using FreeSql.DataAnnotations;
using Prism.Mvvm;
using Syncfusion.Windows.Shared;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace CapMachine.Wpf.Services
{
    /// <summary>
    /// 逻辑服务 - 用于处理数据逻辑转换
    /// </summary>
    public class LogicRuleService : BindableBase
    {
        private readonly ILogService LogService;
        private readonly IFreeSql FreeSql;

        /// <summary>
        /// 逻辑转换规则集合
        /// </summary>
        public ObservableCollection<LogicRuleDto> LogicRuleDtos { get; private set; }

        /// <summary>
        /// DynamicExpresso解释器
        /// </summary>
        private Interpreter CurInterpreter { get; set; }
        public IMapper Mapper { get; }

        /// <summary>
        /// 规则表达式缓存（高性能访问）
        /// Key: 规则名称, Value: 已编译的Lambda表达式
        ///private readonly ConcurrentDictionary<string, Func<double, double>> _expressionCache;
        /// </summary>
        private readonly ConcurrentDictionary<string, Lambda> _expressionCache;

        ///// <summary>
        ///// 创建包含指定值的参数数组
        ///// </summary>
        //private Parameter[] CreateParameters(double value)
        //{
        //    return new Parameter[]
        //    {
        //        new Parameter("value", typeof(double), value)
        //    };
        //}

        /// <summary>
        /// 创建包含指定值的参数
        /// </summary>
        private Parameter CreateParameters(double value)
        {
            return new Parameter("value", typeof(double),value);

        }

        /// <summary>
        /// 实例化函数
        /// </summary>
        public LogicRuleService(ILogService logService, IFreeSql freeSql, IMapper mapper)
        {
            LogService = logService;
            FreeSql = freeSql;
            Mapper = mapper;

            // 初始化集合
            LogicRuleDtos = new ObservableCollection<LogicRuleDto>();

            _expressionCache = new ConcurrentDictionary<string, Lambda>();

            // 初始化DynamicExpresso解释器
            CurInterpreter = new Interpreter();
                //.Reference(typeof(Math))  // 引用Math类
                //                          //.SetVariable("Math", typeof(Math))
                //.SetVariable("value", 0.2);

            try
            {
                // 从数据库加载规则
                LoadRulesFromDatabase();

            }
            catch (Exception ex)
            {
                LogService.Error($"初始化逻辑服务失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 从数据库加载规则
        /// </summary>
        private void LoadRulesFromDatabase()
        {
            try
            {
                // 从数据库加载规则
                var dbRules = FreeSql.Select<LogicRule>().OrderBy(a => a.Id).ToList();
                if (dbRules != null && dbRules.Count > 0)
                {
                    LogicRuleDtos.Clear();
                    _expressionCache.Clear(); // 清空表达式缓存

                    foreach (var rule in dbRules)
                    {
                        LogicRuleDtos.Add(Mapper.Map<LogicRuleDto>(rule));
                    }

                    // 预编译所有表达式
                    WarmUpExpressionCache();

                    //LogService.Info($"已从数据库加载并预编译 {dbRules.Count} 条逻辑规则");
                }
                else
                {
                    LogService.Warn("数据库中没有逻辑规则");
                }
            }
            catch (Exception ex)
            {
                LogService.Error($"从数据库加载逻辑规则失败: {ex.Message}");
                throw; // 重新抛出异常以便调用者处理
            }
        }


        #region 增删改查LogicRule


        /// <summary>
        /// 添加新规则
        /// </summary>
        /// <param name="rule">规则对象</param>
        public void AddRule(LogicRule rule)
        {
            if (string.IsNullOrWhiteSpace(rule.Name))
            {
                MessageBox.Show("规则名称不能为空");
                return;
            }

            if (string.IsNullOrWhiteSpace(rule.Expression))
            {
                MessageBox.Show("规则表达式不能为空");
                return;
            }

            if (LogicRuleDtos.Where(a => a.Name == rule.Name).Any())
            {
                MessageBox.Show("已经有另一个相同名称的规则了");
                return;
            }

            // 验证表达式是否有效
            if (!ValidateExpression(rule.Expression))
            {
                MessageBox.Show("规则表达式验证失败");
                return;
            }

            if (InsertRuleToDb(rule, out LogicRule resultInsert))
            {
                //此时的resultInsert有新增的ID
                // 添加规则
                LogicRuleDtos.Add(Mapper.Map<LogicRuleDto>(resultInsert));

                // 预编译并缓存表达式
                CacheExpression(Mapper.Map<LogicRuleDto>(resultInsert));
            }
            else
            {
                MessageBox.Show("增加数据失败！");
                return;
            }
            //LogService.Info($"添加新规则: {rule.Name}");
        }

        /// <summary>
        /// 保存规格到数据库中
        /// </summary>
        /// <returns></returns>
        public bool InsertRuleToDb(LogicRule rule, out LogicRule ResultInsert)
        {
            try
            {
                // 插入规则到数据库
                var result = FreeSql.Insert<LogicRule>(rule).ExecuteInserted();

                // 检查影响的行数
                bool success = result.Count > 0;

                if (success)
                {
                    ResultInsert = result.FirstOrDefault()!;
                    return success;
                    //LogService.Info($"成功插入规则: {rule.Name}");

                    // 刷新内存中的规则集合
                    //LoadRulesFromDatabase();
                }
                else
                {
                    LogService.Warn($"插入规则失败: {rule.Name}，没有行受影响");
                    ResultInsert = null;
                    return success;
                }


            }
            catch (Exception ex)
            {
                LogService.Error($"插入规则到数据库时发生异常: {ex.Message}");
                ResultInsert = null;
                return false;
            }
        }

        /// <summary>
        /// 更新规则
        /// </summary>
        /// <param name="rule">规则对象</param>
        public void UpdateRule(LogicRule rule)
        {
            if (string.IsNullOrWhiteSpace(rule.Name))
            {
                MessageBox.Show("规则名称不能为空");
                return;
            }

            if (string.IsNullOrWhiteSpace(rule.Expression))
            {
                MessageBox.Show("规则表达式不能为空");
                return;
            }


            // 验证表达式是否有效
            if (!ValidateExpression(rule.Expression))
            {
                MessageBox.Show("规则表达式验证失败");
                return;
            }

            if (UpdateRuleToDb(rule))
            {
                // 更新缓存
                var updatedDto = LogicRuleDtos.FirstOrDefault(r => r.Id == rule.Id);
                var insertIndex = LogicRuleDtos.ToList().FindIndex(x => x.Id > rule.Id);
                if (updatedDto != null)
                {
                    //移除数据
                    LogicRuleDtos.Remove(updatedDto);
                    if (insertIndex == -1)
                    {
                        LogicRuleDtos.Add(Mapper.Map<LogicRuleDto>(rule));
                    }
                    else
                    {
                        // 在找到的位置插入
                        LogicRuleDtos.Insert(insertIndex - 1, Mapper.Map<LogicRuleDto>(rule));
                    }


                    _expressionCache.TryRemove(updatedDto.Name, out _);
                    CacheExpression(updatedDto);
                }
            }

            //LogService.Info($"更新规则: {rule.Name}");
        }

        /// <summary>
        /// 更新规格到数据库中
        /// </summary>
        /// <returns></returns>
        public bool UpdateRuleToDb(LogicRule rule)
        {
            try
            {
                // 更新规则到数据库
                var result = FreeSql.Update<LogicRule>()
                    .Set(a => a.Name, rule.Name)
                    .Set(a => a.Description, rule.Description)
                    .Set(a => a.Expression, rule.Expression)
                    .Set(a => a.ParameterType, rule.ParameterType)
                    .Where(r => r.Id == rule.Id)
                    .ExecuteUpdated();

                // 检查影响的行数
                bool success = result.Count() > 0;

                if (success)
                {
                    //LogService.Info($"成功更新规则: {rule.Name}");

                }
                else
                {
                    //LogService.Warn($"更新规则失败: {rule.Name}，没有行受影响");
                }

                return success;
            }
            catch (Exception ex)
            {
                //LogService.Error($"更新规则到数据库时发生异常: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 删除规则
        /// </summary>
        /// <param name="ruleName">规则名称</param>
        public void DeleteRule(string ruleName)
        {
            var rule = LogicRuleDtos.FirstOrDefault(r => r.Name == ruleName);
            if (rule == null)
            {
                MessageBox.Show("找不到删除的数据");
                return;
            }

            var Count = FreeSql.Delete<LogicRule>().Where(r => r.Id == rule.Id).ExecuteAffrows();
            if (Count > 0)
            {
                // 删除规则
                LogicRuleDtos.Remove(rule);
                // 从缓存中移除表达式
                _expressionCache.TryRemove(ruleName, out _);
            }

            //LogService.Info($"删除规则: {ruleName}");
        }

        /// <summary>
        /// 验证表达式是否有效
        /// </summary>
        /// <param name="expression">表达式字符串</param>
        /// <returns>表达式是否有效</returns>
        private bool ValidateExpression(string expression)
        {
            try
            {
                // 创建测试解释器并直接设置变量
                var interpreter = new Interpreter()
                    .Reference(typeof(Math))  // 引用Math类
                    .SetVariable("Math", typeof(Math))
                    .SetVariable("value", 100); // 直接设置值变量

                // 尝试编译表达式
                var lambda = interpreter.Parse(expression);

                // 尝试执行表达式
                var result = lambda.Invoke();

                // 检查结果是否为数值类型
                if (result is double doubleResult)
                {
                    // 验证结果不是NaN或Infinity
                    if (double.IsNaN(doubleResult) || double.IsInfinity(doubleResult))
                    {
                        //LogService.Warn($"表达式执行结果无效 (NaN或Infinity): {expression}");
                        return false;
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                LogService.Warn($"验证表达式失败: {expression}, 错误: {ex.Message}");
                return false;
            }
        }


        #endregion


        /// <summary>
        /// 根据参数类型获取适用的规则
        /// </summary>
        /// <param name="parameterType">参数类型</param>
        /// <returns>适用的规则列表</returns>
        public IEnumerable<LogicRuleDto> GetRulesByParameterType(string parameterType)
        {
            return LogicRuleDtos.Where(r => r.ParameterType == parameterType);
        }

        /// <summary>
        /// 获取指定名称的规则
        /// </summary>
        /// <param name="ruleName">规则名称</param>
        /// <returns>规则对象</returns>
        public LogicRuleDto GetRuleByName(string ruleName)
        {
            var rule = LogicRuleDtos.FirstOrDefault(r => r.Name == ruleName);
            if (rule == null)
            {
                throw new KeyNotFoundException($"找不到名为 {ruleName} 的规则");
            }
            return rule;
        }

        /// <summary>
        /// 应用逻辑转换 - 主要使用方法
        /// </summary>
        /// <param name="value">输入值</param>
        /// <param name="ruleName">规则名称</param>
        /// <returns>转换后的输出值</returns>
        public double ApplyLogic(double value, string ruleName)
        {
            var rule = GetRuleByName(ruleName);

            return ApplyExpression(value, rule);
        }

        /// <summary>
        /// 应用逻辑转换（基于参数类型自动选择规则）
        /// </summary>
        /// <param name="value">输入值</param>
        /// <param name="parameterType">参数类型</param>
        /// <returns>转换后的输出值</returns>
        public double ApplyLogicByType(double value, string parameterType)
        {
            var rules = GetRulesByParameterType(parameterType).ToList();
            if (rules.Count == 0)
            {
                LogService.Warn($"未找到适用于 {parameterType} 的转换规则，将返回原始值");
                return value;
            }

            // 如果存在多个规则，取第一个
            var rule = rules.First();

            return ApplyExpression(value, rule);
        }

        /// <summary>
        /// 将规则表达式预编译并缓存到字典中
        /// </summary>
        /// <param name="rule">要缓存的规则</param>
        private void CacheExpression(LogicRuleDto rule)
        {
            if (string.IsNullOrEmpty(rule.Name) || string.IsNullOrEmpty(rule.Expression))
            {
                return; // 防止空名称或空表达式
            }

            try
            {
                // 使用已有的CreateParameters方法创建参数声明
                var parameter = CreateParameters(0); // 值不重要，只是为了获取参数声明
                // 只解析一次，得到 Lambda 对象
                var lambda = CurInterpreter.Parse(rule.Expression, parameter); // 只定义参数类型，不传值

                // 存入缓存
                _expressionCache[rule.Name] = lambda;
            }
            catch (Exception ex)
            {
                LogService.Error($"缓存规则 {rule.Name} 表达式失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 预热表达式缓存 - 预编译所有规则
        /// </summary>
        private void WarmUpExpressionCache()
        {
            foreach (var rule in LogicRuleDtos)
            {
                if (!_expressionCache.ContainsKey(rule.Name))
                {
                    CacheExpression(rule);
                }
            }
            LogService.Info($"已预编译 {_expressionCache.Count} 条规则表达式");
        }

        /// <summary>
        /// 根据规则应用表达式（高性能版本）
        /// </summary>
        /// <param name="value">输入值</param>
        /// <param name="rule">规则对象</param>
        /// <returns>转换后的输出值</returns>
        public double ApplyExpression(double value, LogicRuleDto rule)
        {
            try
            {
                // 尝试从缓存获取预编译的表达式
                if (!_expressionCache.TryGetValue(rule.Name, out var compiledExpression))
                {
                    // 如果缓存中没有，则编译并添加到缓存
                    CacheExpression(rule);

                    // 再次尝试获取
                    if (!_expressionCache.TryGetValue(rule.Name, out compiledExpression))
                    {
                        // 初始解析表达式（只需执行一次）
                        string expressionText = rule.Expression;

                        // 强类型函数
                        Func<double, double> compiledFunc = (v) =>
                        {
                            // 高性能版本：直接根据公式计算
                            try
                            {
                                if (expressionText.Contains("value"))
                                {
                                    var parameters = CreateParameters(v);
                                    var lambda = CurInterpreter.Parse(expressionText, parameters);
                                    return (double)lambda.Invoke();
                                }
                                else
                                {
                                    // 简单表达式使用直接求值
                                    return v / 100.0; // 默认处理
                                }
                            }
                            catch
                            {
                                // 出错时返回原值
                                return v;
                            }
                        };
                        // 再次尝试缓存
                        CacheExpression(rule);

                        return compiledFunc(value);
                    }
                }

                // 创建包含实际值的参数
                var parameter = new Parameter("value", typeof(double), value);
                // 使用预编译的表达式执行计算（高性能）
                var convertedValue = (double)compiledExpression.Invoke(value);

                return convertedValue;
            }
            catch (Exception ex)
            {
                //LogService.Error($"应用规则 {rule.Name} 失败: {ex.Message}");
                return value; // 出错时返回原始值
            }
        }


        /// <summary>
        /// 临时测试用
        /// </summary>
        /// <param name="value"></param>
        /// <param name="rule"></param>
        /// <returns></returns>
        public double ApplyExpressionNoCache(double value, LogicRuleDto rule)
        {
            try
            {

                CurInterpreter.SetVariable("value", value);
                var lambda = CurInterpreter.Parse(rule.Expression);
                return (double)lambda.Invoke();

                //// 创建全新的解释器实例
                //var localInterpreter = new Interpreter()
                //    .Reference(typeof(Math))
                //    .SetVariable("Math", typeof(Math));

                //// 直接设置变量值而不是使用参数
                //localInterpreter.SetVariable("value", value);
                //// 解析并执行
                //var result = localInterpreter.Eval<double>(rule.Expression);
                //Console.WriteLine($"直接执行: 输入={value}, 表达式={rule.Expression}, 结果={result}");
                //return result;
            }
            catch (Exception ex)
            {
                LogService.Error($"直接执行表达式失败: {ex.Message}");
                return value;
            }
        }

        /// <summary>
        /// 批量应用逻辑转换 (高性能版本)
        /// </summary>
        /// <param name="values">原始值字典(键为参数名称，值为原始值)</param>
        /// <returns>转换后的值字典</returns>
        public Dictionary<string, double> ApplyBatchLogic(Dictionary<string, double> values)
        {
            // 为了性能，预分配容量
            var result = new Dictionary<string, double>(values.Count);

            // 缓存参数类型到规则的映射，避免重复查询
            var cachedRulesByType = new Dictionary<string, LogicRuleDto>();

            foreach (var entry in values)
            {
                var paramName = entry.Key;
                var origValue = entry.Value;

                try
                {
                    // 获取参数类型
                    var paramType = DetermineParameterType(paramName);

                    // 尝试从缓存获取规则
                    if (!cachedRulesByType.TryGetValue(paramType, out var rule))
                    {
                        var rules = GetRulesByParameterType(paramType).ToList();
                        if (rules.Count > 0)
                        {
                            rule = rules.First();
                            cachedRulesByType[paramType] = rule; // 添加到缓存
                        }
                    }

                    // 如果找到规则，应用转换
                    if (rule != null)
                    {
                        var convertedValue = ApplyExpression(origValue, rule);
                        result.Add(paramName, convertedValue);
                    }
                    else
                    {
                        result.Add(paramName, origValue); // 没有规则时使用原始值
                    }
                }
                catch (Exception ex)
                {
                    LogService.Error($"处理参数 {paramName} 失败: {ex.Message}");
                    result.Add(paramName, origValue); // 出错时使用原始值
                }
            }

            return result;
        }

        /// <summary>
        /// 从参数名称确定参数类型
        /// </summary>
        /// <param name="paramName">参数名称</param>
        /// <returns>参数类型</returns>
        private string DetermineParameterType(string paramName)
        {
            // 根据参数名称确定类型的逻辑
            // 这里使用简单的名称匹配，实际项目中可能需要更复杂的映射
            if (paramName.Contains("速度") || paramName.Contains("转速"))
                return "转速";
            else if (paramName.Contains("功率") || paramName.Contains("pw") || paramName.Contains("power"))
                return "功率";
            else if (paramName.Contains("温度") || paramName.Contains("temp"))
                return "温度";
            else if (paramName.Contains("压力") || paramName.Contains("press"))
                return "压力";

            // 默认类型
            return "通用";
        }
    }
}