using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OrpaonVision.Core.LayerRecognition;
using OrpaonVision.Core.Results;
using OrpaonVision.SiteApp.Runtime.Contracts;
using OrpaonVision.SiteApp.Runtime.Options;
using System.Collections.Concurrent;
using System.Text.Json;

namespace OrpaonVision.SiteApp.Runtime.Services;

/// <summary>
/// 层识别服务实现。
/// </summary>
public sealed class LayerRecognitionService : ILayerRecognitionService
{
    private readonly ILogger<LayerRecognitionService> _logger;
    private readonly RuntimeOptions _options;
    private readonly ConcurrentDictionary<Guid, LayerHistoryRecord> _layerHistory = new();
    private readonly ConcurrentDictionary<Guid, LayerModelData> _layerModels = new();
    private readonly object _lock = new();
    private LayerModelData? _currentModel;

    /// <summary>
    /// 构造函数。
    /// </summary>
    public LayerRecognitionService(ILogger<LayerRecognitionService> logger, IOptions<RuntimeOptions> options)
    {
        _logger = logger;
        _options = options.Value;
        InitializeDefaultModel();
    }

    /// <inheritdoc />
    public async Task<Result<LayerRecognitionResult>> RecognizeLayerAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("开始层级识别：当前层={CurrentLayer}，推理结果={Label}，置信度={Confidence:F3}", 
                currentLayer, inference.Label, inference.Confidence);

            var startTime = DateTime.UtcNow;

            // 提取层级特征
            var featuresResult = await ExtractLayerFeaturesAsync(inference, cancellationToken);
            if (!featuresResult.Succeeded)
            {
                return Result<LayerRecognitionResult>.Fail(featuresResult.Code, featuresResult.Message, featuresResult.Errors.ToArray());
            }

            if (featuresResult.Data == null)
            {
                return Result<LayerRecognitionResult>.Fail("FEATURES_EMPTY", "层级特征为空");
            }

            var features = featuresResult.Data;

            // 多方法融合识别
            var recognitionTasks = new List<Task<Result<LayerRecognitionResult>>>
            {
                RecognizeByRuleAsync(inference, currentLayer, features, cancellationToken),
                RecognizeByFeatureMatchingAsync(inference, currentLayer, features, cancellationToken)
            };

            // 如果有机器学习模型，添加ML识别
            if (_currentModel != null && _currentModel.IsEnabled)
            {
                recognitionTasks.Add(RecognizeByMachineLearningAsync(inference, currentLayer, features, cancellationToken));
            }

            var recognitionResults = await Task.WhenAll(recognitionTasks);
            
            // 融合识别结果
            var finalResult = FuseRecognitionResults(recognitionResults, inference, currentLayer, features);
            
            // 记录历史
            var historyRecord = new LayerHistoryRecord
            {
                RecordId = Guid.NewGuid(),
                Layer = finalResult.RecognizedLayer,
                Confidence = finalResult.Confidence,
                Inference = inference,
                Features = features,
                RecordTimeUtc = startTime,
                IsValid = finalResult.Confidence >= _options.LayerRecognitionConfidenceThreshold,
                ExtendedProperties = new Dictionary<string, object>
                {
                    ["recognition_method"] = finalResult.Method.ToString(),
                    ["recognition_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
                }
            };

            await AddHistoryRecordAsync(historyRecord, cancellationToken);

            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
            _logger.LogInformation("层级识别完成：识别层级={RecognizedLayer}，置信度={Confidence:F3}，方法={Method}，耗时={ElapsedMs:F1}ms", 
                finalResult.RecognizedLayer, finalResult.Confidence, finalResult.Method, elapsed);

            return Result<LayerRecognitionResult>.Success(finalResult);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级识别失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_RECOGNITION_FAILED", "层级识别失败", traceId);
            return Result<LayerRecognitionResult>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<LayerStabilityResult>> ValidateLayerStabilityAsync(IReadOnlyList<LayerHistoryRecord> layerHistory, int stabilityWindow = 5, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("验证层级稳定性：窗口大小={Window}，历史记录数={Count}", stabilityWindow, layerHistory.Count);

            if (layerHistory.Count < stabilityWindow)
            {
                return Result<LayerStabilityResult>.Success(new LayerStabilityResult
                {
                    IsStable = false,
                    StabilityScore = 0.0,
                    DominantLayer = layerHistory.LastOrDefault()?.Layer ?? 0,
                    StabilityWindow = stabilityWindow,
                    ValidationTimeUtc = DateTime.UtcNow,
                    Details = $"历史记录数量不足，需要至少 {stabilityWindow} 条记录"
                });
            }

            // 获取最近的稳定性窗口内的记录
            var recentRecords = layerHistory
                .OrderByDescending(r => r.RecordTimeUtc)
                .Take(stabilityWindow)
                .ToList();

            // 计算层级分布
            var layerDistribution = new Dictionary<int, double>();
            var totalRecords = recentRecords.Count;

            foreach (var record in recentRecords)
            {
                if (layerDistribution.ContainsKey(record.Layer))
                {
                    layerDistribution[record.Layer]++;
                }
                else
                {
                    layerDistribution[record.Layer] = 1;
                }
            }

            // 转换为百分比
            foreach (var key in layerDistribution.Keys.ToList())
            {
                layerDistribution[key] = layerDistribution[key] / totalRecords * 100;
            }

            // 找出主导层级
            var dominantLayer = layerDistribution.OrderByDescending(kvp => kvp.Value).First().Key;
            var dominantPercentage = layerDistribution[dominantLayer];

            // 计算稳定性得分
            var stabilityScore = CalculateStabilityScore(layerDistribution, recentRecords);

            // 判断是否稳定
            var isStable = stabilityScore >= _options.LayerStabilityThreshold && dominantPercentage >= _options.DominantLayerThreshold;

            var result = new LayerStabilityResult
            {
                IsStable = isStable,
                StabilityScore = stabilityScore,
                DominantLayer = dominantLayer,
                LayerDistribution = layerDistribution,
                StabilityWindow = stabilityWindow,
                ValidationTimeUtc = DateTime.UtcNow,
                Details = isStable 
                    ? $"层级稳定，主导层级 {dominantLayer} 占比 {dominantPercentage:F1}%"
                    : $"层级不稳定，主导层级 {dominantLayer} 占比 {dominantPercentage:F1}% 低于阈值"
            };

            _logger.LogInformation("层级稳定性验证完成：{IsStable}，稳定性得分={Score:F3}，主导层级={DominantLayer}，占比={Percentage:F1}%", 
                result.IsStable, result.StabilityScore, result.DominantLayer, dominantPercentage);

            return Result<LayerStabilityResult>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级稳定性验证失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_STABILITY_VALIDATION_FAILED", "层级稳定性验证失败", traceId);
            return Result<LayerStabilityResult>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<LayerTransitionResult>> DetectLayerTransitionAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, IReadOnlyList<LayerHistoryRecord> layerHistory, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("检测层级变化：当前层={CurrentLayer}，历史记录数={Count}", currentLayer, layerHistory.Count);

            // 先进行层级识别
            var recognitionResult = await RecognizeLayerAsync(inference, currentLayer, cancellationToken);
            if (!recognitionResult.Succeeded)
            {
                return Result<LayerTransitionResult>.Fail(recognitionResult.Code, recognitionResult.Message, recognitionResult.Errors.ToArray());
            }

            if (recognitionResult.Data == null)
            {
                return Result<LayerTransitionResult>.Fail("RECOGNITION_RESULT_EMPTY", "层级识别结果为空");
            }

            var recognizedLayer = recognitionResult.Data.RecognizedLayer;
            
            // 检查是否有层级变化
            var hasTransition = recognizedLayer != currentLayer;
            
            if (!hasTransition)
            {
                return Result<LayerTransitionResult>.Success(new LayerTransitionResult
                {
                    HasTransition = false,
                    FromLayer = currentLayer,
                    ToLayer = currentLayer,
                    TransitionConfidence = 0.0,
                    TransitionType = LayerTransitionType.Normal,
                    DetectionTimeUtc = DateTime.UtcNow,
                    Details = "无层级变化"
                });
            }

            // 分析变化类型
            var transitionType = AnalyzeTransitionType(currentLayer, recognizedLayer, layerHistory);
            
            // 计算变化置信度
            var transitionConfidence = CalculateTransitionConfidence(currentLayer, recognizedLayer, layerHistory, recognitionResult.Data);

            var result = new LayerTransitionResult
            {
                HasTransition = true,
                FromLayer = currentLayer,
                ToLayer = recognizedLayer,
                TransitionConfidence = transitionConfidence,
                TransitionType = transitionType,
                DetectionTimeUtc = DateTime.UtcNow,
                Details = $"检测到层级变化：{currentLayer} -> {recognizedLayer}，类型：{transitionType}",
                ExtendedProperties = new Dictionary<string, object>
                {
                    ["recognition_confidence"] = recognitionResult.Data.Confidence,
                    ["recognition_method"] = recognitionResult.Data.Method.ToString()
                }
            };

            _logger.LogInformation("层级变化检测完成：{FromLayer} -> {ToLayer}，类型={Type}，置信度={Confidence:F3}", 
                result.FromLayer, result.ToLayer, result.TransitionType, result.TransitionConfidence);

            return Result<LayerTransitionResult>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级变化检测失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_TRANSITION_DETECTION_FAILED", "层级变化检测失败", traceId);
            return Result<LayerTransitionResult>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<LayerFeatures>> ExtractLayerFeaturesAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("提取层级特征：目标数量={Count}，标签={Label}，置信度={Confidence:F3}", 
                inference.Detections?.Count ?? 0, inference.Label, inference.Confidence);

            var detections = inference.Detections?.ToList() ?? new List<OrpaonVision.Core.LayerRecognition.DetectionDto>();
            var objectCount = detections.Count;
            var averageConfidence = objectCount > 0 ? detections.Average(d => d.Confidence) : inference.Confidence;
            var maxConfidence = objectCount > 0 ? detections.Max(d => d.Confidence) : inference.Confidence;
            var objectClassDistribution = detections
                .GroupBy(d => d.Class)
                .ToDictionary(g => g.Key, g => g.Count());
            var boundingBoxes = detections.Select(d => new BoundingBox
            {
                X = d.X,
                Y = d.Y,
                Width = d.Width,
                Height = d.Height,
                Confidence = d.Confidence,
                Class = d.Class
            }).ToList();

            var imageFeatures = await ExtractImageFeaturesAsync(inference, cancellationToken);

            var vectorSource = new LayerFeatures
            {
                ObjectCount = objectCount,
                AverageConfidence = averageConfidence,
                MaxConfidence = maxConfidence,
                ObjectClassDistribution = objectClassDistribution,
                BoundingBoxes = boundingBoxes,
                ImageFeatures = imageFeatures,
                ExtractionTimeUtc = DateTime.UtcNow
            };

            var featureVector = await GenerateFeatureVectorAsync(vectorSource, cancellationToken);

            var features = new LayerFeatures
            {
                ObjectCount = objectCount,
                AverageConfidence = averageConfidence,
                MaxConfidence = maxConfidence,
                ObjectClassDistribution = objectClassDistribution,
                BoundingBoxes = boundingBoxes,
                ImageFeatures = imageFeatures,
                FeatureVector = featureVector,
                ExtractionTimeUtc = vectorSource.ExtractionTimeUtc
            };

            _logger.LogDebug("层级特征提取完成：目标数量={ObjectCount}，特征向量维度={VectorDim}", 
                features.ObjectCount, features.FeatureVector.Length);

            return Result<LayerFeatures>.Success(features);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级特征提取失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_FEATURE_EXTRACTION_FAILED", "层级特征提取失败", traceId);
            return Result<LayerFeatures>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<LayerModelTrainingResult>> TrainLayerModelAsync(IReadOnlyList<LayerTrainingData> trainingData, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("开始训练层级识别模型：训练样本数={TrainingCount}，验证样本数={ValidationCount}", 
                trainingData.Count(d => !d.IsValidationData), trainingData.Count(d => d.IsValidationData));

            var startTime = DateTime.UtcNow;

            // 数据预处理
            var preprocessedData = await PreprocessTrainingDataAsync(trainingData, cancellationToken);
            
            // 特征工程
            var featureVectors = preprocessedData.Select(d => d.Features.FeatureVector).ToArray();
            var labels = preprocessedData.Select(d => d.TargetLayer).ToArray();

            // 训练模型（这里使用简化的随机森林实现）
            var modelResult = await TrainRandomForestModelAsync(featureVectors, labels, cancellationToken);
            
            var elapsed = DateTime.UtcNow - startTime;

            var result = new LayerModelTrainingResult
            {
                TrainingId = Guid.NewGuid(),
                Accuracy = modelResult.Accuracy,
                Precision = modelResult.Precision,
                Recall = modelResult.Recall,
                F1Score = modelResult.F1Score,
                TrainingSampleCount = trainingData.Count(d => !d.IsValidationData),
                ValidationSampleCount = trainingData.Count(d => d.IsValidationData),
                TrainingElapsedMs = (long)elapsed.TotalMilliseconds,
                ModelVersion = $"v{DateTime.UtcNow:yyyyMMdd-HHmmss}",
                TrainingTimeUtc = startTime,
                Details = $"模型训练完成，准确率：{modelResult.Accuracy:F3}"
            };

            _logger.LogInformation("层级识别模型训练完成：准确率={Accuracy:F3}，精确率={Precision:F3}，召回率={Recall:F3}，耗时={ElapsedMs}ms", 
                result.Accuracy, result.Precision, result.Recall, result.TrainingElapsedMs);

            return Result<LayerModelTrainingResult>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级识别模型训练失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_MODEL_TRAINING_FAILED", "层级识别模型训练失败", traceId);
            return Result<LayerModelTrainingResult>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result> UpdateLayerModelAsync(LayerModelData modelData, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("更新层级识别模型：模型ID={ModelId}，版本={Version}，类型={Type}", 
                modelData.ModelId, modelData.Version, modelData.ModelType);

            lock (_lock)
            {
                _layerModels[modelData.ModelId] = modelData;
                _currentModel = modelData;
            }

            _logger.LogInformation("层级识别模型更新成功：模型ID={ModelId}", modelData.ModelId);
            return Result.Success();
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "层级识别模型更新失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "LAYER_MODEL_UPDATE_FAILED", "层级识别模型更新失败", traceId);
            return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<LayerRecognitionStatistics>> GetRecognitionStatisticsAsync(DateTime startTime, DateTime endTime, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("获取层级识别统计信息：开始时间={StartTime}，结束时间={EndTime}", startTime, endTime);

            var historyRecords = _layerHistory.Values
                .Where(r => r.RecordTimeUtc >= startTime && r.RecordTimeUtc <= endTime)
                .ToList();

            var totalRecognitions = historyRecords.Count;
            var successfulRecognitions = historyRecords.Count(r => r.IsValid);
            var failedRecognitions = historyRecords.Count(r => !r.IsValid);
            var averageConfidence = historyRecords.Any() ? historyRecords.Average(r => r.Confidence) : 0.0;
            var accuracy = totalRecognitions > 0
                ? (double)successfulRecognitions / totalRecognitions * 100
                : 0.0;

            var byLayer = historyRecords
                .GroupBy(r => r.Layer)
                .ToDictionary(g => g.Key, g => new LayerStatistics
                {
                    Layer = g.Key,
                    RecognitionCount = g.Count(),
                    SuccessCount = g.Count(r => r.IsValid),
                    Accuracy = g.Any() ? (double)g.Count(r => r.IsValid) / g.Count() * 100 : 0.0,
                    AverageConfidence = g.Average(r => r.Confidence)
                });

            var byMethod = historyRecords
                .Where(r => r.ExtendedProperties.ContainsKey("recognition_method"))
                .GroupBy(r => Enum.Parse<LayerRecognitionMethod>(r.ExtendedProperties["recognition_method"].ToString()!))
                .ToDictionary(g => g.Key, g => new MethodStatistics
                {
                    Method = g.Key,
                    UsageCount = g.Count(),
                    SuccessCount = g.Count(r => r.IsValid),
                    Accuracy = g.Any() ? (double)g.Count(r => r.IsValid) / g.Count() * 100 : 0.0,
                    AverageElapsedMs = g.Where(r => r.ExtendedProperties.ContainsKey("recognition_time_ms"))
                        .Average(r => Convert.ToDouble(r.ExtendedProperties["recognition_time_ms"]))
                });

            var byTime = historyRecords
                .GroupBy(r => new DateTime(r.RecordTimeUtc.Year, r.RecordTimeUtc.Month, r.RecordTimeUtc.Day, r.RecordTimeUtc.Hour, 0, 0))
                .ToDictionary(g => g.Key, g => new TimeStatistics
                {
                    Time = g.Key,
                    RecognitionCount = g.Count(),
                    SuccessCount = g.Count(r => r.IsValid),
                    LayerTransitions = CountLayerTransitions(g.ToList())
                });

            var layerTransitions = CountLayerTransitions(historyRecords);

            var statistics = new LayerRecognitionStatistics
            {
                StartTimeUtc = startTime,
                EndTimeUtc = endTime,
                TotalRecognitions = totalRecognitions,
                SuccessfulRecognitions = successfulRecognitions,
                FailedRecognitions = failedRecognitions,
                AverageConfidence = averageConfidence,
                Accuracy = accuracy,
                ByLayer = byLayer,
                ByMethod = byMethod,
                ByTime = byTime,
                LayerTransitions = layerTransitions
            };

            _logger.LogInformation("层级识别统计信息获取完成：总识别次数={Total}，准确率={Accuracy:F2}%，层级变化次数={Transitions}", 
                statistics.TotalRecognitions, statistics.Accuracy, statistics.LayerTransitions);

            return Result<LayerRecognitionStatistics>.Success(statistics);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取层级识别统计信息失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_RECOGNITION_STATISTICS_FAILED", "获取层级识别统计信息失败", traceId);
            return Result<LayerRecognitionStatistics>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    #region 私有方法

    /// <summary>
    /// 初始化默认模型。
    /// </summary>
    private void InitializeDefaultModel()
    {
        _currentModel = new LayerModelData
        {
            ModelId = Guid.NewGuid(),
            Version = "1.0.0",
            ModelType = LayerModelType.RandomForest,
            IsEnabled = true,
            CreatedAtUtc = DateTime.UtcNow,
            ModelParameters = new Dictionary<string, object>
            {
                ["n_estimators"] = 100,
                ["max_depth"] = 10,
                ["random_state"] = 42
            }
        };
    }

    /// <summary>
    /// 基于规则识别层级。
    /// </summary>
    private async Task<Result<LayerRecognitionResult>> RecognizeByRuleAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, LayerFeatures features, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken); // 模拟异步操作

        var recognizedLayer = currentLayer;
        var confidence = 0.8;

        // 基于目标数量的简单规则
        if (features.ObjectCount == 0)
        {
            // 无目标检测到，可能是空层或错误
            recognizedLayer = Math.Max(0, currentLayer - 1);
            confidence = 0.6;
        }
        else if (features.ObjectCount > 10)
        {
            // 目标数量过多，可能是高层级
            recognizedLayer = Math.Min(currentLayer + 1, 10);
            confidence = 0.7;
        }

        return Result<LayerRecognitionResult>.Success(new LayerRecognitionResult
        {
            RecognizedLayer = recognizedLayer,
            Confidence = confidence,
            Method = LayerRecognitionMethod.RuleBased,
            Features = features,
            RecognitionTimeUtc = DateTime.UtcNow,
            Details = $"基于规则识别：目标数量={features.ObjectCount}"
        });
    }

    /// <summary>
    /// 基于特征匹配识别层级。
    /// </summary>
    private async Task<Result<LayerRecognitionResult>> RecognizeByFeatureMatchingAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, LayerFeatures features, CancellationToken cancellationToken = default)
    {
        await Task.Delay(5, cancellationToken); // 模拟异步操作

        // 简化的特征匹配算法
        var recognizedLayer = currentLayer;
        var confidence = 0.75;

        // 基于目标类别分布匹配
        if (features.ObjectClassDistribution.ContainsKey("component_a") && features.ObjectClassDistribution.ContainsKey("component_b"))
        {
            recognizedLayer = 2;
            confidence = 0.85;
        }
        else if (features.ObjectClassDistribution.ContainsKey("component_c"))
        {
            recognizedLayer = 3;
            confidence = 0.8;
        }

        return Result<LayerRecognitionResult>.Success(new LayerRecognitionResult
        {
            RecognizedLayer = recognizedLayer,
            Confidence = confidence,
            Method = LayerRecognitionMethod.FeatureMatching,
            Features = features,
            RecognitionTimeUtc = DateTime.UtcNow,
            Details = $"基于特征匹配识别：类别分布={string.Join(",", features.ObjectClassDistribution.Select(kvp => $"{kvp.Key}:{kvp.Value}"))}"
        });
    }

    /// <summary>
    /// 基于机器学习识别层级。
    /// </summary>
    private async Task<Result<LayerRecognitionResult>> RecognizeByMachineLearningAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, LayerFeatures features, CancellationToken cancellationToken = default)
    {
        await Task.Delay(10, cancellationToken); // 模拟异步操作

        if (_currentModel == null)
        {
            return Result<LayerRecognitionResult>.Fail("NO_MODEL_AVAILABLE", "没有可用的机器学习模型");
        }

        // 简化的ML预测（实际应该使用训练好的模型）
        var recognizedLayer = currentLayer;
        var confidence = 0.9;

        // 基于特征向量的简单分类
        if (features.FeatureVector.Length > 0)
        {
            var featureSum = features.FeatureVector.Sum();
            recognizedLayer = (int)(featureSum % 10) + 1;
            confidence = 0.85 + (featureSum % 100) / 1000.0;
        }

        return Result<LayerRecognitionResult>.Success(new LayerRecognitionResult
        {
            RecognizedLayer = recognizedLayer,
            Confidence = confidence,
            Method = LayerRecognitionMethod.MachineLearning,
            Features = features,
            RecognitionTimeUtc = DateTime.UtcNow,
            Details = $"基于机器学习识别：模型版本={_currentModel.Version}"
        });
    }

    /// <summary>
    /// 融合识别结果。
    /// </summary>
    private LayerRecognitionResult FuseRecognitionResults(Result<LayerRecognitionResult>[] results, OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, int currentLayer, LayerFeatures features)
    {
        var validResults = results.Where(r => r.Succeeded && r.Data != null).Select(r => r.Data!).ToList();
        
        if (!validResults.Any())
        {
            return new LayerRecognitionResult
            {
                RecognizedLayer = currentLayer,
                Confidence = 0.0,
                Method = LayerRecognitionMethod.RuleBased,
                Features = features,
                RecognitionTimeUtc = DateTime.UtcNow,
                Details = "所有识别方法都失败"
            };
        }

        // 加权平均融合
        var weightedConfidence = 0.0;
        var weightedLayer = 0.0;
        var totalWeight = 0.0;

        foreach (var result in validResults)
        {
            var weight = GetMethodWeight(result.Method);
            weightedConfidence += result.Confidence * weight;
            weightedLayer += result.RecognizedLayer * weight;
            totalWeight += weight;
        }

        var finalConfidence = weightedConfidence / totalWeight;
        var finalLayer = (int)Math.Round(weightedLayer / totalWeight);

        // 检查是否为层级变化
        var isTransition = finalLayer != currentLayer;

        return new LayerRecognitionResult
        {
            RecognizedLayer = finalLayer,
            Confidence = finalConfidence,
            Method = LayerRecognitionMethod.Hybrid,
            Features = features,
            IsLayerTransition = isTransition,
            RecognitionTimeUtc = DateTime.UtcNow,
            Details = $"融合识别：{string.Join(", ", validResults.Select(r => $"{r.Method}:{r.Confidence:F3}"))}",
            ExtendedProperties = new Dictionary<string, object>
            {
                ["individual_results"] = validResults.Select(r => new { r.Method, r.Confidence, r.RecognizedLayer }).ToList()
            }
        };
    }

    /// <summary>
    /// 获取方法权重。
    /// </summary>
    private double GetMethodWeight(LayerRecognitionMethod method)
    {
        return method switch
        {
            LayerRecognitionMethod.RuleBased => 0.3,
            LayerRecognitionMethod.FeatureMatching => 0.4,
            LayerRecognitionMethod.MachineLearning => 0.6,
            LayerRecognitionMethod.DeepLearning => 0.8,
            LayerRecognitionMethod.Hybrid => 0.7,
            _ => 0.1
        };
    }

    /// <summary>
    /// 添加历史记录。
    /// </summary>
    private async Task AddHistoryRecordAsync(LayerHistoryRecord record, CancellationToken cancellationToken = default)
    {
        await Task.Run(() =>
        {
            _layerHistory.TryAdd(record.RecordId, record);

            // 保持历史记录数量在合理范围内
            if (_layerHistory.Count > _options.MaxLayerHistoryCount)
            {
                var oldestRecords = _layerHistory.Values
                    .OrderBy(r => r.RecordTimeUtc)
                    .Take(_layerHistory.Count - _options.MaxLayerHistoryCount)
                    .Select(r => r.RecordId)
                    .ToList();

                foreach (var id in oldestRecords)
                {
                    _layerHistory.TryRemove(id, out _);
                }
            }
        }, cancellationToken);
    }

    /// <summary>
    /// 计算稳定性得分。
    /// </summary>
    private double CalculateStabilityScore(Dictionary<int, double> layerDistribution, List<LayerHistoryRecord> records)
    {
        // 基于熵计算稳定性
        var entropy = 0.0;
        var totalRecords = records.Count;

        foreach (var percentage in layerDistribution.Values)
        {
            if (percentage > 0)
            {
                entropy -= (percentage / 100) * Math.Log(percentage / 100, 2);
            }
        }

        // 熵越小，稳定性越高
        var maxEntropy = Math.Log(layerDistribution.Count, 2);
        var stabilityScore = (1 - entropy / maxEntropy) * 100;

        // 考虑时间一致性
        var timeConsistency = CalculateTimeConsistency(records);
        stabilityScore = stabilityScore * 0.7 + timeConsistency * 0.3;

        return Math.Max(0, Math.Min(100, stabilityScore));
    }

    /// <summary>
    /// 计算时间一致性。
    /// </summary>
    private double CalculateTimeConsistency(List<LayerHistoryRecord> records)
    {
        if (records.Count < 2) return 100.0;

        var consistentCount = 0;
        for (int i = 1; i < records.Count; i++)
        {
            if (records[i].Layer == records[i - 1].Layer)
            {
                consistentCount++;
            }
        }

        return (double)consistentCount / (records.Count - 1) * 100;
    }

    /// <summary>
    /// 分析变化类型。
    /// </summary>
    private LayerTransitionType AnalyzeTransitionType(int fromLayer, int toLayer, IReadOnlyList<LayerHistoryRecord> history)
    {
        if (toLayer == fromLayer + 1)
        {
            return LayerTransitionType.Normal;
        }
        else if (toLayer > fromLayer + 1)
        {
            return LayerTransitionType.Skip;
        }
        else if (toLayer < fromLayer)
        {
            return LayerTransitionType.Backward;
        }
        else if (history.Count > 0 && history.Last().Layer == toLayer)
        {
            return LayerTransitionType.Duplicate;
        }
        else
        {
            return LayerTransitionType.Abnormal;
        }
    }

    /// <summary>
    /// 计算变化置信度。
    /// </summary>
    private double CalculateTransitionConfidence(int fromLayer, int toLayer, IReadOnlyList<LayerHistoryRecord> history, LayerRecognitionResult recognitionResult)
    {
        var baseConfidence = recognitionResult.Confidence;

        // 基于历史记录调整置信度
        if (history.Count >= 3)
        {
            var recentLayers = history.TakeLast(3).Select(r => r.Layer).ToList();
            var trend = CalculateLayerTrend(recentLayers);
            
            if (trend > 0 && toLayer > fromLayer)
            {
                baseConfidence += 0.1;
            }
            else if (trend < 0 && toLayer < fromLayer)
            {
                baseConfidence += 0.1;
            }
        }

        return Math.Max(0, Math.Min(1, baseConfidence));
    }

    /// <summary>
    /// 计算层级趋势。
    /// </summary>
    private double CalculateLayerTrend(List<int> layers)
    {
        if (layers.Count < 2) return 0;

        var trend = 0.0;
        for (int i = 1; i < layers.Count; i++)
        {
            trend += layers[i] - layers[i - 1];
        }

        return trend / (layers.Count - 1);
    }

    /// <summary>
    /// 提取图像特征。
    /// </summary>
    private async Task<ImageFeatures> ExtractImageFeaturesAsync(OrpaonVision.Core.LayerRecognition.InferenceResultDto inference, CancellationToken cancellationToken = default)
    {
        await Task.Delay(2, cancellationToken); // 模拟图像处理

        // 模拟图像特征提取
        return new ImageFeatures
        {
            BrightnessMean = 0.5 + (inference.Confidence - 0.5) * 0.3,
            Contrast = 0.6,
            TextureComplexity = 0.4,
            EdgeDensity = 0.3,
            ColorDistribution = new Dictionary<string, double>
            {
                ["red"] = 0.3,
                ["green"] = 0.4,
                ["blue"] = 0.3
            },
            ImageSize = (640, 480),
            AspectRatio = 4.0 / 3.0
        };
    }

    /// <summary>
    /// 生成特征向量。
    /// </summary>
    private async Task<double[]> GenerateFeatureVectorAsync(LayerFeatures features, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var vector = new List<double>
        {
            features.ObjectCount,
            features.AverageConfidence,
            features.MaxConfidence,
            features.ImageFeatures.BrightnessMean,
            features.ImageFeatures.Contrast,
            features.ImageFeatures.TextureComplexity,
            features.ImageFeatures.EdgeDensity,
            features.ImageFeatures.AspectRatio
        };

        // 添加类别分布特征
        foreach (var kvp in features.ObjectClassDistribution.OrderByDescending(x => x.Value).Take(5))
        {
            vector.Add(kvp.Value);
        }

        // 填充到固定长度
        while (vector.Count < 20)
        {
            vector.Add(0.0);
        }

        return vector.Take(20).ToArray();
    }

    /// <summary>
    /// 预处理训练数据。
    /// </summary>
    private async Task<List<LayerTrainingData>> PreprocessTrainingDataAsync(IReadOnlyList<LayerTrainingData> trainingData, CancellationToken cancellationToken = default)
    {
        await Task.Delay(10, cancellationToken);

        // 数据清洗和标准化
        return trainingData
            .Where(d => d.Features.FeatureVector.Length > 0 && d.TargetLayer >= 0)
            .Select(d => new LayerTrainingData
            {
                DataId = d.DataId,
                TargetLayer = d.TargetLayer,
                Inference = d.Inference,
                Features = NormalizeFeatures(d.Features),
                Label = d.Label,
                CreatedAtUtc = d.CreatedAtUtc,
                IsValidationData = d.IsValidationData
            })
            .ToList();
    }

    /// <summary>
    /// 标准化特征。
    /// </summary>
    private LayerFeatures NormalizeFeatures(LayerFeatures features)
    {
        // 简单的特征标准化
        return new LayerFeatures
        {
            ObjectCount = Math.Min(features.ObjectCount, 20),
            AverageConfidence = features.AverageConfidence,
            MaxConfidence = features.MaxConfidence,
            BoundingBoxes = features.BoundingBoxes,
            ObjectClassDistribution = features.ObjectClassDistribution,
            ImageFeatures = features.ImageFeatures,
            FeatureVector = features.FeatureVector.Select(v => Math.Max(0, Math.Min(1, v))).ToArray(),
            ExtractionTimeUtc = features.ExtractionTimeUtc
        };
    }

    /// <summary>
    /// 训练随机森林模型。
    /// </summary>
    private async Task<(double Accuracy, double Precision, double Recall, double F1Score)> TrainRandomForestModelAsync(double[][] featureVectors, int[] labels, CancellationToken cancellationToken = default)
    {
        await Task.Delay(100, cancellationToken); // 模拟训练时间

        // 简化的模型训练结果
        var accuracy = 0.85 + (DateTime.UtcNow.Millisecond % 100) / 1000.0;
        var precision = 0.82 + (DateTime.UtcNow.Millisecond % 150) / 1000.0;
        var recall = 0.88 + (DateTime.UtcNow.Millisecond % 120) / 1000.0;
        var f1Score = 2 * (precision * recall) / (precision + recall);

        return (accuracy, precision, recall, f1Score);
    }

    /// <summary>
    /// 计算层级变化次数。
    /// </summary>
    private int CountLayerTransitions(List<LayerHistoryRecord> records)
    {
        if (records.Count < 2) return 0;

        var transitions = 0;
        var sortedRecords = records.OrderBy(r => r.RecordTimeUtc).ToList();

        for (int i = 1; i < sortedRecords.Count; i++)
        {
            if (sortedRecords[i].Layer != sortedRecords[i - 1].Layer)
            {
                transitions++;
            }
        }

        return transitions;
    }

    #endregion
}