using Clipper2Lib;
//using ClipperLib;

using DeepNestLib;

using GeoSigma.SigmaDrawerStyle;

using GeoSigmaDrawLib;

using SigmaDrawerElement;

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Clipper = Clipper2Lib.Clipper;

namespace SmartWells
{
   // public delegate void IterateEventHandler(List<SheetPlacement> placements, double materialUtilization, long elapsedMilliseconds);
   // public delegate void ExportPlaceMentsEventHandler(Bitmap bmp, string info);
    public class CaculateHelpWeb : IDisposable
    {
        /// <summary>
        /// 任务唯一标识符
        /// </summary>
        public string TaskId { get; private set; } = Guid.NewGuid().ToString();

        public IterateEventHandler IterateEvent { get; set; } = null;
        public ExportPlaceMentsEventHandler ExportPlaceMentsEvent { get; set; } = null;

        /// <summary>
        /// web停止线程任务用
        /// </summary>
        private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
        private CountdownEvent countdown = new CountdownEvent(0);

        /// <summary>
        /// 部署文件
        /// </summary>
        public string DeployFile { get; set; } = string.Empty;
        /// <summary>
        /// 边界图层
        /// </summary>
        public string BorderLayer { get; set; } = string.Empty;
        /// <summary>
        /// 断层图层
        /// </summary>
        public string FaultLayer { get; set; } = string.Empty;

        /// <summary>
        /// CoverageRate覆盖率
        /// </summary>
        public double CoverageRate { get; set; } = 0.0;

        /// <summary>
        /// 单侧井
        /// </summary>
        public int SingleWell { get; set; } = 0;

        /// <summary>
        /// 双侧井
        /// </summary>
        public int DoubleWell { get; set; } = 0;

        /// <summary>
        /// 消息Id,和前端进度条通讯用
        /// </summary>
        public string ConnectionId { get; set; } = string.Empty;
        /// <summary>
        /// 是否已经停止运算
        /// </summary>
        public bool IsStop { get; set; } = true;
        /// <summary>
        /// 井参数
        /// </summary>
        public WellsConfig WellParameters { get; set; } = new WellsConfig();
        /// <summary>
        /// 计算参数
        /// </summary>
        public CaculateConfig CaculateParameter { get; set; } = new CaculateConfig();
        /// <summary>
        /// 显示进度事件
        /// </summary>
        public Action<float> DisplayProgressAction { get; set; }

        public CaculateStatus Status { get; set; } = CaculateStatus.None;
        public bool NeedStop
        {
            get
            {
                if (nest != null)
                {
                    return nest.NeedStop;
                }
                return false;
            }
            set
            {
                if (nest != null)
                {
                    nest.NeedStop = value;
                }
            }
        }
        /// <summary>
        /// 图片导出的宽度
        /// </summary>
        public int ImageWidth { get; set; } = 500;
        /// <summary>
        /// 图片输出的高度
        /// </summary>
        public int ImageHeight { get; set; } = 400;

        private SvgNestConfig nestConfig;
        private double partSpacing = 200;
        private double faultInflate = 10;

        private double originX = 0;
        private double originY = 0;

        public NestingContext nest;

        WellGroupParameter groupParaSide2;
        WellGroupParameter groupParaSide1;
        LocalContour wellBox2;
        LocalContour wellBox1;

        ManualResetEvent ma = new ManualResetEvent(false);

       public DrawerData drawer;
        
        public DrawerData OpenDrawerFile()
        {
            if (!File.Exists(this.DeployFile))
            {
                return null;
            }
            if (drawer != null)
            {
                drawer.Dispose();
                drawer = null;
            }

            drawer = new DrawerData();
            //drawer.OpenWithDraw = true;
            try
            {
                if (drawer.OpenFile(this.DeployFile) == false)
                {
                    drawer.Dispose();
                    drawer = null;
                }
            }
            catch (Exception ex)
            {
                drawer.Dispose();
                drawer = null;
                return null;
            }
            return drawer;
        }

        /// <summary>
        /// 保存指定文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public bool SaveDrawerDataFile(string filePath)
        {
            if (drawer == null) return false;
            drawer.SaveAs(filePath);
            return File.Exists(filePath);

        }

        public CaculateHelpWeb()
        {
            this.nestConfig = new SvgNestConfig();
        }
        ~CaculateHelpWeb()
        {
            Dispose(false);
        }
        private bool disposed = false; // 跟踪是否已释放
        /// <summary>
        /// 受保护的虚方法，用于释放资源
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    // 释放托管资源
                    Console.WriteLine("Releasing managed resources.");
                }

                // 释放未托管资源
                if (drawer != null)
                {
                    drawer.Dispose();
                    drawer = null;
                }
                if(this.ma!=null)
                {
                    ma.Dispose();
                }
                disposed = true;
            }
        }
        /// <summary>
        /// 实现 IDisposable 接口
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this); // 防止垃圾回收器再次调用析构函数
        }

        /// <summary>
        /// 暂停
        /// </summary>
        public void Pause()
        {
            NeedStop = true;
            Status = CaculateStatus.Pausing;
            // 信号关闭阻,塞当前线程
            ma.Reset();
        }
        /// <summary>
        /// 继续
        /// </summary>
        public void Continue()
        {
            NeedStop = false;
            if (this.Status!= CaculateStatus.Pausing
                && this.Status != CaculateStatus.Paused)
            {
                return;
            }
            Status = CaculateStatus.Working;
            // 信号打开，不阻塞当前线程
            ma.Set();
        }
        /// <summary>
        /// 停止
        /// </summary>
        public void Stop()
        {
            NeedStop = true;
            Status = CaculateStatus.Stopping;
            this.IsStop = true;
            ma.Set();
        }
        /// <summary>
        /// Web停止
        /// </summary>
        public void WebStop()
        {
           try
            {
                NeedStop = true;
                Status = CaculateStatus.Stopping;
                this.IsStop = true;
                
                // 取消所有挂起的操作
                _cancellationTokenSource.Cancel();
                
                // 释放信号量，避免线程阻塞
                ma.Set();
                
                // 等待线程完成，设置超时防止无限等待
                bool threadCompleted = ma.WaitOne(3000);
                
                if (!threadCompleted)
                {
                    // 记录日志：线程未能在预期时间内完成
                    Console.WriteLine("警告：计算线程未能在预期时间内停止");
                }
            }
            catch (Exception ex)
            {
                // 记录异常
                Console.WriteLine($"停止计算时发生异常: {ex.Message}");
            }
            finally
            {
                // 确保资源被释放
                if (th != null && th.IsAlive)
                {
                    Console.WriteLine("警告：计算线程仍在运行");
                    // 记录线程仍在运行
                    System.Diagnostics.Debug.WriteLine("警告：计算线程仍在运行");
                }
            }
        }
        /// <summary>
        /// 保存部署图
        /// </summary>
        /// <param name="resultFile"></param>
        public bool SaveResult(string resultFile)
        {
            if (nest == null || nest.PlacedPartsCount == 0)
            {
                // MessageBox.Show("未产生正确的结果！", "保存结果", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
            string strExt = Path.GetExtension(resultFile).ToUpper();

            if (strExt == ".DXF")
            {
                DxfParser.Export(resultFile, nest.Polygons.ToArray(), nest.Sheets.ToArray(), this.originX, this.originY);
            }
            else if (strExt == ".SVG")
            {
                SvgParser.Export(resultFile, nest.Polygons.ToArray(), nest.Sheets.ToArray());
            }
            else
            {
                return drawer.SaveAs(resultFile);
            }
            return true;
        }
        /// <summary>
        /// 执行计算
        /// </summary>
        /// <param name="newWork"></param>
        /// <returns></returns>
        public bool Excute(bool newWork = true)
        {
            if (IsStop == false)
            {
                return false;
            }
            NeedStop = false;
            if (newWork)
            {
                if (OpenDrawerFile() == null)
                {
                    return false;
                }
            }
            ma.Set();
            //this.stlInfor.Text = string.Empty;
            // 计算配置
            if (CaculateParameter.SpecifyAngles == true)
            {
                nestConfig.SpecfiedAngles = CaculateParameter.SpeciaAngles.Select(it => (float)(it)).ToArray();
            }
            else
            { // 旋转角度角度
                nestConfig.SpecfiedAngles = null;
                // 部件旋转数
                nestConfig.rotations = CaculateParameter.Rotations;
                nestConfig.AngleStart = (float)CaculateParameter.AngleStart;
                nestConfig.AngleEnd = (float)CaculateParameter.AngleEnd;
            }

            // 部件间间距设置
            nestConfig.spacing = 0;// CaculateParameter.WellsSpace;
            partSpacing = CaculateParameter.WellsSpace;

            //this.borderFile = this.txtBorderFile.Text;
            //this.faultageFile = this.txtFaultage.Text;
            // 打开文件

            //  加载边界数据
            RawDetail detail = loadLayersDetail(this.BorderLayer);// loadDetail(this.borderFile);
            detail.Name = this.BorderLayer;
            if (detail.Outers.Count == 0)
            {
                return false;
            }
            if (detail.Outers.Count > 1)
            {
                detail.Outers.RemoveRange(1, detail.Outers.Count - 1);
            }
            // 计算相对坐标原点
            var bbox = detail.BoundingBox();
            originX = bbox.X;
            originY = bbox.Y;

            detail.Offset(-originX, -originY);

            PathD pathBorder = new PathD();
            foreach (var pt in detail.Outers[0].Points)
            {
                pathBorder.Add(new Clipper2Lib.PointD(pt.X, pt.Y));
            }

            // 加载断层数据
            RawDetail detailFault = loadLayersDetail(this.FaultLayer);// loadDetail(this.faultageFile);
            double dAreaFault = 0;
            if (detailFault.Outers?.Count > 0)
            {
                detailFault.Offset(-originX, -originY);
                PathsD paths = new PathsD(), solution;
                double dMinFaultLength = CaculateParameter.MiniFaultLength;
                foreach (var contour in detailFault.Outers)
                {
                    // 忽略小断层
                    if (this.CaculateParameter.IgnoreMiniFault)
                    {
                        if (contour.Len <= dMinFaultLength)
                        {
                            continue;
                        }
                    }

                    PathD path = new PathD();
                    bool bOutBorder = true;
                    foreach (var pt in contour.Points)
                    {
                        Clipper2Lib.PointD ptd = new Clipper2Lib.PointD(pt.X, pt.Y);
                        if (Clipper2Lib.Clipper.PointInPolygon(ptd, pathBorder) == PointInPolygonResult.IsInside)
                        {
                            bOutBorder = false; // 一旦有一个点在内部，则线不在边界外部
                        }
                        path.Add(new Clipper2Lib.PointD(pt.X, pt.Y));
                    }
                    // 排除边界外断层
                    if (bOutBorder == false)
                    {
                        paths.Add(path);
                    }
                }
                // 断层线外扩成多边形，宽度可调
                solution = Clipper.InflatePaths(paths, faultInflate, Clipper2Lib.JoinType.Round, Clipper2Lib.EndType.Round);
                solution = Clipper.SimplifyPaths(solution, 2.5);
                dAreaFault = Clipper2Lib.Clipper.Area(solution);
                // 多边形添加到边界
                foreach (var pathChild in solution)
                {
                    LocalContour contourChild = new LocalContour();
                    foreach (var pt in pathChild)
                    {
                        contourChild.Points.Add(new PointF((float)pt.x, (float)pt.y));
                    }
                    detail.Outers.Add(contourChild);
                }
            }
            //bbox = detail.BoundingBox();

            // 二次部井
            if (this.WellParameters.DeployAgain)
            {
                // 加载井组数据
                RawDetail detailWells = loadWellGroupDetail("井组");
                // 相对原点进行坐标偏移
                detailWells.Offset(-originX, -originY);
                // 区域外扩
                PathsD paths = new PathsD(), solution;
                foreach (var contour in detailWells.Outers)
                {
                    PathD path = new PathD();
                    bool bOutBorder = true;
                    foreach (var pt in contour.Points)
                    {
                        Clipper2Lib.PointD ptd = new Clipper2Lib.PointD(pt.X, pt.Y);
                        if (Clipper2Lib.Clipper.PointInPolygon(ptd, pathBorder) == PointInPolygonResult.IsInside)
                        {
                            bOutBorder = false; // 一旦有一个点在内部，则线不在边界外部
                        }
                        path.Add(new Clipper2Lib.PointD(pt.X, pt.Y));
                    }
                    // 排除边界外断层
                    if (bOutBorder == false)
                    {
                        if (Math.Abs(path.First().x - path.Last().x) > 1E-4 || Math.Abs(path.First().y - path.Last().y) > 1E-4)
                        {
                            path.Add(new Clipper2Lib.PointD(path.First().x, path.First().y));
                        }
                        paths.Add(path);
                    }
                }
                // 断层线外扩成多边形，宽度可调
                solution = Clipper.InflatePaths(paths, this.partSpacing * 0.5, JoinType.Miter, EndType.Polygon);
                solution = Clipper.SimplifyPaths(solution, 2.5);

                // 统计约束区面积
                dAreaFault += Clipper2Lib.Clipper.Area(solution);

                // 多边形添加到边界
                foreach (var pathChild in solution)
                {
                    LocalContour contourChild = new LocalContour();
                    foreach (var pt in pathChild)
                    {
                        contourChild.Points.Add(new PointF((float)pt.x, (float)pt.y));
                    }
                    detail.Outers.Add(contourChild);
                }
            }

            NFP nfp = detail.ToNfp();
            nest = new NestingContext();
            int src = nest.GetNextSheetSource();
            var ns = Background.clone(nfp);
            Sheet sheet = new Sheet();
            sheet.Points = ns.Points;
            sheet.children = ns.children;
            nest.Sheets.Add(sheet);
            sheet.Width = sheet.WidthCalculated;
            sheet.Height = sheet.HeightCalculated;
            sheet.source = src;

            nest.ReorderSheets();

            // 边界的面积
            double dAreaBorder = Clipper2Lib.Clipper.Area(pathBorder);

            // 生成双侧井组
            DrawerWellGroup wellGroupSide2 = new DrawerWellGroup();

            this.groupParaSide2 = new WellGroupParameter();
            this.groupParaSide2.WellPoint.X = 0;
            this.groupParaSide2.WellPoint.Y = 0;
            this.groupParaSide2.WellPoint.Z = 0;
            this.groupParaSide2.WellPoint.Name = this.WellParameters.WellNamePrefix;
            wellGroupSide2.Name = this.WellParameters.WellNamePrefix;

            this.groupParaSide2.BranchDistanceRight = this.WellParameters.BranchOffset;
            this.groupParaSide2.BranchDistanceLeft = this.groupParaSide2.BranchDistanceRight;
            this.groupParaSide2.BranchAngle = 0.0;
            this.groupParaSide2.BranchSpace = this.WellParameters.BranchSpace;
            this.groupParaSide2.BranchLength = this.WellParameters.BranchLength;
            this.groupParaSide2.BranchCountRight = this.WellParameters.BranchCount;
            this.groupParaSide2.BranchCountLeft = this.groupParaSide2.BranchCountRight;

            wellGroupSide2.Parameter = this.groupParaSide2.Clone();
            bool bSuccess = wellGroupSide2.CreateHorizionWells();
            // 生成单侧井组
            this.groupParaSide1 = this.groupParaSide2.Clone();
            this.groupParaSide1.BranchCountLeft = 0;
            DrawerWellGroup wellGroupSide1 = new DrawerWellGroup();
            wellGroupSide1.Parameter = groupParaSide1.Clone();
            wellGroupSide1.CreateHorizionWells();

            wellBox2 = CreateWellGroupBorder(wellGroupSide2, this.partSpacing);
            wellBox1 = CreateWellGroupBorder(wellGroupSide1, this.partSpacing);

            //List<RawDetail> shapes = new List<RawDetail>();
            int nCountSide2 = 0;
            if (this.WellParameters.DeploySide2 == true)
            {
                RawDetail detail2 = new RawDetail();
                detail2.Outers.Add(wellBox2);
                detail2.Name = "双侧";

                PathD pathSide2 = new PathD();

                foreach (var pt in wellBox2.Points)
                {
                    pathSide2.Add(new Clipper2Lib.PointD(pt.X, pt.Y));
                }
                double dAreaSide2 = Clipper2Lib.Clipper.Area(pathSide2);

                nCountSide2 = (int)Math.Abs((Math.Abs(dAreaBorder) - Math.Abs(dAreaFault)) / dAreaSide2);
                for (int i = 0; i < nCountSide2; i++)
                {
                    nest.ImportFromRawDetail(detail2, 0);
                }
            }
            if (WellParameters.DeploySide1 == true)
            {
                RawDetail detail1 = new RawDetail();
                detail1.Outers.Add(wellBox1);
                detail1.Name = "单侧";
                // 根据不同情况计算单侧方式井部署的数量
                if (this.WellParameters.DeploySide2 == true)
                {
                    int nCountSide1 = (int)(nCountSide2 * 0.35);
                    for (int i = 0; i < nCountSide1; i++)
                    {
                        nest.ImportFromRawDetail(detail1, 1);
                    }
                }
                else
                {
                    PathD pathSide1 = new PathD();
                    foreach (var pt in wellBox1.Points)
                    {
                        pathSide1.Add(new Clipper2Lib.PointD(pt.X, pt.Y));
                    }
                    double dAreaSide1 = Clipper2Lib.Clipper.Area(pathSide1);
                    int nCountSide1 = (int)Math.Abs((Math.Abs(dAreaBorder) - Math.Abs(dAreaFault)) / dAreaSide1);
                    for (int i = 0; i < nCountSide1; i++)
                    {
                        nest.ImportFromRawDetail(detail1, 1);
                    }
                }
            }
            // 设置突变率
            nestConfig.mutationRate = (int)(nest.Polygons.Count * this.CaculateParameter.MutationRate);

            nest.ReorderSheets();
            nest.Config = this.nestConfig;
            IsStop = false;
            return run();
        }
        private bool run()
        {
            if (nest.Polygons.Count == 0 || nest.Sheets.Count == 0)
            {
                //MessageBox.Show("There are no sheets or parts", Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                IsStop = true;
                return false;
            }
            Background.UseParallel = true;

            GeneticAlgorithm.StrictAngles = false;

            return RunDeepnest();
        }
        Thread th;
        //internal void displayProgress(float progress)
        //{
        //    // progressVal = progress;
        //}

        private bool RunDeepnest()
        {
             if (th != null) return false;

            // 重置取消令牌源
            _cancellationTokenSource = new CancellationTokenSource();
            var token = _cancellationTokenSource.Token;

            th = new Thread(() =>
            {
                try
                {
                    nest.StartNest();

                    while (!token.IsCancellationRequested)
                    {
                        this.Status = CaculateStatus.Paused;
                        if (IsStop)
                        {
                            this.Status = CaculateStatus.Stopped;
                            break;
                        }
                        
                        // 检查取消令牌
                        if (token.IsCancellationRequested)
                        {
                            this.Status = CaculateStatus.Stopped;
                            break;
                        }
                        
                        // 根据是否收到信号判断是否阻塞当前线程
                        ma.WaitOne();
                        
                        if (IsStop || token.IsCancellationRequested)
                        {
                            this.Status = CaculateStatus.Stopped;
                            break;
                        }
                        
                        Stopwatch sw = new Stopwatch();
                        sw.Start();
                        this.Status = CaculateStatus.Working;
                        nest.NestIterate();
                        
                        sw.Stop();
                        
                        IterateEvent?.Invoke(nest.Nest.nests, nest.MaterialUtilization, sw.ElapsedMilliseconds);
                        if (ExportPlaceMentsEvent != null)
                        {
                            ExportPlaceMents();
                        }
                    }
                }
                catch (OperationCanceledException)
                {
                    // 正常取消操作，不需要特殊处理
                    this.Status = CaculateStatus.Stopped;
                }
                catch (Exception ex)
                {
                    // 记录异常
                   Console.WriteLine($"计算线程发生异常: {ex.Message}");
                    this.Status = CaculateStatus.Stopped;
                }
                finally
                {
                    th = null;
                }
            });
            th.IsBackground = true;
            th.Start();
            return true;
        }
        private bool isDrawing = false;
        /// <summary>
        /// 生成部署图和部署信息
        /// </summary>
        /// <param name="placementIndex">方案的索引</param>
        /// <param name="image">输出的部署图片</param>
        /// <param name="info">输出的部署信息</param>
        /// <returns></returns>
        public bool CreatePlacementImage(int placementIndex, out Bitmap image, out string info)
        {
            if(nest.Nest.nests.Count<= placementIndex)
            {
                image = null;
                info = null;
                return false;
            }
            SheetPlacement placement = nest.Nest.nests[placementIndex];
            nest.AssignPlacement(placement);

            if(exportPlacementImage(out image, out info))
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 生成部署图和部署信息
        /// </summary>
        /// <param name="image"></param>
        /// <param name="info"></param>
        /// <returns></returns>
        private bool exportPlacementImage(out Bitmap image, out string info)
        {
            image = null;
            info = null;
            if (isDrawing)
            {
                return false;
            }
            isDrawing = true;

            StringBuilder strbStatistic = new StringBuilder();
            foreach (var kv in nest.PartsStatistic)
            {
                strbStatistic.Append($"{kv.Key}:{kv.Value}个  ");
            }
            info = $"覆盖率: {Math.Round(nest.MaterialUtilization * 100.0f, 2)}%  {strbStatistic}";
            CoverageRate = Math.Round(nest.MaterialUtilization * 100.0f, 2);
            addSymbols(drawer);
            // 删除已有井组
           // if (this.WellParameters.DeploySide2 == true)
            {
                //drawer.DeleteLayer(new string[1] { "井组\\双侧" }, true);
                drawer.DeleteLayerElement( "井组\\双侧" , true);
            }
           // if (this.WellParameters.DeploySide1 == true)
            {
                drawer.DeleteLayerElement("井组\\单侧", true);
                //drawer.DeleteLayer(new string[1] { "井组\\单侧" }, true);
            }
            if (sourceWellGroups?.Count > 0)
            {
                foreach (var groupItem in sourceWellGroups)
                {
                    drawer.AddWellGroup(groupItem.Item1, groupItem.Item2);
                }
            }
            //drawer.DeleteLayerElement( "井组" , true);
            // 部件内缩距离
            float fSpace = (float)(partSpacing * 0.5);
            // 断层外扩距离
            float fFaultExpand = fSpace;
            List<PointF> box1 = new List<PointF>();
            box1.AddRange(new PointF[5] {
                    new PointF(wellBox1.Points[0].X+fSpace, wellBox1.Points[0].Y+fSpace),
                    new PointF(wellBox1.Points[1].X-fSpace, wellBox1.Points[1].Y+fSpace),
                    new PointF(wellBox1.Points[2].X-fSpace, wellBox1.Points[2].Y-fSpace),
                    new PointF(wellBox1.Points[3].X+fSpace, wellBox1.Points[3].Y-fSpace),
                    new PointF(wellBox1.Points[4].X+fSpace, wellBox1.Points[4].Y+fSpace) });
            List<PointF> box2 = new List<PointF>();
            box2.AddRange(new PointF[] {
                    new PointF(wellBox2.Points[0].X+fSpace, wellBox2.Points[0].Y+fSpace),
                    new PointF(wellBox2.Points[1].X-fSpace, wellBox2.Points[1].Y+fSpace),
                    new PointF(wellBox2.Points[2].X-fSpace, wellBox2.Points[2].Y-fSpace),
                    new PointF(wellBox2.Points[3].X+fSpace, wellBox2.Points[3].Y-fSpace),
                    new PointF(wellBox2.Points[4].X+fSpace, wellBox2.Points[4].Y+fSpace)});
            //this.resultFile = this.txtResultFile.Text;
            //string strExt = Path.GetExtension(resultFile).ToUpper();

            List<Tuple<NFP, int>> lstWells = new List<Tuple<NFP, int>>();

            HashSet<int> removedIndices = DfdParser.ExportPlacements(nest.Polygons, nest.Sheets.ToArray(), this.originX, this.originY, (polygon, wellType) =>
            {
                // 断层外扩处理
                if (wellType == 2) //strName == "断层")
                {
                    PathsD paths = new PathsD(), solution;
                    PathD path = new PathD();
                    foreach (var pt in polygon.Points)
                    {
                        path.Add(new Clipper2Lib.PointD(pt.x, pt.y));
                    }
                    paths.Add(path);

                    // 断层线外扩成多边形，宽度可调
                    solution = Clipper.InflatePaths(paths, fFaultExpand, JoinType.Round, EndType.Round);
                    solution = Clipper.SimplifyPaths(solution, 2.5);
                    if (solution.Count > 0)
                    {
                        PointF[] pts = solution[0].Select(it => new PointF((float)it.x, (float)it.y)).ToArray();
                        return pts;
                    }
                    return null;
                }
                else if (wellType == 0) //strName.Equals("双侧"))
                {
                    lstWells.Add(new Tuple<NFP, int>(polygon, wellType));
                    // polygon内缩处理
                    return box2.ToArray();
                }
                else if (wellType == 1) //strName.Equals("单侧"))
                {
                    lstWells.Add(new Tuple<NFP, int>(polygon, wellType));
                    return box1.ToArray();
                }
                return null;
            });
            if (lstWells.Count > 0)
            {
                SingleWell = 0;// 计数器清零
                DoubleWell = 0;// 计数器清零
                string strWellName = this.WellParameters.WellNamePrefix;
                //DrawerData drawer = new DrawerData();
                for (int i = 0; i < lstWells.Count; i++)
                {
                    if (removedIndices.Contains(i)) { continue; }
                    Tuple<NFP, int> well = lstWells[i];
                    string strElementData = string.Empty;
                    if (well.Item2 == 0)
                    { // 双侧井组
                        DrawerWellGroup wellGroupSide2 = new DrawerWellGroup();
                        wellGroupSide2.Parameter = this.groupParaSide2.Clone();
                        wellGroupSide2.Parameter.BranchAngle = well.Item1.rotation;
                        wellGroupSide2.Name = $"{strWellName}{i + 1}";
                        wellGroupSide2.CreateHorizionWells();
                        setWellGroupStyle(wellGroupSide2);

                        wellGroupSide2.Offset(this.originX, this.originY);
                        wellGroupSide2.Offset(well.Item1.x, well.Item1.y);
                        DrawerElementProperty element = new DrawerElementProperty();
                        element.Element = wellGroupSide2;
                        element.ElementType = wellGroupSide2.ElementType;
                        strElementData = DrawerElementHelp.Serialize(element);
                        drawer.AddWellGroup("井组\\双侧", strElementData);
                        DoubleWell++;
                    }
                    else
                    { // 单侧井组
                      //wellGroupSide1.Angle = well.Item1.rotation + 90;
                        DrawerWellGroup wellGroupSide1 = new DrawerWellGroup();
                        wellGroupSide1.Name = $"{strWellName}{i + 1}";
                        wellGroupSide1.Parameter = this.groupParaSide1.Clone();
                        wellGroupSide1.Parameter.BranchAngle = well.Item1.rotation;

                        wellGroupSide1.CreateHorizionWells();
                        setWellGroupStyle(wellGroupSide1);
                        wellGroupSide1.Offset(this.originX, this.originY);
                        wellGroupSide1.Offset(well.Item1.x, well.Item1.y);
                        DrawerElementProperty element = new DrawerElementProperty();
                        element.Element = wellGroupSide1;
                        element.ElementType = wellGroupSide1.ElementType;
                        strElementData = DrawerElementHelp.Serialize(element);
                        drawer.AddWellGroup("井组\\单侧", strElementData);
                        SingleWell++;
                    }
                }
            }
            IntPtr hBmp = drawer.GetBitmapHandle(this.ImageWidth, this.ImageHeight, 0);
            image = System.Drawing.Image.FromHbitmap(hBmp);
            image.MakeTransparent(Color.White);
            //this.pictureBox1.Image = bmp;
            drawer.DeleteHbmp(hBmp);
            //this.ExportPlaceMentsEvent?.Invoke(bmp, strInfo);
            isDrawing = false;
            return true;
        }
        /// <summary>
        /// 导出部署图
        /// </summary>
        private void ExportPlaceMents()
        {
            if(exportPlacementImage(out Bitmap image, out string info))
            {
                this.ExportPlaceMentsEvent?.Invoke(image, info);
            }
        }
        /// <summary>
        /// 设置进组的显示样式
        /// </summary>
        /// <param name="wellGroup">井组</param>
        private void setWellGroupStyle(DrawerWellGroup wellGroup)
        {
            // 设置井点样式
            DrawerPointStyle ptstyleWell = new DrawerPointStyle();
            ptstyleWell.AlignHorizion = (int)TextStyleFlags.alignCenterH;
            ptstyleWell.AlignVertical = (int)TextStyleFlags.alignTop;
            ptstyleWell.Offset = new PropertyPoint(0, 50);

            PropertySize txtSize = default(PropertySize);
            txtSize.Width = 100 * 0.4;
            txtSize.Height = 100;
            txtSize.FixScale = true;

            SizeF sizeSymbol = new SizeF(100f, 100f);

            ptstyleWell.TextSize = txtSize;
            ptstyleWell.SymbolSize = sizeSymbol;
            ptstyleWell.SymbolName = "井点";
            wellGroup.WellPointStyle = ptstyleWell;

            // 设置井支入靶点和出靶点样式
            DrawerPointStyle ptStart = ptstyleWell.Clone();
            ptStart.Name = "start";
            ptStart.SymbolName = "入靶点";
            ptStart.SymbolSize = new SizeF((float)(sizeSymbol.Width * 0.5), (float)(sizeSymbol.Height * 0.5));

            DrawerPointStyle ptEnd = ptstyleWell.Clone();
            ptEnd.Name = "end";
            ptEnd.SymbolName = "出靶点";
            ptEnd.SymbolSize = new SizeF((float)(sizeSymbol.Width * 0.5), (float)(sizeSymbol.Height * 0.5));


            DrawerCurveStyle drawerCurveStyleOffset = new DrawerCurveStyle();
            drawerCurveStyleOffset.Name = "offset";

            CurveProperty curvePropertyOffset = new CurveProperty();
            curvePropertyOffset.Width = 5;
            curvePropertyOffset.LineColor = Color.Black;
            drawerCurveStyleOffset.Properties.Add(curvePropertyOffset);

            DrawerCurveStyle drawerCurveStyleHori = new DrawerCurveStyle();
            drawerCurveStyleHori.Name = "horizon";
            CurveProperty curvePropertyHori = new CurveProperty();
            curvePropertyHori.Width = 5;
            curvePropertyHori.LineColor = Color.Black;
            drawerCurveStyleHori.Properties.Add(curvePropertyHori);

            List<DrawerCurveStyle> lineStyles = new List<DrawerCurveStyle>
            {
                drawerCurveStyleOffset,
                drawerCurveStyleHori
            };

            int nBranchAllCount = wellGroup.WellBranches.Count;
            for (int i = 0; i < nBranchAllCount; i++)
            {
                WellBranch branch = wellGroup.WellBranches[i];
                branch.PointStyles = new List<DrawerPointStyle>
                {
                    ptStart,
                    ptEnd
                };

                branch.PointStart.Name = $"{wellGroup.Name}-{i + 1}A";
                branch.PointEnd.Name = $"{wellGroup.Name}-{i + 1}B";

                branch.LineStyles = lineStyles;
            }
        }
        /// <summary>
        /// 添加进组所需符号
        /// </summary>
        /// <param name="drawer"></param>
        private void addSymbols(DrawerData drawer)
        {
            string strSymbolWell = @"Layer M 0
Pline
-0.5,-0.5
-0.5,0.5
0.5,0.5
0.5,-0.5
-0.5,-0.5
";
            drawer.AddDataAsSymble(strSymbolWell, "井点", false);

            strSymbolWell = @"Layer M 0
_Ellipse
0,0
0.5,0.5
0.5 4
";
            drawer.AddDataAsSymble(strSymbolWell, "入靶点", false);

            strSymbolWell = @"Layer M 0
_Ellipse
0,0
0.5,0.5
0.5 4
";
            drawer.AddDataAsSymble(strSymbolWell, "出靶点", false);
        }
        /// <summary>
        /// 加载线数据
        /// </summary>
        /// <param name="layers"></param>
        /// <returns></returns>
        private RawDetail loadLayersDetail(string layers)
        {
            string[] saFullLayers = Regex.Split(layers, ",");
            RawDetail rawDetail = new RawDetail();
            // 遍历每一个图层
            foreach (string layer in saFullLayers)
            {
                string curveData = string.Empty;
                int nCount = drawer.LayerGetCurves(layer, ref curveData, false);
                if (nCount == 0)
                {
                    continue;
                }
                DrawerElementHelp elementHelp = new DrawerElementHelp();
                List<DrawerElementProperty> propertys = elementHelp.DeserializeList(curveData);
                if(propertys == null)
                {
                    continue;
                }
                // 生成每一条线
                foreach (DrawerElementProperty eleProperty in propertys)
                {
                    DrawerPline blockLine = eleProperty.Element as DrawerPline;
                    if (blockLine == null)
                    {
                        continue;
                    }
                    string[] saCoorLine = Regex.Split(blockLine.Coordinate, "\r\n");
                    if (saCoorLine.Length > 1)
                    {
                        // 生成每一个坐标点
                        List<PointF> points = new List<PointF>();
                        foreach (string strLine in saCoorLine)
                        {
                            string[] saCoor = strLine.Split(',');
                            if (saCoor.Length > 1)
                            {
                                points.Add(new PointF(float.Parse(saCoor[0]), float.Parse(saCoor[1])));
                            }
                        }
                        if (points.Count > 0)
                        {
                            rawDetail.Outers.Add(new LocalContour() { Points = points });
                        }
                    }
                }
            }
            return rawDetail;
        }

        private List<Tuple<string, string>> sourceWellGroups = new List<Tuple<string, string>>();

        /// <summary>
        /// 加载井组的轮廓数据
        /// </summary>
        /// <param name="layers"></param>
        /// <returns></returns>
        private RawDetail loadWellGroupDetail(string layers)
        {
            sourceWellGroups = new List<Tuple<string, string>>();
            RawDetail rawDetail = new RawDetail();
            long[] laPos = this.drawer.SearchElementByType((int)DrawElementType.ELEMENT_WELL_GROUP);
            if(laPos == null)
            {
                return rawDetail;
            }
            foreach (long pos in laPos)
            {
                NFP nfpHull = new NFP();
                List<SvgPoint> lstPt = new List<SvgPoint>();

                string strElementData = this.drawer.GetElementByPosition(pos);
                DrawerElementProperty property = DrawerElementHelp.Deserialize(strElementData);
                //Trace.TraceInformation(strElementData);
                //Trace.TraceWarning(strElementData);
                sourceWellGroups.Add(new Tuple<string, string>(property.Layer, strElementData));
                DrawerWellGroup wellGroup = property.Element as DrawerWellGroup;

                lstPt.Add(new SvgPoint(wellGroup.X, wellGroup.Y));
                foreach (WellBranch branch in wellGroup.WellBranches)
                {
                    lstPt.Add(new SvgPoint(branch.PointStart.X, branch.PointStart.Y));
                    lstPt.Add(new SvgPoint(branch.PointEnd.X, branch.PointEnd.Y));
                }
                nfpHull.Points = lstPt;
                NFP hull = Background.getHull(nfpHull);

                LocalContour contourHull = new LocalContour();
                contourHull.Points = new List<PointF>(hull.Points.Select(it => new PointF((float)it.x, (float)it.y)));
                rawDetail.Outers.Add(contourHull);
            }

            return rawDetail;
        }
        private static LocalContour CreateWellGroupBorder(DrawerWellGroup wellGroup, double spacing)
        {
            RectangleD rect = wellGroup.CaculateDataRange();
            float dSpacing = (float)(spacing * 0.5);
            List<PointF> shapePoints = new List<PointF>();
            shapePoints.AddRange(new PointF[5] {
                    new PointF((float)rect.Left-dSpacing, (float)rect.Top-dSpacing),
                    new PointF((float)rect.Right+dSpacing, (float)rect.Top-dSpacing),
                    new PointF((float)rect.Right+dSpacing, (float)rect.Bottom+dSpacing),
                    new PointF((float)rect.Left-dSpacing, (float)rect.Bottom+dSpacing),
                    new PointF((float)rect.Left-dSpacing, (float)rect.Top-dSpacing),
                });
            LocalContour contour = new LocalContour()
            {
                Points = shapePoints,
            };
            return contour;
        }
    }
    // public enum CaculateStatus
    // {
    //     None = 0,
    //     Stopping =1,
    //     Stopped = 2,
    //     Pausing = 3,
    //     Paused = 4,
    //     Working =5,
    // }
}