using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;
using System.Reflection;
using LB_VisionProcesses;
using System.Collections.Concurrent;
using System.Diagnostics;

namespace LB_SmartVision.ProcessRun
{
    public class ExpressionTreeMappingEngine
    {
        private ConcurrentDictionary<string, List<Action<IProcess>>> _compiledMappings;
        private readonly ConcurrentDictionary<string, IProcess> _processContext;

        public ExpressionTreeMappingEngine(ConcurrentDictionary<string, IProcess> processContext)
        {
            _processContext = processContext;
            _compiledMappings = new ConcurrentDictionary<string, List<Action<IProcess>>>();
        }

        public void CompileMappings(ConcurrentDictionary<string, List<Tuple<string, string>>> dicInputsMapping)
        {
            foreach (var processMapping in dicInputsMapping)
            {
                var processName = processMapping.Key;
                var actions = new List<Action<IProcess>>();

                foreach (var tuple in processMapping.Value)
                {
                    if (string.IsNullOrEmpty(tuple.Item2?.Trim()))
                        continue;

                    var action = CreateMappingAction(tuple.Item1, tuple.Item2);
                    if (action != null)
                        actions.Add(action);
                }

                _compiledMappings[processName] = actions;
            }
        }

        private Action<IProcess> CreateMappingAction(string inputPath, string outputPath)
        {
            try
            {
                // 解析输入路径：TargetProcess.InputType.InputProperty
                var inputParts = inputPath.Split('.');
                if (inputParts.Length < 3) return null;

                string targetProcessName = inputParts[0];
                string inputType = inputParts[1]; // 通常是 "Inputs"
                string inputProperty = inputParts[2];

                // 解析输出路径：SourceProcess.OutputType.OutputProperty
                var outputParts = outputPath.Split('.');
                if (outputParts.Length < 2) return null;

                string sourceProcessName = outputParts[0];
                string outputType = outputParts[1]; // "Inputs" 或 "Outputs"
                string outputProperty = outputParts.Length == 3 ? outputParts[2] : "";

                // 创建表达式参数
                var targetParameter = Expression.Parameter(typeof(IProcess), "targetProcess");

                // 构建获取源值的表达式
                var sourceValueExpression = BuildSourceValueExpression(sourceProcessName, outputType, outputProperty);
                if (sourceValueExpression == null) return null;

                // 构建设置目标值的表达式
                var setTargetExpression = BuildSetTargetExpression(targetParameter, inputType, inputProperty, sourceValueExpression);
                if (setTargetExpression == null) return null;

                // 编译为委托
                var lambda = Expression.Lambda<Action<IProcess>>(setTargetExpression, targetParameter);
                return lambda.Compile();
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"创建映射动作失败: {ex.Message}");
                return null;
            }
        }

        private Expression BuildSourceValueExpression(string sourceProcessName, string outputType, string outputProperty)
        {
            // 获取源流程实例：_processContext[sourceProcessName]
            var contextField = Expression.Constant(_processContext);
            var processNameConstant = Expression.Constant(sourceProcessName);
            var getItemMethod = typeof(ConcurrentDictionary<string, IProcess>).GetMethod("get_Item");
            var getProcessExpr = Expression.Call(contextField, getItemMethod, processNameConstant);

            // 转换为 IProcess
            var convertExpr = Expression.Convert(getProcessExpr, typeof(IProcess));

            // 添加 null 检查
            var nullCheck = Expression.NotEqual(convertExpr, Expression.Constant(null, typeof(IProcess)));

            // 根据输出类型和属性构建获取值的表达式
            Expression valueExpression = outputType switch
            {
                "Inputs" => BuildInputsValueExpression(convertExpr, outputProperty),
                "Outputs" => BuildOutputsValueExpression(convertExpr, outputProperty),
                _ => Expression.Constant(null, typeof(object))
            };

            // 如果源流程为 null，返回 null，否则返回值
            return Expression.Condition(nullCheck, Expression.Convert(valueExpression, typeof(object)), Expression.Constant(null, typeof(object)));
        }

        private Expression BuildInputsValueExpression(Expression processExpr, string propertyName)
        {
            if (propertyName == "Image")
            {
                // 首先尝试字段，然后尝试属性
                return GetMemberExpression(processExpr, "InputImage");
            }
            else
            {
                return BuildInputsConcurrentDictionaryExpression(processExpr, propertyName);
            }
        }

        private Expression BuildOutputsValueExpression(Expression processExpr, string propertyName)
        {
            if (propertyName == "Image")
            {
                // 首先尝试字段，然后尝试属性
                return GetMemberExpression(processExpr, "OutputImage");
            }
            else if (propertyName == "Result")
            {
                // 首先尝试字段，然后尝试属性
                return GetMemberExpression(processExpr, "Result");
            }
            else if (propertyName == "Fixture")
            {
                // 通过 Params 获取 Fixture
                var paramsExpr = GetMemberExpression(processExpr, "Params");
                return GetMemberExpression(paramsExpr, "Fixture");
            }
            else
            {
                return BuildOutputsConcurrentDictionaryExpression(processExpr, propertyName);
            }
        }

        private Expression BuildInputsConcurrentDictionaryExpression(Expression processExpr, string propertyName)
        {
            // process.Params.Inputs[propertyName]
            var paramsExpr = GetMemberExpression(processExpr, "Params");
            var inputsExpr = GetMemberExpression(paramsExpr, "Inputs");

            var indexer = inputsExpr.Type.GetProperty("Item", new[] { typeof(string) });
            if (indexer == null)
                throw new InvalidOperationException("Inputs 类型没有字符串索引器");

            var propertyNameConstant = Expression.Constant(propertyName);
            return Expression.Property(inputsExpr, indexer, propertyNameConstant);
        }

        private Expression BuildOutputsConcurrentDictionaryExpression(Expression processExpr, string propertyName)
        {
            // process.Params.Outputs[propertyName]
            var paramsExpr = GetMemberExpression(processExpr, "Params");
            var outputsExpr = GetMemberExpression(paramsExpr, "Outputs");

            var indexer = outputsExpr.Type.GetProperty("Item", new[] { typeof(string) });
            if (indexer == null)
                throw new InvalidOperationException("Outputs 类型没有字符串索引器");

            var propertyNameConstant = Expression.Constant(propertyName);
            return Expression.Property(outputsExpr, indexer, propertyNameConstant);
        }

        /// <summary>
        /// 通用的成员访问方法：首先尝试字段，然后尝试属性
        /// </summary>
        private Expression GetMemberExpression(Expression instance, string memberName)
        {
            var type = instance.Type;

            // 首先尝试字段
            var field = type.GetField(memberName, BindingFlags.Public | BindingFlags.Instance);
            if (field != null)
            {
                return Expression.Field(instance, field);
            }

            // 然后尝试属性
            var property = type.GetProperty(memberName, BindingFlags.Public | BindingFlags.Instance);
            if (property != null)
            {
                return Expression.Property(instance, property);
            }

            throw new InvalidOperationException($"在类型 {type.Name} 中找不到字段或属性: {memberName}");
        }

        private Expression BuildSetTargetExpression(ParameterExpression targetParameter, string inputType, string inputProperty, Expression sourceValueExpression)
        {
            return inputProperty switch
            {
                "Image" => BuildSetImageExpression(targetParameter, sourceValueExpression),
                "Fixture" => BuildSetFixtureExpression(targetParameter, sourceValueExpression),
                "Result" => BuildSetResultExpression(targetParameter, inputProperty, sourceValueExpression),
                _ => BuildSetInputExpression(targetParameter, inputProperty, sourceValueExpression)
            };
        }

        private Expression BuildSetImageExpression(ParameterExpression target, Expression sourceValue)
        {
            // target.InputImage = sourceValue
            var inputImageExpr = GetMemberExpression(target, "InputImage");
            return Expression.Assign(inputImageExpr, Expression.Convert(sourceValue, inputImageExpr.Type));
        }

        private Expression BuildSetFixtureExpression(ParameterExpression target, Expression sourceValue)
        {
            //// target.Params.Fixture = sourceValue ?? new Fixture()
            //var paramsExpr = GetMemberExpression(target, "Params");
            //var fixtureExpr = GetMemberExpression(paramsExpr, "Fixture");

            //// 如果源值为null，创建新的Fixture
            //var newFixtureExpr = Expression.New(typeof(Fixture));
            //var coalesceExpr = Expression.Coalesce(
            //    Expression.Convert(sourceValue, typeof(Fixture)),
            //    newFixtureExpr
            //);

            //return Expression.Assign(fixtureExpr, coalesceExpr);

            // 如果源值为null，就设置为null，不创建新对象
            var paramsExpr = GetMemberExpression(target, "Params");
            var fixtureExpr = GetMemberExpression(paramsExpr, "Fixture");

            var convertedSourceValue = Expression.Convert(sourceValue, typeof(Fixture));
            return Expression.Assign(fixtureExpr, convertedSourceValue);
        }

        private Expression BuildSetResultExpression(ParameterExpression target, string propertyName, Expression sourceValue)
        {
            // target.Params.Inputs[propertyName] = sourceValue
            var paramsExpr = GetMemberExpression(target, "Params");
            var inputsExpr = GetMemberExpression(paramsExpr, "Inputs");

            var indexer = inputsExpr.Type.GetProperty("Item", new[] { typeof(string) });
            if (indexer == null)
                return Expression.Empty();

            var propertyNameConstant = Expression.Constant(propertyName);
            var targetIndexExpr = Expression.Property(inputsExpr, indexer, propertyNameConstant);

            return Expression.Assign(targetIndexExpr, Expression.Convert(sourceValue, targetIndexExpr.Type));
        }

        private Expression BuildSetInputExpression(ParameterExpression target, string propertyName, Expression sourceValue)
        {
            // 检查字典是否包含该键，如果包含则赋值
            var paramsExpr = GetMemberExpression(target, "Params");
            var inputsExpr = GetMemberExpression(paramsExpr, "Inputs");

            var containsMethod = inputsExpr.Type.GetMethod("Contains", new[] { typeof(string) });
            if (containsMethod == null)
                return Expression.Empty();

            var propertyNameConstant = Expression.Constant(propertyName);
            var containsCall = Expression.Call(inputsExpr, containsMethod, propertyNameConstant);

            // 如果包含键，则赋值
            var indexer = inputsExpr.Type.GetProperty("Item", new[] { typeof(string) });
            if (indexer == null)
                return Expression.Empty();

            var targetIndexExpr = Expression.Property(inputsExpr, indexer, propertyNameConstant);
            var assignExpr = Expression.Assign(
                targetIndexExpr,
                Expression.Convert(sourceValue, targetIndexExpr.Type)
            );

            // 条件表达式：if (inputs.Contains(propertyName)) { inputs[propertyName] = sourceValue; }
            return Expression.IfThen(containsCall, assignExpr);
        }

        public void UpdateInputs(IProcess process)
        {
            if (_compiledMappings.TryGetValue(process.strProcessName, out var actions))
            {
                foreach (var action in actions)
                {
                    try
                    {
                        action(process);
                    }
                    catch (Exception ex)
                    {
                        // 处理运行时异常
                        Debug.WriteLine($"执行映射动作失败: {ex.Message}");
                    }
                }
            }
        }

        public void Dispose()
        {
            foreach (var list in _compiledMappings.Values)
            {
                list.Clear();
            }
            _compiledMappings.Clear();
        }

        public void ClearMappings()
        {
            _compiledMappings.Clear();
        }

        public void RemoveProcessMappings(string processName)
        {
            _compiledMappings.TryRemove(processName, out _);
        }
    }

    // 辅助扩展方法，用于调试
    public static class ExpressionTreeDebugExtensions
    {
        public static void DebugMemberAccess(this ExpressionTreeMappingEngine engine, IProcess testProcess)
        {
            var processType = typeof(IProcess);

            Debug.WriteLine("=== IProcess 成员调试信息 ===");
            Debug.WriteLine("字段:");
            foreach (var field in processType.GetFields(BindingFlags.Public | BindingFlags.Instance))
            {
                Debug.WriteLine($"  {field.Name} : {field.FieldType.Name}");
            }

            Debug.WriteLine("属性:");
            foreach (var prop in processType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                Debug.WriteLine($"  {prop.Name} : {prop.PropertyType.Name}");
            }

            // 测试具体成员访问
            try
            {
                var processExpr = Expression.Parameter(typeof(IProcess), "p");
                var outputImageExpr = Expression.Field(processExpr, "OutputImage");
                var lambda = Expression.Lambda<Func<IProcess, object>>(outputImageExpr, processExpr).Compile();
                var result = lambda(testProcess);
                Debug.WriteLine($"OutputImage 字段访问成功: {result ?? "null"}");
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"OutputImage 字段访问失败: {ex.Message}");
            }
        }
    }
}