using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using Bricscad.EditorInput;
using ImTools;
using IniParser.Model;
using Microsoft.Win32;
using Newtonsoft.Json;
using Prism.Events;
using Prism.Services.Dialogs;
using SWS.CAD.Base;
using SWS.Commons;
using SWS.Electrical.Models;
using SWS.Model;
using SWS.Service;
using SWS.WPF.ViewModels;
using Teigha.DatabaseServices;
using Teigha.Geometry;
using Teigha.GraphicsSystem;
using Telerik.Windows.Controls;
using Unity;
using Visibility = System.Windows.Visibility;

namespace SWS.Electrical.ViewModels
{
    public class MessageModel
    {
        /// <summary>
        /// 信息
        /// </summary>
        public string Message { get; set; }
        /// <summary>
        /// 是否成功
        /// </summary>
        public bool IsSuccess { get; set; } = true;
    }
    public class DialogAutoArrangeLayoutViewModel : DialogBase, IDialogAware
    {
        private ObservableCollection<DtoDrawing> _listDrawings;
        /// <summary>
        /// 布置图列表
        /// </summary>
        public ObservableCollection<DtoDrawing> listDrawings
        {
            get { return this._listDrawings; }
            set
            {
                if (value != this._listDrawings)
                {
                    this._listDrawings = value;
                    RaisePropertyChanged(nameof(listDrawings));
                }
            }
        }
        private ObservableCollection<DtoAutoPlotLayout> _listBasePoint;
        /// <summary>
        /// 正常基点元件列表
        /// </summary>
        public ObservableCollection<DtoAutoPlotLayout> listBasePoint
        {
            get { return this._listBasePoint; }
            set
            {
                if (value != this._listBasePoint)
                {
                    this._listBasePoint = value;
                    RaisePropertyChanged(nameof(listBasePoint));
                }
            }
        }
        private ObservableCollection<DtoAutoPlotLayout> _listErrBasePoint;
        /// <summary>
        /// 异常基点元件列表
        /// </summary>
        public ObservableCollection<DtoAutoPlotLayout> listErrBasePoint
        {
            get { return this._listErrBasePoint; }
            set
            {
                if (value != this._listErrBasePoint)
                {
                    this._listErrBasePoint = value;
                    RaisePropertyChanged(nameof(listErrBasePoint));
                }
            }
        }
        private DtoAutoPlotLayout _SelectedTag;
        /// <summary>
        /// 基点元件
        /// </summary>
        public DtoAutoPlotLayout SelectedTag
        {
            get { return this._SelectedTag; }
            set
            {
                this._SelectedTag = value;
                RaisePropertyChanged(nameof(SelectedTag));
            }
        }
        private bool _IsSelectAll = false;
        public bool IsSelectAll
        {
            get { return _IsSelectAll; }
            set
            {
                _IsSelectAll = value;
                RaisePropertyChanged(nameof(IsSelectAll));
            }
        }
        private ObservableCollection<TextBlock> _listMsg;
        /// <summary>
        /// 信息列表
        /// </summary>
        public ObservableCollection<TextBlock> listMsg
        {
            get { return this._listMsg; }
            set
            {
                if (value != this._listMsg)
                {
                    this._listMsg = value;
                    RaisePropertyChanged(nameof(listMsg));
                }
            }
        }
        private ObservableCollection<KeyValueModel> _listRange;
        /// <summary>
        /// 范围
        /// </summary>
        public ObservableCollection<KeyValueModel> listRange
        {
            get { return this._listRange; }
            set
            {
                if (value != this._listRange)
                {
                    this._listRange = value;
                    RaisePropertyChanged(nameof(listRange));
                }
            }
        }
        private KeyValueModel _selectRange;
        /// <summary>
        /// 选中范围
        /// </summary>
        public KeyValueModel selectRange
        {
            get { return this._selectRange; }
            set
            {
                if (value != this._selectRange)
                {
                    this._selectRange = value;
                    RangeChange(value);
                    RaisePropertyChanged(nameof(selectRange));
                }
            }
        }

        private ObservableCollection<KeyValueModel> _listOperator;
        /// <summary>
        /// 判断
        /// </summary>
        public ObservableCollection<KeyValueModel> listOperator
        {
            get { return this._listOperator; }
            set
            {
                if (value != this._listOperator)
                {
                    this._listOperator = value;
                    RaisePropertyChanged(nameof(listOperator));
                }
            }
        }
        private KeyValueModel _selectOperator;
        /// <summary>
        /// 选中判断
        /// </summary>
        public KeyValueModel selectOperator
        {
            get { return this._selectOperator; }
            set
            {
                if (value != this._selectOperator)
                {
                    this._selectOperator = value;
                    RaisePropertyChanged(nameof(selectOperator));
                }
            }
        }
        private ObservableCollection<KeyValueModel> _listValue;
        /// <summary>
        /// 输入值 列表
        /// </summary>
        public ObservableCollection<KeyValueModel> listValue
        {
            get { return this._listValue; }
            set
            {
                if (value != this._listValue)
                {
                    this._listValue = value;
                    RaisePropertyChanged(nameof(listValue));
                }
            }
        }
        private string _inputValue = "";
        /// <summary>
        /// 输入值
        /// </summary>
        public string inputValue
        {
            get { return _inputValue; }
            set { _inputValue = value; OnPropertyChanged(nameof(inputValue)); }
        }
        private string _NormalTagCount = "正常元件";
        /// <summary>
        /// 正常位号
        /// </summary>
        public string NormalTagCount
        {
            get { return _NormalTagCount; }
            set { _NormalTagCount = value; OnPropertyChanged(nameof(NormalTagCount)); }
        }
        private string _ErrTagCount = "异常元件";
        /// <summary>
        /// 异常位号
        /// </summary>
        public string ErrTagCount
        {
            get { return _ErrTagCount; }
            set { _ErrTagCount = value; OnPropertyChanged(nameof(ErrTagCount)); }
        }
        private bool _isCheckDelete = false;
        /// <summary>
        /// 删除现有元件再绘制
        /// </summary>
        public bool isCheckDelete
        {
            get { return _isCheckDelete; }
            set { _isCheckDelete = value; OnPropertyChanged(nameof(isCheckDelete)); }
        }

        /// <summary>
        /// 命令事件
        /// </summary>
        public ICommand Command_StartDrawing { get; set; }
        public ICommand Command_GetBasePoint { get; set; }

        public ICommand Command_SelectedTag { get; set; }

        public ICommand Command_SelectedAll { get; set; }

        PlotLayoutService _ServicePlotLayout;
        DrawingServce _ServiceDrawing;
        AnnexesService _ServiceAnnexes;
        LibraryFileService _ServiceLibraryFile;
        DrawingCatalogueService _ServiceDrawingCatalogue;
        EnginedataService _ServiceEnginedata;
        ObjectTypeService _ServiceObjectType;
        ProjectSettingsService _ServiceProjectSettings;
        DataItemService _ServiceDataItem;
        List<string> listTagNumberSucc = new List<string>();
        private bool isDrawing = false;//是否正在画图
        private string dwgName = string.Empty;
        private List<string> listLibraryTagName = new List<string>();//元件图纸上的位号属性名称,
        private List<KeyValueModel> listDeck = new List<KeyValueModel>();//甲板号值列表
        private List<KeyValueModel> listSystem = new List<KeyValueModel>();//所属系统值列表 
        List<ec_enginedata> listEnginedata = new List<ec_enginedata>();//要绘制的多个位号的位号信息
        List<ec_objecttype> listObjecttype = new List<ec_objecttype>();//要绘制的多个位号的属性信息列表
        List<ec_enginedata> listUpdateEnginedata = new List<ec_enginedata>();//要绘制的多个位号的关联图纸属性列表
        IEventAggregator eventAggregator;
        public DialogAutoArrangeLayoutViewModel()
        {
            Command_StartDrawing = new DelegateCommand(onStartDrawing);
            Command_GetBasePoint = new DelegateCommand(onGetBasePoint);
            Command_SelectedTag = new DelegateCommand(onSelectedTag);
            Command_SelectedAll = new DelegateCommand(onSelectedAll);
            title = "布置图自动绘制";
            _ServicePlotLayout = GlobalObject.container.Resolve<PlotLayoutService>();
            _ServiceDrawing = GlobalObject.container.Resolve<DrawingServce>();
            _ServiceAnnexes = GlobalObject.container.Resolve<AnnexesService>();
            _ServiceLibraryFile = GlobalObject.container.Resolve<LibraryFileService>();
            _ServiceDrawingCatalogue = GlobalObject.container.Resolve<DrawingCatalogueService>();
            _ServiceEnginedata = GlobalObject.container.Resolve<EnginedataService>();
            _ServiceObjectType = GlobalObject.container.Resolve<ObjectTypeService>();
            _ServiceProjectSettings = GlobalObject.container.Resolve<ProjectSettingsService>();
            _ServiceDataItem = GlobalObject.container.Resolve<DataItemService>();
            eventAggregator = GlobalObject.container.Resolve<IEventAggregator>();
            listDrawings = new ObservableCollection<DtoDrawing>();
            listBasePoint = new ObservableCollection<DtoAutoPlotLayout>();
            listErrBasePoint = new ObservableCollection<DtoAutoPlotLayout>();
            listMsg = new ObservableCollection<TextBlock>(); 
            eventAggregator.GetEvent<sendMessageEvent>().Subscribe(onReceviceMsg, ThreadOption.UIThread, true);
            var list = new ObservableCollection<KeyValueModel>();
            list.Add(new KeyValueModel { Key = "甲板号", Value = "甲板号" });
            //list.Add(new KeyValueModel { Key = "区域", Value = "区域" });
            list.Add(new KeyValueModel { Key = "所属系统", Value = "所属系统" });
            listRange = new ObservableCollection<KeyValueModel>(list);
            listOperator = new ObservableCollection<KeyValueModel>()
            {   new KeyValueModel { Key = "等于", Value = "=" }
            };
            selectOperator = listOperator[0];
        }

        public string Title => "";

        public event Action<IDialogResult> RequestClose;

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {

        }
        private List<TreeModel> GetChildNodes(TreeModel treeModel)
        {
            List<TreeModel> listModel = new List<TreeModel>();
            if (treeModel.ChildNodes != null && treeModel.ChildNodes.Any())
            {
                foreach (var item in treeModel.ChildNodes)
                {
                    if (item.NodeType == "1")
                    {
                        listModel.Add(item);
                    }
                    else
                    {
                        var list = GetChildNodes(item);
                        if (list.Any())
                        {
                            listModel.AddRange(list);
                        }
                    }
                }
                return listModel;
            }
            else
            {
                return listModel;
            }
        }
        public async void OnDialogOpened(IDialogParameters parameters)
        {
            try
            {
                //if (GlobalObj.treeDrawings.Any())
                //{
                //    foreach (var model in GlobalObj.treeDrawings)
                //    {
                //        if (model.Text == "布置图")
                //        {
                //            foreach (var item in model.ChildNodes)
                //            {
                //                if (item.NodeType == "1")
                //                {
                //                    listDrawings.Add(new DtoDrawing() { DrawingFileID = item.ID, DrawingFileName = item.Text });
                //                }
                //                else
                //                {
                //                    if (item.Text == "封面、目录、设计说明" || item.Text == "材料表")
                //                    { continue; }
                //                    var list = GetChildNodes(item);
                //                    if (list.Any())
                //                    {
                //                        foreach (var dto in list)
                //                        {
                //                            listDrawings.Add(new DtoDrawing() { DrawingFileID = dto.ID, DrawingFileName = dto.Text });
                //                        }
                //                    }
                //                }
                //            }
                //        }
                //    }
                //}
                IsBusy = true;
                BusyContent = "数据加载中...";
                if (!listDrawings.Any())
                {
                    AddMsg($"布置图列表加载中...");
                    var listDwg = await _ServiceDrawing.GetDrawingCatalogue();
                    if (listDwg == null || !listDwg.Any())
                    {
                        AddMsg($"布置图列表没有数据！");
                        return;
                    }
                    GlobalObject.AllDrawings = listDwg.ToList();
                    foreach (var model in listDwg)
                    {
                        if (model.Text == "布置图")
                        {
                            if (model.ChildNodes == null)
                            {
                                AddMsg($"布置图列表没有数据！");
                                continue;
                            }
                            foreach (var item in model.ChildNodes)
                            {
                                if (item.NodeType == "1")
                                {
                                    listDrawings.Add(new DtoDrawing() { DrawingFileID = item.ID, DrawingFileName = item.Text });
                                }
                                else
                                {
                                    if (item.Text == "封面、目录、设计说明" || item.Text == "材料表")
                                    { continue; }
                                    var list = GetChildNodes(item);
                                    if (list.Any())
                                    {
                                        foreach (var dto in list)
                                        {
                                            listDrawings.Add(new DtoDrawing() { DrawingFileID = dto.ID, DrawingFileName = dto.Text });
                                        }
                                    }
                                }
                            }
                        }
                    }
                    AddMsg($"布置图列表加载完成！");
                }
                var settingModel = await _ServiceProjectSettings.GetEntity("布置图图例显示位号名称");
                if (settingModel == null)
                {
                    listLibraryTagName.Add("位号");//默认
                }
                else { listLibraryTagName = settingModel.SettingValue.Split(',').ToList(); }
                //区域下拉框对应值列表
                //var listDetail = await _ServiceDataItem.GetDetails("Area");
                //if (listDetail != null && listDetail.Any())
                //{
                //    foreach (var item in listDetail)
                //    { listArea.Add(new KeyValueModel() { Key = item.DataItemName, Value = item.DataItemName }); }
                //}
                //甲板号下拉框对应值列表
                var listDetail = await _ServiceDataItem.GetDetails("甲板号");
                if (listDetail != null && listDetail.Any())
                {
                    foreach (var item in listDetail)
                    { listDeck.Add(new KeyValueModel() { Key = item.DataItemName, Value = item.DataItemName }); }
                }
                //所属系统下拉框对应值列表
                listDetail = await _ServiceDataItem.GetDetails("Be_DrawingSystem");
                if (listDetail != null && listDetail.Any())
                {
                    foreach (var item in listDetail)
                    { listSystem.Add(new KeyValueModel() { Key = item.DataItemName, Value = item.DataItemName }); }
                }
                selectRange = listRange[0];
                IsBusy = false;
            }
            catch (Exception ex)
            {
                IsBusy = false;
                MessageBox.Show("DialogOpened异常：" + ex.Message);
            }
        }
        /// <summary>
        /// 下拉值列表绑定
        /// </summary>
        /// <param name="model"></param>
        private void RangeChange(KeyValueModel model)
        {
            inputValue = "";
            if (model.Value == "甲板号")
            { listValue = new ObservableCollection<KeyValueModel>(listDeck); }
            //else if (model.Value == "区域")
            //{ listValue = new ObservableCollection<KeyValueModel>(listArea); }
            else if (model.Value == "所属系统")
            { listValue = new ObservableCollection<KeyValueModel>(listSystem); }
        }
        /// <summary>
        /// 获取基点信息
        /// </summary>
        /// <param name="o"></param>
        public async void onGetBasePoint(object o)
        {
            if (isDrawing)
            {
                MessageBox.Show("正在自动绘制元件中，请勿操作...");
                return;
            }
            var listSelDwg = listDrawings.Where(a => a.IsSelected == true).ToList();
            if (!listSelDwg.Any())
            {
                AddMsg("请先选择布置图！");
                MessageBox.Show("请先选择布置图！");
                return;
            }

            try
            {
                IsBusy = true;
                BusyContent = "数据加载中...";
                AddMsg("开始查询布置图基点元件信息...");
                List<DtoAutoPlotLayout> listDto = new List<DtoAutoPlotLayout>();
                List<DtoAutoPlotLayout> listErrDto = new List<DtoAutoPlotLayout>();
                bool isBasePointErr = false;
                bool isTagErr = false;
                int index = 1;
                int count = listSelDwg.Count;
                foreach (var dwg in listSelDwg)
                {
                    BusyContent = $"数据加载中......{index}/{count}";
                    var list = await _ServicePlotLayout.GetBasePointByDwg(selectRange.Value, selectOperator.Value, inputValue, dwg.DrawingFileID);
                    index++;
                    if (list == null)
                    { continue; }
                    foreach (var basePoint in list)
                    {
                        if (basePoint.area != null && basePoint.area.ToLower() == "err")
                        { isBasePointErr = true; }
                        else { isBasePointErr = false; }
                        if (basePoint.Tags.Any())
                        {
                            foreach (var tag in basePoint.Tags)
                            {
                                if (tag.area != null && tag.area.ToLower() == "err")
                                { isTagErr = true; }
                                else { isTagErr = false; }
                                if (isBasePointErr || isTagErr)
                                {
                                    string strErr = isBasePointErr ? "基点异常;" : "";
                                    strErr += isTagErr ? "元件异常" : "";
                                    strErr = strErr.EndsWith(";") ? strErr.Replace(";", "") : strErr;
                                    listErrDto.Add(new DtoAutoPlotLayout()
                                    {
                                        IsSelected = true,
                                        DrawingFileID = dwg.DrawingFileID,
                                        DrawingFileName = dwg.DrawingFileName,
                                        EngineDataID = basePoint.EngineDataID,
                                        BasePointTagNumber = basePoint.TagNumber,
                                        RoomNo = basePoint.RoomNo,
                                        Scale = basePoint.Scale,
                                        FileId = basePoint.FileId,
                                        PixelOnDwg = basePoint.PixelOnDwg,
                                        IsNotDefaultSymbol = basePoint.IsNotDefaultSymbol,
                                        X = basePoint.X,
                                        XOff = basePoint.XOff,
                                        YOff = basePoint.YOff,
                                        deck = basePoint.deck,
                                        area = basePoint.area,
                                        AutoDrawing = strErr,
                                        TagNumber = tag.TagNumber,
                                        TagNumber_Upper = basePoint.TagNumber_Upper,
                                        TagNumber_Lower = basePoint.TagNumber_Lower,
                                        Tag = tag
                                    });
                                }
                                else
                                {
                                    listDto.Add(new DtoAutoPlotLayout()
                                    {
                                        IsSelected = true,
                                        DrawingFileID = dwg.DrawingFileID,
                                        DrawingFileName = dwg.DrawingFileName,
                                        EngineDataID = basePoint.EngineDataID,
                                        BasePointTagNumber = basePoint.TagNumber,
                                        RoomNo = basePoint.RoomNo,
                                        Scale = basePoint.Scale,
                                        FileId = basePoint.FileId,
                                        PixelOnDwg = basePoint.PixelOnDwg,
                                        IsNotDefaultSymbol = basePoint.IsNotDefaultSymbol,
                                        X = basePoint.X,
                                        XOff = basePoint.XOff,
                                        YOff = basePoint.YOff,
                                        deck = basePoint.deck,
                                        area = basePoint.area,
                                        AutoDrawing = "未绘制",
                                        TagNumber = tag.TagNumber,
                                        TagNumber_Upper = basePoint.TagNumber_Upper,
                                        TagNumber_Lower = basePoint.TagNumber_Lower,
                                        Tag = tag
                                    });
                                }
                            }
                        }
                    }
                }
                listBasePoint = new ObservableCollection<DtoAutoPlotLayout>(listDto);
                listErrBasePoint = new ObservableCollection<DtoAutoPlotLayout>(listErrDto);
                NormalTagCount = $"正常元件({listBasePoint.Count}个)";
                ErrTagCount = $"异常元件({listErrBasePoint.Count}个)";
                IsSelectAll = listBasePoint.Any() ? true : false;
                AddMsg("布置图基点元件信息查询完成！");
                IsBusy = false;
            }
            catch (Exception ex)
            {
                AddMsg("基点元件信息查询异常：" + ex.Message);
                IsBusy = false;
            }
        }
        public async void onStartDrawing(object o)
        {
            if (isDrawing)
            {
                MessageBox.Show("正在自动绘制元件中，请勿操作...");
                return;
            }

            var msg = string.Empty;
            var filePath = string.Empty;
            var listDto = listBasePoint.Where(a => a.IsSelected == true).ToList();
            if (!listDto.Any())
            {
                MessageBox.Show("请先勾选基点元件信息！");
                return;
            }
            listMsg.Clear();
            var progress = new Progress<MessageModel>(UpdateProgress);
            await DoWorkAsync(progress, new CancellationTokenSource());


            #region back

            //try
            //{
            //    isDrawing = true;
            //    List<ec_library_file> listFile = new List<ec_library_file>();
            //    List<string> listBlockDwgPath = new List<string>();   //图块下载路径列表，同个异形块下载一次，先下载后删除
            //    listMsg.Clear();
            //    listUpdateEnginedata.Clear();
            //    //获取多个位号属性 
            //    AddMsg($"开始获取全部位号属性...");
            //    string strTagNumbers = string.Join(",", listDto.Select(a => a.TagNumber).ToList());
            //    listObjecttype = await _ServiceObjectType.GetTagInfosByTags(strTagNumbers);
            //    listEnginedata = await _ServiceObjectType.GetEngineDataListByTags(strTagNumbers);
            //    AddMsg($"获取全部位号类型属性完成，共有{listObjecttype.Count}种类型！");
            //    //循环画图
            //    for (int i = 0; i < listDto.Count; i++)
            //    {
            //        var basePoint = listDto[i];
            //        if (basePoint.AutoDrawing == "已绘制")
            //        {
            //            AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已绘制,跳至下一个元件");
            //            continue;
            //        }
            //        if (basePoint.AutoDrawing == "已存在" && !isCheckDelete)
            //        {
            //            AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已存在,跳至下一个元件");
            //            continue;
            //        }

            //        msg = OpenDwg(basePoint);
            //        if (!string.IsNullOrEmpty(msg))
            //        {
            //            AddMsg($"图纸打开失败：{msg}", false);
            //            continue;
            //        }
            //        var listTag = listDto.Where(a => a.DrawingFileID == basePoint.DrawingFileID).Select(a => a.TagNumber).ToList();
            //        var listEntitys = isCheckDelete ? General.GetAllEntity(listTag) : General.GetAllEntity(new List<string>());//获取图纸所有实体
            //        var entity = listEntitys.FirstOrDefault(a => a.Handle.ToString() == basePoint.PixelOnDwg);
            //        if (entity == null)
            //        {
            //            AddMsg($"当前基点：{basePoint.BasePointTagNumber} 在图上找不到，不添加此元件，跳至下一个元件", false);
            //            continue;
            //        }
            //        var tag = basePoint.Tag;
            //        var tagDto = listEntitys.FirstOrDefault(a => a.TagNumber == basePoint.TagNumber);
            //        if (tagDto != null)
            //        {
            //            AddMsg($"当前元件：{basePoint.TagNumber} 在图上已存在，句柄:{tagDto.Handle}，不添加此元件，跳至下一个元件", false);
            //            basePoint.AutoDrawing = "已存在";
            //            basePoint.TagPixelOnDwg = tagDto.Handle;
            //            continue;
            //        }
            //        filePath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.TagNumber}.dwg");
            //        string blockName = string.Empty;
            //        if (string.IsNullOrEmpty(tag.FileId))
            //        {
            //            //元件ID为空 用本地默认图块图纸
            //            if (!string.IsNullOrEmpty(tag.TagNumber_Lower))
            //            {
            //                var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形两行图块.dwg");
            //                if (!File.Exists(blockDwgPath))
            //                {
            //                    AddMsg($"默认图块找不到：{blockDwgPath}", false);
            //                    continue;
            //                }
            //                //默认上下图块
            //                blockName = "常规矩形两行图块";
            //                File.Copy(blockDwgPath, filePath, true);
            //                AddMsg($"本地默认常规图块图纸复制成功");
            //            }
            //            else
            //            {
            //                var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形单行图块.dwg");
            //                if (!File.Exists(blockDwgPath))
            //                {
            //                    AddMsg($"默认图块找不到：{blockDwgPath}", false);
            //                    continue;
            //                }
            //                //默认图块,只有中间部分
            //                blockName = "常规矩形单行图块";
            //                File.Copy(blockDwgPath, filePath, true);
            //                AddMsg($"本地默认常规图块图纸复制成功");
            //            }
            //        }
            //        else
            //        {
            //            string blockDwgPath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.FileId}.dwg");
            //            if (File.Exists(blockDwgPath))
            //            {
            //                File.Copy(blockDwgPath, filePath, true);
            //                var item = listFile.FirstOrDefault(a => a.LibraryFileID == tag.FileId);
            //                if (item != null)
            //                {
            //                    blockName = item.LibraryFileName;
            //                }
            //                else { blockName = tag.TagNumber; }
            //                AddMsg($"元件图纸：{tag.TagNumber}，已下载过，复制本地缓存块图纸文件成功");
            //            }
            //            else
            //            {
            //                //下载元件图纸文件 
            //                var obj = await _ServiceLibraryFile.GetEntity(tag.FileId);
            //                blockName = obj.LibraryFileName;
            //                AddMsg($"元件图纸：{tag.TagNumber}， 开始下载...");
            //                msg = await _ServiceAnnexes.DownloadFile(blockDwgPath, obj.FolderId);
            //                if (!string.IsNullOrEmpty(msg))
            //                {
            //                    AddMsg($"元件图纸下载失败，信息:" + msg, false);
            //                    continue;
            //                }
            //                File.Copy(blockDwgPath, filePath, true);
            //                listBlockDwgPath.Add(blockDwgPath);
            //                listFile.Add(obj);
            //                AddMsg($"元件图纸：{tag.TagNumber}， 下载成功");
            //            }
            //        }
            //        listBlockDwgPath.Add(filePath);
            //        //把元件的位号属性改成要绘制的位号值
            //        var flag = General.UpdateCableNo(filePath, listLibraryTagName, tag.TagNumber, tag.IsNotDefaultSymbol, tag.TagNumber_Upper, tag.TagNumber_Lower);

            //        //X轴：图上基点的坐标X +(接口数据元件的X + 接口数据元件的XOFF -接口数据基点的X-接口数据基点的Xoff）*比例系数
            //        //Y轴：图上基点的坐标Y +(接口数据元件的Yoff-接口数据基点的Yoff）*比例系数
            //        double scale = basePoint.Scale;//比例系数
            //        double x = entity.X + (tag.X + double.Parse(tag.XOff) - basePoint.X - double.Parse(basePoint.XOff)) * scale;
            //        AddMsg($"块X坐标计算：{entity.X}+({tag.X}+{tag.XOff}-{basePoint.X}-{basePoint.XOff})*{scale}={x}");
            //        double y = entity.Y + (double.Parse(tag.YOff) - double.Parse(basePoint.XOff)) * scale;
            //        AddMsg($"块Y坐标计算：{entity.Y}+({tag.YOff}-{basePoint.XOff})*{scale}={y}");
            //        AddMsg($"块最后坐标：{x}，{y}，0");
            //        double z = entity.Z;
            //        Point3d tagPoint = new Point3d(x, y, z);
            //        AddMsg($"元件图纸：{tag.TagNumber}， 开始添加进布置图中...");
            //        msg =await AddBlock(basePoint, blockName, filePath, tagPoint);
            //        if (string.IsNullOrEmpty(msg))
            //        {
            //            AddMsg($"布置图：{basePoint.DrawingFileName}，成功插入元件:" + tag.TagNumber);
            //            basePoint.AutoDrawing = "已绘制";
            //            //当下一个要画元件的图纸和当前图纸不一样时，保存图纸
            //            if (i + 1 >= listDto.Count)
            //            { General.SetDrawingReadOnly(dwgName, false); }
            //            else
            //            {
            //                var nextTag = listDto[i + 1];
            //                if (basePoint.DrawingFileID != nextTag.DrawingFileID)
            //                { General.SetDrawingReadOnly(dwgName, false); }
            //            }
            //        }
            //        else
            //        {
            //            basePoint.AutoDrawing = "已失败";
            //            AddMsg($"元件：{tag.TagNumber}，绘制异常：{msg}", false);
            //        }

            //    }
            //    if (listUpdateEnginedata.Any())
            //    {
            //        AddMsg($"开始批量位号关联属性，数量：{listUpdateEnginedata.Count}......");
            //        msg = await _ServiceObjectType.UpdatePixelAndPropBatch(listUpdateEnginedata);
            //        if (string.IsNullOrEmpty(msg))
            //        {
            //            AddMsg("位号关联属性成功，数量：" + listUpdateEnginedata.Count);
            //        }
            //        else
            //        {
            //            AddMsg($"位号关联属性失败，数量：{listUpdateEnginedata.Count},异常：{msg}", false);
            //        }
            //    }
            //    foreach (var file in listBlockDwgPath)
            //    {
            //        File.Delete(file);//删除缓存图块图纸文件
            //        File.Delete(file.Replace(".dwg", ".bak"));
            //    }
            //    AddMsg("操作已完成！");
            //    isDrawing = false;
            //}
            //catch (Exception ex)
            //{
            //    MessageBox.Show("绘图异常：" + ex.Message);
            //    isDrawing = false;
            //}
            #endregion
        }
        #region DoWork
        private void UpdateProgress(MessageModel dto)
        {
            System.Windows.Application.Current.Dispatcher.Invoke(new System.Action(() =>
            {
                AddMsg(dto.Message, dto.IsSuccess);
            }));
        }

        private async Task DoWorkAsync(IProgress<MessageModel> progress, CancellationTokenSource cts)
        {
            try
            {
                int time = 1;
                var msg = string.Empty;
                var filePath = string.Empty;
                var listDto = listBasePoint.Where(a => a.IsSelected == true).ToList();
                isDrawing = true;
                List<ec_library_file> listFile = new List<ec_library_file>();
                List<string> listBlockDwgPath = new List<string>();   //图块下载路径列表，同个异形块下载一次，先下载后删除
                listMsg.Clear();
                listUpdateEnginedata.Clear();
                //获取多个位号属性 
                AddMsg($"开始获取全部位号属性...");
                await Task.Delay(time, cts.Token);
                string strTagNumbers = string.Join(",", listDto.Select(a => a.TagNumber).ToList());
                listObjecttype = await _ServiceObjectType.GetTagInfosByTags(strTagNumbers);
                listEnginedata = await _ServiceObjectType.GetEngineDataListByTags(strTagNumbers);
                AddMsg($"获取全部位号类型属性完成，共有{listObjecttype.Count}种类型！");
                await Task.Delay(time, cts.Token);
                //循环画图
                for (int i = 0; i < listDto.Count; i++)
                {
                    cts.Token.ThrowIfCancellationRequested();
                    var basePoint = listDto[i];
                    if (basePoint.AutoDrawing == "已绘制" && !isCheckDelete)
                    {
                        AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已绘制,跳至下一个元件", false);
                        await Task.Delay(time, cts.Token);
                        continue;
                    }
                    if (basePoint.AutoDrawing == "已存在" && !isCheckDelete)
                    {
                        AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已存在,跳至下一个元件", false);
                        await Task.Delay(time, cts.Token);
                        continue;
                    }

                    msg = OpenDwg(basePoint);
                    if (!string.IsNullOrEmpty(msg))
                    {
                        AddMsg($"图纸打开失败：{msg}", false);
                        await Task.Delay(time, cts.Token);
                        continue;
                    }
                    var listTag = listDto.Where(a => a.DrawingFileID == basePoint.DrawingFileID).Select(a => a.TagNumber).ToList();
                    var listEntitys = isCheckDelete ? General.GetAllEntity(listTag) : General.GetAllEntity(new List<string>());//获取图纸所有实体
                    var entity = listEntitys.FirstOrDefault(a => a.Handle.ToString() == basePoint.PixelOnDwg);
                    if (entity == null)
                    {
                        AddMsg($"当前基点：{basePoint.BasePointTagNumber} 在图上找不到，不添加此元件，跳至下一个元件", false);
                        await Task.Delay(time, cts.Token);
                        continue;
                    }
                    var tag = basePoint.Tag;
                    var tagDto = listEntitys.FirstOrDefault(a => a.TagNumber == basePoint.TagNumber);
                    if (tagDto != null)
                    {
                        AddMsg($"当前元件：{basePoint.TagNumber} 在图上已存在，句柄:{tagDto.Handle}，不添加此元件，跳至下一个元件", false);
                        basePoint.AutoDrawing = "已存在";
                        basePoint.TagPixelOnDwg = tagDto.Handle;
                        await Task.Delay(time, cts.Token);
                        continue;
                    }
                    filePath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.TagNumber}.dwg");
                    string blockName = string.Empty;
                    if (string.IsNullOrEmpty(tag.FileId))
                    {
                        //元件ID为空 用本地默认图块图纸
                        if (!string.IsNullOrEmpty(tag.TagNumber_Lower))
                        {
                            var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形两行图块.dwg");
                            if (!File.Exists(blockDwgPath))
                            {
                                AddMsg($"默认图块找不到：{blockDwgPath}", false);
                                await Task.Delay(time, cts.Token);
                                continue;
                            }
                            //默认上下图块
                            blockName = "常规矩形两行图块";
                            File.Copy(blockDwgPath, filePath, true);
                        }
                        else
                        {
                            var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形单行图块.dwg");
                            if (!File.Exists(blockDwgPath))
                            {
                                AddMsg($"默认图块找不到：{blockDwgPath}", false);
                                await Task.Delay(time, cts.Token);
                                continue;
                            }
                            //默认图块,只有中间部分
                            blockName = "常规矩形单行图块";
                            File.Copy(blockDwgPath, filePath, true);
                        }
                    }
                    else
                    {
                        string blockDwgPath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.FileId}.dwg");
                        if (File.Exists(blockDwgPath))
                        {
                            File.Copy(blockDwgPath, filePath, true);
                            var item = listFile.FirstOrDefault(a => a.LibraryFileID == tag.FileId);
                            if (item != null)
                            {
                                blockName = item.LibraryFileName;
                            }
                            else { blockName = tag.TagNumber; }
                        }
                        else
                        {
                            //下载元件图纸文件 
                            var obj = await _ServiceLibraryFile.GetEntity(tag.FileId);
                            blockName = obj.LibraryFileName;
                            AddMsg($"元件图纸：{tag.TagNumber}， 开始下载...");
                            await Task.Delay(time, cts.Token);
                            msg = await _ServiceAnnexes.DownloadFile(blockDwgPath, obj.FolderId);
                            if (!string.IsNullOrEmpty(msg))
                            {
                                AddMsg($"元件图纸下载失败，信息:{msg}", false);
                                await Task.Delay(time, cts.Token);
                                continue;
                            }
                            File.Copy(blockDwgPath, filePath, true);
                            listBlockDwgPath.Add(blockDwgPath);
                            listFile.Add(obj);
                            AddMsg($"元件图纸：{tag.TagNumber}， 下载成功");
                            await Task.Delay(time, cts.Token);
                        }
                    }
                    listBlockDwgPath.Add(filePath);
                    //把元件的位号属性改成要绘制的位号值
                    var flag = General.UpdateCableNo(filePath, listLibraryTagName, tag.TagNumber, tag.IsNotDefaultSymbol, tag.TagNumber_Upper, tag.TagNumber_Lower);
                    //X轴：图上基点的坐标X +(接口数据元件的X + 接口数据元件的XOFF -接口数据基点的X-接口数据基点的Xoff）*比例系数
                    //Y轴：图上基点的坐标Y +(接口数据元件的Yoff-接口数据基点的Yoff）*比例系数
                    double scale = basePoint.Scale;//比例系数
                    double x = 0;
                    double y = 0;
                    if (tag.X != 0)//肋位号不为0的时候，去肋位号相关数据去算坐标
                    {
                        x = entity.X + (tag.X + double.Parse(tag.XOff) - basePoint.X - double.Parse(basePoint.XOff)) * scale;
                        msg = $"块X坐标计算：{entity.X}+({tag.X}+{tag.XOff}-{basePoint.X}-{basePoint.XOff})*{scale}={x}";
                        AddMsg(msg);
                        y = entity.Y + (double.Parse(tag.YOff) - double.Parse(basePoint.XOff)) * scale;
                        msg = $"块Y坐标计算：{entity.Y}+({tag.YOff}-{basePoint.XOff})*{scale}={y}";
                        AddMsg(msg);
                        await Task.Delay(time, cts.Token);
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(tag.RoomNo))
                        {
                            int rnd = new Random().Next(1, 5);
                            x = entity.X + rnd;
                            msg = $"块X坐标取房间号基点附近：{entity.X}+{rnd}={x}";
                            AddMsg(msg);
                            y = entity.Y + rnd;
                            msg = $"块Y坐标取房间号基点附近：{entity.Y}+{rnd}={y}";
                            AddMsg(msg);
                            await Task.Delay(time, cts.Token);
                        }
                        else
                        {
                            x = entity.X + (tag.X + double.Parse(tag.XOff) - basePoint.X - double.Parse(basePoint.XOff)) * scale;
                            msg = $"块X坐标计算：{entity.X}+({tag.X}+{tag.XOff}-{basePoint.X}-{basePoint.XOff})*{scale}={x}";
                            AddMsg(msg);
                            y = entity.Y + (double.Parse(tag.YOff) - double.Parse(basePoint.XOff)) * scale;
                            msg = $"块Y坐标计算：{entity.Y}+({tag.YOff}-{basePoint.XOff})*{scale}={y}";
                            AddMsg(msg);
                            await Task.Delay(time, cts.Token);
                        }
                    }
                    double z = entity.Z;
                    Point3d tagPoint = new Point3d(x, y, z);
                    AddMsg($"元件图纸：{tag.TagNumber}， 开始添加进布置图中...");
                    await Task.Delay(time, cts.Token);
                    msg = await AddBlock(basePoint, blockName, filePath, tagPoint);
                    if (string.IsNullOrEmpty(msg))
                    {
                        AddMsg($"布置图：{basePoint.DrawingFileName}，成功插入元件:{tag.TagNumber}");
                        basePoint.AutoDrawing = "已绘制";
                        await Task.Delay(time, cts.Token);
                        //当下一个要画元件的图纸和当前图纸不一样时，保存图纸
                        if (i + 1 >= listDto.Count)
                        {
                            AddMsg($"布置图：{basePoint.DrawingFileName},开始保存...");
                            await Task.Delay(time, cts.Token);
                            General.SetDrawingReadOnly(dwgName, false);
                            msg = $"布置图：{basePoint.DrawingFileName},保存完成";
                            await Task.Delay(time, cts.Token);
                        }
                        else
                        {
                            var nextTag = listDto[i + 1];
                            if (basePoint.DrawingFileID != nextTag.DrawingFileID)
                            {
                                AddMsg($"布置图：{basePoint.DrawingFileName},开始保存...");
                                await Task.Delay(time, cts.Token);
                                General.SetDrawingReadOnly(dwgName, false);
                                AddMsg($"布置图：{basePoint.DrawingFileName},保存完成");
                                await Task.Delay(time, cts.Token);
                            }
                        }
                    }
                    else
                    {
                        basePoint.AutoDrawing = "已失败";
                        AddMsg($"元件：{tag.TagNumber}，绘制异常：{msg}");
                        await Task.Delay(time, cts.Token);
                    }
                }
                if (listUpdateEnginedata.Any())
                {
                    AddMsg($"开始批量位号关联属性，数量：{listUpdateEnginedata.Count}......");
                    await Task.Delay(time, cts.Token);
                    msg = await _ServiceObjectType.UpdatePixelAndPropBatch(listUpdateEnginedata);
                    if (string.IsNullOrEmpty(msg))
                    {
                        AddMsg("位号关联属性成功，数量：" + listUpdateEnginedata.Count);
                        await Task.Delay(time, cts.Token);
                    }
                    else
                    {
                        AddMsg($"位号关联属性失败，数量：{listUpdateEnginedata.Count},异常：{msg}");
                        await Task.Delay(time, cts.Token);
                    }
                }
                foreach (var file in listBlockDwgPath)
                {
                    File.Delete(file);//删除缓存图块图纸文件
                    File.Delete(file.Replace(".dwg", ".bak"));
                }
                AddMsg("操作已完成！"); 
                isDrawing = false;
            }
            catch (Exception ex)
            {
                MessageBox.Show("绘图异常：" + ex.Message);
                LoggerHelper.Current.Error("绘图异常：" + ex.ToString());
                isDrawing = false;
            }
        }

        #endregion
        private async void onAutoDrawing()
        {
            #region back
            var msg = string.Empty;
            var filePath = string.Empty;
            var listDto = listBasePoint.Where(a => a.IsSelected == true).ToList();
            if (!listDto.Any())
            {
                MessageBox.Show("请先勾选基点元件信息！");
                return;
            }
            try
            {
                List<ec_library_file> listFile = new List<ec_library_file>();
                List<string> listBlockDwgPath = new List<string>();   //图块下载路径列表，同个异形块下载一次，先下载后删除
                isDrawing = true;
                listUpdateEnginedata.Clear();
                //获取多个位号属性 
                AddMsg($"开始获取全部位号属性...");
                string strTagNumbers = string.Join(",", listDto.Select(a => a.TagNumber).ToList());
                listObjecttype = await _ServiceObjectType.GetTagInfosByTags(strTagNumbers);
                listEnginedata = await _ServiceObjectType.GetEngineDataListByTags(strTagNumbers);
                AddMsg($"获取全部位号类型属性完成，共有{listObjecttype.Count}种类型！");
                //循环画图
                for (int i = 0; i < listDto.Count; i++)
                { 
                    var basePoint = listDto[i];
                    if (basePoint.AutoDrawing == "已绘制" && !isCheckDelete)
                    {
                        AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已绘制,跳至下一个元件");
                        continue;
                    }
                    if (basePoint.AutoDrawing == "已存在" && !isCheckDelete)
                    {
                        AddMsg($"当前基点[{basePoint.BasePointTagNumber}]和元件[{basePoint.TagNumber}]已存在,跳至下一个元件");
                        continue;
                    }

                    msg = OpenDwg(basePoint);
                    if (!string.IsNullOrEmpty(msg))
                    {
                        AddMsg($"图纸打开失败：{msg}", false);
                        continue;
                    }
                    var listTag = listDto.Where(a => a.DrawingFileID == basePoint.DrawingFileID).Select(a => a.TagNumber).ToList();
                    var listEntitys = isCheckDelete ? General.GetAllEntity(listTag) : General.GetAllEntity(new List<string>());//获取图纸所有实体
                    var entity = listEntitys.FirstOrDefault(a => a.Handle.ToString() == basePoint.PixelOnDwg);
                    if (entity == null)
                    {
                        AddMsg($"当前基点：{basePoint.BasePointTagNumber} 在图上找不到，不添加此元件，跳至下一个元件", false);
                        continue;
                    }
                    var tag = basePoint.Tag;
                    var tagDto = listEntitys.FirstOrDefault(a => a.TagNumber == basePoint.TagNumber);
                    if (tagDto != null)
                    {
                        AddMsg($"当前元件：{basePoint.TagNumber} 在图上已存在，句柄:{tagDto.Handle}，不添加此元件，跳至下一个元件", false);
                        basePoint.AutoDrawing = "已存在";
                        basePoint.TagPixelOnDwg = tagDto.Handle;
                        continue;
                    }
                    filePath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.TagNumber}.dwg");
                    string blockName = string.Empty;
                    if (string.IsNullOrEmpty(tag.FileId))
                    {
                        //元件ID为空 用本地默认图块图纸
                        if (!string.IsNullOrEmpty(tag.TagNumber_Lower))
                        {
                            var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形两行图块.dwg");
                            if (!File.Exists(blockDwgPath))
                            {
                                AddMsg($"默认图块找不到：{blockDwgPath}", false);
                                continue;
                            }
                            //默认上下图块
                            blockName = "常规矩形两行图块";
                            File.Copy(blockDwgPath, filePath, true);
                            AddMsg($"本地默认常规图块图纸复制成功");
                        }
                        else
                        {
                            var blockDwgPath = Path.Combine(GlobalObject.GetDllPath(), "Template\\常规矩形单行图块.dwg");
                            if (!File.Exists(blockDwgPath))
                            {
                                AddMsg($"默认图块找不到：{blockDwgPath}", false);
                                continue;
                            }
                            //默认图块,只有中间部分
                            blockName = "常规矩形单行图块";
                            File.Copy(blockDwgPath, filePath, true);
                            AddMsg($"本地默认常规图块图纸复制成功");
                        }
                    }
                    else
                    {
                        string blockDwgPath = Path.Combine(GlobalObject.GetCacheFolder(), $"{tag.FileId}.dwg");
                        if (File.Exists(blockDwgPath))
                        {
                            File.Copy(blockDwgPath, filePath, true);
                            var item = listFile.FirstOrDefault(a => a.LibraryFileID == tag.FileId);
                            if (item != null)
                            {
                                blockName = item.LibraryFileName;
                            }
                            else { blockName = tag.TagNumber; }
                            AddMsg($"元件图纸：{tag.TagNumber}，已下载过，复制本地缓存块图纸文件成功");
                        }
                        else
                        {
                            //下载元件图纸文件 
                            var obj = await _ServiceLibraryFile.GetEntity(tag.FileId);
                            blockName = obj.LibraryFileName;
                            AddMsg($"元件图纸：{tag.TagNumber}， 开始下载...");
                            msg = await _ServiceAnnexes.DownloadFile(blockDwgPath, obj.FolderId);
                            if (!string.IsNullOrEmpty(msg))
                            {
                                AddMsg($"元件图纸下载失败，信息:" + msg, false);
                                continue;
                            }
                            File.Copy(blockDwgPath, filePath, true);
                            listBlockDwgPath.Add(blockDwgPath);
                            listFile.Add(obj);
                            AddMsg($"元件图纸：{tag.TagNumber}， 下载成功");
                        }
                    }
                    listBlockDwgPath.Add(filePath);
                    //把元件的位号属性改成要绘制的位号值
                    var flag = General.UpdateCableNo(filePath, listLibraryTagName, tag.TagNumber, tag.IsNotDefaultSymbol, tag.TagNumber_Upper, tag.TagNumber_Lower);

                    //X轴：图上基点的坐标X +(接口数据元件的X + 接口数据元件的XOFF -接口数据基点的X-接口数据基点的Xoff）*比例系数
                    //Y轴：图上基点的坐标Y +(接口数据元件的Yoff-接口数据基点的Yoff）*比例系数
                    double scale = basePoint.Scale;//比例系数
                    double x = entity.X + (tag.X + double.Parse(tag.XOff) - basePoint.X - double.Parse(basePoint.XOff)) * scale;
                    AddMsg($"块X坐标计算：{entity.X}+({tag.X}+{tag.XOff}-{basePoint.X}-{basePoint.XOff})*{scale}={x}");
                    double y = entity.Y + (double.Parse(tag.YOff) - double.Parse(basePoint.XOff)) * scale;
                    AddMsg($"块Y坐标计算：{entity.Y}+({tag.YOff}-{basePoint.XOff})*{scale}={y}");
                    AddMsg($"块最后坐标：{x}，{y}，0");
                    double z = entity.Z;
                    Point3d tagPoint = new Point3d(x, y, z);
                    AddMsg($"元件图纸：{tag.TagNumber}， 开始添加进布置图中...");
                    msg = await AddBlock(basePoint, blockName, filePath, tagPoint);
                    if (string.IsNullOrEmpty(msg))
                    {
                        AddMsg($"布置图：{basePoint.DrawingFileName}，成功插入元件:" + tag.TagNumber);
                        basePoint.AutoDrawing = "已绘制";
                        //当下一个要画元件的图纸和当前图纸不一样时，保存图纸
                        if (i + 1 >= listDto.Count)
                        { General.SetDrawingReadOnly(dwgName, false); }
                        else
                        {
                            var nextTag = listDto[i + 1];
                            if (basePoint.DrawingFileID != nextTag.DrawingFileID)
                            { General.SetDrawingReadOnly(dwgName, false); }
                        }
                    }
                    else
                    {
                        basePoint.AutoDrawing = "已失败";
                        AddMsg($"元件：{tag.TagNumber}，绘制异常：{msg}", false);
                    }

                }
                if (listUpdateEnginedata.Any())
                {
                    AddMsg($"开始批量位号关联属性，数量：{listUpdateEnginedata.Count}......");
                    msg = await _ServiceObjectType.UpdatePixelAndPropBatch(listUpdateEnginedata);
                    if (string.IsNullOrEmpty(msg))
                    {
                        AddMsg("位号关联属性成功，数量：" + listUpdateEnginedata.Count);
                    }
                    else
                    {
                        AddMsg($"位号关联属性失败，数量：{listUpdateEnginedata.Count},异常：{msg}", false);
                    }
                }
                foreach (var file in listBlockDwgPath)
                {
                    File.Delete(file);//删除缓存图块图纸文件
                    File.Delete(file.Replace(".dwg", ".bak"));
                }
                AddMsg("操作已完成！");
                isDrawing = false;
            }
            catch (Exception ex)
            {
                MessageBox.Show("绘图异常：" + ex.Message);
                isDrawing = false;
            }
            #endregion
        }
        /// <summary>
        /// 打开图纸
        /// </summary> 
        /// <returns></returns>
        private string OpenDwg(DtoAutoPlotLayout dto)
        {
            try
            {
                string res = string.Empty;
                string fullpath = string.Empty;
                string folderpath = GlobalObject.GetDwgPath(dto.DrawingFileID);
                fullpath = Path.Combine(GlobalObj.LocalWorkDir, GlobalObject.curProject.ProjectName, folderpath, $"{dto.DrawingFileName}");

                if (!File.Exists(fullpath))
                {
                    return dto.DrawingFileName + ",图纸文件不存在,请先检出到本地！";
                }
                if (dto.DrawingFileName == General.GetDwgName())
                {
                    return res;
                }
                var listName = General.GetAllOpenDrawingNames();
                if (!listName.Contains(fullpath))
                {
                    General.OpenDwg(fullpath);
                    dwgName = fullpath;
                    AddMsg($"打开图纸：{dto.DrawingFileName} ");
                    return res;
                }
                else
                {
                    General.SwitchToDocument(fullpath);
                    dwgName = fullpath;
                    AddMsg($"已打开图纸：{dto.DrawingFileName} ");
                    return res;
                }

            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }

        private async Task<string> AddBlock(DtoAutoPlotLayout basePoint, string tagName, string blockDwg, Point3d tagPoint)
        {
            try
            {
                string dwgId = basePoint.DrawingFileID;
                string enginedataId = basePoint.Tag.EngineDataID;
                string blockDwgId = basePoint.Tag.FileId;
                string tagNumber = basePoint.Tag.TagNumber;
                double scale = basePoint.Scale;
                string msg = string.Empty;
                //string tagNum = string.Empty;
                //var lsitEnginedata = await _ServiceObjectType.GetEngineDataListByTags(tagNumber); 
                //if (!lsitEnginedata.Any())
                //{
                //    msg = $"元件位号：{tagNumber},属性未绑定,_ServiceObjectType.GetEngineDataListByTags({tagNumber})接口无数据";
                //    AddMsg(msg, false);
                //    return msg;
                //}
                var enginedata = listEnginedata.FirstOrDefault(a => a.TagNumber == tagNumber);
                if (enginedata == null)
                {
                    msg = $"元件位号：{tagNumber},找不到位号工程属性，无法关联属性！";
                    return msg;
                }
                string objTypeId = enginedata.ObjectTypeID;
                string objTypeName = enginedata.ObjectTypeName;
                var objId = General.AddTagDWG(blockDwg, tagName, tagNumber, objTypeId, scale, tagPoint);
                #region 图纸上保存图元属性 
                if (!objId.IsNull)
                {
                    //AddMsg($"元件已添加至图纸，句柄:{objId.Handle.ToString()}");
                    //RefreshUI(999, $"元件已添加至图纸，句柄:{objId.Handle.ToString()}");
                    //var dwgLibrary = await _ServiceLibraryFile.GetEntity(blockDwgId);
                    List<ec_enginedata_property> listPro = new List<ec_enginedata_property>();
                    var handlid = objId.Handle.ToString();//添加图元返回的句柄  
                    ec_enginedata item = new ec_enginedata();
                    item.EngineDataID = enginedataId;
                    item.TagNumber = tagNumber;
                    item.ObjectTypeID = objTypeId;
                    //item.Layout_Block_File = dwgLibrary;
                    var tagInfo = listObjecttype.FirstOrDefault(a => a.ObjectTypeID == enginedata.ObjectTypeID);
                    if (tagInfo == null)
                    {
                        msg = $"元件位号：{tagNumber},找不到位号属性信息，无法关联属性！";
                        return msg;
                    }
                    foreach (var dto in tagInfo.tags[0].EngineDataProperty)
                    {
                        listPro.Add(new ec_enginedata_property()
                        {
                            EngineDataPropertyID = dto.PropertyID,
                            PropertyName = dto.PropertyName,
                            PropertyNameEN = dto.PropertyNameEN,
                            PropertyValue = dto.PropertyValue,
                            MeasuringUnit = dto.MeasuringUnit,
                            PropertyGID = dto.PropertyGID,
                            PropertyGroupName = dto.PropertyGroupName
                        });
                    }
                    item.EngineDataProperty = listPro;
                    List<ec_enginedata_pixel> listPixel = new List<ec_enginedata_pixel>();
                    var pixelDto = new ec_enginedata_pixel()
                    {
                        TagNumber = tagNumber,
                        DrawingFileID = dwgId,
                        LibraryFileID = blockDwgId,// == null ? "" : dwgLibrary.LibraryFileID
                        PixelCode = handlid,
                        ObjectTypeID = objTypeId,
                        ObjectTypeName = objTypeName,
                        EngineDataProperty = listPro
                    };
                    listPixel.Add(pixelDto);
                    item.EngineDataPixel = listPixel;
                    basePoint.TagPixelOnDwg = handlid;
                    listUpdateEnginedata.Add(item);
                    return "";
                }
                else
                {
                    msg = $"元件：{blockDwg} ，添加失败";
                    return msg;
                }
                #endregion
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        public void onSelectedTag(object o)
        {
            var dto = listBasePoint.Where(p => p.TagNumber == o.ToString()).FirstOrDefault();
            if (dto != null)
            {
                if (!dto.IsSelected && IsSelectAll)
                {
                    IsSelectAll = false;
                }
                else if (dto.IsSelected && !IsSelectAll)
                {
                    foreach (var item in listBasePoint)
                    {
                        if (!item.IsSelected) return;
                    }
                    IsSelectAll = true;
                }
            }
        }
        public void onSelectedAll(object o)
        {
            foreach (var item in listBasePoint)
            {
                item.IsSelected = IsSelectAll;
            } 
        }

        string message = string.Empty;
        bool isSuccess = false;  
        
        /// <summary>
        /// 添加 提示信息
        /// </summary>
        /// <param name="msg">信息</param>
        /// <param name="isSucc">是否成功</param>
        private void AddMsg(string msg, bool isSucc = true)
        {
            try
            {
                System.Windows.Application.Current.Dispatcher.Invoke((System.Action)(() =>
                {
                    TextBlock tb = new TextBlock();
                    tb.Text = DateTime.Now.ToString("yyyy-MM-6dd HH:mm:ss:ffff") + "==>> " + msg;
                    tb.Foreground = isSucc ? Brushes.LightSeaGreen : Brushes.Red;
                    listMsg.Add(tb);
                }));
                //Task.Delay(100);
            }
            catch (Exception ex)
            {
                MessageBox.Show("添加提示信息异常：" + ex.Message);
            }
        }
        private void onReceviceMsg(MessageModel model)
        {
            AddMsg(model.Message, model.IsSuccess);
        }
    }
}