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

namespace OrpaonVision.SiteApp.Runtime.Services;

/// <summary>
/// 统计服务实现。
/// </summary>
#if DISABLED_LEGACY_STATISTICS_SERVICE
public sealed class StatisticsService : IStatisticsService
{
    private readonly ILogger<StatisticsService> _logger;
    private readonly RuntimeOptions _options;
    private readonly ConcurrentDictionary<string, StatisticsConfig> _statisticsConfigs = new();
    private readonly ConcurrentDictionary<string, object> _statisticsCache = new();
    private readonly object _lock = new();

    /// <summary>
    /// 构造函数。
    /// </summary>
    public StatisticsService(ILogger<StatisticsService> logger, IOptions<RuntimeOptions> options)
    {
        _logger = logger;
        _options = options.Value;
        InitializeDefaultStatisticsConfigs();
        _logger.LogInformation("统计服务已初始化");
    }

    /// <inheritdoc />
    public async Task<Result<CycleTimeStatistics>> GetCycleTimeStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取节拍统计信息：开始时间={StartTime}，结束时间={EndTime}，产品类型={ProductTypeCode}", 
                startTime, endTime, productTypeCode);

            var cacheKey = $"cycle_time_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{productTypeCode}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取节拍统计信息");
                return Result.Success((CycleTimeStatistics)cached);
            }

            var statistics = await GenerateCycleTimeStatisticsAsync(startTime, endTime, productTypeCode, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("节拍统计信息获取完成：总处理数={Total}，成功率={SuccessRate:F2}%，平均节拍={AvgCycleTime:F2}秒", 
                statistics.TotalProcessedCount, statistics.OverallSuccessRate, statistics.AverageCycleTimeSeconds);

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

    /// <inheritdoc />
    public async Task<Result<ShiftStatistics>> GetShiftStatisticsAsync(DateTime shiftDate, ShiftType? shiftType = null, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取班次统计信息：日期={ShiftDate}，班次类型={ShiftType}，产品类型={ProductTypeCode}", 
                shiftDate, shiftType, productTypeCode);

            var cacheKey = $"shift_{shiftDate:yyyyMMdd}_{shiftType}_{productTypeCode}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取班次统计信息");
                return Result.Success((ShiftStatistics)cached);
            }

            var statistics = await GenerateShiftStatisticsAsync(shiftDate, shiftType, productTypeCode, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("班次统计信息获取完成：计划产量={Planned}，实际产量={Actual}，完成率={CompletionRate:F2}%，合格率={PassRate:F2}%", 
                statistics.PlannedProductionCount, statistics.ActualProductionCount, statistics.ProductionCompletionRate, statistics.QualityPassRate);

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

    /// <inheritdoc />
    public async Task<Result<IReadOnlyList<ShiftInfo>>> GetShiftListAsync(DateTime startDate, DateTime endDate, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取班次列表：开始日期={StartDate}，结束日期={EndDate}", startDate, endDate);

            var shiftList = await GenerateShiftListAsync(startDate, endDate, cancellationToken);

            _logger.LogInformation("班次列表获取完成：班次数量={ShiftCount}", shiftList.Count);
            return Result.Success<IReadOnlyList<ShiftInfo>>(shiftList);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取班次列表失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_SHIFT_LIST_FAILED", "获取班次列表失败", traceId);
            return Result.FailWithTrace<IReadOnlyList<ShiftInfo>>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<ProductionEfficiencyStatistics>> GetProductionEfficiencyStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, StatisticsGranularity granularity = StatisticsGranularity.Hourly, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取生产效率统计：开始时间={StartTime}，结束时间={EndTime}，产品类型={ProductTypeCode}，粒度={Granularity}", 
                startTime, endTime, productTypeCode, granularity);

            var cacheKey = $"efficiency_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{productTypeCode}_{granularity}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取生产效率统计");
                return Result.Success((ProductionEfficiencyStatistics)cached);
            }

            var statistics = await GenerateProductionEfficiencyStatisticsAsync(startTime, endTime, productTypeCode, granularity, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("生产效率统计获取完成：OEE={OEE:F2}%，时间利用率={TimeUtilization:F2}%，设备利用率={EquipmentUtilization:F2}%", 
                statistics.OverallEquipmentEffectiveness, statistics.TimeUtilizationRate, statistics.EquipmentUtilizationRate);

            return Result.Success(statistics);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取生产效率统计失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_PRODUCTION_EFFICIENCY_STATISTICS_FAILED", "获取生产效率统计失败", traceId);
            return Result.FailWithTrace<ProductionEfficiencyStatistics>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<QualityStatistics>> GetQualityStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取质量统计信息：开始时间={StartTime}，结束时间={EndTime}，产品类型={ProductTypeCode}", 
                startTime, endTime, productTypeCode);

            var cacheKey = $"quality_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{productTypeCode}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取质量统计信息");
                return Result.Success((QualityStatistics)cached);
            }

            var statistics = await GenerateQualityStatisticsAsync(startTime, endTime, productTypeCode, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("质量统计信息获取完成：总检测数={Total}，合格数={Qualified}，合格率={PassRate:F2}%", 
                statistics.TotalInspectionCount, statistics.QualifiedCount, statistics.OverallPassRate);

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

    /// <inheritdoc />
    public async Task<Result<EquipmentUtilizationStatistics>> GetEquipmentUtilizationStatisticsAsync(DateTime startTime, DateTime endTime, string? equipmentId = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取设备利用率统计：开始时间={StartTime}，结束时间={EndTime}，设备ID={EquipmentId}", 
                startTime, endTime, equipmentId);

            var cacheKey = $"equipment_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{equipmentId}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取设备利用率统计");
                return Result.Success((EquipmentUtilizationStatistics)cached);
            }

            var statistics = await GenerateEquipmentUtilizationStatisticsAsync(startTime, endTime, equipmentId, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("设备利用率统计获取完成：总体利用率={Overall:F2}%，生产利用率={Production:F2}%，可用率={Availability:F2}%", 
                statistics.OverallUtilizationRate, statistics.ProductionUtilizationRate, statistics.AvailabilityRate);

            return Result.Success(statistics);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取设备利用率统计失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_EQUIPMENT_UTILIZATION_STATISTICS_FAILED", "获取设备利用率统计失败", traceId);
            return Result.FailWithTrace<EquipmentUtilizationStatistics>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<AlarmStatisticsSummary>> GetAlarmStatisticsSummaryAsync(DateTime startTime, DateTime endTime, OrpaonVision.Core.Common.AlarmLevel? alarmLevel = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取报警统计摘要：开始时间={StartTime}，结束时间={EndTime}，报警级别={AlarmLevel}", 
                startTime, endTime, alarmLevel);

            var cacheKey = $"alarm_summary_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{alarmLevel}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取报警统计摘要");
                return Result.Success((AlarmStatisticsSummary)cached);
            }

            var statistics = await GenerateAlarmStatisticsSummaryAsync(startTime, endTime, alarmLevel, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, statistics);
            }

            _logger.LogInformation("报警统计摘要获取完成：总报警数={Total}，活跃数={Active}，确认数={Confirmed}，清除数={Cleared}", 
                statistics.TotalAlarmCount, statistics.ActiveAlarmCount, statistics.ConfirmedAlarmCount, statistics.ClearedAlarmCount);

            return Result.Success(statistics);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取报警统计摘要失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_ALARM_STATISTICS_SUMMARY_FAILED", "获取报警统计摘要失败", traceId);
            return Result.FailWithTrace<AlarmStatisticsSummary>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<ComprehensiveProductionReport>> GetComprehensiveProductionReportAsync(OrpaonVision.Core.Statistics.ProductionReportType reportType, DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取综合生产报告：报告类型={ReportType}，开始时间={StartTime}，结束时间={EndTime}，产品类型={ProductTypeCode}", 
                reportType, startTime, endTime, productTypeCode);

            var report = await GenerateComprehensiveProductionReportAsync(reportType, startTime, endTime, productTypeCode, cancellationToken);

            _logger.LogInformation("综合生产报告获取完成：报告ID={ReportId}，总体评分={OverallScore:F2}", 
                report.ReportId, report.ExecutiveSummary.OverallScore);

            return Result.Success(report);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取综合生产报告失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_COMPREHENSIVE_PRODUCTION_REPORT_FAILED", "获取综合生产报告失败", traceId);
            return Result.FailWithTrace<ComprehensiveProductionReport>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<RealTimeStatisticsDashboard>> GetRealTimeStatisticsDashboardAsync(string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取实时统计仪表板：产品类型={ProductTypeCode}", productTypeCode);

            var dashboard = await GenerateRealTimeStatisticsDashboardAsync(productTypeCode, cancellationToken);

            _logger.LogInformation("实时统计仪表板获取完成：更新时间={UpdateTime}，当前OEE={OEE:F2}%", 
                dashboard.LastUpdatedUtc, dashboard.Efficiency.CurrentOEE);

            return Result.Success(dashboard);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取实时统计仪表板失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_REAL_TIME_STATISTICS_DASHBOARD_FAILED", "获取实时统计仪表板失败", traceId);
            return Result.FailWithTrace<RealTimeStatisticsDashboard>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<HistoricalTrendData>> GetHistoricalTrendDataAsync(MetricType metricType, DateTime startTime, DateTime endTime, string? productTypeCode = null, StatisticsGranularity granularity = StatisticsGranularity.Hourly, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("获取历史趋势数据：指标类型={MetricType}，开始时间={StartTime}，结束时间={EndTime}，产品类型={ProductTypeCode}，粒度={Granularity}", 
                metricType, startTime, endTime, productTypeCode, granularity);

            var cacheKey = $"trend_{metricType}_{startTime:yyyyMMddHHmm}_{endTime:yyyyMMddHHmm}_{productTypeCode}_{granularity}";
            
            if (_options.EnableStatisticsCache && _statisticsCache.TryGetValue(cacheKey, out var cached))
            {
                _logger.LogDebug("从缓存获取历史趋势数据");
                return Result.Success((HistoricalTrendData)cached);
            }

            var trendData = await GenerateHistoricalTrendDataAsync(metricType, startTime, endTime, productTypeCode, granularity, cancellationToken);

            if (_options.EnableStatisticsCache)
            {
                _statisticsCache.TryAdd(cacheKey, trendData);
            }

            _logger.LogInformation("历史趋势数据获取完成：指标类型={MetricType}，数据点数量={DataPointCount}，趋势方向={Trend}", 
                metricType, trendData.DataPoints.Count, trendData.TrendAnalysis.TrendDescription);

            return Result.Success(trendData);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取历史趋势数据失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_HISTORICAL_TREND_DATA_FAILED", "获取历史趋势数据失败", traceId);
            return Result.FailWithTrace<HistoricalTrendData>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<StatisticsConfig>> CreateStatisticsConfigAsync(StatisticsConfig config, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("创建统计配置：配置类型={ConfigType}，产品类型={ProductTypeCode}，配置名称={ConfigName}", 
                config.ConfigType, config.ProductTypeCode, config.ConfigName);

            lock (_lock)
            {
                config.ConfigId = Guid.NewGuid();
                config.CreatedAtUtc = DateTime.UtcNow;
                config.UpdatedAtUtc = DateTime.UtcNow;
                config.Version = "1.0";
                
                var key = $"{config.ConfigType}_{config.ProductTypeCode}_{config.ConfigName}";
                _statisticsConfigs[key] = config;
            }

            _logger.LogInformation("统计配置创建成功：配置ID={ConfigId}，配置名称={ConfigName}", 
                config.ConfigId, config.ConfigName);

            return Result.Success(config);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "创建统计配置失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "CREATE_STATISTICS_CONFIG_FAILED", "创建统计配置失败", traceId);
            return Result.FailWithTrace<StatisticsConfig>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result> UpdateStatisticsConfigAsync(StatisticsConfig config, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("更新统计配置：配置ID={ConfigId}，配置名称={ConfigName}", 
                config.ConfigId, config.ConfigName);

            lock (_lock)
            {
                var key = $"{config.ConfigType}_{config.ProductTypeCode}_{config.ConfigName}";
                if (_statisticsConfigs.ContainsKey(key))
                {
                    config.UpdatedAtUtc = DateTime.UtcNow;
                    _statisticsConfigs[key] = config;
                }
                else
                {
                    return Result.Fail("CONFIG_NOT_FOUND", $"未找到配置：{config.ConfigId}");
                }
            }

            _logger.LogInformation("统计配置更新成功：配置ID={ConfigId}", config.ConfigId);
            return Result.Success();
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "更新统计配置失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "UPDATE_STATISTICS_CONFIG_FAILED", "更新统计配置失败", traceId);
            return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<StatisticsConfig>> GetStatisticsConfigAsync(StatisticsConfigType configType, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogDebug("获取统计配置：配置类型={ConfigType}，产品类型={ProductTypeCode}", configType, productTypeCode);

            var key = $"{configType}_{productTypeCode}";
            if (_statisticsConfigs.TryGetValue(key, out var config))
            {
                return Result.Success(config);
            }

            // 尝试获取默认配置
            var defaultKey = $"{configType}_default";
            if (_statisticsConfigs.TryGetValue(defaultKey, out var defaultConfig))
            {
                return Result.Success(defaultConfig);
            }

            return Result.FailWithTrace<StatisticsConfig>("CONFIG_NOT_FOUND", $"未找到配置：{configType}", string.Empty);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取统计配置失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "GET_STATISTICS_CONFIG_FAILED", "获取统计配置失败", traceId);
            return Result.FailWithTrace<StatisticsConfig>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public async Task<Result<StatisticsExportResult>> ExportStatisticsAsync(StatisticsExportRequest exportRequest, CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("导出统计数据：导出类型={ExportType}，格式={ExportFormat}，统计类型={StatisticsType}", 
                exportRequest.ExportType, exportRequest.ExportFormat, exportRequest.StatisticsType);

            var startTime = DateTime.UtcNow;
            var result = await GenerateStatisticsExportAsync(exportRequest, cancellationToken);
            var elapsed = DateTime.UtcNow - startTime;

            var exportResult = new StatisticsExportResult
            {
                RequestId = exportRequest.RequestId,
                IsSuccess = true,
                FilePath = result.FilePath,
                FileSizeBytes = result.FileSizeBytes,
                RecordCount = result.RecordCount,
                ExportElapsedMs = (long)elapsed.TotalMilliseconds,
                ExportTimeUtc = DateTime.UtcNow,
                ResultDescription = $"导出完成：{result.RecordCount}条记录，文件大小{result.FileSizeBytes}字节",
                ExtendedProperties = new Dictionary<string, object>
                {
                    ["export_type"] = exportRequest.ExportType,
                    ["export_format"] = exportRequest.ExportFormat,
                    ["statistics_type"] = exportRequest.StatisticsType
                }
            };

            _logger.LogInformation("统计数据导出完成：文件路径={FilePath}，记录数量={RecordCount}，耗时={ElapsedMs}ms", 
                exportResult.FilePath, exportResult.RecordCount, exportResult.ExportElapsedMs);

            return Result.Success(exportResult);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "导出统计数据失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "EXPORT_STATISTICS_FAILED", "导出统计数据失败", traceId);
            return Result.FailWithTrace<StatisticsExportResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    #region 私有方法

    /// <summary>
    /// 初始化默认统计配置。
    /// </summary>
    private void InitializeDefaultStatisticsConfigs()
    {
        var defaultConfigs = new List<StatisticsConfig>
        {
            new()
            {
                ConfigId = Guid.NewGuid(),
                ConfigType = StatisticsConfigType.CycleTime,
                ProductTypeCode = "default",
                ConfigName = "默认节拍统计配置",
                ConfigDescription = "系统默认的节拍统计配置",
                Parameters = new Dictionary<string, object>
                {
                    ["target_cycle_time_seconds"] = 60.0,
                    ["tolerance_percentage"] = 10.0,
                    ["enable_trend_analysis"] = true
                },
                IsEnabled = true,
                CreatedAtUtc = DateTime.UtcNow,
                UpdatedAtUtc = DateTime.UtcNow,
                Version = "1.0"
            },
            new()
            {
                ConfigId = Guid.NewGuid(),
                ConfigType = StatisticsConfigType.Shift,
                ProductTypeCode = "default",
                ConfigName = "默认班次统计配置",
                ConfigDescription = "系统默认的班次统计配置",
                Parameters = new Dictionary<string, object>
                {
                    ["shift_duration_hours"] = 8.0,
                    ["target_production_rate"] = 100,
                    ["enable_anomaly_detection"] = true
                },
                IsEnabled = true,
                CreatedAtUtc = DateTime.UtcNow,
                UpdatedAtUtc = DateTime.UtcNow,
                Version = "1.0"
            },
            new()
            {
                ConfigId = Guid.NewGuid(),
                ConfigType = StatisticsConfigType.Quality,
                ProductTypeCode = "default",
                ConfigName = "默认质量统计配置",
                ConfigDescription = "系统默认的质量统计配置",
                Parameters = new Dictionary<string, object>
                {
                    ["target_pass_rate"] = 95.0,
                    ["enable_defect_analysis"] = true,
                    ["enable_improvement_suggestions"] = true
                },
                IsEnabled = true,
                CreatedAtUtc = DateTime.UtcNow,
                UpdatedAtUtc = DateTime.UtcNow,
                Version = "1.0"
            }
        };

        foreach (var config in defaultConfigs)
        {
            var key = $"{config.ConfigType}_{config.ProductTypeCode}_{config.ConfigName}";
            _statisticsConfigs[key] = config;
        }
    }

    /// <summary>
    /// 生成节拍统计信息。
    /// </summary>
    private async Task<CycleTimeStatistics> GenerateCycleTimeStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        // 简化处理：生成模拟数据
        var random = new Random();
        var totalProcessed = random.Next(100, 500);
        var successCount = (int)(totalProcessed * (0.85 + random.NextDouble() * 0.1));
        var failedCount = totalProcessed - successCount;

        var cycleTimes = Enumerable.Range(0, totalProcessed)
            .Select(_ => 45 + random.NextDouble() * 30) // 45-75秒
            .ToList();

        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };

        return new CycleTimeStatistics
        {
            TimeRange = timeRange,
            ProductTypeCode = productTypeCode ?? "default",
            TotalProcessedCount = totalProcessed,
            SuccessfulProcessedCount = successCount,
            FailedProcessedCount = failedCount,
            AverageCycleTimeSeconds = cycleTimes.Average(),
            MinCycleTimeSeconds = cycleTimes.Min(),
            MaxCycleTimeSeconds = cycleTimes.Max(),
            CycleTimeStandardDeviationSeconds = CalculateStandardDeviation(cycleTimes),
            TargetCycleTimeSeconds = 60.0,
            CountAchievedCycleTime = cycleTimes.Count(t => t <= 60.0),
            ByHour = GenerateHourlyCycleTimeStatistics(startTime, endTime, cycleTimes),
            ByProductType = GenerateProductTypeCycleTimeStatistics(productTypeCode, totalProcessed, successCount, cycleTimes.Average()),
            Distribution = GenerateCycleTimeDistribution(cycleTimes, 60.0),
            Trend = GenerateCycleTimeTrend(cycleTimes),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 50,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成班次统计信息。
    /// </summary>
    private async Task<ShiftStatistics> GenerateShiftStatisticsAsync(DateTime shiftDate, ShiftType? shiftType, string? productTypeCode, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var shiftInfo = GenerateShiftInfo(shiftDate, shiftType);
        var plannedProduction = random.Next(200, 400);
        var actualProduction = (int)(plannedProduction * (0.9 + random.NextDouble() * 0.15));
        var qualifiedCount = (int)(actualProduction * (0.92 + random.NextDouble() * 0.06));

        return new ShiftStatistics
        {
            ShiftInfo = shiftInfo,
            ProductTypeCode = productTypeCode ?? "default",
            PlannedProductionCount = plannedProduction,
            ActualProductionCount = actualProduction,
            QualifiedProductionCount = qualifiedCount,
            UnqualifiedProductionCount = actualProduction - qualifiedCount,
            ShiftStartTimeUtc = shiftDate.Add(shiftInfo.StartTime),
            ShiftEndTimeUtc = shiftDate.Add(shiftInfo.EndTime),
            ActualWorkingHours = shiftInfo.DurationHours * (0.85 + random.NextDouble() * 0.1),
            EquipmentDowntimeHours = shiftInfo.DurationHours * (0.05 + random.NextDouble() * 0.05),
            AverageCycleTimeSeconds = 55 + random.NextDouble() * 10,
            ByHour = GenerateHourlyShiftStatistics(shiftInfo, actualProduction, qualifiedCount),
            ByProductType = GenerateProductTypeShiftStatistics(productTypeCode, actualProduction, qualifiedCount, 60.0),
            AnomalyStatistics = GenerateShiftAnomalyStatistics(random),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 60,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成班次列表。
    /// </summary>
    private async Task<IReadOnlyList<ShiftInfo>> GenerateShiftListAsync(DateTime startDate, DateTime endDate, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var shiftList = new List<ShiftInfo>();
        var currentDate = startDate;

        while (currentDate <= endDate)
        {
            // 生成当天的班次
            var shifts = new[] { ShiftType.Morning, ShiftType.Afternoon, ShiftType.Night };
            
            foreach (var shiftType in shifts)
            {
                var shiftInfo = GenerateShiftInfo(currentDate, shiftType);
                shiftList.Add(shiftInfo);
            }

            currentDate = currentDate.AddDays(1);
        }

        return shiftList.AsReadOnly();
    }

    /// <summary>
    /// 生成生产效率统计。
    /// </summary>
    private async Task<ProductionEfficiencyStatistics> GenerateProductionEfficiencyStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode, StatisticsGranularity granularity, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var plannedHours = (endTime - startTime).TotalHours;
        var actualHours = plannedHours * (0.85 + random.NextDouble() * 0.1);
        var equipmentHours = actualHours * (0.9 + random.NextDouble() * 0.08);
        var plannedProduction = (int)(plannedHours * 50); // 每小时50个
        var actualProduction = (int)(plannedProduction * (0.88 + random.NextDouble() * 0.1));
        var qualifiedCount = (int)(actualProduction * (0.94 + random.NextDouble() * 0.04));

        return new ProductionEfficiencyStatistics
        {
            TimeRange = timeRange,
            ProductTypeCode = productTypeCode ?? "default",
            Granularity = granularity,
            PlannedWorkingHours = plannedHours,
            ActualWorkingHours = actualHours,
            EquipmentRunningHours = equipmentHours,
            PlannedProductionCount = plannedProduction,
            ActualProductionCount = actualProduction,
            QualifiedProductionCount = qualifiedCount,
            ByTimeSlot = GenerateTimeSlotEfficiency(startTime, endTime, actualProduction, qualifiedCount, equipmentHours),
            Trend = GenerateEfficiencyTrend(),
            Benchmark = GenerateEfficiencyBenchmark(),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 70,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成质量统计信息。
    /// </summary>
    private async Task<QualityStatistics> GenerateQualityStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var totalInspection = random.Next(500, 1000);
        var qualifiedCount = (int)(totalInspection * (0.92 + random.NextDouble() * 0.05));
        var unqualifiedCount = totalInspection - qualifiedCount;

        return new QualityStatistics
        {
            TimeRange = timeRange,
            ProductTypeCode = productTypeCode ?? "default",
            TotalInspectionCount = totalInspection,
            QualifiedCount = qualifiedCount,
            UnqualifiedCount = unqualifiedCount,
            ByDefectType = GenerateDefectStatistics(unqualifiedCount),
            BySeverity = GenerateSeverityStatistics(unqualifiedCount),
            ByProductType = GenerateProductTypeQualityStatistics(productTypeCode, totalInspection, qualifiedCount),
            ByTimeSlot = GenerateQualityTimeSlotStatistics(startTime, endTime, totalInspection, qualifiedCount),
            Trend = GenerateQualityTrend(),
            ImprovementSuggestions = GenerateQualityImprovementSuggestions(),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 80,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成设备利用率统计。
    /// </summary>
    private async Task<EquipmentUtilizationStatistics> GenerateEquipmentUtilizationStatisticsAsync(DateTime startTime, DateTime endTime, string? equipmentId, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var plannedHours = (endTime - startTime).TotalHours;
        var actualHours = plannedHours * (0.8 + random.NextDouble() * 0.15);
        var productionHours = actualHours * (0.85 + random.NextDouble() * 0.1);
        var maintenanceHours = plannedHours * (0.02 + random.NextDouble() * 0.03);
        var failureHours = plannedHours * (0.01 + random.NextDouble() * 0.02);
        var idleHours = actualHours - productionHours - maintenanceHours - failureHours;

        return new EquipmentUtilizationStatistics
        {
            TimeRange = timeRange,
            EquipmentId = equipmentId ?? "EQ001",
            EquipmentName = "主检测设备",
            PlannedRunningHours = plannedHours,
            ActualRunningHours = actualHours,
            ProductionHours = productionHours,
            MaintenanceHours = maintenanceHours,
            FailureHours = failureHours,
            IdleHours = idleHours,
            MeanTimeBetweenFailuresHours = 100 + random.NextDouble() * 50,
            MeanTimeToRepairHours = 2 + random.NextDouble() * 3,
            ByDate = GenerateDailyUtilizationStatistics(startTime, endTime, plannedHours, actualHours),
            Trend = GenerateUtilizationTrend(),
            MaintenanceSuggestions = GenerateMaintenanceSuggestions(),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 90,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成报警统计摘要。
    /// </summary>
    private async Task<AlarmStatisticsSummary> GenerateAlarmStatisticsSummaryAsync(DateTime startTime, DateTime endTime, AlarmLevel? alarmLevel, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var totalAlarms = random.Next(10, 50);
        var activeAlarms = random.Next(0, 5);
        var confirmedAlarms = (int)(totalAlarms * 0.8);
        var clearedAlarms = (int)(totalAlarms * 0.7);

        var byAlarmLevel = new Dictionary<AlarmLevel, int>
        {
            [AlarmLevel.Info] = random.Next(5, 15),
            [AlarmLevel.Warning] = random.Next(3, 10),
            [AlarmLevel.Error] = random.Next(2, 8),
            [AlarmLevel.Critical] = random.Next(1, 5),
            [AlarmLevel.Fatal] = random.Next(0, 2)
        };

        var byAlarmType = new Dictionary<AlarmType, int>
        {
            [AlarmType.System] = random.Next(2, 8),
            [AlarmType.Equipment] = random.Next(3, 10),
            [AlarmType.Process] = random.Next(2, 6),
            [AlarmType.Quality] = random.Next(1, 5),
            [AlarmType.Safety] = random.Next(0, 3)
        };

        return new AlarmStatisticsSummary
        {
            TimeRange = timeRange,
            TotalAlarmCount = totalAlarms,
            ActiveAlarmCount = activeAlarms,
            ConfirmedAlarmCount = confirmedAlarms,
            ClearedAlarmCount = clearedAlarms,
            ByAlarmLevel = byAlarmLevel,
            ByAlarmType = byAlarmType,
            AverageConfirmTimeMinutes = 5 + random.NextDouble() * 10,
            AverageClearTimeMinutes = 10 + random.NextDouble() * 20,
            AlarmFrequencyPerHour = totalAlarms / Math.Max((endTime - startTime).TotalHours, 1),
            Trend = GenerateAlarmTrend(),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 100,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成综合生产报告。
    /// </summary>
    private async Task<ComprehensiveProductionReport> GenerateComprehensiveProductionReportAsync(ProductionReportType reportType, DateTime startTime, DateTime endTime, string? productTypeCode, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var reportId = Guid.NewGuid();

        return new ComprehensiveProductionReport
        {
            ReportId = reportId,
            ReportType = reportType,
            TimeRange = timeRange,
            ProductTypeCode = productTypeCode ?? "default",
            GeneratedAtUtc = DateTime.UtcNow,
            ExecutiveSummary = GenerateExecutiveSummary(),
            Production = GenerateProductionStatistics(),
            Quality = await GenerateQualityStatisticsAsync(startTime, endTime, productTypeCode, cancellationToken),
            Equipment = GenerateEquipmentStatistics(),
            Alarms = await GenerateAlarmStatisticsSummaryAsync(startTime, endTime, null, cancellationToken),
            Trends = GenerateTrendAnalysis(),
            Recommendations = GenerateImprovementRecommendations(),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 200,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成实时统计仪表板。
    /// </summary>
    private async Task<RealTimeStatisticsDashboard> GenerateRealTimeStatisticsDashboardAsync(string? productTypeCode, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var now = DateTime.UtcNow;

        return new RealTimeStatisticsDashboard
        {
            LastUpdatedUtc = now,
            ProductTypeCode = productTypeCode ?? "default",
            CurrentShift = GenerateShiftInfo(now.Date, GetCurrentShiftType(now)),
            Production = GenerateRealTimeProductionMetrics(random),
            Quality = GenerateRealTimeQualityMetrics(random),
            Equipment = GenerateRealTimeEquipmentMetrics(random),
            Alarms = GenerateRealTimeAlarmMetrics(random),
            Efficiency = GenerateRealTimeEfficiencyMetrics(random),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 30,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成历史趋势数据。
    /// </summary>
    private async Task<HistoricalTrendData> GenerateHistoricalTrendDataAsync(MetricType metricType, DateTime startTime, DateTime endTime, string? productTypeCode, StatisticsGranularity granularity, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var random = new Random();
        var timeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime };
        var dataPoints = GenerateTrendDataPoints(metricType, startTime, endTime, granularity, random);

        return new HistoricalTrendData
        {
            MetricType = metricType,
            Granularity = granularity,
            TimeRange = timeRange,
            DataPoints = dataPoints,
            TrendAnalysis = GenerateTrendAnalysis(),
            Statistics = GenerateTrendStatisticsSummary(dataPoints),
            ExtendedProperties = new Dictionary<string, object>
            {
                ["generation_time_ms"] = 120,
                ["data_source"] = "simulated"
            }
        };
    }

    /// <summary>
    /// 生成统计数据导出。
    /// </summary>
    private async Task<(string FilePath, long FileSizeBytes, int RecordCount)> GenerateStatisticsExportAsync(StatisticsExportRequest exportRequest, CancellationToken cancellationToken = default)
    {
        await Task.Delay(1, cancellationToken);

        var fileName = $"statistics_export_{exportRequest.RequestId:N}.{exportRequest.ExportFormat.ToString().ToLower()}";
        var filePath = Path.Combine(Path.GetTempPath(), fileName);
        
        // 简化处理：生成模拟文件
        var recordCount = 1000;
        var fileContent = GenerateExportFileContent(exportRequest, recordCount);
        await File.WriteAllTextAsync(filePath, fileContent, cancellationToken);
        
        var fileInfo = new FileInfo(filePath);
        
        return (filePath, fileInfo.Length, recordCount);
    }

    #endregion

    #region 辅助方法

    /// <summary>
    /// 计算标准差。
    /// </summary>
    private double CalculateStandardDeviation(IEnumerable<double> values)
    {
        var valuesList = values.ToList();
        var mean = valuesList.Average();
        var variance = valuesList.Sum(x => Math.Pow(x - mean, 2)) / valuesList.Count;
        return Math.Sqrt(variance);
    }

    /// <summary>
    /// 生成按小时分组的节拍统计。
    /// </summary>
    private Dictionary<int, HourlyCycleTimeStatistics> GenerateHourlyCycleTimeStatistics(DateTime startTime, DateTime endTime, List<double> cycleTimes)
    {
        var hourlyStats = new Dictionary<int, HourlyCycleTimeStatistics>();
        var random = new Random();

        for (int hour = 0; hour < 24; hour++)
        {
            var count = random.Next(5, 20);
            var successCount = (int)(count * (0.85 + random.NextDouble() * 0.1));
            var avgCycleTime = 50 + random.NextDouble() * 20;

            hourlyStats[hour] = new HourlyCycleTimeStatistics
            {
                Hour = hour,
                ProcessedCount = count,
                SuccessCount = successCount,
                AverageCycleTimeSeconds = avgCycleTime
            };
        }

        return hourlyStats;
    }

    /// <summary>
    /// 生成按产品类型分组的节拍统计。
    /// </summary>
    private Dictionary<string, ProductTypeCycleTimeStatistics> GenerateProductTypeCycleTimeStatistics(string? productTypeCode, int totalProcessed, int successCount, double avgCycleTime)
    {
        return new Dictionary<string, ProductTypeCycleTimeStatistics>
        {
            [productTypeCode ?? "default"] = new ProductTypeCycleTimeStatistics
            {
                ProductTypeCode = productTypeCode ?? "default",
                ProcessedCount = totalProcessed,
                SuccessCount = successCount,
                AverageCycleTimeSeconds = avgCycleTime
            }
        };
    }

    /// <summary>
    /// 生成节拍时间分布。
    /// </summary>
    private CycleTimeDistribution GenerateCycleTimeDistribution(List<double> cycleTimes, double targetTime)
    {
        var belowTarget = cycleTimes.Count(t => t < targetTime * 0.9);
        var withinRange = cycleTimes.Count(t => t >= targetTime * 0.9 && t <= targetTime * 1.1);
        var aboveRange = cycleTimes.Count - belowTarget - withinRange;
        var total = cycleTimes.Count;

        return new CycleTimeDistribution
        {
            BelowTargetCount = belowTarget,
            WithinTargetRangeCount = withinRange,
            AboveTargetRangeCount = aboveRange,
            BelowTargetPercentage = (double)belowTarget / total * 100,
            WithinTargetRangePercentage = (double)withinRange / total * 100,
            AboveTargetRangePercentage = (double)aboveRange / total * 100
        };
    }

    /// <summary>
    /// 生成节拍趋势分析。
    /// </summary>
    private CycleTimeTrend GenerateCycleTimeTrend(List<double> cycleTimes)
    {
        var random = new Random();
        var direction = random.NextDouble() > 0.5 ? TrendDirection.Increasing : TrendDirection.Decreasing;
        var changeRate = random.NextDouble() * 10 - 5; // -5% to +5%

        return new CycleTimeTrend
        {
            Direction = direction,
            ChangeRatePercentage = changeRate,
            TrendDescription = $"节拍时间呈{direction}趋势，变化率{changeRate:F2}%",
            PredictedNextCycleTimeSeconds = cycleTimes.Average() * (1 + changeRate / 100),
            Confidence = 0.7 + random.NextDouble() * 0.2
        };
    }

    /// <summary>
    /// 生成班次信息。
    /// </summary>
    private ShiftInfo GenerateShiftInfo(DateTime shiftDate, ShiftType? shiftType)
    {
        var type = shiftType ?? ShiftType.Morning;
        var (startTime, endTime) = type switch
        {
            ShiftType.Morning => (new TimeSpan(8, 0, 0), new TimeSpan(16, 0, 0)),
            ShiftType.Afternoon => (new TimeSpan(16, 0, 0), new TimeSpan(0, 0, 0)),
            ShiftType.Night => (new TimeSpan(0, 0, 0), new TimeSpan(8, 0, 0)),
            _ => (new TimeSpan(8, 0, 0), new TimeSpan(16, 0, 0))
        };

        return new ShiftInfo
        {
            ShiftId = Guid.NewGuid(),
            ShiftDate = shiftDate,
            ShiftType = type,
            ShiftName = $"{type}班",
            StartTime = startTime,
            EndTime = endTime,
            Operators = new[] { "操作员A", "操作员B" },
            Supervisor = "主管A"
        };
    }

    /// <summary>
    /// 生成按小时分组的班次统计。
    /// </summary>
    private Dictionary<int, HourlyShiftStatistics> GenerateHourlyShiftStatistics(ShiftInfo shiftInfo, int actualProduction, int qualifiedCount)
    {
        var hourlyStats = new Dictionary<int, HourlyShiftStatistics>();
        var random = new Random();
        var startHour = (int)shiftInfo.StartTime.TotalHours;
        var endHour = (int)shiftInfo.EndTime.TotalHours;

        for (int hour = startHour; hour < endHour; hour++)
        {
            var hourProduction = random.Next(5, 15);
            var hourQualified = (int)(hourProduction * (0.9 + random.NextDouble() * 0.08));

            hourlyStats[hour] = new HourlyShiftStatistics
            {
                Hour = hour,
                ProductionCount = hourProduction,
                QualifiedCount = hourQualified,
                EquipmentRunningMinutes = 50 + random.NextDouble() * 10,
                EquipmentDowntimeMinutes = random.NextDouble() * 5
            };
        }

        return hourlyStats;
    }

    /// <summary>
    /// 生成按产品类型分组的班次统计。
    /// </summary>
    private Dictionary<string, ProductTypeShiftStatistics> GenerateProductTypeShiftStatistics(string? productTypeCode, int actualProduction, int qualifiedCount, double avgCycleTime)
    {
        return new Dictionary<string, ProductTypeShiftStatistics>
        {
            [productTypeCode ?? "default"] = new ProductTypeShiftStatistics
            {
                ProductTypeCode = productTypeCode ?? "default",
                ProductionCount = actualProduction,
                QualifiedCount = qualifiedCount,
                AverageCycleTimeSeconds = avgCycleTime
            }
        };
    }

    /// <summary>
    /// 生成班次异常统计。
    /// </summary>
    private ShiftAnomalyStatistics GenerateShiftAnomalyStatistics(Random random)
    {
        var totalAnomalies = random.Next(0, 10);
        
        return new ShiftAnomalyStatistics
        {
            TotalAnomalyCount = totalAnomalies,
            EquipmentFailureCount = random.Next(0, totalAnomalies / 2),
            QualityAnomalyCount = random.Next(0, totalAnomalies / 2),
            ProcessAnomalyCount = random.Next(0, totalAnomalies / 2),
            DowntimeMinutes = random.NextDouble() * 30,
            AnomalyRate = totalAnomalies > 0 ? random.NextDouble() * 5 : 0.0
        };
    }

    /// <summary>
    /// 生成时间段效率。
    /// </summary>
    private Dictionary<DateTime, TimeSlotEfficiency> GenerateTimeSlotEfficiency(DateTime startTime, DateTime endTime, int actualProduction, int qualifiedCount, double equipmentHours)
    {
        var timeSlotEfficiency = new Dictionary<DateTime, TimeSlotEfficiency>();
        var random = new Random();
        var current = startTime;

        while (current < endTime)
        {
            var slotProduction = random.Next(5, 20);
            var slotQualified = (int)(slotProduction * (0.9 + random.NextDouble() * 0.08));
            var slotEfficiency = 0.7 + random.NextDouble() * 0.2;

            timeSlotEfficiency[current] = new TimeSlotEfficiency
            {
                TimeSlot = current,
                ProductionCount = slotProduction,
                QualifiedCount = slotQualified,
                EquipmentRunningMinutes = 50 + random.NextDouble() * 10,
                OverallEfficiency = slotEfficiency * 100
            };

            current = current.AddHours(1);
        }

        return timeSlotEfficiency;
    }

    /// <summary>
    /// 生成效率趋势分析。
    /// </summary>
    private EfficiencyTrend GenerateEfficiencyTrend()
    {
        var random = new Random();
        var direction = random.NextDouble() > 0.5 ? TrendDirection.Increasing : TrendDirection.Decreasing;
        var changeRate = random.NextDouble() * 8 - 4; // -4% to +4%

        return new EfficiencyTrend
        {
            Direction = direction,
            ChangeRatePercentage = changeRate,
            TrendDescription = $"效率呈{direction}趋势，变化率{changeRate:F2}%",
            PredictedNextEfficiency = 75 + random.NextDouble() * 15,
            Confidence = 0.6 + random.NextDouble() * 0.3
        };
    }

    /// <summary>
    /// 生成效率基准对比。
    /// </summary>
    private EfficiencyBenchmark GenerateEfficiencyBenchmark()
    {
        var random = new Random();

        return new EfficiencyBenchmark
        {
            HistoricalBestEfficiency = 85 + random.NextDouble() * 10,
            HistoricalAverageEfficiency = 75 + random.NextDouble() * 8,
            IndustryBenchmarkEfficiency = 80 + random.NextDouble() * 10,
            TargetEfficiency = 82 + random.NextDouble() * 8
        };
    }

    /// <summary>
    /// 生成缺陷统计。
    /// </summary>
    private Dictionary<DefectType, DefectStatistics> GenerateDefectStatistics(int totalDefects)
    {
        var random = new Random();
        var defectStats = new Dictionary<DefectType, DefectStatistics>();

        var defectTypes = new[] { DefectType.Appearance, DefectType.Dimension, DefectType.Function, DefectType.Material, DefectType.Process };
        var remainingDefects = totalDefects;

        foreach (var defectType in defectTypes)
        {
            if (remainingDefects <= 0) break;

            var count = random.Next(0, remainingDefects / 2 + 1);
            remainingDefects -= count;

            defectStats[defectType] = new DefectStatistics
            {
                DefectType = defectType,
                DefectCount = count,
                Percentage = totalDefects > 0 ? (double)count / totalDefects * 100 : 0,
                AverageSeverity = 1 + random.NextDouble() * 2
            };
        }

        return defectStats;
    }

    /// <summary>
    /// 生成严重程度统计。
    /// </summary>
    private Dictionary<DefectSeverity, SeverityStatistics> GenerateSeverityStatistics(int totalDefects)
    {
        var random = new Random();
        var severityStats = new Dictionary<DefectSeverity, SeverityStatistics>();

        var severities = new[] { DefectSeverity.Minor, DefectSeverity.Normal, DefectSeverity.Serious, DefectSeverity.Critical };
        var remainingDefects = totalDefects;

        foreach (var severity in severities)
        {
            if (remainingDefects <= 0) break;

            var count = random.Next(0, remainingDefects / 2 + 1);
            remainingDefects -= count;

            severityStats[severity] = new SeverityStatistics
            {
                Severity = severity,
                DefectCount = count,
                Percentage = totalDefects > 0 ? (double)count / totalDefects * 100 : 0
            };
        }

        return severityStats;
    }

    /// <summary>
    /// 生成按产品类型分组的质量统计。
    /// </summary>
    private Dictionary<string, ProductTypeQualityStatistics> GenerateProductTypeQualityStatistics(string? productTypeCode, int totalInspection, int qualifiedCount)
    {
        return new Dictionary<string, ProductTypeQualityStatistics>
        {
            [productTypeCode ?? "default"] = new ProductTypeQualityStatistics
            {
                ProductTypeCode = productTypeCode ?? "default",
                InspectionCount = totalInspection,
                QualifiedCount = qualifiedCount
            }
        };
    }

    /// <summary>
    /// 生成按检测时间的质量统计。
    /// </summary>
    private Dictionary<DateTime, QualityTimeSlotStatistics> GenerateQualityTimeSlotStatistics(DateTime startTime, DateTime endTime, int totalInspection, int qualifiedCount)
    {
        var timeSlotStats = new Dictionary<DateTime, QualityTimeSlotStatistics>();
        var random = new Random();
        var current = startTime;

        while (current < endTime)
        {
            var slotInspection = random.Next(10, 30);
            var slotQualified = (int)(slotInspection * (0.9 + random.NextDouble() * 0.08));

            timeSlotStats[current] = new QualityTimeSlotStatistics
            {
                InspectionTime = current,
                InspectionCount = slotInspection,
                QualifiedCount = slotQualified
            };

            current = current.AddHours(2);
        }

        return timeSlotStats;
    }

    /// <summary>
    /// 生成质量趋势分析。
    /// </summary>
    private QualityTrend GenerateQualityTrend()
    {
        var random = new Random();
        var direction = random.NextDouble() > 0.3 ? TrendDirection.Stable : (random.NextDouble() > 0.5 ? TrendDirection.Increasing : TrendDirection.Decreasing);
        var changeRate = random.NextDouble() * 6 - 3; // -3% to +3%

        return new QualityTrend
        {
            Direction = direction,
            ChangeRatePercentage = changeRate,
            TrendDescription = $"质量呈{direction}趋势，变化率{changeRate:F2}%",
            PredictedNextPassRate = 92 + random.NextDouble() * 6,
            Confidence = 0.7 + random.NextDouble() * 0.2
        };
    }

    /// <summary>
    /// 生成质量改进建议。
    /// </summary>
    private IReadOnlyList<QualityImprovementSuggestion> GenerateQualityImprovementSuggestions()
    {
        var random = new Random();
        var suggestions = new List<QualityImprovementSuggestion>();

        var suggestionTypes = new[] { SuggestionType.ProcessImprovement, SuggestionType.EquipmentMaintenance, SuggestionType.OperatorTraining };
        var difficulties = new[] { ImplementationDifficulty.Easy, ImplementationDifficulty.Medium, ImplementationDifficulty.Difficult };

        foreach (var type in suggestionTypes.Take(2))
        {
            suggestions.Add(new QualityImprovementSuggestion
            {
                SuggestionId = Guid.NewGuid(),
                SuggestionType = type,
                Title = $"{type}建议",
                Description = $"通过{type}提升产品质量",
                Priority = random.Next(1, 5),
                ExpectedImpact = "预计提升合格率2-5%",
                Difficulty = difficulties[random.Next(difficulties.Length)]
            });
        }

        return suggestions.AsReadOnly();
    }

    /// <summary>
    /// 生成按日期分组的利用率统计。
    /// </summary>
    private Dictionary<DateTime, DailyUtilizationStatistics> GenerateDailyUtilizationStatistics(DateTime startTime, DateTime endTime, double plannedHours, double actualHours)
    {
        var dailyStats = new Dictionary<DateTime, DailyUtilizationStatistics>();
        var random = new Random();
        var current = startTime.Date;

        while (current <= endTime.Date)
        {
            dailyStats[current] = new DailyUtilizationStatistics
            {
                Date = current,
                PlannedRunningHours = 24,
                ActualRunningHours = 20 + random.NextDouble() * 4
            };

            current = current.AddDays(1);
        }

        return dailyStats;
    }

    /// <summary>
    /// 生成利用率趋势分析。
    /// </summary>
    private UtilizationTrend GenerateUtilizationTrend()
    {
        var random = new Random();
        var direction = random.NextDouble() > 0.4 ? TrendDirection.Stable : TrendDirection.Fluctuating;
        var changeRate = random.NextDouble() * 4 - 2; // -2% to +2%

        return new UtilizationTrend
        {
            Direction = direction,
            ChangeRatePercentage = changeRate,
            TrendDescription = $"设备利用率呈{direction}趋势，变化率{changeRate:F2}%",
            PredictedNextUtilization = 80 + random.NextDouble() * 15,
            Confidence = 0.6 + random.NextDouble() * 0.3
        };
    }

    /// <summary>
    /// 生成维护建议。
    /// </summary>
    private IReadOnlyList<MaintenanceSuggestion> GenerateMaintenanceSuggestions()
    {
        var random = new Random();
        var suggestions = new List<MaintenanceSuggestion>();

        var maintenanceTypes = new[] { MaintenanceType.Preventive, MaintenanceType.Predictive, MaintenanceType.Corrective };

        foreach (var type in maintenanceTypes.Take(2))
        {
            suggestions.Add(new MaintenanceSuggestion
            {
                SuggestionId = Guid.NewGuid(),
                MaintenanceType = type,
                Title = $"{type}维护建议",
                Description = $"建议进行{type}维护",
                Priority = random.Next(1, 5),
                EstimatedMaintenanceHours = 2 + random.NextDouble() * 4,
                EstimatedCost = 1000 + random.NextDouble() * 3000,
                SuggestedMaintenanceTime = DateTime.UtcNow.AddDays(random.Next(1, 7))
            });
        }

        return suggestions.AsReadOnly();
    }

    /// <summary>
    /// 生成报警趋势分析。
    /// </summary>
    private AlarmTrend GenerateAlarmTrend()
    {
        var random = new Random();
        var direction = random.NextDouble() > 0.6 ? TrendDirection.Stable : (random.NextDouble() > 0.5 ? TrendDirection.Increasing : TrendDirection.Decreasing);
        var changeRate = random.NextDouble() * 15 - 7.5; // -7.5% to +7.5%

        return new AlarmTrend
        {
            Direction = direction,
            ChangeRatePercentage = changeRate,
            TrendDescription = $"报警数量呈{direction}趋势，变化率{changeRate:F2}%",
            PredictedNextAlarmCount = random.Next(5, 25),
            Confidence = 0.5 + random.NextDouble() * 0.4
        };
    }

    /// <summary>
    /// 生成执行摘要。
    /// </summary>
    private ExecutiveSummary GenerateExecutiveSummary()
    {
        var random = new Random();

        return new ExecutiveSummary
        {
            OverallScore = 75 + random.NextDouble() * 15,
            KeyMetrics = new Dictionary<string, double>
            {
                ["生产完成率"] = 85 + random.NextDouble() * 10,
                ["质量合格率"] = 92 + random.NextDouble() * 6,
                ["设备利用率"] = 80 + random.NextDouble() * 15,
                ["OEE"] = 70 + random.NextDouble() * 20
            },
            Achievements = new[] { "生产效率提升5%", "质量指标达标" },
            Issues = new[] { "设备故障率偏高", "人员操作需优化" },
            SummaryDescription = "整体运行状况良好，部分指标需持续改进"
        };
    }

    /// <summary>
    /// 生成生产统计。
    /// </summary>
    private ProductionStatistics GenerateProductionStatistics()
    {
        var random = new Random();

        return new ProductionStatistics
        {
            PlannedProduction = 1000,
            ActualProduction = (int)(1000 * (0.88 + random.NextDouble() * 0.1)),
            QualifiedProduction = (int)(950 * (0.92 + random.NextDouble() * 0.06)),
            AverageCycleTimeSeconds = 55 + random.NextDouble() * 10
        };
    }

    /// <summary>
    /// 生成设备统计。
    /// </summary>
    private EquipmentStatistics GenerateEquipmentStatistics()
    {
        var random = new Random();

        return new EquipmentStatistics
        {
            EquipmentCount = 5,
            AverageUtilizationRate = 75 + random.NextDouble() * 15,
            AverageAvailabilityRate = 85 + random.NextDouble() * 10,
            TotalDowntimeHours = 2 + random.NextDouble() * 3
        };
    }

    /// <summary>
    /// 生成趋势分析。
    /// </summary>
    private TrendAnalysis GenerateTrendAnalysis()
    {
        var random = new Random();

        return new TrendAnalysis
        {
            ProductionTrend = TrendDirection.Stable,
            QualityTrend = TrendDirection.Increasing,
            EquipmentTrend = TrendDirection.Fluctuating,
            AlarmTrend = TrendDirection.Decreasing,
            TrendDescription = "生产稳定，质量提升，设备需关注"
        };
    }

    /// <summary>
    /// 生成改进建议。
    /// </summary>
    private IReadOnlyList<ImprovementRecommendation> GenerateImprovementRecommendations()
    {
        var random = new Random();
        var recommendations = new List<ImprovementRecommendation>();

        var categories = new[] { RecommendationCategory.ProductionOptimization, RecommendationCategory.QualityImprovement, RecommendationCategory.EquipmentMaintenance };

        foreach (var category in categories.Take(3))
        {
            recommendations.Add(new ImprovementRecommendation
            {
                RecommendationId = Guid.NewGuid(),
                Category = category,
                Title = $"{category}建议",
                Description = $"建议进行{category}改进",
                Priority = random.Next(1, 5),
                ExpectedBenefit = "预计提升效率3-8%",
                ImplementationCost = 5000 + random.NextDouble() * 10000,
                ReturnOnInvestment = 150 + random.NextDouble() * 100
            });
        }

        return recommendations.AsReadOnly();
    }

    /// <summary>
    /// 生成实时生产指标。
    /// </summary>
    private RealTimeProductionMetrics GenerateRealTimeProductionMetrics(Random random)
    {
        return new RealTimeProductionMetrics
        {
            CurrentHourProduction = random.Next(8, 15),
            CurrentShiftProduction = random.Next(80, 120),
            TodayProduction = random.Next(200, 300),
            CurrentCycleTimeSeconds = 50 + random.NextDouble() * 15,
            CycleTimeAchievementRate = 85 + random.NextDouble() * 10,
            ProductionSpeedTrend = TrendDirection.Stable
        };
    }

    /// <summary>
    /// 生成实时质量指标。
    /// </summary>
    private RealTimeQualityMetrics GenerateRealTimeQualityMetrics(Random random)
    {
        return new RealTimeQualityMetrics
        {
            CurrentHourPassRate = 92 + random.NextDouble() * 6,
            CurrentShiftPassRate = 93 + random.NextDouble() * 5,
            TodayPassRate = 94 + random.NextDouble() * 4,
            RecentDefectCount = random.Next(0, 5),
            QualityTrend = TrendDirection.Stable
        };
    }

    /// <summary>
    /// 生成实时设备指标。
    /// </summary>
    private RealTimeEquipmentMetrics GenerateRealTimeEquipmentMetrics(Random random)
    {
        return new RealTimeEquipmentMetrics
        {
            RunningEquipmentCount = 4,
            DownEquipmentCount = 1,
            CurrentUtilizationRate = 78 + random.NextDouble() * 12,
            CurrentAvailabilityRate = 88 + random.NextDouble() * 8,
            EquipmentStatusTrend = TrendDirection.Stable
        };
    }

    /// <summary>
    /// 生成实时报警指标。
    /// </summary>
    private RealTimeAlarmMetrics GenerateRealTimeAlarmMetrics(Random random)
    {
        return new RealTimeAlarmMetrics
        {
            ActiveAlarmCount = random.Next(0, 3),
            TodayNewAlarmCount = random.Next(5, 15),
            CriticalAlarmCount = random.Next(0, 2),
            LastAlarmTime = random.NextDouble() > 0.3 ? DateTime.UtcNow.AddMinutes(-random.Next(10, 120)) : null,
            AlarmTrend = TrendDirection.Stable
        };
    }

    /// <summary>
    /// 生成实时效率指标。
    /// </summary>
    private RealTimeEfficiencyMetrics GenerateRealTimeEfficiencyMetrics(Random random)
    {
        return new RealTimeEfficiencyMetrics
        {
            CurrentOEE = 72 + random.NextDouble() * 16,
            TimeUtilizationRate = 85 + random.NextDouble() * 10,
            EquipmentUtilizationRate = 80 + random.NextDouble() * 15,
            PerformanceEfficiency = 88 + random.NextDouble() * 8,
            EfficiencyTrend = TrendDirection.Stable
        };
    }

    /// <summary>
    /// 生成趋势数据点。
    /// </summary>
    private IReadOnlyList<TrendDataPoint> GenerateTrendDataPoints(MetricType metricType, DateTime startTime, DateTime endTime, StatisticsGranularity granularity, Random random)
    {
        var dataPoints = new List<TrendDataPoint>();
        var current = startTime;
        var interval = granularity switch
        {
            StatisticsGranularity.Minutely => TimeSpan.FromMinutes(1),
            StatisticsGranularity.Hourly => TimeSpan.FromHours(1),
            StatisticsGranularity.Daily => TimeSpan.FromDays(1),
            _ => TimeSpan.FromHours(1)
        };

        while (current <= endTime)
        {
            var value = GetMetricValue(metricType, random);
            
            dataPoints.Add(new TrendDataPoint
            {
                Timestamp = current,
                Value = value,
                Unit = GetMetricUnit(metricType)
            });

            current = current.Add(interval);
        }

        return dataPoints.AsReadOnly();
    }

    /// <summary>
    /// 获取指标值。
    /// </summary>
    private double GetMetricValue(MetricType metricType, Random random)
    {
        return metricType switch
        {
            MetricType.Production => 50 + random.NextDouble() * 30,
            MetricType.Quality => 90 + random.NextDouble() * 8,
            MetricType.EquipmentUtilization => 75 + random.NextDouble() * 20,
            MetricType.CycleTime => 45 + random.NextDouble() * 25,
            MetricType.OEE => 70 + random.NextDouble() * 20,
            MetricType.AlarmCount => random.NextDouble() * 10,
            MetricType.Downtime => random.NextDouble() * 5,
            MetricType.Efficiency => 80 + random.NextDouble() * 15,
            _ => random.NextDouble() * 100
        };
    }

    /// <summary>
    /// 获取指标单位。
    /// </summary>
    private string GetMetricUnit(MetricType metricType)
    {
        return metricType switch
        {
            MetricType.Production => "个",
            MetricType.Quality => "%",
            MetricType.EquipmentUtilization => "%",
            MetricType.CycleTime => "秒",
            MetricType.OEE => "%",
            MetricType.AlarmCount => "个",
            MetricType.Downtime => "小时",
            MetricType.Efficiency => "%",
            _ => ""
        };
    }

    /// <summary>
    /// 生成趋势统计摘要。
    /// </summary>
    private TrendStatisticsSummary GenerateTrendStatisticsSummary(IReadOnlyList<TrendDataPoint> dataPoints)
    {
        if (!dataPoints.Any())
        {
            return new TrendStatisticsSummary();
        }

        var values = dataPoints.Select(dp => dp.Value).ToList();
        var sortedValues = values.OrderBy(v => v).ToList();

        return new TrendStatisticsSummary
        {
            DataPointCount = dataPoints.Count,
            MinValue = sortedValues.First(),
            MaxValue = sortedValues.Last(),
            AverageValue = values.Average(),
            MedianValue = sortedValues[sortedValues.Count / 2],
            StandardDeviation = CalculateStandardDeviation(values)
        };
    }

    /// <summary>
    /// 生成导出文件内容。
    /// </summary>
    private string GenerateExportFileContent(StatisticsExportRequest exportRequest, int recordCount)
    {
        var random = new Random();
        var content = new System.Text.StringBuilder();

        // 简化处理：生成CSV格式内容
        content.AppendLine("ID,时间,数值,单位");
        
        for (int i = 0; i < recordCount; i++)
        {
            var timestamp = DateTime.UtcNow.AddMinutes(-random.Next(0, 1440));
            var value = random.NextDouble() * 100;
            var unit = "个";

            content.AppendLine($"{i + 1},{timestamp:yyyy-MM-dd HH:mm:ss},{value:F2},{unit}");
        }

        return content.ToString();
    }

    /// <summary>
    /// 获取当前班次类型。
    /// </summary>
    private ShiftType GetCurrentShiftType(DateTime dateTime)
    {
        var hour = dateTime.Hour;
        
        return hour switch
        {
            >= 8 and < 16 => ShiftType.Morning,
            >= 16 and < 24 => ShiftType.Afternoon,
            _ => ShiftType.Night
        };
    }

    #endregion
}

#endif

/// <summary>
/// 统计服务实现（最小可编译版本）。
/// </summary>
public sealed class StatisticsService : IStatisticsService
{
    private readonly ILogger<StatisticsService> _logger;

    public StatisticsService(ILogger<StatisticsService> logger, IOptions<RuntimeOptions> options)
    {
        _logger = logger;
    }

    public Task<Result<CycleTimeStatistics>> GetCycleTimeStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var data = new CycleTimeStatistics
        {
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            ProductTypeCode = productTypeCode ?? string.Empty,
            TotalProcessedCount = 0,
            SuccessfulProcessedCount = 0,
            FailedProcessedCount = 0,
            AverageCycleTimeSeconds = 0,
            MinCycleTimeSeconds = 0,
            MaxCycleTimeSeconds = 0,
            CycleTimeStandardDeviationSeconds = 0,
            TargetCycleTimeSeconds = 0,
            CountAchievedCycleTime = 0
        };

        return Task.FromResult(Result<CycleTimeStatistics>.Success(data));
    }

    public Task<Result<ShiftStatistics>> GetShiftStatisticsAsync(DateTime shiftDate, ShiftType? shiftType = null, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var actualShiftType = shiftType ?? ShiftType.Morning;
        var data = new ShiftStatistics
        {
            ShiftInfo = new ShiftInfo
            {
                ShiftId = Guid.NewGuid(),
                ShiftDate = shiftDate.Date,
                ShiftType = actualShiftType,
                ShiftName = actualShiftType.ToString(),
                StartTime = TimeSpan.Zero,
                EndTime = TimeSpan.FromHours(8)
            },
            ProductTypeCode = productTypeCode ?? string.Empty,
            PlannedProductionCount = 0,
            ActualProductionCount = 0,
            QualifiedProductionCount = 0,
            UnqualifiedProductionCount = 0,
            ShiftStartTimeUtc = shiftDate,
            ShiftEndTimeUtc = shiftDate.AddHours(8),
            ActualWorkingHours = 0,
            EquipmentDowntimeHours = 0,
            AverageCycleTimeSeconds = 0
        };

        return Task.FromResult(Result<ShiftStatistics>.Success(data));
    }

    public Task<Result<IReadOnlyList<ShiftInfo>>> GetShiftListAsync(DateTime startDate, DateTime endDate, CancellationToken cancellationToken = default)
    {
        IReadOnlyList<ShiftInfo> data = Array.Empty<ShiftInfo>();
        return Task.FromResult(Result<IReadOnlyList<ShiftInfo>>.Success(data));
    }

    public Task<Result<ProductionEfficiencyStatistics>> GetProductionEfficiencyStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, StatisticsGranularity granularity = StatisticsGranularity.Hourly, CancellationToken cancellationToken = default)
    {
        var data = new ProductionEfficiencyStatistics
        {
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            ProductTypeCode = productTypeCode ?? string.Empty,
            Granularity = granularity,
            PlannedWorkingHours = 0,
            ActualWorkingHours = 0,
            EquipmentRunningHours = 0,
            PlannedProductionCount = 0,
            ActualProductionCount = 0,
            QualifiedProductionCount = 0
        };

        return Task.FromResult(Result<ProductionEfficiencyStatistics>.Success(data));
    }

    public Task<Result<QualityStatistics>> GetQualityStatisticsAsync(DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var data = new QualityStatistics
        {
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            ProductTypeCode = productTypeCode ?? string.Empty,
            TotalInspectionCount = 0,
            QualifiedCount = 0,
            UnqualifiedCount = 0
        };

        return Task.FromResult(Result<QualityStatistics>.Success(data));
    }

    public Task<Result<EquipmentUtilizationStatistics>> GetEquipmentUtilizationStatisticsAsync(DateTime startTime, DateTime endTime, string? equipmentId = null, CancellationToken cancellationToken = default)
    {
        var data = new EquipmentUtilizationStatistics
        {
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            EquipmentId = equipmentId ?? string.Empty,
            PlannedRunningHours = 0,
            ActualRunningHours = 0,
            ProductionHours = 0,
            MaintenanceHours = 0,
            FailureHours = 0,
            IdleHours = 0
        };

        return Task.FromResult(Result<EquipmentUtilizationStatistics>.Success(data));
    }

    public Task<Result<AlarmStatisticsSummary>> GetAlarmStatisticsSummaryAsync(DateTime startTime, DateTime endTime, OrpaonVision.Core.Common.AlarmLevel? alarmLevel = null, CancellationToken cancellationToken = default)
    {
        var data = new AlarmStatisticsSummary
        {
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            TotalAlarmCount = 0,
            ActiveAlarmCount = 0,
            ConfirmedAlarmCount = 0,
            ClearedAlarmCount = 0
        };

        return Task.FromResult(Result<AlarmStatisticsSummary>.Success(data));
    }

    public Task<Result<ComprehensiveProductionReport>> GetComprehensiveProductionReportAsync(OrpaonVision.Core.Statistics.ProductionReportType reportType, DateTime startTime, DateTime endTime, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var data = new ComprehensiveProductionReport
        {
            ReportId = Guid.NewGuid(),
            ReportType = reportType,
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            ProductTypeCode = productTypeCode ?? string.Empty,
            GeneratedAtUtc = DateTime.UtcNow
        };

        return Task.FromResult(Result<ComprehensiveProductionReport>.Success(data));
    }

    public Task<Result<RealTimeStatisticsDashboard>> GetRealTimeStatisticsDashboardAsync(string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var data = new RealTimeStatisticsDashboard
        {
            ProductTypeCode = productTypeCode ?? string.Empty,
            LastUpdatedUtc = DateTime.UtcNow
        };

        return Task.FromResult(Result<RealTimeStatisticsDashboard>.Success(data));
    }

    public Task<Result<HistoricalTrendData>> GetHistoricalTrendDataAsync(MetricType metricType, DateTime startTime, DateTime endTime, string? productTypeCode = null, StatisticsGranularity granularity = StatisticsGranularity.Hourly, CancellationToken cancellationToken = default)
    {
        var data = new HistoricalTrendData
        {
            MetricType = metricType,
            TimeRange = new TimeRange { StartTimeUtc = startTime, EndTimeUtc = endTime },
            Granularity = granularity
        };

        return Task.FromResult(Result<HistoricalTrendData>.Success(data));
    }

    public Task<Result<StatisticsConfig>> CreateStatisticsConfigAsync(StatisticsConfig config, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Result<StatisticsConfig>.Success(config));
    }

    public Task<Result> UpdateStatisticsConfigAsync(StatisticsConfig config, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Result.Success());
    }

    public Task<Result<StatisticsConfig>> GetStatisticsConfigAsync(StatisticsConfigType configType, string? productTypeCode = null, CancellationToken cancellationToken = default)
    {
        var config = new StatisticsConfig
        {
            ConfigId = Guid.NewGuid(),
            ConfigType = configType,
            ProductTypeCode = productTypeCode ?? string.Empty,
            ConfigName = $"{configType}-default",
            IsEnabled = true,
            CreatedAtUtc = DateTime.UtcNow,
            UpdatedAtUtc = DateTime.UtcNow,
            Version = "1.0"
        };

        return Task.FromResult(Result<StatisticsConfig>.Success(config));
    }

    public Task<Result<StatisticsExportResult>> ExportStatisticsAsync(StatisticsExportRequest exportRequest, CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("统计导出请求: {RequestId}", exportRequest.RequestId);

        var result = new StatisticsExportResult
        {
            RequestId = exportRequest.RequestId,
            IsSuccess = true,
            FilePath = string.Empty,
            FileSizeBytes = 0,
            RecordCount = 0,
            ExportElapsedMs = 0,
            ExportTimeUtc = DateTime.UtcNow,
            ResultDescription = "OK"
        };

        return Task.FromResult(Result<StatisticsExportResult>.Success(result));
    }
}