using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Windows;
using Prism.Commands;
using Prism.Mvvm;
using XP.Common.GeneralForm.Views;
using XP.Common.Logging.Interfaces;
using XP.Common.PdfViewer.Interfaces;
using XP.ReportEngine.Configs;
using XP.ReportEngine.Interfaces;
using XP.ReportEngine.Models;
using XP.ReportEngine.Services;

namespace XP.ReportEngine.ViewModels
{
    /// <summary>
    /// 报告生成演示窗口 ViewModel | Report generation demo window ViewModel
    /// 演示如何使用 IReportService 生成 PDF 报告
    /// Demonstrates how to use IReportService to generate PDF reports
    /// </summary>
    public class ReportDemoViewModel : BindableBase
    {
        private readonly IReportService _reportService;
        private readonly IPdfViewerService _pdfViewerService;
        private readonly IPdfPrintService _pdfPrintService;
        private readonly ILoggerService _logger;
        private readonly ReportIdGenerator _reportIdGenerator;
        private readonly ReportConfig _reportConfig;

        private string _productName = "PCB-TEST-001";
        private string _operatorName = "戚明轩 mingxuan.qi@hexagon.com";
        private string _description = "BGA 焊球气泡率检测";
        private string _cncProgram = "Prog001";
        private string _productCode = "PCBA-X100";
        private string _workpieceSN = "SN20250001";
        private string _deviceId = "XP-CT-001";
        private string _machineId = "MC01";
        private string _statusMessage = "就绪";
        private string _lastOutputPath;
        private bool _isGenerating;

        #region 属性 | Properties

        /// <summary>
        /// 产品名称 | Product name
        /// </summary>
        public string ProductName
        {
            get => _productName;
            set => SetProperty(ref _productName, value);
        }

        /// <summary>
        /// 操作员 | Operator
        /// </summary>
        public string OperatorName
        {
            get => _operatorName;
            set => SetProperty(ref _operatorName, value);
        }

        /// <summary>
        /// 描述 | Description
        /// </summary>
        public string Description
        {
            get => _description;
            set => SetProperty(ref _description, value);
        }

        /// <summary>
        /// CNC 程序名称 | CNC program name
        /// </summary>
        public string CncProgram
        {
            get => _cncProgram;
            set => SetProperty(ref _cncProgram, value);
        }

        /// <summary>
        /// 产品类型码 | Product type code
        /// </summary>
        public string ProductCode
        {
            get => _productCode;
            set => SetProperty(ref _productCode, value);
        }

        /// <summary>
        /// 工件 SN 码 | Workpiece serial number
        /// </summary>
        public string WorkpieceSN
        {
            get => _workpieceSN;
            set => SetProperty(ref _workpieceSN, value);
        }

        /// <summary>
        /// 检测设备编号 | Inspection device ID
        /// </summary>
        public string DeviceId
        {
            get => _deviceId;
            set => SetProperty(ref _deviceId, value);
        }

        /// <summary>
        /// 生产机台号 | Production machine ID
        /// </summary>
        public string MachineId
        {
            get => _machineId;
            set => SetProperty(ref _machineId, value);
        }

        /// <summary>
        /// 状态信息 | Status message
        /// </summary>
        public string StatusMessage
        {
            get => _statusMessage;
            set => SetProperty(ref _statusMessage, value);
        }

        /// <summary>
        /// 是否正在生成 | Whether generating
        /// </summary>
        public bool IsGenerating
        {
            get => _isGenerating;
            set
            {
                if (SetProperty(ref _isGenerating, value))
                {
                    GenerateReportCommand.RaiseCanExecuteChanged();
                    OpenViewerCommand.RaiseCanExecuteChanged();
                    PrintReportCommand.RaiseCanExecuteChanged();
                }
            }
        }

        #endregion

        #region 命令 | Commands

        /// <summary>
        /// 生成报告命令 | Generate report command
        /// </summary>
        public DelegateCommand GenerateReportCommand { get; }

        /// <summary>
        /// 打开 PDF 阅读器命令 | Open PDF viewer command
        /// </summary>
        public DelegateCommand OpenViewerCommand { get; }

        /// <summary>
        /// 打印报告命令 | Print report command
        /// </summary>
        public DelegateCommand PrintReportCommand { get; }

        #endregion

        /// <summary>
        /// 构造函数 | Constructor
        /// </summary>
        public ReportDemoViewModel(
            IReportService reportService,
            IPdfViewerService pdfViewerService,
            IPdfPrintService pdfPrintService,
            ILoggerService logger,
            ReportIdGenerator reportIdGenerator,
            ReportConfig reportConfig)
        {
            _reportService = reportService ?? throw new ArgumentNullException(nameof(reportService));
            _pdfViewerService = pdfViewerService ?? throw new ArgumentNullException(nameof(pdfViewerService));
            _pdfPrintService = pdfPrintService ?? throw new ArgumentNullException(nameof(pdfPrintService));
            _logger = logger?.ForModule<ReportDemoViewModel>() ?? throw new ArgumentNullException(nameof(logger));
            _reportIdGenerator = reportIdGenerator ?? throw new ArgumentNullException(nameof(reportIdGenerator));
            _reportConfig = reportConfig ?? throw new ArgumentNullException(nameof(reportConfig));

            GenerateReportCommand = new DelegateCommand(async () => await GenerateReportAsync(), () => !IsGenerating);
            OpenViewerCommand = new DelegateCommand(OpenViewer, () => !IsGenerating && !string.IsNullOrEmpty(_lastOutputPath));
            PrintReportCommand = new DelegateCommand(PrintReport, () => !IsGenerating && !string.IsNullOrEmpty(_lastOutputPath));
        }

        /// <summary>
        /// 生成报告（带进度条）| Generate report (with progress window)
        /// </summary>
        private async Task GenerateReportAsync()
        {
            IsGenerating = true;
            StatusMessage = "正在生成报告...";

            try
            {
                // 构建文件名占位符参数 | Build file name placeholder parameters
                var fileNameParams = new Dictionary<string, string>
                {
                    ["ReportId"] = _reportIdGenerator.GenerateNext(),
                    ["ProductName"] = ProductName,
                    ["CncProgram"] = CncProgram,
                    ["ProductCode"] = ProductCode,
                    ["WorkpieceSN"] = WorkpieceSN,
                    ["DeviceId"] = DeviceId,
                    ["MachineId"] = MachineId,
                    ["Result"] = "Pass"
                };

                // 确定输出路径：提示用户是否使用默认位置 | Determine output path: ask user whether to use default location
                var defaultOutputPath = _reportConfig.ResolveOutputFilePath(fileNameParams);
                var defaultFileName = System.IO.Path.GetFileName(defaultOutputPath);

                var result = MessageBox.Show(
                    $"是否将报告输出到默认位置？\r\n{defaultOutputPath}",
                    "输出位置确认",
                    MessageBoxButton.YesNoCancel,
                    MessageBoxImage.Question);

                if (result == MessageBoxResult.Cancel)
                {
                    StatusMessage = "已取消生成";
                    IsGenerating = false;
                    return;
                }

                string outputPath;
                if (result == MessageBoxResult.No)
                {
                    // 用户选择自定义位置 | User chooses custom location
                    var saveDialog = new Microsoft.Win32.SaveFileDialog
                    {
                        Title = "选择报告保存位置",
                        Filter = "PDF 文件 (*.pdf)|*.pdf",
                        FileName = defaultFileName,
                        DefaultExt = ".pdf",
                        InitialDirectory = System.IO.Path.GetDirectoryName(defaultOutputPath)
                    };

                    if (saveDialog.ShowDialog() != true)
                    {
                        StatusMessage = "已取消生成";
                        IsGenerating = false;
                        return;
                    }

                    outputPath = saveDialog.FileName;
                }
                else
                {
                    // 使用默认路径 | Use default path
                    outputPath = defaultOutputPath;
                }

                // 创建进度条窗口 | Create progress window
                var progressWindow = new ProgressWindow(
                    title: "报告生成中",
                    message: "正在准备数据...",
                    isCancelable: false,
                    logger: _logger);

                progressWindow.Owner = Application.Current.MainWindow;
                progressWindow.Show();

                try
                {
                    // 步骤 1：准备模拟数据 | Step 1: Prepare mock data
                    progressWindow.UpdateProgress("正在准备检测数据...", 10);
                    await Task.Delay(300); // 模拟耗时 | Simulate delay

                    var processorOutputs = CreateMockProcessorOutputs();

                    // 步骤 2：构建报告请求 | Step 2: Build report request
                    progressWindow.UpdateProgress("正在组装报告数据...", 30);
                    await Task.Delay(200);

                    var request = new ReportRequest
                    {
                        ProcessorOutputs = processorOutputs,
                        Metadata = new ReportMetadata
                        {
                            ReportId = fileNameParams["ReportId"],
                            InspectionDate = DateTime.Now,
                            SampleName = ProductName,
                            OperatorName = OperatorName,
                            Description = Description
                        },
                        OutputFilePath = outputPath,
                        FileNameParameters = fileNameParams
                    };

                    // 注入工件整体图片 | Inject workpiece overview image
                    var workpieceImagePath = System.IO.Path.Combine(MockImageDirectory, "OverView.png");
                    if (File.Exists(workpieceImagePath))
                    {
                        request.AdditionalImages["workpieceImage"] = new ImageData
                        {
                            SourceType = ImageSourceType.FilePath,
                            FilePath = workpieceImagePath
                        };
                    }

                    // 步骤 3：调用报告服务生成（在后台线程执行，避免阻塞 UI）
                    // Step 3: Call report service (on background thread to avoid blocking UI)
                    progressWindow.UpdateProgress("正在生成 PDF...", 60);
                    await Task.Delay(200);

                    var genResult = await Task.Run(() => _reportService.GenerateAsync(request));

                    // 步骤 4：处理结果 | Step 4: Handle result
                    progressWindow.UpdateProgress("正在完成...", 95);
                    await Task.Delay(200);

                    if (genResult.IsSuccess)
                    {
                        _lastOutputPath = genResult.OutputFilePath;
                        StatusMessage = $"报告生成成功：{genResult.OutputFilePath}";
                        _logger.Info("报告生成成功：{Path} | Report generated successfully: {Path}", genResult.OutputFilePath);

                        progressWindow.UpdateProgress("报告生成完成！", 100);
                        await Task.Delay(500);

                        // 根据配置自动打开 PDF 阅读器 | Auto-open PDF viewer based on config
                        if (_reportConfig.AutoOpenAfterGenerate)
                        {
                            try
                            {
                                _pdfViewerService.OpenViewer(genResult.OutputFilePath);
                            }
                            catch (Exception viewerEx)
                            {
                                _logger.Warn("自动打开 PDF 失败 | Auto-open PDF failed: {Message}", viewerEx.Message);
                            }
                        }
                    }
                    else
                    {
                        StatusMessage = $"报告生成失败：{genResult.ErrorMessage}";
                        _logger.Error(null, "报告生成失败：{Message} | Report generation failed: {Message}", genResult.ErrorMessage);

                        MessageBox.Show(
                            $"报告生成失败：\n{genResult.ErrorMessage}",
                            "错误",
                            MessageBoxButton.OK,
                            MessageBoxImage.Error);
                    }
                }
                finally
                {
                    progressWindow.Close();
                }
            }
            catch (Exception ex)
            {
                StatusMessage = $"报告生成异常：{ex.Message}";
                _logger.Error(ex, "报告生成异常 | Report generation exception: {Message}", ex.Message);

                MessageBox.Show(
                    $"报告生成过程中发生异常：\n{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
            finally
            {
                IsGenerating = false;
                OpenViewerCommand.RaiseCanExecuteChanged();
                PrintReportCommand.RaiseCanExecuteChanged();
            }
        }

        /// <summary>
        /// 打开 PDF 阅读器 | Open PDF viewer
        /// </summary>
        private void OpenViewer()
        {
            if (string.IsNullOrEmpty(_lastOutputPath) || !File.Exists(_lastOutputPath))
            {
                MessageBox.Show("PDF 文件不存在，请先生成报告。", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            try
            {
                // 使用 XP.Common PDF 阅读器打开 | Open with XP.Common PDF viewer
                _pdfViewerService.OpenViewer(_lastOutputPath);
                _logger.Info("使用内置 PDF 阅读器打开：{Path} | Opened with built-in PDF viewer: {Path}", _lastOutputPath);
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "打开 PDF 失败 | Failed to open PDF: {Message}", ex.Message);
                MessageBox.Show($"打开 PDF 失败：\n{ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 打印报告 | Print report
        /// </summary>
        private void PrintReport()
        {
            if (string.IsNullOrEmpty(_lastOutputPath) || !File.Exists(_lastOutputPath))
            {
                MessageBox.Show("PDF 文件不存在，请先生成报告。", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            try
            {
                var confirmed = _pdfPrintService.PrintWithDialog(_lastOutputPath);
                if (confirmed)
                { 
                    _logger.Info("报告已发送到打印机：{Path} | Report sent to printer: {Path}", _lastOutputPath);
                    StatusMessage = "报告已发送到打印机";
                }
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "打印报告失败 | Failed to print report: {Message}", ex.Message);
                MessageBox.Show($"打印失败：\n{ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        #region 模拟数据 | Mock Data

        /// <summary>
        /// 模拟图像目录路径 | Mock image directory path
        /// </summary>
        private const string MockImageDirectory = @"D:\XPData\DetectorImages";

        /// <summary>
        /// 创建模拟处理器输出数据（演示用，覆盖所有检测类型）
        /// Create mock processor outputs (for demo, covers all inspection types)
        /// </summary>
        private List<ProcessorOutput> CreateMockProcessorOutputs()
        {
            return new List<ProcessorOutput>
            {
                CreateLineMeasurementOutput(),
                CreateBgaVoidRateOutput(),
                CreateVoidMeasurementOutput(),
                CreateFillRateOutput()
            };
        }

        /// <summary>
        /// 创建线测量处理器模拟数据 | Create line measurement processor mock data
        /// </summary>
        private ProcessorOutput CreateLineMeasurementOutput()
        {
            return new ProcessorOutput
            {
                ProcessorType = "LineMeasurementProcessor",
                OutputData = new Dictionary<string, object>
                {
                    ["MeasurementType"] = "TwoPointDistance",
                    ["Point1"] = "X=125.32, Y=80.15",
                    ["Point2"] = "X=340.78, Y=80.15",
                    ["PixelDistance"] = 215.46,
                    ["ActualDistance"] = 3.256,
                    ["Unit"] = "mm",
                    ["Angle"] = 0.0
                },
                AnnotatedImage = LoadMockImage("BGA.png")
            };
        }

        /// <summary>
        /// 创建 BGA 气泡率处理器模拟数据 | Create BGA void rate processor mock data
        /// </summary>
        private ProcessorOutput CreateBgaVoidRateOutput()
        {
            // 生成 64 组 BGA 球模拟数据 | Generate 64 BGA ball mock data
            var bgaBalls = new List<Dictionary<string, object>>();
            var random = new Random(42); // 固定种子确保可重复 | Fixed seed for reproducibility
            var voidLimit = 0.05;

            for (int i = 1; i <= 64; i++)
            {
                // 大部分合格，少数不合格 | Most pass, a few fail
                double voidRate;
                if (i == 12 || i == 27 || i == 41 || i == 58)
                {
                    // 这几个球不合格 | These balls fail
                    voidRate = Math.Round(0.05 + random.NextDouble() * 0.03, 4);
                }
                else
                {
                    voidRate = Math.Round(random.NextDouble() * 0.045, 4);
                }

                var area = Math.Round(190.0 + random.NextDouble() * 15.0, 1);
                var classification = voidRate > voidLimit ? "Fail" : "Pass";

                bgaBalls.Add(new Dictionary<string, object>
                {
                    ["Index"] = i,
                    ["VoidRate"] = voidRate,
                    ["Area"] = area,
                    ["Classification"] = classification
                });
            }

            return new ProcessorOutput
            {
                ProcessorType = "BgaVoidRateProcessor",
                OutputData = new Dictionary<string, object>
                {
                    ["BgaCount"] = 64,
                    ["VoidRate"] = 0.028,
                    ["FillRate"] = 0.972,
                    ["TotalBgaArea"] = 12500.5,
                    ["TotalVoidArea"] = 350.2,
                    ["Classification"] = "Pass",
                    ["VoidLimit"] = 0.05,
                    ["BgaBalls"] = bgaBalls
                },
                AnnotatedImage = LoadMockImage("BGA.png")
            };
        }

        /// <summary>
        /// 创建空隙测量处理器模拟数据 | Create void measurement processor mock data
        /// </summary>
        private ProcessorOutput CreateVoidMeasurementOutput()
        {
            return new ProcessorOutput
            {
                ProcessorType = "VoidMeasurementProcessor",
                OutputData = new Dictionary<string, object>
                {
                    ["RoiArea"] = 5000.0,
                    ["TotalVoidArea"] = 125.8,
                    ["VoidRate"] = 0.025,
                    ["VoidLimit"] = 0.05,
                    ["VoidCount"] = 5,
                    ["MaxVoidArea"] = 65.2,
                    ["Classification"] = "Pass",
                    ["Voids"] = new List<Dictionary<string, object>>
                    {
                        new() { ["Index"] = 1, ["Area"] = 65.2, ["AreaPercent"] = 1.30, ["CenterX"] = 120.5, ["CenterY"] = 85.3 },
                        new() { ["Index"] = 2, ["Area"] = 38.4, ["AreaPercent"] = 0.77, ["CenterX"] = 200.1, ["CenterY"] = 150.8 },
                        new() { ["Index"] = 3, ["Area"] = 22.2, ["AreaPercent"] = 0.44, ["CenterX"] = 80.0, ["CenterY"] = 220.5 },
                        new() { ["Index"] = 4, ["Area"] = 15.6, ["AreaPercent"] = 0.31, ["CenterX"] = 310.2, ["CenterY"] = 95.7 },
                        new() { ["Index"] = 5, ["Area"] = 8.9, ["AreaPercent"] = 0.18, ["CenterX"] = 155.8, ["CenterY"] = 280.1 }
                    }
                },
                AnnotatedImage = LoadMockImage("Void.png")
            };
        }

        /// <summary>
        /// 创建通孔填锡率处理器模拟数据 | Create via fill rate processor mock data
        /// </summary>
        private ProcessorOutput CreateFillRateOutput()
        {
            return new ProcessorOutput
            {
                ProcessorType = "FillRateProcessor",
                OutputData = new Dictionary<string, object>
                {
                    ["FillRate"] = 0.85,
                    ["VoidRate"] = 0.15,
                    ["FullDistance"] = 1.60,
                    ["FillDistance"] = 1.36,
                    ["THTLimit"] = 0.75,
                    ["Classification"] = "Pass",
                    ["E1"] = new Dictionary<string, object>
                    {
                        ["CenterX"] = 256.0, ["CenterY"] = 256.0,
                        ["SemiAxisA"] = 120.5, ["SemiAxisB"] = 118.2, ["Angle"] = 2.3
                    },
                    ["E2"] = new Dictionary<string, object>
                    {
                        ["CenterX"] = 256.0, ["CenterY"] = 256.0,
                        ["SemiAxisA"] = 95.8, ["SemiAxisB"] = 93.1, ["Angle"] = 2.3
                    },
                    ["E3"] = new Dictionary<string, object>
                    {
                        ["CenterX"] = 256.0, ["CenterY"] = 256.0,
                        ["SemiAxisA"] = 70.2, ["SemiAxisB"] = 68.5, ["Angle"] = 1.8
                    },
                    ["E4"] = new Dictionary<string, object>
                    {
                        ["CenterX"] = 256.0, ["CenterY"] = 256.0,
                        ["SemiAxisA"] = 45.0, ["SemiAxisB"] = 43.7, ["Angle"] = 1.5
                    }
                },
                AnnotatedImage = LoadMockImage("Void.png")
            };
        }

        /// <summary>
        /// 加载模拟图像文件 | Load mock image file
        /// 从指定目录加载图像，文件不存在时返回 null
        /// Loads image from specified directory, returns null if file not found
        /// </summary>
        /// <param name="fileName">图像文件名 | Image file name</param>
        /// <returns>图像数据对象或 null | ImageData object or null</returns>
        private ImageData LoadMockImage(string fileName)
        {
            var filePath = System.IO.Path.Combine(MockImageDirectory, fileName);
            if (!File.Exists(filePath))
            {
                _logger.Warn("模拟图像文件不存在：{Path} | Mock image file not found: {Path}", filePath);
                return null;
            }

            return new ImageData
            {
                SourceType = ImageSourceType.FilePath,
                FilePath = filePath
            };
        }

        #endregion
    }
}