using log4net;
using Microsoft.Win32;
using NPOI.SS.Formula.PTG;
using NPOI.SS.UserModel;
using NPOI.Util;
using NPOI.XSSF.UserModel;
using PdmSwPlugin.Commmon.Control;
using PdmSwPlugin.Commmon.Util.UI;
using PdmSwPlugin.Common;
using PdmSwPlugin.Common.Constants;
using PdmSwPlugin.Common.Control.TreeGrid;
using PdmSwPlugin.Common.Entity.DrawAudit;
using PdmSwPlugin.Common.Entity.Pdm;
using PdmSwPlugin.Common.Entity.System;
using PdmSwPlugin.Common.Interface;
using PdmSwPlugin.Common.Setting;
using PdmSwPlugin.Common.Util;
using PdmSwPlugin.Common.Util.Http;
using PdmSwPlugin.Common.Util.UI;
using PdmSwPlugin.PDM.Constant;
using PdmSwPlugin.PDM.Model;
using SolidWorks.Interop.sldworks;
using SolidWorks.Interop.swconst;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Interop;
using static PdmSwPlugin.PDM.Event.PdmEvent;

namespace PdmSwPlugin.PDM
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    [PdmSwPlugin(Title = "PDM")]
    public partial class PdmControl : UserControl, IActiveDocChangeHandler
    {
        private static ILog Logger = LogManager.GetLogger("PDM");
        SldWorks SwApp;

        private Model.PdmControlModel model;
        private readonly HttpClient Client;
        private string CurrentUserName;
        private readonly int MaxThreads;
        private ModelDoc2 OpenDoc { get; set; }
        private HttpClientCreator clientCreator { get; set; }

        private volatile PdmStatus workStatus;

        private TaskFactory taskFactory = LimitedConcurrencyLevelTaskSchedulerMsn.Factory;

        SldWorks ISwAppSetter.SwApp => SwApp;

        public PdmControl() : this(null)
        {
        }

        public PdmControl(SldWorks swAddin)
        {
            SwApp = swAddin;
            InitializeComponent();
            // 滚动事件
            // RaiseWheelEvent();
            model = new Model.PdmControlModel();
            model.bomTreeReader.SingleCompleted += BomTreeReader_SingleCompleted;
            DataContext = model;
            clientCreator = new HttpClientCreator(new HttpConfig(
                PluginSetting.Instance.TimeOut,
                PluginSetting.Instance.BaseAddress));
            Client = clientCreator.GetClient();
            CurrentUserName = System.Environment.UserName;
            PdmBom.InBomChanged += PdmBom_InBomChanged;
            InitDemonThread();
        }

        private void PdmBom_InBomChanged(object sender, bool e)
        {
            //if (e)
            //{
            //    MaskAdorner.ShowMask(content, "请稍后...");
            //}
            //else {
            //    MaskAdorner.HideMask(content);
            //}

            MaskAdorner.ShowMask(content, "请稍后...");

            Task.Run(() =>
            {
                try
                {
                    workStatus = PdmStatus.READING;
                    PdmBom bom = sender as PdmBom;
                    bom.UpdateInBom(e);
                    RefreshBomTree();
                }
                finally
                {
                    MaskAdorner.HideMask(content);
                    workStatus = PdmStatus.FREE;
                }
            });
        }

        private void RefreshBomTree()
        {
            var cache = model.BomTree;
            model.BomTree = new ObservableCollection<PdmBom>();
            model.BomTree = cache;
        }

        /// <summary>
        /// 加载BOM结构时，单个BOM完成事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BomTreeReader_SingleCompleted(object sender, PdmBom e)
        {
            MaskAdorner.ShowMessage(content, e.d3FilePath);
        }

        /// <summary>
        /// 刷新BOM列表
        /// 内部消化异常，不往外发
        /// </summary>
        public ObservableCollection<PdmBom> RefreshBomList(ModelDoc2 doc)
        {
            OpenDoc = doc;
            try
            {
                if (doc == null)
                {
                    this.Warning("请打开一张图纸");
                    return new ObservableCollection<PdmBom>();
                }
                //if (7 == doc.GetBlockingState())
                //{
                //    this.Warning("请等待文档加载完毕");
                //    return new ObservableCollection<PdmBom>();
                //}

                DateTime beforeDT = DateTime.Now;

                model.DoRefresh(Client, SwApp, doc);

                DateTime now = DateTime.Now;
                double times = DateTime.Now.Subtract(beforeDT).TotalMilliseconds;
                return model.BomTree;
            }
            catch (Exception e)
            {
                // FillBomInfo(boms, bomInfos, drawInfos);
                model.BomTree = new ObservableCollection<PdmBom>();
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Refresh Bom List Failed.", e);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，刷新失败:{e.Message}");
                return new ObservableCollection<PdmBom>();
            }
        }

        public void AutoSaveAlert(List<string> msgs)
        {
            //Dispatcher.Invoke(() =>
            //{
            //    MultiExWindow exWin = new MultiExWindow(this, "以下文档因删除特定配置而被保存", msgs, "文件路径");
            //    ShowExWindow(exWin);
            //});
        }

        /// <summary>
        /// 刷新按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void Refresh_Click(object sender, RoutedEventArgs e)
        {
            MaskAdorner.ShowMask(content, "请求中，请稍后...");
            try
            {
                workStatus = PdmStatus.READING;
                Logger.Debug("PDM插件，刷新列表...");
                // !!! Task.Run中不能抛出异常，不然会中断程序
                // 这里一定要用Task.Run，不然会阻塞UI线程，导致遮罩层显示不出来
                // 垃圾WPF
                await Task.Run(() =>
                {
                    RefreshBomList(SwApp.IActiveDoc2);
                    if (model.bomTreeReader.needSaveList.Count > 0)
                    {
                        List<string> msgs = new List<string>(model.bomTreeReader.needSaveList);
                        AutoSaveAlert(msgs);
                    }
                });
                Logger.Debug("PDM插件，列表刷新完成！");
            }
            finally
            {
                workStatus = PdmStatus.FREE;
                MaskAdorner.HideMask(content);
            }
        }

        public void ValidateBoms(out string error)
        {
            error = null;
            ObservableCollection<PdmBom> boms = model.BomTree;
            if (boms == null || boms.Count <= 0)
            {
                error = string.Empty;
            }

            List<string> lostBoms = model.CacheList.Where(b => b.lost).Select(b => b.partModel).ToList();
            if (lostBoms != null && lostBoms.Count > 0)
            {
                error = "[" + string.Join(",", lostBoms) + "]文件不存在！请检查";
            }
        }

        /// <summary>
        /// 检出操作，同步方法，不关注校验，校验放外边
        /// </summary>
        private object DoCheckOut()
        {
            ObservableCollection<PdmBom> boms = model.BomTree;
            string bomId = boms[0].id;
            PdmBomParam param = new PdmBomParam
            {
                id = bomId,
                checkUserName = CurrentUserName
            };
            Result<object> res = Client.PostSyncAction<object>(param, "wpf/bom/openApi/checkOut");
            return res.HandleResult();
        }

        /// <summary>
        /// 检出操作，同步方法，不关注校验，校验放外边
        /// </summary>
        private Exception DoCheckOutAndRefresh()
        {
            try
            {
                _ = DoCheckOut();
                RefreshBomList(SwApp.IActiveDoc2);
                return null;
            }
            catch (Exception e)
            {
                return e;
            }
        }

        /// <summary>
        /// 检入操作，同步方法
        /// </summary>
        private object DoCheckIn()
        {
            Dictionary<string, object> param = new Dictionary<string, object> {
                    { "treeList",model.BomTree },
                    { "list",model.CacheList},
                    { "checkInUsername",CurrentUserName}
                };
            Result<object> result = Client.PostSyncAction<object>(param, "wpf/bom/openApi/checkIn");
            return result.HandleResult();
        }

        private Exception DoCheckInAndRefresh()
        {
            try
            {
                _ = DoCheckIn();
                RefreshBomList(SwApp.IActiveDoc2);
                return null;
            }
            catch (Exception e)
            {
                return e;
            }
        }

        private bool SameDoc(out string message)
        {
            message = null;
            ModelDoc2 currentDoc = SwApp.IActiveDoc2;
            if (currentDoc.GetSaveFlag())
            {
                message = "请先保存当前文档";
                return false;
            }
            // 傻逼C#，直接=赋值的对象==返回false，qnmd弱智东西
            if (OpenDoc == currentDoc)
            {
                return true;
            }
            string sb1 = OpenDoc?.GetPathName();
            string sb2 = currentDoc?.GetPathName();
            if (sb1 != sb2)
            {
                message = "当前BOM与图纸不对应，请刷新BOM列表";
                return false;
            }
            return true;
        }

        private async void CheckOut_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                MaskAdorner.ShowMask(content);
                if (!SameDoc(out string ErrMsg))
                {
                    this.Warning(ErrMsg);
                    return;
                }

                ValidateBoms(out string message);
                if (message != null)
                {
                    if (message != string.Empty)
                    {
                        this.Show(message, true);
                    }
                    return;
                }
                Logger.Debug("PDM插件，开始检出...");
                ObservableCollection<PdmBom> boms = model.BomTree;
                string bomId = boms[0].id;
                if (string.IsNullOrEmpty(bomId))
                {
                    this.Show("该BOM并未检入!", true);
                    return;
                }
                // Task.Run中不能有未处理的异常，所以返回出来，放到主函数做异常处理
                Exception error = await Task.Run(() =>
                {
                    return DoCheckOutAndRefresh();
                });
                if (error != null)
                {
                    throw error;
                }
                Logger.Debug("PDM插件，检出完成！");
                this.Show("检出成功", true);
            }
            catch (Exception ex)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}，Check In Bom Failed.", ex);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，检入Bom失败！{ex.Message}");
            }
            finally
            {
                MaskAdorner.HideMask(content);
            }
        }

        private async void CheckIn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                Logger.Debug("PDM插件，开始检入...");
                MaskAdorner.ShowMask(content);
                if (!SameDoc(out string ErrMsg))
                {
                    this.Warning(ErrMsg);
                    return;
                }

                ValidateBoms(out string message);
                if (message != null)
                {
                    if (message != string.Empty)
                    {
                        this.Show(message, true);
                    }
                    return;
                }
                Exception error = await Task.Run(() =>
                {
                    return DoCheckInAndRefresh();
                });
                if (error != null)
                {
                    throw error;
                }
                Logger.Debug("PDM插件，检入完成！");
                this.Show("检入成功", true);
            }
            catch (Exception ex)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Check In BOM Failed.", ex);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，检入BOM失败！{ex.Message}");
            }
            finally
            {
                MaskAdorner.HideMask(content);
            }
        }

        private async void CheckIn_Click2(object sender, RoutedEventArgs e)
        {
            try
            {
                MaskAdorner.ShowMask(content);
                ValidateBoms(out string message);
                if (message != null)
                {
                    if (message != string.Empty)
                    {
                        this.Show(message, true);
                    }
                    return;
                }

                Dictionary<string, object> param = new Dictionary<string, object> {
                    { "treeList",model.BomTree },
                    { "list",model.CacheList},
                    { "checkInUsername",CurrentUserName}
                };

                MultipartFormDataContent httpContent = new MultipartFormDataContent
                {
                    { new StringContent(JsonUtil.Serialize(param)), "sb" }
                };
                List<PdmBom> boms = model.GetModifiedBoms();
                FileInfo fileInfo;
                foreach (PdmBom bom in boms)
                {
                    fileInfo = new FileInfo(bom.d3FilePath);
                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(bom.d3FilePath)), bom.partModel + "_3d", fileInfo.Name);
                    if (!string.IsNullOrEmpty(bom.d2FilePath) && File.Exists(bom.d2FilePath))
                    {
                        fileInfo = new FileInfo(bom.d2FilePath);
                        httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(bom.d2FilePath)), bom.partModel + "_2d", fileInfo.Name);
                    }
                    if (!string.IsNullOrEmpty(bom.pdfFilePath) && File.Exists(bom.pdfFilePath))
                    {
                        fileInfo = new FileInfo(bom.pdfFilePath);
                        httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(bom.pdfFilePath)), bom.partModel + "_pdf", fileInfo.Name);
                    }
                }

                Result<object> result = await Client.PostAsyncAction<object>("wpf/bom/openApi/checkInWithFile", httpContent);
                object res = result.HandleResult();
                RefreshBomList(SwApp.IActiveDoc2);
                this.Show("检入成功", true);
            }
            catch (Exception ex)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Check In Bom With File Failed.", ex);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，检入失败！{ex.Message}");
            }
            finally
            {
                MaskAdorner.HideMask(content);
            }
        }

        private async void CheckIn_Click3(object sender, RoutedEventArgs e)
        {
            try
            {
                MaskAdorner.ShowMask(content);
                if (!SameDoc(out string ErrMsg))
                {
                    this.Warning(ErrMsg);
                    return;
                }

                ValidateBoms(out string message);
                if (message != null)
                {
                    if (message != string.Empty)
                    {
                        this.Show(message, true);
                    }
                    return;
                }
                Logger.Debug("PDM插件，带图纸的检入开始...");
                // 图纸变更过的BOM，已经按照型号筛选过
                List<PdmBom> modifiedBoms = model.GetModifiedBoms();
                if (modifiedBoms.Count <= 0)
                {
                    // 没有变更的图纸就直接检入，这里要用Task，否则蒙版不起作用
                    Exception err = await Task.Run(() =>
                    {
                        return DoCheckInAndRefresh();
                    });
                    if (err != null)
                    {
                        throw err;
                    }
                    this.Show("检入成功", true);
                    return;
                }

                // 多线程计数器
                CountdownEvent counter = new CountdownEvent(modifiedBoms.Count);
                // 异常收集
                Dictionary<PdmBom, Exception> errors = new Dictionary<PdmBom, Exception>();
                if (MaxThreads <= 0)
                {
                    await Task.Run(() =>
                    {
                        SendFileToServerBatch(new object[] { modifiedBoms, counter, errors });
                    });
                }
                else
                {
                    // 线程数
                    int taskCount = MaxThreads;
                    // 任务总数
                    int totalCount = modifiedBoms.Count;
                    // 每个线程处理的任务数
                    int eachCount = totalCount / taskCount;
                    // 余数
                    int otherCount = totalCount % taskCount;
                    int handledCount = 0;
                    for (int i = 0; i < taskCount; i++)
                    {
                        IEnumerable<PdmBom> boms;
                        if (i + 1 <= otherCount)
                        {
                            boms = modifiedBoms.Skip(handledCount).Take(eachCount + 1);
                        }
                        else
                        {
                            boms = modifiedBoms.Skip(handledCount).Take(eachCount);
                        }
                        handledCount += boms.Count();
                        await Task.Run(() =>
                        {
                            SendFileToServerBatch(new object[] { boms, counter, errors });
                        });
                    }
                }

                //foreach (var bom in modifiedBoms)
                //{
                //    ThreadPool.QueueUserWorkItem(new WaitCallback(SendFileToServer), new object[] { bom, counter, errors });
                //}
                counter.Wait();
                counter.Dispose();
                if (errors.Count > 0)
                {
                    string Msg = "";
                    foreach (PdmBom bom in errors.Keys)
                    {
                        Exception err = errors[bom];
                        Logger.Error($"V{PdmUser.LoginUser.pluginVersion},[{bom.partModel}] Upload Draw Failed.", err);
                        Msg += $"[{bom.partModel}]上传图纸错误!{err.Message}\r\n";
                    }
                    this.Show(Msg);
                    return;
                }
                Logger.Debug("PDM插件，带图纸的检入，图纸上传完成！正在检入...");
                // Task.Run中不能有未处理的异常，所以返回出来，放到主函数做异常处理
                Exception error = await Task.Run(() =>
                {
                    return DoCheckInAndRefresh();
                });
                if (error != null)
                {
                    throw error;
                }
                Logger.Debug("PDM插件，带图纸的检入，检入完成！");
                this.Show("检入成功", true);
            }
            catch (Exception ex)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Check In BOM With File Failed.", ex);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，检入失败！{ex.Message}");
            }
            finally
            {
                MaskAdorner.HideMask(content);
            }
        }

        private async void SendFileToServer(object state)
        {
            object[] args = (object[])state;
            PdmBom mainBom = (PdmBom)args[0];
            BomInfo param = new BomInfo()
            {
                partModel = mainBom.partModel,
                d3FileId = mainBom.d3FileId,
                d3FilePath = mainBom.d3FilePath,

                d2FileId = mainBom.d2FileId,
                d2FilePath = mainBom.d2FilePath,

                pdfFileId = mainBom.pdfFileId,
                pdfFilePath = mainBom.pdfFilePath,

                checkUserName = CurrentUserName
            };

            CountdownEvent counter = (CountdownEvent)args[1];
            Dictionary<PdmBom, Exception> errors = (Dictionary<PdmBom, Exception>)args[2];

            try
            {
                FileInfo fileInfo;
                var httpContent = new MultipartFormDataContent();
                httpContent.Add(new StringContent(JsonUtil.Serialize(param)), "bomStr");

                fileInfo = new FileInfo(param.d3FilePath);
                httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(param.d3FilePath)), param.partModel + "_3d", fileInfo.Name);
                if (!string.IsNullOrEmpty(param.d2FilePath) && File.Exists(param.d2FilePath))
                {
                    fileInfo = new FileInfo(param.d2FilePath);
                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(param.d2FilePath)), param.partModel + "_2d", fileInfo.Name);
                }
                if (!string.IsNullOrEmpty(param.pdfFilePath) && File.Exists(param.pdfFilePath))
                {
                    fileInfo = new FileInfo(param.pdfFilePath);
                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(param.pdfFilePath)), param.partModel + "_pdf", fileInfo.Name);
                }

                Result<BomInfo> result = await Client.PostAsyncAction<BomInfo>("wpf/bom/openApi/updateBomFile", httpContent);
                BomInfo res = result.HandleResult();

                mainBom._drawInfo.d3Md5 = res.d3Md5;
                mainBom._drawInfo.d2Md5 = res.d2Md5;
                mainBom._drawInfo.pdfMd5 = res.pdfMd5;

                mainBom._drawInfo.d3FileId = res.d3FileId;
                mainBom._drawInfo.d2FileId = res.d2FileId;
                mainBom._drawInfo.pdfFileId = res.pdfFileId;

            }
            catch (Exception e)
            {
                errors.Add(mainBom, e);
            }
            finally
            {
                _ = counter.Signal();
            }
        }

        /// <summary>
        /// 批量上传图纸到PDM服务器
        /// </summary>
        /// <param name="state">参数</param>
        private void SendFileToServerBatch(object state)
        {
            object[] args = (object[])state;
            IEnumerable<PdmBom> mainBoms = (IEnumerable<PdmBom>)args[0];
            CountdownEvent counter = (CountdownEvent)args[1];
            Dictionary<PdmBom, Exception> errors = (Dictionary<PdmBom, Exception>)args[2];
            foreach (PdmBom mainBom in mainBoms)
            {
                BomInfo param = new BomInfo()
                {
                    partModel = mainBom.partModel,
                    d3FileId = mainBom.d3FileId,
                    d3FilePath = mainBom.d3FilePath,

                    d2FileId = mainBom.d2FileId,
                    d2FilePath = mainBom.d2FilePath,

                    pdfFileId = mainBom.pdfFileId,
                    pdfFilePath = mainBom.pdfFilePath,

                    checkUserName = CurrentUserName
                };
                try
                {
                    string d3FilePath = param.d3FilePath;
                    if (string.IsNullOrEmpty(d3FilePath) || !File.Exists(d3FilePath))
                    {
                        throw new Exception($"未找到3D图纸");
                    }
                    string d2FilePath = Path.Combine(Path.GetDirectoryName(d3FilePath), Path.GetFileNameWithoutExtension(d3FilePath) + ".SLDDRW");
                    if (string.IsNullOrEmpty(d2FilePath) || !File.Exists(d2FilePath))
                    {
                        throw new Exception($"未找到工程图文件");
                    }
                    FileInfo fileInfo;
                    MultipartFormDataContent httpContent = new MultipartFormDataContent();
                    httpContent.Add(new StringContent(JsonUtil.Serialize(param)), "bomStr");
                    fileInfo = new FileInfo(d3FilePath);
                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(d3FilePath)), param.partModel + "_3d", fileInfo.Name);
                    fileInfo = new FileInfo(d2FilePath);

                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(d2FilePath)), param.partModel + "_2d", fileInfo.Name);
                    if (!string.IsNullOrEmpty(param.pdfFilePath) && File.Exists(param.pdfFilePath))
                    {
                        fileInfo = new FileInfo(param.pdfFilePath);
                        httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(param.pdfFilePath)), param.partModel + "_pdf", fileInfo.Name);
                    }

                    Result<BomInfo> result = Client.PostSyncAction<BomInfo>("wpf/bom/openApi/updateBomFile", httpContent);
                    BomInfo res = result.HandleResult();

                    mainBom._drawInfo.d3Md5 = res.d3Md5;
                    mainBom._drawInfo.d2Md5 = res.d2Md5;
                    mainBom._drawInfo.pdfMd5 = res.pdfMd5;

                    mainBom._drawInfo.d3FileId = res.d3FileId;
                    mainBom._drawInfo.d2FileId = res.d2FileId;
                    mainBom._drawInfo.pdfFileId = res.pdfFileId;
                }
                catch (Exception e)
                {
                    errors.Add(mainBom, e);
                }
                finally
                {
                    _ = counter.Signal();
                }
            }
        }

        /// <summary>
        /// 为未建料的物料生成建料Excel
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Excel_Click(object sender, RoutedEventArgs e)
        {
            if (!SameDoc(out string ErrMsg))
            {
                this.Warning(ErrMsg);
                return;
            }

            List<PdmBom> nos = model.CacheList.Where(b => b.needOrdered && b.inDb != true).ToList();
            if (nos.Count <= 0)
            {
                this.Show("没有需要建料的物料", true);
                return;
            }
            try
            {
                Logger.Debug("PDM插件，正在导出新建物料...");
                string targetPath;
                SaveFileDialog dialog = new SaveFileDialog();
                dialog.Filter = "文件|*.xlsx";
                dialog.Title = "建料申请";
                dialog.DefaultExt = "文件|*.xlsx";
                dialog.FileName = "建料申请.xlsx";
                if (dialog.ShowDialog() == true)
                {
                    targetPath = dialog.FileName;
                }
                else
                {
                    Logger.Debug("PDM插件，用户取消导出");
                    return;
                }

                // 从资源中获取模板
                byte[] template = Properties.Resources.Template;

                IWorkbook wb;
                using (ByteArrayInputStream rfs = new ByteArrayInputStream(template))
                {
                    wb = new XSSFWorkbook(rfs);
                    rfs.Close();
                }
                var sh = wb.GetSheetAt(0);
                HashSet<string> models = new HashSet<string>();
                int startRow = 6;
                for (int i = 0; i < nos.Count; i++)
                {
                    PdmBom bom = nos[i];
                    if (models.Contains(bom.partModel))
                    {
                        continue;
                    }

                    models.Add(bom.partModel);
                    sh.ShiftRows(startRow, startRow + 22, 1);

                    IRow row = sh.CreateRow(startRow);
                    IRow styleRow = sh.GetRow(startRow - 1);
                    row.Height = styleRow.Height;

                    row.CreateCell(0).SetCellValue(i + 1);
                    row.CreateCell(2).SetCellValue("pcs");
                    row.CreateCell(5).SetCellValue(bom.partModel);
                    row.CreateCell(6).SetCellValue("");
                    if (bom.jgj == true)
                    {
                        row.CreateCell(1).SetCellValue("A65");
                        string des = bom.partModel;
                        if (bom.properties.ContainsKey(PropertyName.JGJ_TYPE))
                        {
                            des += "-" + bom.properties[PropertyName.JGJ_TYPE];
                        }
                        if (bom.properties.ContainsKey(PropertyName.STUFF_TYPE))
                        {
                            des += "-" + bom.properties[PropertyName.STUFF_TYPE];
                        }
                        row.CreateCell(3).SetCellValue(des);
                        row.CreateCell(4).SetCellValue("加工件");
                    }
                    else
                    {
                        row.CreateCell(1).SetCellValue("");
                        row.CreateCell(3).SetCellValue("");
                        row.CreateCell(4).SetCellValue(bom.partBrandName);
                    }
                    for (int j = 0; j <= 6; j++)
                    {
                        row.GetCell(j).CellStyle = styleRow.GetCell(j).CellStyle;
                    }

                    startRow++;
                }
                FileStream fs = new FileStream(targetPath, FileMode.Create);
                wb.Write(fs, false);
                wb.Close();
                Logger.Debug("PDM插件，新建物料导出完成！");
                System.Diagnostics.Process.Start(targetPath);
            }
            catch (Exception ex)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Export Material Excel Failed.", ex);
                this.Error($"V{PdmUser.LoginUser.pluginVersion}，导出建料文档失败！{ex.Message}");
            }
        }

        /// <summary>
        /// 从服务器获取BOM信息
        /// </summary>
        /// <param name="topBomModel">顶层BOM型号</param>
        /// <returns>型号-Bom字典</returns>
        private Dictionary<string, BomInfo> GetBomsFromWeb(PdmBomParam param)
        {
            Result<Dictionary<string, BomInfo>> result =
                    Client.PostSyncAction<Dictionary<string, BomInfo>>(param, "wpf/bom/openApi/bomInfo");
            Dictionary<string, BomInfo> bomInfo = result.HandleResult();
            return bomInfo;
        }

        public void OnSwActiveDocChange(ModelDoc2 lastDoc, ModelDoc2 doc, Component2 comp)
        {
            //Dispatcher.Invoke(delegate
            //{
            //    logger.Debug("PDM插件，切换文档事件触发...");
            //    Button_Click(null, null);
            //});
        }

        public void SetSwApp(SldWorks SwApp)
        {
            this.SwApp = SwApp;
        }

        private void GlobalCheckBox_Checked(object sender, RoutedEventArgs e)
        {
            CheckBox cb = sender as CheckBox;
            //PdmBom bom = cb.DataContext as PdmBom;
            //bom.selected = cb.IsChecked.Value;
            //List<PdmBom> allBoms = model.bomTreeReader.CacheList.ToList();
            //foreach (PdmBom bom in allBoms)
            //{
            //    if (bom.checkBoxEnabled)
            //    {
            //        bom.selected = cb.IsChecked.Value;
            //    }
            //}
            List<PdmBom> treeBoms = model.bomTreeReader.TreeList.ToList();
            if (treeBoms == null || treeBoms.Count <= 0) return;
            treeBoms[0].selected = cb.IsChecked.Value;
            model.RefreshSelectedBomCount();
        }

        private void SingleCheckBox_Event(object sender, RoutedEventArgs e)
        {
            model.RefreshSelectedBomCount();
        }

        /// <summary>
        /// SolidWorks文档保存后触发
        /// 下面俩参数我也没搞懂有啥用
        /// </summary>
        /// <param name="doc">文档</param>
        /// <param name="comp">组件</param>
        public void OnSwActiveDocSaved(ModelDoc2 doc, Component2 comp)
        {
            // RefreshBomList(SwApp.IActiveDoc2);
        }

        private void treeDataGrid_LoadingRow(object sender, DataGridRowEventArgs e)
        {
            TreeItemData row = e.Row.Item as TreeItemData;
            PdmBom bom = row.Data as PdmBom;
            // 型材子料不可选
            // 丢失的BOM不可选
            e.Row.IsEnabled = !(bom.xcChild == true || bom.lost);
        }

        public void OnCustomPropertyChange(string propName, string Configuration, string oldValue, string NewValue, int valueType)
        {
            //throw new NotImplementedException();
        }

        /// <summary>
        /// 处理质量，保留6位小数
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static string HandleMass(double number)
        {
            return Math.Round(number, 6).ToString("0.000000");
        }

        public DrawInfo GetSingleDrawInfo(PdmBom bom)
        {
            ModelDoc2 sldDoc = bom.doc;
            Component2 component = bom.component;
            Dictionary<string, string> allProperties = new Dictionary<string, string>();
            allProperties["物料型号"] = bom.partModel;
            DrawInfo drawInfo = bom._drawInfo;
            drawInfo.isHidden = bom.isHidden;
            drawInfo.allProperties = allProperties;
            allProperties["压缩"] = bom.suppressed.ToString();
            allProperties["轻量化"] = bom.lightWeight.ToString();

            string filepath = component.GetPathName();
            // 文件是否存在
            allProperties["图纸是否存在"] = "true";
            // 带后缀的全名
            allProperties["文件全称"] = Path.GetFileName(filepath);
            // 不带后缀的文件名
            allProperties["文件名"] = Path.GetFileNameWithoutExtension(filepath);
            // 文件后缀
            allProperties["文件后缀"] = Path.GetExtension(filepath);
            // 文件路径
            allProperties["文件路径"] = filepath;
            allProperties["历史图纸"] = drawInfo.HistoryData.ToString();
            string drawFilePath = filepath.Replace(Path.GetExtension(filepath), ".slddrw");
            bool drawExists = File.Exists(drawFilePath);
            // 工程图一致性检查 
            allProperties["工程图是否存在"] = drawExists.ToString();
            // 不跳过检查的加工件，如果工程图不存在，设置noDrw为true
            if (!drawExists && !bom.skipCheck && bom.produceWay == "加工件")
            {
                drawInfo.noDrw = true;
            }
            allProperties["md5"] = bom.localD3Md5;
            if (bom.lost || bom.BomInfo.isHidden || sldDoc == null)
            {
                allProperties["图纸是否存在"] = "false";
                return drawInfo;
            }
            // 文件保存状态
            allProperties["图纸保存状态"] = sldDoc.GetSaveFlag().ToString();
            Dictionary<string, string> properties = CustomPropertyUtil.GetCustomProperties2(sldDoc, true, new HashSet<string>
            {
                "重量"
            }, null);
            // 图纸属性
            if (properties != null)
            {
                foreach (string key in properties.Keys)
                {
                    allProperties[key] = properties[key];
                }
            }
            if (drawExists)
            {
                string[] refs = SwDMUtil.GetDrawingRef2(drawFilePath, out string err, out int[] status);
                string refPath = "";
                if (refs != null && refs.Length > 0)
                {
                    foreach (var rf in refs)
                    {
                        if (string.Equals(rf, filepath, StringComparison.CurrentCultureIgnoreCase))
                        {
                            refPath = rf;
                            refPath = Path.GetFileName(refPath);
                            break;
                        }
                    }
                }
                else
                {
                    Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, [{drawFilePath}] Read slddrw Ref Path Failed.[{err}]");
                }

                //string refPath = SwDMUtil.GetDrawingRef(drawFilePath, out string errMsg);
                //if (refPath == null)
                //{
                //    Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, [{drawFilePath}] Read slddrw Ref Path Failed.[{errMsg}]");
                //}
                //else
                //{
                //    refPath = Path.GetFileName(refPath);
                //}
                Logger.Debug($"V{PdmUser.LoginUser.pluginVersion}，文档路径：【{filepath}】\r\n" +
                    $"工程图路径:【{drawFilePath}】\r\n" +
                    $"文件全称：【{allProperties["文件全称"]}】\r\n" +
                    $"Result：【{string.Join(",", refs ?? new string[] { })}】\r\n" +
                    $"Status：【{string.Join(",", status ?? new int[] { })}】\r\n" +
                    $"引用路径：【{refPath}】");
                allProperties["工程图引用文件"] = refPath;
            }
            // 质量属性
            try
            {
                // IModelDocExtension ext = sldDoc.Extension;
                // double[] massPropertys = ext.GetMassProperties2(0, out int status, false);
                double[] massPropertys = SwDMUtil.GetMassProperty(filepath, out string errMSg);
                if (massPropertys == null)
                {
                    throw new Exception(errMSg);
                }
                allProperties["体积"] = HandleMass(massPropertys[3]);
                allProperties["表面积"] = HandleMass(massPropertys[4]);
                allProperties["质量"] = HandleMass(massPropertys[5]);
                Logger.Debug(JsonUtil.Serialize(massPropertys));
            }
            catch (Exception e)
            {
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion},[{filepath}] Read Mass Properties Failed.", e);
            }
            allProperties["图纸类型"] = bom.produceWay;//bom.BomInfo.jgj;

            bom.BomInfo.properties = allProperties;
            return drawInfo;
        }

        public Dictionary<string, DrawInfo> GetAllPropertiesByTask(List<string> ErrMsgs)
        {
            ConcurrentDictionary<string, DrawInfo> result = new ConcurrentDictionary<string, DrawInfo>();
            PdmBom topBom = model.BomTree[0];
            CountdownEvent counter = new CountdownEvent(1);
            GetAllByTask(new object[] { topBom, result, counter, ErrMsgs, 0 });
            counter.Wait();
            return new Dictionary<string, DrawInfo>(result);
        }

        public void GetAllByTask(object param)
        {
            object[] datas = param as object[];
            PdmBom bom = (PdmBom)datas[0];
            ModelDoc2 sldDoc = bom.doc;
            Component2 component = bom.component;
            ConcurrentDictionary<string, DrawInfo> result = (ConcurrentDictionary<string, DrawInfo>)datas[1];
            CountdownEvent counter = (CountdownEvent)datas[2];
            List<string> ErrMsgs = (List<string>)datas[3];
            int level = (int)datas[4];
            try
            {
                counter.AddCount();
                string filepath = bom.partNo;
                lock (result)
                {
                    if (result.ContainsKey(filepath))
                    {
                        if (bom.isHidden)
                        {
                            result[filepath].isHidden = true;
                        }
                        return;
                    }
                    if (!bom.skipCheck)
                    {
                        result[filepath] = GetSingleDrawInfo(bom);
                        if (bom.BomInfo.inKeeDeeDb == true) result[filepath]._inKeeDeeDb = true;

                    }
                }

                ObservableCollection<PdmBom> children = bom.modules;
                if (children != null)
                {
                    foreach (PdmBom child in children)
                    {
                        taskFactory.StartNew(() =>
                        {
                            GetAllByTask(new object[] { child, result, counter, ErrMsgs, 1 });
                        });
                    }
                }
                MaskAdorner.ShowMessage(content, filepath);
            }
            catch (Exception e)
            {
                bom.drawInfo.checkRuleResult = 2;
                bom.drawInfo.errMessages = new List<string> { e.Message };
                Logger.Error($"V{PdmUser.LoginUser.pluginVersion},[{bom.filePath}] Read MASS Properies Failed.", e);
            }
            finally
            {
                counter.Signal();
                if (level == 0)
                {
                    counter.Signal();
                }
            }
        }

        public bool DoCheckRuleAsync(out List<string> messages)
        {
            var temp = new List<string>();
            bool allSuccess = true;
            Dictionary<string, DrawInfo> properties = GetAllPropertiesByTask(temp);
            MaskAdorner.ShowMessage(content, "正在请求数据...");
            // var factory = LimitedConcurrencyLevelTaskScheduler.Factory;
            CountdownEvent counter = new CountdownEvent(properties.Count);
            int iii = 0;
            var start = DateTime.Now;
            Logger.Debug("DoCheckRuleAsync Start...");
            foreach (KeyValuePair<string, DrawInfo> property in properties)
            {
                /// Task.Run 这个方法最快，但不好管控，因为不知道属性字典有多大
                /// taskFactory.StartNew 稳定一点吗？
                taskFactory.StartNew(() =>
                {
                    string key = property.Key;
                    iii++;
                    try
                    {
                        Logger.Debug($"{key} checking rule...");
                        DrawInfo checkResult;
                        Result<DrawInfo> result = Client.PostSyncAction<DrawInfo>(property.Value, "wpf/bom/openApi/checkRuleSingle");
                        checkResult = result.HandleResult();
                        properties[key].checkRuleResult = checkResult.checkRuleResult;
                        properties[key].errMessages = checkResult.errMessages;
                        var msgs = checkResult.errMessages;
                        if (property.Value.noDrw || property.Value.isHidden || (!properties[key].HistoryData && (!checkResult.checkRuleOk)))
                        {
                            allSuccess = false;
                        }

                        lock (temp)
                        {
                            if (property.Value.isHidden)
                            {
                                temp.Add($"物料【{key}】被设置为隐藏!");
                            }
                            if (property.Value.noDrw && property.Value.HistoryData)
                            {
                                temp.Add($"物料【{key}】未找到工程图!");
                            }
                            if (!properties[key].HistoryData)
                            {
                                if (msgs != null && msgs.Count > 0)
                                {
                                    foreach (string msg in msgs)
                                    {
                                        temp.Add($"物料【{key}】未通过规则检查！{msg}");
                                    }
                                }
                            }
                        }
                        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                    }
                    catch (Exception ex)
                    {
                        properties[key].checkRuleResult = 2;
                        properties[key].errMessages = new List<string> { "发起检查失败，请重试" };
                        lock (temp)
                        {
                            temp.Add($"物料【{key}】发起检查失败，请重试");
                        }
                        allSuccess = false;
                        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                    }
                    finally
                    {
                        counter.Signal();
                    }
                });

                //LimitedConcurrencyLevelTaskScheduler scheduler = new LimitedConcurrencyLevelTaskScheduler(int.MaxValue);
                //Task.Factory.StartNew(() => {
                //    string key = property.Key;
                //    iii++;
                //    try
                //    {
                //        Logger.Error($"{key} checking rule...");
                //        Result<DrawInfo> result = Client.PostSyncAction<DrawInfo>(property.Value, "wpf/bom/openApi/checkRuleSingle");
                //        DrawInfo checkResult = result.HandleResult();
                //        properties[key].checkRuleResult = checkResult.checkRuleResult;
                //        properties[key].errMessages = checkResult.errMessages;
                //        var msgs = checkResult.errMessages;
                //        if (!properties[key].HistoryData && !checkResult.checkRuleOk)
                //        {
                //            allSuccess = false;
                //        }

                //        if (!properties[key].HistoryData && msgs != null && msgs.Count > 0)
                //        {
                //            lock (temp)
                //            {
                //                foreach (string msg in msgs)
                //                {
                //                    temp.Add($"物料【{key}】未通过规则检查！{msg}");
                //                }
                //            }
                //        }
                //        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                //    }
                //    catch (Exception ex)
                //    {
                //        properties[key].checkRuleResult = 2;
                //        properties[key].errMessages = new List<string> { "发起检查失败，请重试" };
                //        lock (temp)
                //        {
                //            temp.Add($"物料【{key}】发起检查失败，请重试");
                //        }
                //        allSuccess = false;
                //        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                //    }
                //    finally
                //    {
                //        counter.Signal();
                //    }
                //}, CancellationToken.None, TaskCreationOptions.None, scheduler);


                /// 下面两个都在管控Task数量，但还是很慢
                /*string key = property.Key;
                _ = ThreadPool.QueueUserWorkItem(
                (WaitCallback)delegate
                {
                    iii++;
                    try
                    {
                        Logger.Error($"{key} checking rule...");
                        Result<DrawInfo> result = Client.PostSyncAction<DrawInfo>(property.Value, "wpf/bom/openApi/checkRuleSingle");
                        DrawInfo checkResult = result.HandleResult();
                        properties[key].checkRuleResult = checkResult.checkRuleResult;
                        properties[key].errMessages = checkResult.errMessages;
                        var msgs = checkResult.errMessages;
                        if (!properties[key].HistoryData && !checkResult.checkRuleOk)
                        {
                            allSuccess = false;
                        }

                        if (!properties[key].HistoryData && msgs != null && msgs.Count > 0)
                        {
                            lock (temp)
                            {
                                foreach (string msg in msgs)
                                {
                                    temp.Add($"物料【{key}】未通过规则检查！{msg}");
                                }
                            }
                        }
                        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                    }
                    catch (Exception ex)
                    {
                        properties[key].checkRuleResult = 2;
                        properties[key].errMessages = new List<string> { "发起检查失败，请重试" };
                        lock (temp)
                        {
                            temp.Add($"物料【{key}】发起检查失败，请重试");
                        }
                        allSuccess = false;
                        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                    }
                    finally
                    {
                        counter.Signal();
                    }
                });*/

                //factory.StartNew(() =>
                //{
                //    string key = property.Key;
                //    iii++;
                //    try
                //    {
                //        Logger.Error($"{key} checking rule...");
                //        Result<DrawInfo> result = Client.PostSyncAction<DrawInfo>(property.Value, "wpf/bom/openApi/checkRuleSingle");
                //        DrawInfo checkResult = result.HandleResult();
                //        properties[key].checkRuleResult = checkResult.checkRuleResult;
                //        properties[key].errMessages = checkResult.errMessages;
                //        var msgs = checkResult.errMessages;
                //        if (!properties[key].HistoryData && !checkResult.checkRuleOk)
                //        {
                //            allSuccess = false;
                //        }

                //        if (!properties[key].HistoryData && msgs != null && msgs.Count > 0)
                //        {
                //            lock (temp)
                //            {
                //                foreach (string msg in msgs)
                //                {
                //                    temp.Add($"物料【{key}】未通过规则检查！{msg}");
                //                }
                //            }
                //        }
                //        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                //    }
                //    catch (Exception ex)
                //    {
                //        properties[key].checkRuleResult = 2;
                //        properties[key].errMessages = new List<string> { "发起检查失败，请重试" };
                //        lock (temp)
                //        {
                //            temp.Add($"物料【{key}】发起检查失败，请重试");
                //        }
                //        allSuccess = false;
                //        MaskAdorner.ShowMessage(content, $"物料【{key}】检查完成");
                //    }
                //    finally
                //    {
                //        counter.Signal();
                //    }
                //});
            }
            counter.Wait();
            counter.Dispose();
            messages = temp;
            Logger.Debug($"DoCheckRuleAsync Ended in {(DateTime.Now - start).TotalMilliseconds}ms.");
            return allSuccess;
        }

        private void ShowExWindow(MultiExWindow exWin)
        {
            IntPtr winformWindow = Process.GetCurrentProcess().MainWindowHandle;
            if (winformWindow != null)
                new WindowInteropHelper(exWin) { Owner = winformWindow };
            exWin.ShowDialog();
        }

        /// <summary>
        /// 规则检查按钮点击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CheckRule_Click(object sender, RoutedEventArgs e)
        {
            if (SwApp.IActiveDoc2 == null)
            {
                RefreshBomList(null);
                return;
            }
            workStatus = PdmStatus.CHECKING;
            MaskAdorner.ShowMask(content, "检查中，请稍后...");
            Task.Run(() =>
            {
                try
                {
                    RefreshBomList(SwApp.IActiveDoc2);
                    if (model.bomTreeReader.needSaveList.Count > 0)
                    {
                        List<string> infos = new List<string>(model.bomTreeReader.needSaveList);
                        AutoSaveAlert(infos);
                    }

                    if (!DoCheckRuleAsync(out List<string> msgs))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            MultiExWindow exWin = new MultiExWindow(this, "检查结果", msgs);
                            ShowExWindow(exWin);
                        });
                    }
                }
                catch (Exception ex)
                {
                    Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, PDM check rule failed.", ex);
                    this.Error($"V{PdmUser.LoginUser.pluginVersion}，图纸检查执行失败！{ex.Message}");
                }
                finally
                {
                    workStatus = PdmStatus.FREE;
                    MaskAdorner.HideMask(content);
                }
            });
        }

        /// <summary>
        /// 刷新WEB数据
        /// </summary>
        public void RefreshWebBomInfo()
        {
            model.RefreshWebInfo(Client);
        }

        /// <summary>
        /// 发起审批按钮点击
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void DrawAudit_Click(object sender, RoutedEventArgs e)
        {
            if (SwApp.IActiveDoc2 == null)
            {
                RefreshBomList(null);
                return;
            }
            workStatus = PdmStatus.UPLOADING;
            MaskAdorner.ShowMask(content, "请求中，请稍等...");
            Task.Run(() =>
            {
                try
                {
                    // 对所有的BOM做规则检查
                    bool allSuccess = DoCheckRuleAsync(out _);
                    // 先获取所有的BOM
                    HashSet<string> cache = new HashSet<string>();
                    // 然后筛选选中的BOM
                    List<PdmBom> boms = model.bomTreeReader.CacheList.Where(b => b.selected).ToList();
                    if (boms == null || boms.Count <= 0)
                    {   // 如果没有选中的BOM，那就是所有BOM
                        boms = model.bomTreeReader.CacheList.ToList();
                    }
                    // 筛选有图纸的，在物料明细中，未提交的，在物料明细表中的零件体加工件进行上传
                    boms = boms.Where(b =>
                    {
                        if (!cache.Contains(b.partModel))
                        {
                            cache.Add(b.partModel);
                            return b.NeedAudit;
                        }
                        return false;
                    }).ToList();

                    if (boms == null || boms.Count <= 0)
                    {
                        this.Warning("只有未提交过或发生变更的加工件图纸可以进行审核");
                        return;
                    }

                    if (!allSuccess)
                    {
                        // 如果有未通过的图纸，需要提示
                        var err = boms.Where(b => b.noDrw || b.isHidden || (!b.IsHistoryData && (!b.checkRuleOk))).ToList();
                        if (err != null && err.Count > 0)
                        {
                            List<string> msgs = new List<string>();
                            foreach (var ee in err)
                            {
                                if (ee.noDrw && ee.IsHistoryData)
                                {
                                    msgs.Add($"物料【{ee.partNo}】未通过规则检查！未找到工程图");
                                }
                                if (ee.drawInfo.isHidden)
                                {
                                    msgs.Add($"物料【{ee.partNo}】未通过规则检查！被设为隐藏");
                                }
                                if (ee.drawInfo.errMessages == null)
                                {
                                    msgs.Add($"物料【{ee.partNo}】未通过规则检查！");
                                    continue;
                                }
                                foreach (string msg in ee.drawInfo.errMessages)
                                {
                                    msgs.Add($"物料【{ee.partNo}】未通过规则检查！{msg}");
                                }
                            }

                            Dispatcher.Invoke(() =>
                            {
                                MultiExWindow exWin = new MultiExWindow(this, "多个待提交的图纸未通过规则检查，请确认", msgs);
                                ShowExWindow(exWin);
                            });
                            return;
                        }
                    }

                    // 都通过了，再进行审批

                    // 筛选非特殊的审核
                    boms = boms.Where(b => !b._drawInfo.isSpecial).ToList();
                    if (boms == null || boms.Count <= 0) return;

                    // 先申请单号
                    DrawAuditOrder daOrder = new DrawAuditOrder
                    {
                        requestUserId = PdmUser.LoginUser.id,
                        requestUser = PdmUser.LoginUser.realname
                    };
                    try
                    {
                        Result<DrawAuditOrder> res = Client.PostSyncAction<DrawAuditOrder>(daOrder, "drawAudit/order/create");
                        daOrder = res.HandleResult();
                    }
                    catch (Exception ex)
                    {
                        Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Request AuditOrder Code Failed.", ex);
                        this.Error($"V{PdmUser.LoginUser.pluginVersion}，请求审批单号失败! {ex.Message}");
                        return;
                    }

                    ConcurrentQueue<string> errs = new ConcurrentQueue<string>();
                    CountdownEvent counter = new CountdownEvent(boms.Count);
                    int successCount = 0;
                    ConcurrentQueue<string> pathCache = new ConcurrentQueue<string>(boms.Select(b => b.filePath).ToList());
                    foreach (PdmBom bom in boms)
                    {
                        taskFactory.StartNew(() =>
                        {
                            try
                            {
                                MaskAdorner.ShowMessage(content, $"正在上传【{bom.partNo}】...");
                                UploadDraw(daOrder, bom, pathCache);
                                Interlocked.Increment(ref successCount);
                            }
                            catch (Exception ex)
                            {
                                Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, [{bom.partModel}] Request Audit Failed.", ex);
                                errs.Enqueue($"物料【{bom.partModel}】发起审批失败！{ex.Message}");
                            }
                            finally
                            {
                                counter.Signal();
                            }
                        });
                    }
                    counter.Wait();
                    counter.Dispose();
                    if (successCount > 0)
                    {
                        try
                        {
                            var param = new DrawAudit
                            {
                                orderId = daOrder.id,
                                count = successCount
                            };
                            var msgRes = Client.PostSyncAction<object>(param, "drawAudit/sendToAuditor");
                            msgRes.HandleResult();
                        }
                        catch (Exception ig)
                        {
                            Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Send Audit Socket Failed.", ig);
                        }
                    }
                    // 刷新服务器上的BOM信息
                    RefreshWebBomInfo();
                    if (errs.Count > 0)
                    {
                        Dispatcher.Invoke(() =>
                        {
                            MultiExWindow exWindow = new MultiExWindow(this, "审批失败", errs.ToList());
                            exWindow.ShowDialog();
                        });
                    }
                }
                catch (Exception ex)
                {
                    Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Request audit failed", ex);
                    this.Error($"V{PdmUser.LoginUser.pluginVersion}，发起审批异常！{ex}");
                }
                finally
                {
                    workStatus = PdmStatus.FREE;
                    MaskAdorner.HideMask(content);
                }
            });
        }

        /// <summary>
        /// 上传图纸操作
        /// </summary>
        /// <param name="daOrder"></param>
        /// <param name="bom"></param>
        private void UploadDraw(DrawAuditOrder daOrder, PdmBom bom, ConcurrentQueue<string> pathCache)
        {
            if (bom.BomInfo.drawingType == (int)swDocumentTypes_e.swDocASSEMBLY && bom.children != null && bom.children.Count > 0)
            {
                foreach (PdmBom child in bom.children)
                {
                    UploadChildDraw(daOrder, child, true, pathCache);
                }
            }
            UploadSingleDraw(daOrder, bom, false);
        }

        /// <summary>
        /// 上传子零件图纸，有递归
        /// </summary>
        /// <param name="daOrder"></param>
        /// <param name="bom"></param>
        /// <param name="justUpload"></param>
        private void UploadChildDraw(DrawAuditOrder daOrder, PdmBom bom, bool justUpload, ConcurrentQueue<string> pathCache)
        {
            if (bom.BomInfo.drawingType == (int)swDocumentTypes_e.swDocASSEMBLY && bom.children != null && bom.children.Count > 0)
            {
                foreach (PdmBom child in bom.children)
                {
                    UploadChildDraw(daOrder, child, justUpload, pathCache);
                }
            }
            if (!pathCache.Contains(bom.filePath))
            {
                UploadSingleDraw(daOrder, bom, justUpload);
                pathCache.Append(bom.filePath);
            }
        }

        /// <summary>
        /// 上传单张图纸
        /// </summary>
        /// <param name="daOrder"></param>
        /// <param name="bom"></param>
        /// <param name="justUpload"></param>
        /// <exception cref="Exception"></exception>
        private void UploadSingleDraw(DrawAuditOrder daOrder, PdmBom bom, bool justUpload)
        {
            try
            {
                string d3FilePath = bom.d3FilePath;
                string d2FilePath = d3FilePath.Replace(Path.GetExtension(d3FilePath), ".slddrw");
                if (string.IsNullOrEmpty(d3FilePath) || !File.Exists(d3FilePath))
                {
                    throw new Exception($"[{bom.partModel}]未找到3D图纸");
                }
                // !justUpload（需要审核）要判断2D图纸存不存在
                if (!justUpload && (string.IsNullOrEmpty(d2FilePath) || !File.Exists(d2FilePath)))
                {
                    throw new Exception($"[{bom.partModel}]未找到工程图纸");
                }
                MultipartFormDataContent httpContent = new MultipartFormDataContent();
                httpContent.Add(new StringContent(bom.partNo), "materialCode");
                httpContent.Add(new StringContent(bom.partNo), "materialModel");
                httpContent.Add(new StringContent(daOrder.id), "orderId");
                httpContent.Add(new StringContent(justUpload.ToString()), "justUpload");
                FileInfo fileInfo = new FileInfo(d3FilePath);
                httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(d3FilePath)), "d3File", fileInfo.Name);
                //  !justUpload（需要审核）要上传2D图
                if (!justUpload)
                {
                    FileInfo file2Info = new FileInfo(d2FilePath);
                    httpContent.Add(new ByteArrayContent(FileUtil.toByteArray(d2FilePath)), "d2File", file2Info.Name);
                }
                Result<DrawAudit> res = Client.PostSyncAction<DrawAudit>("drawAudit/add", httpContent);
                DrawAudit da = res.HandleResult();
            }
            catch (NullReferenceException nex)
            {
                Logger.Error($"UploadSingleDraw NullReferenceException.", nex);
            }
        }

        private void Exclude_Click(object sender, RoutedEventArgs e)
        {
            if (SwApp.IActiveDoc2 == null)
            {
                RefreshBomList(null);
                return;
            }
            if (SwApp.SendMsgToUser2("确定将未通过的物料全部排除物料明细表吗？", (int)swMessageBoxIcon_e.swMbWarning
                   , (int)swMessageBoxBtn_e.swMbYesNo) == (int)swMessageBoxResult_e.swMbHitYes)
            {
                MaskAdorner.ShowMask(content, "操作中，请稍后...");
                Task.Run(() =>
                {
                    try
                    {
                        workStatus = PdmStatus.READING;
                        List<PdmBom> boms = model.bomTreeReader.CacheList.Where(b => b.BomInfo.status == "rejected")
                        .ToList();
                        if (boms == null || boms.Count <= 0)
                        {
                            this.Warning("没有未通过的物料");
                            return;
                        }
                        Dispatcher.Invoke(() =>
                        {
                            foreach (PdmBom bom in boms)
                            {
                                bom.UpdateInBom(true);
                            }
                            RefreshBomTree();
                        });

                    }
                    finally
                    {
                        workStatus = PdmStatus.FREE;
                        MaskAdorner.HideMask(content);
                    }
                });
            }
        }

        /// <summary>
        /// 树数据展示过滤
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CollectionViewSource_Filter(object sender, FilterEventArgs e)
        {
            if (e.Item is TreeItemData data)
            {
                e.Accepted = data.IsVisible;
            }
        }

        /// <summary>
        /// 树展开/关闭事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void treeDataGrid_ExpandedChange(object sender, bool e)
        {
            CollectionViewSource cvs = this.Resources["TreeGridFilter"] as CollectionViewSource;
            cvs?.View.Refresh();
        }

        /// <summary>
        /// 双击打开检查结果
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TextBox_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            try
            {
                // 检查是否是双击
                if (e.ClickCount == 2)
                {
                    TextBlock textBlock = sender as TextBlock;
                    PdmBom bom = textBlock.DataContext as PdmBom;
                    if (bom.checkRuleResult == 0)
                    {
                        this.Warning("该图纸还未检查");
                        return;
                    }

                    List<string> errs = new List<string>();
                    if (bom.noDrw && bom.IsHistoryData)
                    {
                        errs.Add("工程图不存在 ");
                    }
                    if (bom.isHidden)
                    {
                        errs.Add("文档被设置为隐藏");
                    }
                    if (bom.drawInfo.errMessages != null)
                    {
                        errs.AddRange(bom.drawInfo.errMessages);
                    }
                    if (errs.Count > 0)
                    {
                        MultiExWindow exWin = new MultiExWindow(this, "检查结果", errs);
                        ShowExWindow(exWin);
                    }
                    else if (bom.checkRuleResult == 3)
                    {
                        string title = string.Empty;
                        if (bom.IsHistoryData)
                        {
                            title = "历史图纸无需检查";
                        }
                        else if (bom.ExcludeFromBOM)
                        {
                            title = "不在物料明细表中的物料无需检查";
                        }
                        else if (bom.component?.IsVirtual == true)
                        {
                            title = "虚拟件无需检查";
                        }
                        else
                        {
                            title = "无需检查";
                        }
                        this.Info(title);
                        return;
                    }
                    else if (bom.checkRuleOk && !bom.isHidden)
                    {
                        this.Show("规则检查通过");
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error("Double Click CheckRule Exception.", ex);
                this.Error($"未知异常:{ex.Message}");
            }
        }

        /// <summary>
        /// 双击打开审核详情
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AuditTextBox_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            try
            {
                // 检查是否是双击
                if (e.ClickCount == 2)
                {
                    TextBlock textBlock = sender as TextBlock;
                    PdmBom bom = textBlock.DataContext as PdmBom;
                    if (bom._drawInfo.isSpecial)
                    {
                        this.Info("无需审核");
                        return;
                    }
                    if (bom.BomInfo.inKeeDeeDb == true)
                    {
                        this.Info("已入系统");
                        return;
                    }
                    if (string.IsNullOrEmpty(bom.BomInfo.status))
                    {
                        if (bom.produceWay == "模组" || bom.produceWay == "标准件")
                        {
                            this.Info($"{bom.produceWay}无需审核");
                            return;
                        }
                        if (bom.IsHistoryData && !bom.localDocChanged)
                        {
                            this.Info("历史图纸无需审核");
                            return;
                        }
                        if (bom.IsHistoryData && bom.localDocChanged)
                        {
                            this.Info("历史图纸一致性变更，需审核");
                            return;
                        }
                        this.Warning("该图纸未审核");
                        return;
                    }
                    MaskAdorner.ShowMask(content, "请求中，请稍后...");
                    Task.Run(() =>
                    {
                        try
                        {
                            Result<List<DrawAuditHis>> res = Client.GetSyncAction<List<DrawAuditHis>>("drawAudit/listTaskHis", new DrawAudit
                            {
                                id = bom.BomInfo.id
                            });
                            var datas = res.HandleResult();
                            Dispatcher.Invoke(() =>
                            {
                                //DrawAuditHisWindow window = new DrawAuditHisWindow(this, $"【{bom.partModel}】审核详情", datas);
                                RichHisWindow window = new RichHisWindow(this, $"【{bom.partModel}】审核详情", datas);

                                window.ShowDialog();
                            });
                        }
                        catch (Exception ex)
                        {
                            Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, Get draw audit history failed.", ex);
                            this.Error($"V{PdmUser.LoginUser.pluginVersion}，获取审核历史失败！{ex.Message}");
                        }
                        finally
                        {
                            MaskAdorner.HideMask(content);
                        }
                    });
                }
            }
            catch (Exception ex)
            {
                Logger.Error("Double Click Audit Status Exception.", ex);
                this.Error($"未知异常:{ex.Message}");
            }
        }


        private volatile IntPtr importPtr = IntPtr.Zero;
        private volatile IntPtr checkInPtr = IntPtr.Zero;

        private readonly object importLock = new object();
        private readonly object checkInLock = new object();

        // 捕捉到插件启动事件
        private event PtrHandler PtrCheckHandler;

        /// <summary>
        /// 搜索是否有导入窗口，有就一直最小化，并执行规则检查
        /// </summary>
        /// <returns></returns>
        private async Task ListenImportHandle()
        {
            IntPtr ptr = WindowIntPtrUtil.FindWindow(null, PluginSetting.Instance.ImportListenName);
            if (ptr == IntPtr.Zero)
            {
                return;
            }
            if (ptr != importPtr)
            {
                WindowIntPtrUtil.ShowWindow(ptr, 6);
                lock (importLock)
                {
                    importPtr = ptr;
                    PtrCheckHandler += ImportHandler;
                }
                await PtrHandler2();
            }
            else if (workStatus == PdmStatus.DO_LISTENING)
            {
                WindowIntPtrUtil.ShowWindow(ptr, 6);
            }
        }

        /// <summary>
        /// 规则检查执行完之后的操作，成功就激活导入窗口，失败就关闭导入窗口
        /// </summary>
        /// <param name="errs"></param>
        /// <param name="ex"></param>
        /// <param name="success"></param>
        private void ImportHandler(List<string> errs, Exception ex, bool success)
        {
            lock (importLock)
            {
                if (success)
                {
                    WindowIntPtrUtil.ShowWindow(importPtr, 1);
                }
                else
                {
                    WindowIntPtrUtil.KillProcessByIntPtr(importPtr);
                    importPtr = IntPtr.Zero;
                }
                PtrCheckHandler -= ImportHandler;
            }
        }

        /// <summary>
        /// 搜索是否有检入窗口，有就一直最小化，并执行规则检查
        /// </summary>
        /// <returns></returns>
        private async Task ListenCheckInHandle()
        {

            IntPtr ptr = WindowIntPtrUtil.FindWindow(null, PluginSetting.Instance.CheckInListenName);
            if (ptr == IntPtr.Zero)
            {
                return;
            }
            if (ptr != checkInPtr)
            {
                WindowIntPtrUtil.ShowWindow(ptr, 6);
                lock (checkInLock)
                {
                    checkInPtr = ptr;
                    PtrCheckHandler += CheckInWindowHandler;
                }
                await PtrHandler2();
            }
            else if (workStatus == PdmStatus.DO_LISTENING)
            {
                WindowIntPtrUtil.ShowWindow(ptr, 6);
            }
        }

        /// <summary>
        /// 规则检查执行完之后的操作，成功就激活导入窗口，失败就关闭导入窗口
        /// </summary>
        /// <param name="errs"></param>
        /// <param name="ex"></param>
        /// <param name="success"></param>
        private void CheckInWindowHandler(List<string> errs, Exception ex, bool success)
        {
            lock (checkInLock)
            {
                if (success)
                {
                    WindowIntPtrUtil.ShowWindow(checkInPtr, 1);
                }
                else
                {
                    WindowIntPtrUtil.KillProcessByIntPtr(checkInPtr);
                    checkInPtr = IntPtr.Zero;
                }
                PtrCheckHandler -= CheckInWindowHandler;
            }
        }

        private async Task PtrHandler2()
        {
            if (workStatus == PdmStatus.FREE)
            {
                workStatus = PdmStatus.DO_LISTENING;
                MaskAdorner.ShowMask(content, "检查中，请稍后...");
                await Task.Run(() =>
                {
                    try
                    {
                        // 执行规则检查并获取结果
                        RefreshBomList(SwApp.IActiveDoc2);
                        if (model.bomTreeReader.CacheList.Count <= 0)
                        {
                            throw new CantCheckInException(new List<string> { "请打开一张图纸" });
                        }
                        if (model.bomTreeReader.needSaveList.Count > 0)
                        {
                            List<string> infos = new List<string>(model.bomTreeReader.needSaveList);
                            AutoSaveAlert(infos);
                        }

                        DoCheckRuleAsync(out _);
                        // 筛选所有在物料明细表中，不跳过检查并且检查未通过的，类型是加工件的未通过审核的，加工件审核通过的但图纸变更的
                        List<string> errs = model.bomTreeReader.CacheList.Select(b => b.NeedStopCheckIn())
                        .Where(s => s != null).ToList();

                        if (errs != null && errs.Count > 0)
                        {
                            throw new CantCheckInException(errs);
                        }
                        PtrCheckHandler?.Invoke(null, null, true);
                    }
                    catch (CantCheckInException cex)
                    {
                        PtrCheckHandler?.Invoke(cex.errs, null, false);
                        Dispatcher.Invoke(() =>
                        {
                            MultiExWindow exWin = new MultiExWindow(this, "检入停止", cex.errs);
                            exWin.ShowDialog();
                        });
                    }
                    catch (Exception ex)
                    {
                        PtrCheckHandler?.Invoke(null, ex, false);
                        Logger.Error($"V{PdmUser.LoginUser.pluginVersion}, PDM check rule failed.", ex);
                        this.Error($"V{PdmUser.LoginUser.pluginVersion}，图纸检查执行失败：{ex.Message}");
                    }
                    finally
                    {
                        workStatus = PdmStatus.FREE;
                        MaskAdorner.HideMask(content);
                    }
                });
            }
            else if (workStatus != PdmStatus.DO_LISTENING)
            {
                PtrCheckHandler?.Invoke(null, null, false);
                if (workStatus == PdmStatus.CHECKING)
                {
                    this.Info("正在进行规则检查，请勿检入");
                }
                else if (workStatus == PdmStatus.READING)
                {
                    this.Info("正在加载，请勿检入");
                }
                else if (workStatus == PdmStatus.UPLOADING)
                {
                    this.Info("正在上传图纸，请勿检入");
                }
            }
        }


        private Task importListenTask;
        private Task checkInListenTask;
        /// <summary>
        /// 开启插件监听线程
        /// </summary>
        public void InitDemonThread()
        {
            importListenTask = Task.Run(() =>
            {
                while (true)
                {
                    // 监听导入插件的启动
                    ListenImportHandle();
                    Thread.Sleep(PluginSetting.Instance.ScanInterval);
                }
            });

            checkInListenTask = Task.Run(() =>
            {
                while (true)
                {
                    // 监听检入插件的启动
                    ListenCheckInHandle();
                    Thread.Sleep(PluginSetting.Instance.ScanInterval);
                }
            });
        }

        public void OnDocDestroy(ModelDoc2 doc)
        {

        }

        public void AfterDocDestroy()
        {

        }

        public void DisabledHandler()
        {

        }
    }
}