using Microsoft.Extensions.Logging;
using OrpaonVision.Core.Results;
using OrpaonVision.Core.Training;
using OrpaonVision.Core.Training.Contracts;
using System.IO;
using System.IO.Compression;
using System.Text.Json;
using System.Text.Json.Schema;

namespace OrpaonVision.ConfigApp.Infrastructure.Services;

/// <summary>
/// 规则校验服务实现。
/// </summary>
public class RuleValidationService : IRuleValidationService
{
    private readonly ILogger<RuleValidationService> _logger;

    /// <summary>
    /// 初始化规则校验服务。
    /// </summary>
    /// <param name="logger">日志记录器。</param>
    public RuleValidationService(ILogger<RuleValidationService> logger)
    {
        _logger = logger;
    }

    /// <summary>
    /// 校验规则快照包。
    /// </summary>
    public async Task<Result<RuleSnapshotValidationResultDto>> ValidateRuleSnapshotPackageAsync(
        string packagePath,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("开始校验规则快照包: {PackagePath}", packagePath);

            if (!File.Exists(packagePath))
            {
                return Result<RuleSnapshotValidationResultDto>.Fail("PACKAGE_NOT_FOUND", "规则快照包文件不存在。");
            }

            var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
            Directory.CreateDirectory(tempDir);

            try
            {
                // 解压包文件
                ZipFile.ExtractToDirectory(packagePath, tempDir);

                // 校验各个部分
                var layerOrderResult = await ValidateLayerOrderInPackageAsync(tempDir, cancellationToken);
                var partCodeResult = await ValidatePartCodeUniquenessInPackageAsync(tempDir, cancellationToken);
                var schemaResult = await ValidateSchemaInPackageAsync(tempDir, cancellationToken);

                var validationResult = new RuleSnapshotValidationResultDto
                {
                    IsValid = layerOrderResult.Succeeded && layerOrderResult.Data!.IsValid &&
                              partCodeResult.Succeeded && partCodeResult.Data!.IsValid &&
                              schemaResult.Succeeded && schemaResult.Data!.IsValid,
                    Errors = CombineErrors(layerOrderResult, partCodeResult, schemaResult),
                    Warnings = CombineWarnings(layerOrderResult, partCodeResult, schemaResult),
                    LayerOrderValidation = layerOrderResult.Data ?? new LayerOrderValidationResultDto(),
                    PartCodeUniquenessValidation = partCodeResult.Data ?? new PartCodeUniquenessValidationResultDto(),
                    SchemaValidation = schemaResult.Data ?? new SchemaValidationResultDto()
                };

                _logger.LogInformation("规则快照包校验完成: {PackagePath}, IsValid: {IsValid}", 
                    packagePath, validationResult.IsValid);

                return Result<RuleSnapshotValidationResultDto>.Success(validationResult);
            }
            finally
            {
                // 清理临时目录
                if (Directory.Exists(tempDir))
                {
                    Directory.Delete(tempDir, true);
                }
            }
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "校验规则快照包失败。TraceId: {TraceId}", traceId);
            return Result<RuleSnapshotValidationResultDto>.FailWithTrace(
                "VALIDATE_PACKAGE_FAILED", "校验规则快照包失败。", traceId, ex.Message);
        }
    }

    /// <summary>
    /// 校验层顺序。
    /// </summary>
    public async Task<Result<LayerOrderValidationResultDto>> ValidateLayerOrderAsync(
        string[] layerOrderData,
        string[] expectedOrder,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("开始校验层顺序");

            var errors = new List<string>();
            var isValid = true;

            // 检查层顺序是否匹配
            if (layerOrderData.Length != expectedOrder.Length)
            {
                errors.Add($"层数量不匹配，期望: {expectedOrder.Length}，实际: {layerOrderData.Length}");
                isValid = false;
            }

            for (int i = 0; i < Math.Min(layerOrderData.Length, expectedOrder.Length); i++)
            {
                if (layerOrderData[i] != expectedOrder[i])
                {
                    errors.Add($"第 {i + 1} 层不匹配，期望: {expectedOrder[i]}，实际: {layerOrderData[i]}");
                    isValid = false;
                }
            }

            var result = new LayerOrderValidationResultDto
            {
                IsValid = isValid,
                Errors = errors.ToArray(),
                ActualLayerOrder = layerOrderData,
                ExpectedLayerOrder = expectedOrder
            };

            _logger.LogInformation("层顺序校验完成: IsValid: {IsValid}", isValid);
            return Result<LayerOrderValidationResultDto>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "校验层顺序失败。TraceId: {TraceId}", traceId);
            return Result<LayerOrderValidationResultDto>.FailWithTrace(
                "VALIDATE_LAYER_ORDER_FAILED", "校验层顺序失败。", traceId, ex.Message);
        }
    }

    /// <summary>
    /// 校验部件编码唯一性。
    /// </summary>
    public async Task<Result<PartCodeUniquenessValidationResultDto>> ValidatePartCodeUniquenessAsync(
        string[] partCodes,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("开始校验部件编码唯一性");

            var errors = new List<string>();
            var duplicateCodes = partCodes
                .GroupBy(code => code)
                .Where(group => group.Count() > 1)
                .Select(group => group.Key)
                .ToArray();

            var isValid = duplicateCodes.Length == 0;

            if (!isValid)
            {
                errors.AddRange(duplicateCodes.Select(code => $"部件编码 '{code}' 重复出现"));
            }

            var result = new PartCodeUniquenessValidationResultDto
            {
                IsValid = isValid,
                Errors = errors.ToArray(),
                DuplicatePartCodes = duplicateCodes,
                AllPartCodes = partCodes
            };

            _logger.LogInformation("部件编码唯一性校验完成: IsValid: {IsValid}, DuplicateCount: {DuplicateCount}", 
                isValid, duplicateCodes.Length);

            return Result<PartCodeUniquenessValidationResultDto>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "校验部件编码唯一性失败。TraceId: {TraceId}", traceId);
            return Result<PartCodeUniquenessValidationResultDto>.FailWithTrace(
                "VALIDATE_PART_CODE_FAILED", "校验部件编码唯一性失败。", traceId, ex.Message);
        }
    }

    /// <summary>
    /// 校验Schema合法性。
    /// </summary>
    public async Task<Result<SchemaValidationResultDto>> ValidateSchemaAsync(
        string[] schemaFiles,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("开始校验Schema合法性");

            var errors = new List<string>();
            var warnings = new List<string>();
            var validatedFiles = new List<string>();
            var isValid = true;

            foreach (var schemaFile in schemaFiles)
            {
                if (!File.Exists(schemaFile))
                {
                    errors.Add($"Schema文件不存在: {schemaFile}");
                    isValid = false;
                    continue;
                }

                try
                {
                    var schemaContent = await File.ReadAllTextAsync(schemaFile, cancellationToken);
                    
                    // 简单的JSON Schema校验
                    if (!IsValidJson(schemaContent))
                    {
                        errors.Add($"Schema文件格式无效: {schemaFile}");
                        isValid = false;
                    }
                    else
                    {
                        validatedFiles.Add(schemaFile);
                    }
                }
                catch (Exception ex)
                {
                    errors.Add($"读取Schema文件失败: {schemaFile}, 错误: {ex.Message}");
                    isValid = false;
                }
            }

            var result = new SchemaValidationResultDto
            {
                IsValid = isValid,
                Errors = errors.ToArray(),
                Warnings = warnings.ToArray(),
                SchemaVersion = "1.0", // 可以从配置中读取
                ValidatedFiles = validatedFiles.ToArray()
            };

            _logger.LogInformation("Schema合法性校验完成: IsValid: {IsValid}, ValidatedFileCount: {ValidatedFileCount}", 
                isValid, validatedFiles.Count);

            return Result<SchemaValidationResultDto>.Success(result);
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "校验Schema合法性失败。TraceId: {TraceId}", traceId);
            return Result<SchemaValidationResultDto>.FailWithTrace(
                "VALIDATE_SCHEMA_FAILED", "校验Schema合法性失败。", traceId, ex.Message);
        }
    }

    #region 辅助方法

    /// <summary>
    /// 在包中校验层顺序。
    /// </summary>
    private async Task<Result<LayerOrderValidationResultDto>> ValidateLayerOrderInPackageAsync(
        string packageDir,
        CancellationToken cancellationToken)
    {
        var layerOrderFile = Path.Combine(packageDir, "rules", "layer-order.json");
        
        if (!File.Exists(layerOrderFile))
        {
            return Result<LayerOrderValidationResultDto>.Fail("LAYER_ORDER_FILE_NOT_FOUND", "层顺序配置文件不存在。");
        }

        try
        {
            var layerOrderContent = await File.ReadAllTextAsync(layerOrderFile, cancellationToken);
            var layerOrderData = JsonSerializer.Deserialize<string[]>(layerOrderContent) ?? Array.Empty<string>();
            
            // 默认期望的层顺序 - 可以从配置中读取
            var expectedOrder = new[] { "background", "foreground", "defect", "annotation" };

            return await ValidateLayerOrderAsync(layerOrderData, expectedOrder, cancellationToken);
        }
        catch (Exception ex)
        {
            return Result<LayerOrderValidationResultDto>.Fail("PARSE_LAYER_ORDER_FAILED", $"解析层顺序配置失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 在包中校验部件编码唯一性。
    /// </summary>
    private async Task<Result<PartCodeUniquenessValidationResultDto>> ValidatePartCodeUniquenessInPackageAsync(
        string packageDir,
        CancellationToken cancellationToken)
    {
        var partsFile = Path.Combine(packageDir, "rules", "parts.json");
        
        if (!File.Exists(partsFile))
        {
            return Result<PartCodeUniquenessValidationResultDto>.Fail("PARTS_FILE_NOT_FOUND", "部件配置文件不存在。");
        }

        try
        {
            var partsContent = await File.ReadAllTextAsync(partsFile, cancellationToken);
            var partsData = JsonSerializer.Deserialize<JsonElement>(partsContent);
            
            var partCodes = new List<string>();
            if (partsData.ValueKind == JsonValueKind.Array)
            {
                foreach (var part in partsData.EnumerateArray())
                {
                    if (part.TryGetProperty("code", out var codeProperty))
                    {
                        partCodes.Add(codeProperty.GetString() ?? string.Empty);
                    }
                }
            }

            return await ValidatePartCodeUniquenessAsync(partCodes.ToArray(), cancellationToken);
        }
        catch (Exception ex)
        {
            return Result<PartCodeUniquenessValidationResultDto>.Fail("PARSE_PARTS_FAILED", $"解析部件配置失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 在包中校验Schema。
    /// </summary>
    private async Task<Result<SchemaValidationResultDto>> ValidateSchemaInPackageAsync(
        string packageDir,
        CancellationToken cancellationToken)
    {
        var schemaDir = Path.Combine(packageDir, "schema");
        
        if (!Directory.Exists(schemaDir))
        {
            return Result<SchemaValidationResultDto>.Fail("SCHEMA_DIR_NOT_FOUND", "Schema目录不存在。");
        }

        var schemaFiles = Directory.GetFiles(schemaDir, "*.json", SearchOption.AllDirectories);
        return await ValidateSchemaAsync(schemaFiles, cancellationToken);
    }

    /// <summary>
    /// 检查是否为有效的JSON。
    /// </summary>
    private static bool IsValidJson(string jsonString)
    {
        try
        {
            JsonDocument.Parse(jsonString);
            return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 合并错误信息。
    /// </summary>
    private static string[] CombineErrors(
        Result<LayerOrderValidationResultDto> layerOrderResult,
        Result<PartCodeUniquenessValidationResultDto> partCodeResult,
        Result<SchemaValidationResultDto> schemaResult)
    {
        var errors = new List<string>();

        if (!layerOrderResult.Succeeded)
        {
            errors.Add($"层顺序校验失败: {layerOrderResult.Message}");
        }
        else if (layerOrderResult.Data?.Errors.Length > 0)
        {
            errors.AddRange(layerOrderResult.Data.Errors);
        }

        if (!partCodeResult.Succeeded)
        {
            errors.Add($"部件编码校验失败: {partCodeResult.Message}");
        }
        else if (partCodeResult.Data?.Errors.Length > 0)
        {
            errors.AddRange(partCodeResult.Data.Errors);
        }

        if (!schemaResult.Succeeded)
        {
            errors.Add($"Schema校验失败: {schemaResult.Message}");
        }
        else if (schemaResult.Data?.Errors.Length > 0)
        {
            errors.AddRange(schemaResult.Data.Errors);
        }

        return errors.ToArray();
    }

    /// <summary>
    /// 合并警告信息。
    /// </summary>
    private static string[] CombineWarnings(
        Result<LayerOrderValidationResultDto> layerOrderResult,
        Result<PartCodeUniquenessValidationResultDto> partCodeResult,
        Result<SchemaValidationResultDto> schemaResult)
    {
        var warnings = new List<string>();

        if (layerOrderResult.Succeeded && layerOrderResult.Data != null)
        {
            // 层顺序校验通常没有警告
        }

        if (partCodeResult.Succeeded && partCodeResult.Data != null)
        {
            // 部件编码校验通常没有警告
        }

        if (schemaResult.Succeeded && schemaResult.Data?.Warnings.Length > 0)
        {
            warnings.AddRange(schemaResult.Data.Warnings);
        }

        return warnings.ToArray();
    }

    #endregion
}