using EPLAN.Harness.Common;
using EPLAN.Harness.Common.Extensions;
using EPLAN.Harness.Common.LrsSystem;
using EPLAN.Harness.Core.Controls;
using EPLAN.Harness.Core.Settings;
using EPLAN.Harness.IO;
using EPLAN.Harness.ProjectCore.Report;
using Microsoft.Win32;
using Sinvo.EplanHpD.Plugin.WPFUI.Models;
using Sinvo.EplanHpD.Plugin.WPFUI.Utils;
using Sinvo.EplanHpD.Plugin.WPFUI.ViewModel;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;

namespace Sinvo.EplanHpD.Plugin.WPFUI;

/// <summary>
/// MainWindow.xaml 的交互逻辑
/// </summary>
public partial class MainWindow : Window
{
    private readonly MainViewModel ViewModel;
    public delegate void UpdateDataGridColumns(List<DataGridColumn> columns, DataGridType type);
    private IEnumerable<BaseReportEntry> datas;
    private List<ReportColumn> reportColumns;
    public MainWindow(IEnumerable<BaseReportEntry> datas, List<ReportColumn> columns)
    {
        InitializeComponent();
        this.DataContext = ViewModel = new MainViewModel();
        ViewModel.UpdateDataGridColumns = UpdateDataGridColumnsByType;
        this.datas = datas;
        this.reportColumns = columns;
        ViewModel.DataColumns = [];
        ViewModel.Data = [];
        ViewModel.StuffedData = [];
        ViewModel.ExportData = [];
    }

    public void UpdateDataGridColumnsByType(List<DataGridColumn> columns, DataGridType type)
    {
        try
        {
            //this.Dispatcher.BeginInvoke(delegate ()
            //{
            switch (type)
            {
                case DataGridType.Originial:
                    UpdateOriginialDataGridColumns(columns);
                    break;
                case DataGridType.Import:
                    UpdateImportDataGridColumns(columns);
                    break;
                default:
                    break;
            }
            //}); 
        }
        catch (System.Exception ex)
        {
            FlexMessageBox.Error($"{ex}");
        }

    }

    public void UpdateOriginialDataGridColumns(List<DataGridColumn> columns)
    {
        OriginialDataGrid.Columns.Clear();
        //var columns = ViewModel.DataColumns; 
        foreach (var column in columns)
        {
            OriginialDataGrid.Columns.Add(column);
        }
    }
    public void UpdateImportDataGridColumns(List<DataGridColumn> columns)
    {
        ImportDataGrid.Columns.Clear();
        //var columns = ViewModel.DataColumns;
        foreach (var column in columns)
        {
            ImportDataGrid.Columns.Add(column);
        }
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        DataTabControl.SelectedIndex = 1;
        LoadingMask.Visibility = Visibility.Visible;
        try
        {
            ViewModel.CheckAll();
        }
        catch (System.Exception ex)
        {
            Trace.WriteLine(ex.ToString());
        }
        LoadingMask.Visibility = Visibility.Collapsed;
    }

    //private void GetDataBtn_Click(object sender, RoutedEventArgs e)
    //{
    //    var result = ExcelHelper.GetWireTerminalMappingTable();

    //}

    private void GenTemplateBtn_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            DataTabControl.SelectedIndex = 2;
            ViewModel.GenExportData();
        }
        catch (System.Exception ex)
        {
            FlexMessageBox.Error($"{ex}");
        }
    }

    private async void Window_Loaded(object sender, RoutedEventArgs e)
    {
        try
        {
            LoadingMask.Visibility = Visibility.Visible;
            await LoadDataAsync(datas, reportColumns);
        }
        catch (System.Exception ex)
        {
            FlexMessageBox.Error($"{ex}");
        }

    }
    public async Task LoadDataAsync(IEnumerable<BaseReportEntry> reportData, List<ReportColumn> columns)
    {

        var dataColumns = ViewModel.GetColumns(columns);


        var data = ViewModel.LoadReportDataAsync(reportData, columns);

        Task.WaitAll(dataColumns, data);
        var stuffedData = ViewModel.StuffData(data.Result);

        stuffedData.ContinueWith(x =>
        {
            _ = this.Dispatcher.BeginInvoke(delegate ()
             {
                 try
                 {
                     ViewModel.DataColumns?.Clear();
                     dataColumns.Result.Where(it => it != null).ForEach(ViewModel.DataColumns.Add);
                     ViewModel.Data?.Clear();
                     data.Result.Where(it => it != null).ForEach(ViewModel.Data.Add);
                     ViewModel.StuffedData?.Clear();
                     stuffedData.Result.Where(it => it != null).ForEach(ViewModel.StuffedData.Add);
                     UpdateDataGridColumnsByType([.. ViewModel.DataColumns], DataGridType.Originial);
                 }
                 catch (Exception ex)
                 {
                     Trace.WriteLine($"{ex}");
                 }
                 LoadingMask.Visibility = Visibility.Collapsed;

             });
        });
    }
    private void ExportDataBtn_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            if (ViewModel.ExportData == null || ViewModel.ExportData.Count <= 0)
            {
                FlexMessageBox.Info($"无数据可导出！");
            }
            else
            {
                SaveFileDialog saveFileDialog = new SaveFileDialog
                {
                    Filter = Singleton<LRS>.Instance["Report_ExpFilter", "Report_ExpFilter"],
                    FilterIndex = StudioSettings.Instance.ReportExport_FilterIndex,
                    FileName = $"单芯线下单{DateTime.Now:yyyy_MM_dd}.xlsx",
                    AddExtension = true,
                    InitialDirectory = StudioSettings.Instance.ReportExport_Path,
                    CheckPathExists = true
                };
                if (saveFileDialog.ShowDialog() == true)
                {
                    ExcelHelper.SaveByTemplate(ViewModel.ExportData, Path.Combine(FlexIOBase.GetParentPath(saveFileDialog.FileName), saveFileDialog.FileName));
                }
            }

        }
        catch (System.Exception ex)
        {
            FlexMessageBox.Error($"{ex}");
        }
    }

    private void IgnoreSelectedError_Click(object sender, RoutedEventArgs e)
    {
        if (ModelGenDataGrid.SelectedItems != null)
        {
            var selectedRows = ModelGenDataGrid.SelectedItems;
            foreach (var item in selectedRows)
            {
                if (item is StuffedDataModel model)
                {
                    model.IsIgnore = true;
                }
            }
        }
    }

    private void Copy_Click(object sender, RoutedEventArgs e)
    {
        if (sender is MenuItem item)
        {
            var selectItems = ModelGenDataGrid.SelectedItems;
            if (item.Tag?.ToString() == "MNo")
            {
                var str = string.Join("\n", selectItems.Cast<StuffedDataModel>().Select(item => item.WireCode));
                Clipboard.SetText(str);
            }
            if (item.Tag?.ToString() == "ErrMsg")
            {
                var str = string.Join("\n", selectItems.Cast<StuffedDataModel>().Select(item => item.CheckedMsg));
                Clipboard.SetText(str);
            }
            if (item.Tag?.ToString() == "MNoAndErrMsg")
            {
                var str = string.Join("\n", selectItems.Cast<StuffedDataModel>().Select(item => $"{item.WireCode}\t{item.CheckedMsg}"));
                Clipboard.SetText(str);
            }
            if (item.Tag?.ToString() == "WireName")
            {
                var str = string.Join("\n", selectItems.Cast<StuffedDataModel>().Select(item => $"{item.WireName}"));
                Clipboard.SetText(str);
            }
        }
        e.Handled = true;
    }
}