using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using CloudPrint.Client.Helpers;
using CloudPrint.Client.Models;
using CloudPrint.Client.Services.Abstractions;
using SharpCompress.Common;
using SharpCompress.Readers;

namespace CloudPrint.Client.Services;

/// <summary>
/// 文件处理服务：校验白名单、管理本地文库副本、解压压缩包、转换 Office/TXT 并处理 PDF 页码范围。
/// </summary>
public sealed class FileService : IFileService
{
    private const int MaxArchiveEntries = 512;
    private const int MaxArchiveNestingDepth = 3;
    private const long MaxExtractedFileSizeBytes = 200L * 1024 * 1024;

    private static readonly HashSet<string> SupportedExtensionSet = new(StringComparer.OrdinalIgnoreCase)
    {
        ".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx",
        ".jpg", ".jpeg", ".png", ".bmp", ".gif", ".zip", ".rar"
    };

    private readonly PdfProcessor _pdfProcessor;

    public FileService()
        : this(new PdfProcessor())
    {
    }

    public FileService(PdfProcessor pdfProcessor)
    {
        _pdfProcessor = pdfProcessor;
    }

    public long MaxFileSizeBytes { get; } = 50L * 1024 * 1024;

    public IReadOnlyCollection<string> SupportedExtensions => SupportedExtensionSet;

    public bool IsSupported(string path)
    {
        return SupportedExtensionSet.Contains(Path.GetExtension(path));
    }

    public FileValidationResult ValidateFile(string path, long? maxFileSizeBytes = null)
    {
        if (string.IsNullOrWhiteSpace(path))
        {
            return FileValidationResult.Failure("文件路径不能为空");
        }

        if (!File.Exists(path))
        {
            return FileValidationResult.Failure("文件不存在");
        }

        if (!IsSupported(path))
        {
            return FileValidationResult.Failure($"不支持的文件类型：{Path.GetExtension(path)}");
        }

        var fileInfo = new FileInfo(path);
        var limit = maxFileSizeBytes ?? MaxFileSizeBytes;
        if (fileInfo.Length > limit)
        {
            return FileValidationResult.Failure($"文件超过大小限制：{FormatSize(limit)}");
        }

        return FileValidationResult.Success();
    }

    public CloudPrintDocument CreateLocalDocument(string path)
    {
        var validation = ValidateFile(path);
        if (!validation.IsValid)
        {
            throw new InvalidOperationException(validation.Message);
        }

        var fileInfo = new FileInfo(path);
        return new CloudPrintDocument
        {
            Id = Environment.TickCount,
            FileName = fileInfo.Name,
            FilePath = fileInfo.FullName,
            FileType = fileInfo.Extension.TrimStart('.').ToLowerInvariant(),
            FileSize = fileInfo.Length,
            Title = Path.GetFileNameWithoutExtension(fileInfo.Name),
            Description = "本地文库待上传文件",
            CategoryName = "未分类",
            CreatedAt = DateTime.Now
        };
    }

    public CloudPrintDocument CopyToLibrary(string sourcePath, string libraryRoot, string categoryName, int categoryId = 0)
    {
        var document = CreateLocalDocument(sourcePath);
        var safeCategoryName = PathHelper.SanitizePathSegment(string.IsNullOrWhiteSpace(categoryName) ? "未分类" : categoryName);
        var root = string.IsNullOrWhiteSpace(libraryRoot)
            ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "CloudPrintLibrary")
            : libraryRoot;

        var targetDirectory = Path.Combine(root, safeCategoryName);
        Directory.CreateDirectory(targetDirectory);

        var targetPath = PathHelper.CreateUniqueFilePath(targetDirectory, document.FileName);
        File.Copy(sourcePath, targetPath);

        var copiedFileInfo = new FileInfo(targetPath);
        return new CloudPrintDocument
        {
            Id = Environment.TickCount,
            FileName = copiedFileInfo.Name,
            FilePath = copiedFileInfo.FullName,
            FileType = copiedFileInfo.Extension.TrimStart('.').ToLowerInvariant(),
            FileSize = copiedFileInfo.Length,
            Title = document.Title,
            Description = document.Description,
            CategoryName = categoryName,
            CategoryId = categoryId,
            SyncStatus = "本地",
            CreatedAt = DateTime.Now
        };
    }

    public string PrepareForPrint(PrintJob job)
    {
        ArgumentNullException.ThrowIfNull(job);

        if (string.IsNullOrWhiteSpace(job.FilePath))
        {
            return string.Empty;
        }

        var extension = Path.GetExtension(job.FilePath).ToLowerInvariant();
        return extension switch
        {
            ".pdf" => job.FilePath,
            ".jpg" or ".jpeg" or ".png" or ".bmp" or ".gif" => job.FilePath,
            ".doc" or ".docx" or ".xls" or ".xlsx" or ".ppt" or ".pptx" or ".txt" => job.FilePath,
            ".zip" or ".rar" => job.FilePath,
            _ => job.FilePath
        };
    }

    public async Task<FilePreparationResult> PrepareForPrintAsync(PrintJob job, string cacheRoot, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(job);

        if (string.IsNullOrWhiteSpace(job.FilePath))
        {
            throw new InvalidOperationException("打印任务缺少文件路径");
        }

        if (!File.Exists(job.FilePath))
        {
            throw new FileNotFoundException("打印文件不存在", job.FilePath);
        }

        var root = string.IsNullOrWhiteSpace(cacheRoot)
            ? Path.Combine(Path.GetTempPath(), "CloudPrint.Client", "prepared")
            : cacheRoot;
        Directory.CreateDirectory(root);

        return await PreparePathAsync(job.FilePath, root, job.PageRange, 0, cancellationToken).ConfigureAwait(true);
    }

    private async Task<FilePreparationResult> PreparePathAsync(string sourcePath, string root, string pageRange, int archiveDepth, CancellationToken cancellationToken)
    {
        var extension = Path.GetExtension(sourcePath).ToLowerInvariant();

        if (IsPdf(extension))
        {
            return await PreparePdfAsync(sourcePath, root, pageRange, cancellationToken).ConfigureAwait(true);
        }

        if (IsImage(extension))
        {
            return new FilePreparationResult
            {
                SourcePath = sourcePath,
                PreparedPath = sourcePath,
                Converted = false,
                Message = "文件无需转换"
            };
        }

        if (extension is ".zip" or ".rar")
        {
            if (archiveDepth >= MaxArchiveNestingDepth)
            {
                throw new InvalidOperationException($"压缩包嵌套层级过深，最多允许 {MaxArchiveNestingDepth} 层");
            }

            var extractedPath = ExtractFirstPrintableFileFromArchive(sourcePath, root);
            return await PreparePathAsync(extractedPath, root, pageRange, archiveDepth + 1, cancellationToken).ConfigureAwait(true);
        }

        if (IsOfficeOrText(extension))
        {
            var pdfPath = await ConvertToPdfWithLibreOfficeAsync(sourcePath, root, cancellationToken).ConfigureAwait(true);
            var preparedPdf = await PreparePdfAsync(pdfPath, root, pageRange, cancellationToken).ConfigureAwait(true);
            return new FilePreparationResult
            {
                SourcePath = sourcePath,
                PreparedPath = preparedPdf.PreparedPath,
                Converted = true,
                Message = preparedPdf.PreparedPath == pdfPath ? "已转换为 PDF" : "已转换为 PDF 并裁剪页码范围"
            };
        }

        throw new NotSupportedException($"不支持的打印文件类型：{extension}");
    }

    private async Task<FilePreparationResult> PreparePdfAsync(string pdfPath, string root, string pageRange, CancellationToken cancellationToken)
    {
        var outputDirectory = Path.Combine(root, "pdf-pages", DateTime.Now.ToString("yyyyMMddHHmmssfff"));
        var preparedPath = await _pdfProcessor.ExtractPageRangeAsync(pdfPath, pageRange, outputDirectory, cancellationToken).ConfigureAwait(true);
        return new FilePreparationResult
        {
            SourcePath = pdfPath,
            PreparedPath = preparedPath,
            Converted = preparedPath != pdfPath,
            Message = preparedPath == pdfPath ? "PDF 文件无需转换" : $"已按页码范围裁剪：{pageRange}"
        };
    }

    private string ExtractFirstPrintableFileFromArchive(string archivePath, string root)
    {
        var extractDirectory = Path.Combine(root, PathHelper.SanitizePathSegment(Path.GetFileNameWithoutExtension(archivePath)), DateTime.Now.ToString("yyyyMMddHHmmssfff"));
        Directory.CreateDirectory(extractDirectory);

        using var stream = File.OpenRead(archivePath);
        using var reader = ReaderFactory.OpenReader(stream);
        var entryCount = 0;

        while (reader.MoveToNextEntry())
        {
            if (reader.Entry.IsDirectory)
            {
                continue;
            }

            entryCount++;
            if (entryCount > MaxArchiveEntries)
            {
                throw new InvalidOperationException($"压缩包条目过多，最多允许 {MaxArchiveEntries} 个文件");
            }

            if (!IsPrintableArchiveEntry(reader.Entry))
            {
                continue;
            }

            if (reader.Entry.Size > MaxExtractedFileSizeBytes)
            {
                throw new InvalidOperationException($"压缩包内文件超过解压大小限制：{FormatSize(MaxExtractedFileSizeBytes)}");
            }

            var targetPath = CreateSafeExtractPath(extractDirectory, reader.Entry.Key);
            Directory.CreateDirectory(Path.GetDirectoryName(targetPath) ?? extractDirectory);
            using var input = reader.OpenEntryStream();
            using var output = File.Create(targetPath);
            input.CopyTo(output);
            return targetPath;
        }

        throw new InvalidOperationException("压缩包中没有可打印文件");
    }

    private static string CreateSafeExtractPath(string extractDirectory, string? entryKey)
    {
        var normalizedKey = string.IsNullOrWhiteSpace(entryKey)
            ? Guid.NewGuid().ToString("N")
            : entryKey.Replace('\\', '/');
        var safeSegments = normalizedKey
            .Split('/', StringSplitOptions.RemoveEmptyEntries)
            .Where(segment => segment != "." && segment != "..")
            .Select(PathHelper.SanitizePathSegment)
            .Where(segment => !string.IsNullOrWhiteSpace(segment))
            .ToArray();

        if (safeSegments.Length == 0)
        {
            safeSegments = new[] { Guid.NewGuid().ToString("N") };
        }

        var targetPath = Path.GetFullPath(Path.Combine(new[] { extractDirectory }.Concat(safeSegments).ToArray()));
        var safeRoot = Path.GetFullPath(extractDirectory) + Path.DirectorySeparatorChar;
        if (!targetPath.StartsWith(safeRoot, StringComparison.OrdinalIgnoreCase))
        {
            throw new InvalidOperationException("压缩包包含不安全的文件路径");
        }

        return targetPath;
    }

    private static bool IsPrintableArchiveEntry(IEntry entry)
    {
        var extension = Path.GetExtension(entry.Key ?? string.Empty).ToLowerInvariant();
        return SupportedExtensionSet.Contains(extension);
    }

    private static async Task<string> ConvertToPdfWithLibreOfficeAsync(string sourcePath, string outputRoot, CancellationToken cancellationToken)
    {
        var sofficePath = FindLibreOfficeExecutable();
        if (string.IsNullOrWhiteSpace(sofficePath))
        {
            throw new FileNotFoundException("未找到 LibreOffice soffice.exe，无法转换 Office/TXT 文件");
        }

        var outputDirectory = Path.Combine(outputRoot, "converted", DateTime.Now.ToString("yyyyMMddHHmmssfff"));
        Directory.CreateDirectory(outputDirectory);

        var startInfo = new ProcessStartInfo
        {
            FileName = sofficePath,
            Arguments = $"--headless --convert-to pdf --outdir \"{outputDirectory}\" \"{sourcePath}\"",
            CreateNoWindow = true,
            UseShellExecute = false,
            RedirectStandardError = true,
            RedirectStandardOutput = true
        };

        using var process = Process.Start(startInfo) ?? throw new InvalidOperationException("启动 LibreOffice 失败");
        await process.WaitForExitAsync(cancellationToken).ConfigureAwait(true);

        if (process.ExitCode != 0)
        {
            var error = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(true);
            throw new InvalidOperationException($"LibreOffice 转换失败：{error}");
        }

        var expectedPdfPath = Path.Combine(outputDirectory, Path.ChangeExtension(Path.GetFileName(sourcePath), ".pdf"));
        if (File.Exists(expectedPdfPath))
        {
            return expectedPdfPath;
        }

        var generatedPdf = Directory.EnumerateFiles(outputDirectory, "*.pdf", SearchOption.TopDirectoryOnly).FirstOrDefault();
        return generatedPdf ?? throw new FileNotFoundException("LibreOffice 未生成 PDF 文件");
    }

    private static string? FindLibreOfficeExecutable()
    {
        var candidates = new[]
        {
            Environment.GetEnvironmentVariable("SOFFICE_PATH"),
            @"C:\Program Files\LibreOffice\program\soffice.exe",
            @"C:\Program Files (x86)\LibreOffice\program\soffice.exe"
        };

        return candidates.FirstOrDefault(path => !string.IsNullOrWhiteSpace(path) && File.Exists(path));
    }

    private static bool IsPdf(string extension) => extension == ".pdf";

    private static bool IsImage(string extension)
    {
        return extension is ".jpg" or ".jpeg" or ".png" or ".bmp" or ".gif";
    }

    private static bool IsOfficeOrText(string extension)
    {
        return extension is ".doc" or ".docx" or ".xls" or ".xlsx" or ".ppt" or ".pptx" or ".txt";
    }

    private static string FormatSize(long bytes)
    {
        return bytes >= 1024 * 1024
            ? $"{bytes / 1024d / 1024d:F2} MB"
            : $"{bytes / 1024d:F2} KB";
    }
}