using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using DfdIO;
using NetTopologySuite.Geometries;
using NetTopologySuite.Operation.Distance;
using NetTopologySuite.Precision;
//using SqlSugar;
//using WorkData;
//using WorkData.Entity;
//using DQ.Construction.Util;
//using WorkData;
using NetTopologySuite.Operation.Relate;
using System.Diagnostics;
using NetTopologySuite.Algorithm;
using System.Runtime.InteropServices;
//using ParameterDQ.Construction.Util;
using NeighborInterpolator;
using System.Security.Permissions;
using System.Data.SqlClient;
using NetTopologySuite.Index.Strtree;

namespace Construction.BatchCreateMap
{
    public delegate void ProgressEvent(string eventName, int curentStep);
    public class LayerCreate
    {
        private const double Zero = 1E-5;
        public ProgressEvent ProgressChanged;
        public static string ExePath { get; set; } = string.Empty;
        public static string XYZPath // dfCreatef(x,y)
        {
            get
            {
                return Path.Combine(ExePath, "GridModel.exe");
            }
        }
        //public static string IdmPath
        //{
        //    get
        //    {
        //        return Path.Combine(ExePath, "GridModel.exe");
        //    }
        //}
        //string onCurveModelPath = "C:\\DF42\\bin\\CurveModel.exe";//等值线

        private List<int> listProcessIds = new List<int>();
        public void KillProgress()
        {
            for (int i = 0; i < listProcessIds.Count; i++)
            {

                try
                {
                    Process process = Process.GetProcessById(listProcessIds[i]);
                    process.Kill();
                    process.WaitForExit(500); // 等待进程退出
                }
                catch (ArgumentException)
                {
                    // 进程已退出
                }
                catch (System.ComponentModel.Win32Exception ex)
                {
                    // 处理权限不足等异常
                }

                listProcessIds.RemoveAt(i);
                i--;
            }
        }
        
        public static string CurveModelPath
        {
            get
            {
                return Path.Combine(ExePath, "CurveModel.exe");
            }
        }
        //private static string _BorderFile;
        //public static string BorderFile
        //{
        //    get
        //    {
        //        //string strFile = WorkData.Config.ProjectPath + "\\result\\border.dfd";
        //        //if (File.Exists(strFile))
        //        //{
        //        //    return strFile;
        //        //}
        //        return _BorderFile;
        //    }
        //    set
        //    {
        //        _BorderFile = value;
        //    }
        //}
        //private double _XMin, _XMax, _YMin, _YMax;
        /// <summary>
        /// 搜索所有文件夹
        /// </summary>
        /// <param name="dirName"></param>
        public string SearchFolder(string dirName, string layerName)  //参数为指定的目录   
        {
            string strFind = "";
            //在指定目录及子目录下查找文件 
            DirectoryInfo dir = new DirectoryInfo(dirName);
            try
            {
                foreach (DirectoryInfo d in dir.GetDirectories())     // 查找子目录     
                {
                    strFind = SearchFolder(dir + "\\" + d.ToString(), layerName);
                    if (strFind.Length > 0)
                    {
                        return strFind;
                    }
                }
                // 文件处理
                foreach (FileInfo f in dir.GetFiles("*.*"))             // 查找文件   
                {
                    if (Path.GetFileNameWithoutExtension(f.Name)
                        .Equals(layerName, StringComparison.CurrentCultureIgnoreCase))
                    {
                        strFind = f.FullName;
                        return strFind;
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return "";
            }
            return "";
        }
        ///// <summary>
        ///// 创建断层文件
        ///// </summary>
        ///// <param name="layerName"></param>
        ///// <returns></returns>
        //public string CreateFault(string layerName)
        //{
        //    InterpretFault fault = DBHelp.Db.Queryable<InterpretFault>().Single(
        //        it => it.CW.ToUpper()==layerName.ToUpper());
        //    if (fault ==null||fault.FILE_DATA==null||fault.FILE_DATA.Length==0) { return ""; }
        //    string strFaultData = System.Text.Encoding.Default.GetString(fault.FILE_DATA);

        //    // 生成断层文件
        //    DfdFormat dfdFormat = new DfdFormat();
        //    string strFault = dfdFormat.DataToDfdString(strFaultData,new char[] { '\t' , ' ' }, "断层", LineDataFormat.XYName);

        //    string strWriteFile = WorkData.Config.ProjectPath + "\\middle\\"+ layerName+"_f.dfd";
        //    using (StreamWriter sw = new StreamWriter(strWriteFile,false, Encoding.Default))
        //    {
        //        sw.WriteLine(strFault);
        //    }
        //    return strWriteFile;
        //}
        /// <summary>
        /// 生成边界
        /// </summary>
        /// <param name="xyzFile"></param>
        /// <param name="outFile"></param>
        /// <returns></returns>
        //public bool CreateBorderForRange(string xyzFile, string outFile)
        //{
        //    try
        //    {
        //        var range = ParameterDataWriter.ReadXYZRange(xyzFile);

        //        DfLine dfLine = new DfLine();
        //        dfLine.Points.Add(new DfPoint(range.XMin.Value, range.YMin.Value));
        //        dfLine.Points.Add(new DfPoint(range.XMin.Value, range.YMax.Value));
        //        dfLine.Points.Add(new DfPoint(range.XMax.Value, range.YMax.Value));
        //        dfLine.Points.Add(new DfPoint(range.XMax.Value, range.YMin.Value));
        //        dfLine.Points.Add(new DfPoint(range.XMin.Value, range.YMin.Value));

        //        dfLine.Layer = "边界";
        //        DfdWriter dfdWriter = new DfdWriter(outFile);
        //        dfdWriter.WriteDfdLine(new List<DfLine>() { dfLine }, false);

        //        return true;
        //    }
        //    catch (Exception ex)
        //    {
        //        return false;
        //    }
        //}
        public bool CreateBorder(string xyzFile, string outFile)
        {
            try
            {
                List<Coordinate> coordinates = new List<Coordinate>();
                string strLine = "";
                using (StreamReader sr = new StreamReader(xyzFile, Encoding.Default))
                {
                    string[] straXY;
                    double dX = 0, dY = 0;
                    while (sr.Peek() > -1)
                    {
                        strLine = sr.ReadLine();
                        straXY = strLine.Split(',');
                        if (straXY.Length < 3)
                        {
                            continue;
                        }
                        if (double.TryParse(straXY[0] + "", out dX)
                        && double.TryParse(straXY[1] + "", out dY))
                        {
                            coordinates.Add(new Coordinate(dX, dY));
                        }
                    }
                }
                //PrecisionModel precisionModel = new PrecisionModel(PrecisionModel.MaximumPreciseValue);
                //GeometryFactory factory = new GeometryFactory(precisionModel, 0);
                var convexHullOp = new ConvexHull(coordinates, GeometryFactory.Default);
                var ch = convexHullOp.GetConvexHull();

                //Trace.WriteLine("ConvexHull:");
                //Trace.WriteLine($"Geometry type: {ch.GeometryType}");
                //Trace.WriteLine($"Number of points: {ch.NumPoints}");

                //Trace.WriteLine("Before Simplify:");
                //Trace.WriteLine(string.Format("Geometry type: {0}", ch.GeometryType));
                //if (ch is Polygon p)
                //{
                //    var ring = (LinearRing)p.ExteriorRing;
                //    Trace.WriteLine(string.Format("Exterior ring orientation: {0}", ring.IsCCW ? "counter-clockwise" : "clockwise"));
                //    //p.Reverse();
                //    //ring = (LinearRing)p.ExteriorRing;
                //    //Trace.WriteLine(string.Format("Exterior ring orientation: {0}", ring.IsCCW ? "counter-clockwise" : "clockwise"));
                //}
                //Trace.WriteLine(ch.AsText());

                //actual = actual.Reverse();


                //foreach (Coordinate coor in actual.Coordinates)
                //{
                //    Trace.WriteLine($"{coor.X},{coor.Y}");
                //}

                //double dTolerance = 1E-7;
                //Geometry geoSimplify = NetTopologySuite.Simplify.TopologyPreservingSimplifier.Simplify(actual, dTolerance);
                //Trace.WriteLine("After Simplify:");
                //foreach (Coordinate coor in geoSimplify.Coordinates)
                //{
                //    Trace.WriteLine($"{coor.X},{coor.Y}");
                //}

                //CoordinateList lstBorder = PointsHull.Brahamscan(ch.Coordinates, 10);

                DfLine dfLine = new DfLine();
                foreach (Coordinate coor in ch.Coordinates)
                {
                    dfLine.Points.Add(new DfPoint(coor.X, coor.Y));
                }
                dfLine.Layer = "边界";
                DfdWriter dfdWriter = new DfdWriter(outFile);
                dfdWriter.WriteDfdLine(new List<DfLine>() { dfLine }, false);

                return true;
            }
            catch (System.Exception ex)
            {
                return false;
            }
        }
        //public bool CreateBorder(string xyzFile, string outFile)
        //{
        //    try
        //    {
        //        List<Coordinate> coordinates = new List<Coordinate>();
        //        string strLine = "";
        //        using (StreamReader sr = new StreamReader(xyzFile, Encoding.Default))
        //        {
        //            string[] straXY;
        //            double dX = 0, dY = 0;
        //            while (sr.Peek() > -1)
        //            {
        //                strLine = sr.ReadLine();
        //                straXY = strLine.Split(',');
        //                if(straXY.Length < 3)
        //                {
        //                    continue;
        //                }
        //                if (Double.TryParse(straXY[0] + "", out dX)
        //                && Double.TryParse(straXY[1] + "", out dY))
        //                {
        //                    coordinates.Add(new Coordinate(dX, dY));
        //                }                            
        //            }
        //        }

        //        PrecisionModel precisionModel = new PrecisionModel(PrecisionModel.MaximumPreciseValue);
        //        GeometryFactory factory = new GeometryFactory(precisionModel, 0);                
        //        var ch = new ConvexHull(coordinates, factory);
        //        var actual = ch.GetConvexHull();

        //        List<DfPoint> lstDfPoints = new List<DfPoint>();
        //        for (int i = 2; i < actual.Coordinates.Count(); i++)
        //        {
        //            lstDfPoints.Add(new DfPoint(actual.Coordinates[i].X, actual.Coordinates[i].Y));
        //        }
        //        DfLine dfLine = new DfLine(lstDfPoints);
        //        dfLine.Layer = "边界";
        //        //string strBorderMap = WorkData.Config.ProjectPath + "\\result\\border.dfd";
        //        DfdWriter dfdWriter = new DfdWriter(outFile);
        //        dfdWriter.WriteDfdLine(new List<DfLine>() { dfLine }, false);

        //        return true;
        //    }
        //    catch (System.Exception ex)
        //    {
        //        return false;
        //    }
        //}
        public bool CreateBorder(DataTable data, string fileName)
        {
            try
            {
                int nCount = data.Rows.Count;
                List<Coordinate> coordinates = new List<Coordinate>();
                double dX = 0, dY = 0;
                for (int i = 0; i < nCount; i++)
                {
                    if (Double.TryParse(data.Rows[i]["X"] + "", out dX)
                        && Double.TryParse(data.Rows[i]["Y"] + "", out dY))
                    {
                        coordinates.Add(new Coordinate(dX, dY));
                    }
                }
                GeometryFactory factory = new GeometryFactory();
                MultiPoint pts = factory.CreateMultiPointFromCoords(coordinates.ToArray());
                Geometry hull = pts.ConvexHull();
                List<DfPoint> lstDfPoints = new List<DfPoint>();
                for (int i = 0; i < hull.Coordinates.Count(); i++)
                {
                    lstDfPoints.Add(new DfPoint(hull.Coordinates[i].X, hull.Coordinates[i].Y));
                }
                DfLine dfLine = new DfLine(lstDfPoints);
                dfLine.Layer = "边界";
                //string strBorderMap = WorkData.Config.ProjectPath + "\\result\\border.dfd";
                DfdWriter dfdWriter = new DfdWriter(fileName);
                dfdWriter.WriteDfdLine(new List<DfLine>() { dfLine }, false);

                return true;
            }
            catch (System.Exception ex)
            {
                return false;
            }
        }
        public void AppendFile(string fileSource, string fileAppend)
        {
            string strAppendData = "";
            using (StreamReader sr = new StreamReader(fileAppend, Encoding.Default))
            {
                strAppendData = sr.ReadToEnd();
            }
            using (StreamWriter sw = new StreamWriter(fileSource, true, Encoding.Default))
            {
                sw.WriteLine(strAppendData);
            }
        }
        [Flags]
        public enum ThreadAccess : int
        {
            TERMINATE = (0x0001),
            SUSPEND_RESUME = (0x0002),
            GET_CONTEXT = (0x0008),
            SET_CONTEXT = (0x0010),
            SET_INFORMATION = (0x0020),
            QUERY_INFORMATION = (0x0040),
            SET_THREAD_TOKEN = (0x0080),
            IMPERSONATE = (0x0100),
            DIRECT_IMPERSONATION = (0x0200)
        }
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId);
        [DllImport("kernel32.dll")]
        private static extern uint GetCurrentThreadId();

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool CloseHandle(IntPtr hObject);
        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool TerminateThread(IntPtr hThread, uint dwExitCode);

        /// <summary>
        /// 终止网格化处理线程
        /// </summary>
        [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
        public bool AboutGridProcess()
        {
            if (ProcessThread != null)
            {
                //// 获取线程ID
                //IntPtr handle = OpenThread(ThreadAccess.TERMINATE, false, ProcessThreadId);

                //// 终止线程
                //if (handle != IntPtr.Zero)
                //{
                //    TerminateThread(handle, 0); // 或者其他的退出码
                //    CloseHandle(handle);

                //    ProcessThreadId = 0;
                //    return true;
                //}
                //return false;

                // 强制终止线程
                ProcessThread.Interrupt();
                ProcessThread.Abort();
                ProcessThread.Join();
            }
            return false;
        }
        /// <summary>
        /// 网格化处理线程
        /// </summary>
        public static Thread ProcessThread { get; set; } = null;
        public static uint ProcessThreadId { get; set; } = 0;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="para"></param>
        /// <param name="outputDir"></param>
        /// <param name="fileName"></param>
        /// <param name="flag">处理标识:
        /// 0-网格化、生成等值线、断层内等值线清理、断层搭接；
        /// 1-网格化、生成等值线、断层内等值线清理;
        /// 2-网格化、生成等值线
        /// 3-网格化。
        /// 默认值是0</param>
        /// <returns></returns>
        public bool CreateLayerMapWithPara(GridCreateParameter para, string outputDir, string fileName
            , int flag = 0)
        {
            ProcessThread = null;
            if (!outputDir.EndsWith("\\"))
            {
                outputDir += "\\";
            }
            string strInput = Convert2AbsolutePath(para.DataRootPath, para.Input); 
            string strOutput = Convert2AbsolutePath(para.DataRootPath, para.Output); 
            string strOutline = Convert2AbsolutePath(para.DataRootPath, para.Outline);
            strOutline = string.IsNullOrEmpty(strOutline) ? "NULL" : strOutline;
            string strFaultFile = Convert2AbsolutePath(para.DataRootPath, para.Faultage);
            strFaultFile = string.IsNullOrEmpty(strFaultFile) ? "NULL" : strFaultFile;

            string strParaFile = para.FilePath;
            //string strFaultFile = para.Faultage;

            string strCurveFile = $"{outputDir}{fileName}.kev";
            string strDfgFile = $"{outputDir}{fileName}.dfg";

            if (para.CreateType == ModelCreateType.Curvature)
            { // 最小曲率法
              //bool bResult = false;
              //ProcessThread = new Thread(new ThreadStart(() =>
              //{
              //    ProcessThreadId = GetCurrentThreadId();
              //    try
              //    {
              //        ModelCreateCurvature.BuildMinCurvatureGrid3(strInput, strFaultFile, strOutline,
              //           (ulong)para.M, /*(ulong)para.N,*/ -1, 0.0001, 0.0, 0, strCurveFile
              //          , 0, 64
              //          , para.CurveSpace, para.LableSpace, para.Times
              //          , para.XMin, para.YMin, para.XMax, para.YMax);
              //        bResult = processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
              //    }
              //    catch (ThreadAbortException ex)
              //    {
              //        bResult = false;
              //    }
              //}), 20 * 1024 * 1024);
              //ProcessThread.Start();
              //ProcessThread.Join();
              //return bResult;

                Dictionary<string, object> dic = new Dictionary<string, object>()
                {
                    { "--source-point-file",$"\"{strInput}\"" },
                    { "--fault",$"\"{strFaultFile}\""  },
                    { "--breakline",$"\"{strOutline}\"" },
                    { "--x-nodes-count",(ulong)para.M },
                    { "--max-iteration", -1 },
                    { "--residual",  0.0001 },
                    { "--fill-value", 0.0},
                    { "--fault-edge-level",0 },
                    { "--output-file", $"\"{strCurveFile}\"" },
                    { "--estimate-factor",0 },
                    { "--corner-weight", 64 },
                    { "--contour-step", para.CurveSpace },
                    { "--contour-mark-step", para.LableSpace },
                    { "--insert-times",  para.Times },
                    { "--smooth-times",  para.Smooth },
                    { "--area", $"{para.XMin},{para.YMin},{para.XMax},{para.YMax}" },
                };

                string strParameter = string.Join(" ", dic.Select(x => $"{x.Key} {x.Value}"));
                // 执行网格化模块
                Process p = new Process();

                p.StartInfo.FileName = "SurfaceGrid.exe";   //exe程序文件地址

                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardInput = false;
                p.StartInfo.RedirectStandardOutput = false;
                p.StartInfo.RedirectStandardError = false;
                p.StartInfo.CreateNoWindow = true;

                p.StartInfo.Arguments = strParameter;  // 参数 多个参数使用空格分开     

                p.Start();
                listProcessIds.Add(p.Id);
                p.WaitForExit();
                p.Close();
                return processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
            }
            else if (para.CreateType == ModelCreateType.IDM)
            { // 反距离加权法
                IntPtr pEvent = IntPtr.Zero;
                if (ProgressChanged != null)
                {
                    pEvent = Marshal.GetFunctionPointerForDelegate(ProgressChanged);
                }
                bool bResult = false;
                ProcessThread = new Thread(new ThreadStart(() =>
                {
                    ProcessThreadId = GetCurrentThreadId();
                    try
                    {
                        // SetDllDirectory(System.Windows.Forms.Application.StartupPath);
                        ModelCreateIDW.IDWModelCreate(strInput, strOutline, strFaultFile, strCurveFile,
                        para.M, para.Smooth, 3, pEvent, para.Times, para.CurveSpace, para.LableSpace
                        , para.XMin, para.YMin, para.XMax, para.YMax);
                        bResult = processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
                    }
                    catch (ThreadAbortException)
                    {
                        bResult = false;
                    }
                }), 2621440);
                ProcessThread.Start();
                ProcessThread.Join();
                return bResult;
            }
            else if (para.CreateType == ModelCreateType.NatureNeighbor)
            { // 自然临近法
                bool bResult = false;
                ProcessThread = new Thread(new ThreadStart(() =>
                {
                    ProcessThreadId = GetCurrentThreadId();
                    try
                    {
                        GridCreator creater = new GridCreator();
                        creater.Create(strInput, strCurveFile, strOutline
                            , para.M, para.N, para.Times, para.CurveSpace, para.LableSpace
                            , para.XMin, para.YMin, para.XMax, para.YMax);
                        bResult = processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
                    }
                    catch (ThreadAbortException ex)
                    {
                        bResult = false;
                    }
                }));
                ProcessThread.Start();
                ProcessThread.Join();
                return bResult;
            }
            else if(para.CreateType == ModelCreateType.QuikGrid)
            {
                bool bResult  = QuikGridCS.Interface.QuikGridCreate(strInput, strCurveFile, para.M, para.N, para.CurveSpace, para.LableSpace, para.Smooth);
                //bResult = processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
                return bResult;
            }
            else if(para.CreateType == ModelCreateType.GmtSplineGrid)
            {
                //样条插值
                string strParameter = "";
                string strOutputFile = $"{outputDir}{fileName}.grd";
                string outputFile = $"{outputDir}{fileName}.kev";
                strParameter = string.Format("\"{0}\" \"{1}\" \"{2}\" \"{3}\" \"{4}\" {5} {6} {7} {8} {9} {10} {11} {12}"
                    , strInput, strOutputFile, strFaultFile
                    , strOutline, outputFile, para.XStep
                    , 0, para.CurveSpace, para.LableSpace
                    , para.XMin, para.YMin, para.XMax, para.YMax
                    );

                string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
                string exeDir = Path.GetDirectoryName(exePath);
                string exeFilePath = Path.Combine(exeDir, "GmtSurfaceGrid.exe");
                Trace.WriteLine(strParameter);

                // 执行网格化模块
                Process p = new Process();
                p.StartInfo.FileName = exeFilePath;   //exe程序文件地址
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardOutput = true;
                p.StartInfo.RedirectStandardError = true;
                p.StartInfo.CreateNoWindow = true;
                p.StartInfo.Arguments = strParameter;  // 参数 多个参数使用空格分开     
                p.Start();
                p.WaitForExit();
                string output = p.StandardOutput.ReadToEnd();
                string error = p.StandardError.ReadToEnd();
                string result = string.IsNullOrWhiteSpace(error) ? output : error;
                int exitCode = p.ExitCode;
                p.Close();

                bool state = (exitCode == 0 ? true : false);
                return state;
            }
            else
            { // 最小张力法
                string strParameter = "";
                if (strOutline.Equals("NULL", StringComparison.CurrentCultureIgnoreCase))
                {
                    strParameter = string.Format("\"{0}\" \"{1}\" {2} \"{3}\" \"{4}\" {5} {6} {7} {8} {9} {10} {11}"
                        , strInput, strOutput, para.Times
                        , strOutline, strFaultFile
                        , para.M, para.Smooth, 0        // 最后一项为断层优先级
                        , para.XMin, para.YMin, para.XMax, para.YMax);
                }
                else
                {
                    strParameter = string.Format("\"{0}\" \"{1}\" {2} \"{3}\" \"{4}\" {5} {6} {7}"
                        , strInput, strOutput, para.Times
                        , strOutline, strFaultFile
                        , para.M, para.Smooth, 0);      // 最后一项为断层优先级
                }
                // CreateBorder();
                Trace.WriteLine(strParameter);

                // 执行网格化模块
                Process p = new Process();
                p.StartInfo.FileName = XYZPath;   //exe程序文件地址

                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardInput = false;
                p.StartInfo.RedirectStandardOutput = false;
                p.StartInfo.RedirectStandardError = false;
                p.StartInfo.CreateNoWindow = true;
                p.StartInfo.Arguments = strParameter;  // 参数 多个参数使用空格分开     

                p.Start();
                p.WaitForExit();
                p.Close();

                if (flag >= 3) return true;
                // 等值线
                string strCurveParameter = "";
                strCurveParameter += "\"" + strOutput + "\"";
                strCurveParameter += " ";
                strCurveParameter += "\"" + strCurveFile + "\"";

                if (strFaultFile.Equals("NULL"))
                {
                    strFaultFile = null;
                }
                if (strFaultFile != null && strFaultFile.Length > 0)
                {
                    strCurveParameter += " \"" + strFaultFile + "\" " + para.CurveSpace;
                }
                else
                {
                    strCurveParameter += " NULL " + para.CurveSpace;
                }
                if (para.LableSpace > 0)
                {
                    strCurveParameter += " " + para.LableSpace;
                }
                Trace.WriteLine(strCurveParameter);
                p = new System.Diagnostics.Process();
                p.StartInfo.FileName = CurveModelPath;   // exe程序文件地址
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardInput = false;
                p.StartInfo.RedirectStandardOutput = false;
                p.StartInfo.RedirectStandardError = false;
                p.StartInfo.CreateNoWindow = true;
                p.StartInfo.Arguments = strCurveParameter;  // 参数多个参数使用空格分开               
                p.Start();
                p.WaitForExit();
                p.Close();

                // 追加断层
                if (strFaultFile != null && strFaultFile.Length > 0)
                    AppendFile(strCurveFile, strFaultFile);
                return processAfterGrid(outputDir, fileName, flag, strFaultFile, strCurveFile, strDfgFile);
            }
        }

        private bool processAfterGrid(string outputDir, string fileName, int flag, string strFaultFile, string strCurveFile, string strDfgFile)
        {
            if (flag >= 2) return true;
            // 断层清理
            if (ClearLineInFault(strCurveFile, "等值线", "断层") == false)
            {
                return true;
            }

            // 断层搭接
            if (flag >= 1)
            {
                return true;
            }
            // 读取网格信息
            DfgReader dfg = new DfgReader(strDfgFile);
            dfg.ReadHead();
            double dStepX = dfg.DeltX;
            double dStepY = dfg.DeltY;
            List<DfLine> extendCurves = LineOfExtend2Fault(Math.Max(dStepX, dStepY) * 2, strCurveFile, strFaultFile, "等值线", "断层");

            string strCurveFileBak = (outputDir + fileName + "_Curve.kev");
            File.Copy(strCurveFile, strCurveFileBak, true);
            DfdWriter dfdWriter = new DfdWriter(strCurveFile);
            dfdWriter.WriteDfg(strDfgFile, "背景", false);

            dfdWriter.WriteDfdLine(extendCurves, true);
            // 追加断层
            if (strFaultFile != null && strFaultFile.Length > 0)
                AppendFile(strCurveFile, strFaultFile);

            return true;
        }

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool SetDllDirectory(string lpPathName);
        ///// <summary>
        ///// 按地层成图
        ///// </summary>
        ///// <param name="layerName"></param>
        ///// <param name="borderFile"></param>
        ///// <returns></returns>
        //public bool CreateLayerMap(string layerName)
        //{
        //    if (GetMapRange()==false) return false;
        //    CreateBorder();
        //    //var result = DBHelp.Db.Queryable<WellDepositBoundary, WellBase>(
        //    //    (boundary, wellBase) => new JoinQueryInfos(
        //    //        JoinType.Left, boundary.JH == wellBase.JH)
        //    //    )//.Where(boundary => boundary[layerName] == layerName)
        //    //     .Select((boundary, wellBase) => 
        //    //     new {X = wellBase.X, Y=wellBase.Y, Z = boundary.Jxz }
        //    //     ).ToList();
        //    string strColumnName = DBHelp.GetColumnName<WellDepositBoundary>(layerName);
        //    var result = DBHelp.Db.Queryable<WellDepositBoundary, WellBase>(
        //        (boundary, wellBase) => new JoinQueryInfos(
        //            JoinType.Left, boundary.JH==wellBase.JH))
        //         .Select("wellBase.X, wellBase.Y,boundary."+strColumnName).ToDataTable();

        //    string strDataFile = WorkData.Config.ProjectPath + @"\temp\" + layerName + ".xyz";
        //    // 写散点文件
        //    using (StreamWriter sw = new StreamWriter(strDataFile, false, Encoding.Default))
        //    {
        //        for(int i = 0; i < result.Rows.Count; i++)
        //        {
        //            var line = result.Rows[i];
        //            sw.WriteLine("{0},{1},{2}", line[0], line[1], line[2]);
        //        }
        //    }
        //    string strFaultFile = CreateFault(layerName);
        //    // 写参数文件
        //    string strParaFile = WorkData.Config.ProjectPath + @"\middle\" + layerName + ".ini";
        //    Parameter util = new Parameter();
        //    util.FilePath = strParaFile;
        //    util.Input = strDataFile;
        //    util.Output = WorkData.Config.ProjectPath + @"\temp\" + layerName + ".f(x,y)";
        //    util.Outline = BorderFile;
        //    if (strFaultFile.Length > 0)
        //    {
        //        util.Faultage = strFaultFile; // 断层
        //    }
        //    util.XMax = _XMin;
        //    util.XMax = _XMax;
        //    util.YMin = _YMin;
        //    util.YMax = _YMax;
        //    util.M = 640;
        //    util.N = 304;
        //    util.Times = 1;
        //    util.WriteData();

        //    return CreateLayerMapWithPara(layerName, util);            
        //}
        private bool Extent2Fault(DfLine line, List<LineString> cooFaults, double dStep, DfLine lineDes)
        {
            bool bSuccess = false;
            int nPtCount = line.Points.Count;
            line.CopyTo(lineDes);
            double dDistanceStart = dStep;
            double dDistanceEnd = dStep;
            LineString faultStart = null;
            LineString faultEnd = null;
            Coordinate ptStart1 = new Coordinate(line.Points[1].X, line.Points[1].Y);
            Coordinate ptStart2 = new Coordinate(line.Points[0].X, line.Points[0].Y);
            Coordinate ptEnd1 = new Coordinate(line.Points[nPtCount - 2].X, line.Points[nPtCount - 2].Y);
            Coordinate ptEnd2 = new Coordinate(line.Points[nPtCount - 1].X, line.Points[nPtCount - 1].Y);

            if (ptStart1.Equals2D(ptStart2) || ptEnd1.Equals2D(ptEnd2))
            {
                return false;
            }
            bool bSkipHead = false;
            bool bSkipTail = false;
            for (int i = 0; i < cooFaults.Count; i++)
            {
                //if(faultEnd !=null && faultStart!=null)
                //{
                //    break;
                //}
                // 首节点
                if (bSkipHead == false)
                {
                    double dDistance = new DistanceOp(cooFaults[i], new Point(ptStart2)).Distance();
                    if (dDistance <= dDistanceStart)
                    {
                        if (dDistance < Zero)
                        {
                            bSkipHead = true;
                        }
                        else
                        {
                            dDistanceStart = dDistance;
                            faultStart = cooFaults[i];
                        }
                    }
                }
                // 尾节点
                if (bSkipTail == false)// faultEnd == null &&
                {
                    double dDistance = new DistanceOp(cooFaults[i], new Point(ptEnd2)).Distance();
                    if (dDistance <= dDistanceEnd)
                    {
                        if (dDistance < Zero)
                        {
                            bSkipTail = true;
                        }
                        else
                        {
                            dDistanceEnd = dDistance;
                            faultEnd = cooFaults[i];
                        }
                    }
                }
            }
            if (faultStart != null && bSkipHead != true)
            {
                var crossPt = GetCrossPt(ptStart1, ptStart2, faultStart, dStep);
                lineDes.Points.Insert(0, new DfPoint(crossPt.X, crossPt.Y));
                bSuccess = true;
            }
            if (faultEnd != null && bSkipTail != true)
            {
                var crossPt = GetCrossPt(ptEnd1, ptEnd2, faultEnd, dStep);
                lineDes.Points.Add(new DfPoint(crossPt.X, crossPt.Y));

                bSuccess = true;
            }
            return bSuccess;
        }
        public bool LineOfExtend2Fault(string fileName, double dStep, string curveLayer = "等值线", string faultLayer = "断层")
        {
            // 读取所有断层
            DfdReader curveReader = new DfdReader(fileName);
            List<DfLine> dfFaults = curveReader.GetDfdLinesByLayer(faultLayer);

            List<LineString> cooFaults = new List<LineString>();
            foreach (DfLine fault in dfFaults)
            {
                int nCount = fault.Points.Count;
                if (nCount < 4) continue;
                Coordinate[] coordinates = new Coordinate[nCount];
                for (int i = 0; i < nCount; i++)
                {
                    coordinates[i] = new Coordinate(fault.Points[i].X, fault.Points[i].Y);
                }
                cooFaults.Add(new LineString(coordinates));
            }

            // 逐行读取
            DfdElementReader elementReader = new DfdElementReader(fileName);

            string strFileBack = CreateBackupFileName(fileName);
            StreamWriter sw = new StreamWriter(strFileBack, false, Encoding.Default);
            string strLayerSub = curveLayer + "\\";
            string strLine;
            while ((strLine = elementReader.ReadLine()) != null)
            {
                //Trace.WriteLine(strLine);
                if ((elementReader.LayerName == curveLayer || elementReader.LayerName.StartsWith(strLayerSub))
                    && elementReader.CurElementType == DfdIO.Elements.ElementType.ELEMENT_LINE)
                {
                    DfLine eleLine = elementReader.ReadLineElement();

                    if (eleLine.Points.Count < 2)
                    {
                        // 忽略无效曲线
                        elementReader.CurElementType = DfdIO.Elements.ElementType.ELEMENT_NONE;
                    }
                    else
                    {
                        // 进行延伸处理
                        DfLine lineNew = new DfLine();
                        Extent2Fault(eleLine, cooFaults, dStep, lineNew);
                        string strLineData = lineNew.ToString(false);
                        sw.WriteLine(strLineData);
                        elementReader.CurElementType = DfdIO.Elements.ElementType.ELEMENT_NONE;
                    }
                }
                else
                {
                    sw.WriteLine(strLine);
                }
            }
            sw.Flush();
            sw.Close();
            elementReader.EndReader();
            File.Delete(fileName);
            File.Copy(strFileBack, fileName);

            return true;
        }
        private List<DfLine> LineOfExtend2Fault(double dStep, string curveFile, string faultFile
            , string curveLayer = "等值线", string faultLayer = "断层")
        {
            DfdReader curveReader = new DfdReader(curveFile);
            if (faultFile == null || faultFile.Length == 0)
            {
                return curveReader.GetDfdLinesByLayer(curveLayer, 1);
            }
            List<DfLine> dfLinesNew = new List<DfLine>();
            // DfdReader curveReader = new DfdReader(curveFile);
            // 等值线
            List<DfLine> dfCurves = curveReader.GetDfdLinesByLayer(curveLayer, 1);
            DfdReader faultReader = new DfdReader(faultFile);
            // 断层
            List<DfLine> dfFaults = faultReader.GetDfdLinesByLayer(faultLayer);
            // 断层
            List<LineString> cooFaults = new List<LineString>();
            foreach (DfLine fault in dfFaults)
            {
                int nCount = fault.Points.Count;
                Coordinate[] coordinates = new Coordinate[nCount];
                for (int i = 0; i < nCount; i++)
                {
                    coordinates[i] = new Coordinate(fault.Points[i].X, fault.Points[i].Y);
                }
                cooFaults.Add(new LineString(coordinates));
            }
            Coordinate ptStart1, ptStart2;
            Coordinate ptEnd1, ptEnd2;
            //DistanceOp op;
            double dDistanceStart = dStep, dDistanceEnd = dStep;
            //Coordinate cooClosestPtStart=null, cooClosestPtEnd = null;
            LineString faultStart = null, faultEnd = null;
            //int nPtCount = 0;
            //Parallel.ForEach(dfCurves,(line, loopState) =>
            //FormProcess prog = new FormProcess();
            //prog.Show();
            // TODO：多CPU，去重复运算
            int nCurvesCount = dfCurves.Count;
            int nIndex = 0;
            int nStep = 0;
            foreach (DfLine line in dfCurves)
            {
                int nPtCount = line.Points.Count;
                if (nPtCount < 2) continue;
                DfLine lineNew = line.Copy();
                //cooClosestPtStart = null;
                //cooClosestPtEnd = null;
                dDistanceStart = dStep;
                dDistanceEnd = dStep;
                faultStart = null; faultEnd = null;
                ptStart1 = new Coordinate(line.Points[1].X, line.Points[1].Y);
                ptStart2 = new Coordinate(line.Points[0].X, line.Points[0].Y);
                ptEnd1 = new Coordinate(line.Points[nPtCount - 2].X, line.Points[nPtCount - 2].Y);
                ptEnd2 = new Coordinate(line.Points[nPtCount - 1].X, line.Points[nPtCount - 1].Y);
                for (int i = 0; i < cooFaults.Count; i++)
                {
                    // 首节点 
                    double dDistance = new DistanceOp(cooFaults[i], new Point(ptStart2)).Distance();
                    // 到断层的距离小于阈值
                    if (dDistance <= dDistanceStart)
                    {
                        dDistanceStart = dDistance;
                        faultStart = cooFaults[i];
                    }
                    // 尾节点
                    dDistance = new DistanceOp(cooFaults[i], new Point(ptEnd2)).Distance();
                    if (dDistance <= dDistanceEnd)
                    {
                        dDistanceEnd = dDistance;
                        faultEnd = cooFaults[i];
                    }
                }
                if (faultStart != null)
                {
                    var crossPt = GetCrossPt(ptStart1, ptStart2, faultStart, dStep);
                    lineNew.Points.Insert(0, new DfPoint(crossPt.X, crossPt.Y));
                }
                if (faultEnd != null)
                {
                    var crossPt = GetCrossPt(ptEnd1, ptEnd2, faultEnd, dStep);
                    lineNew.Points.Add(new DfPoint(crossPt.X, crossPt.Y));
                }
                dfLinesNew.Add(lineNew);
                //}
                nIndex++;
                nStep = (int)(((double)nIndex / (double)nCurvesCount) * 100);

                ProgressChanged?.Invoke("断层搭接", nStep);
            }

            return dfLinesNew;
        }
        /// <summary>
        /// 等值线搭接断层
        /// </summary>
        /// <param name="dStep">网格步长</param>
        /// <param name="curveFile">等值线文件</param>
        /// <param name="faultFile">断层文件</param>
        /// <param name="outFile">结果输出文件</param>
        /// <param name="curveLayer">等值线图层</param>
        /// <param name="faultLayer">断层图层</param>
        public void Extend2Fault(double dStep, string curveFile, string faultFile, string outFile
            , string curveLayer = "等值线", string faultLayer = "断层")
        {
            List<DfLine> extendCurves = LineOfExtend2Fault(dStep, curveFile, faultFile, curveLayer, faultLayer);
            DfdWriter dfdWriter = new DfdWriter(outFile);
            dfdWriter.WriteDfdLine(extendCurves, true);
            // 追加断层
            if (faultFile != null && faultFile.Length > 0)
            {
                AppendFile(outFile, faultFile);
            }
        }
        /// <summary>
        /// 等值线搭接断层
        /// </summary>
        /// <param name="gridFile">网格文件</param>
        /// <param name="curveFile">等值线文件</param>
        /// <param name="faultFile">断层文件</param>
        /// <param name="outFile">结果输出文件</param>
        /// <param name="curveLayer">等值线图层</param>
        /// <param name="faultLayer">断层图层</param>
        public void Extend2Fault(string gridFile, string curveFile, string faultFile, string outFile
            , string curveLayer = "等值线", string faultLayer = "断层")
        {
            // 读取网格信息
            DfgReader dfg = new DfgReader(gridFile);
            dfg.ReadHead();
            double dStepX = dfg.DeltX;
            double dStepY = dfg.DeltY;
            double dStep = Math.Max(dStepX, dStepY) * 2;
            List<DfLine> extendCurves = LineOfExtend2Fault(dStep, curveFile, faultFile, curveLayer, faultLayer);
            DfdWriter dfdWriter = new DfdWriter(outFile);
            dfdWriter.WriteDfdLine(extendCurves, true);
            // 追加断层
            if (faultFile != null && faultFile.Length > 0)
            {
                AppendFile(outFile, faultFile);
            }
        }

        public bool ClearLineInFault(string fileName
            , string curveLayer = "等值线", string faultLayer = "断层")
        {
            // 读取所有断层
            DfdReader curveReader = new DfdReader(fileName);
            List<DfLine> dfFaults = curveReader.GetDfdLinesByLayer(faultLayer);
            if (dfFaults == null || dfFaults.Count == 0)
            {
                return false;
            }
            List<Polygon> cooFaults = new List<Polygon>();
            foreach (DfLine fault in dfFaults)
            {
                if (!fault.IsPolyline)
                {
                    continue;
                }
                fault.CloseData();
                int nCount = fault.Points.Count;
                if (nCount < 4) continue;
                Coordinate[] coordinates = new Coordinate[nCount];
                for (int i = 0; i < nCount; i++)
                {
                    coordinates[i] = new Coordinate(fault.Points[i].X, fault.Points[i].Y);
                }
                cooFaults.Add(new Polygon(new LinearRing(coordinates)));
            }

            // 逐行读取
            DfdElementReader elementReader = new DfdElementReader(fileName);

            string strFileBack = CreateBackupFileName(fileName);
            StreamWriter sw = new StreamWriter(strFileBack, false, Encoding.Default);
            string strLayerSub = curveLayer + "\\";
            string strLine;
            while ((strLine = elementReader.ReadLine()) != null)
            {
                if ((elementReader.LayerName == curveLayer || elementReader.LayerName.StartsWith(strLayerSub))
                    && elementReader.CurElementType == DfdIO.Elements.ElementType.ELEMENT_LINE)
                {
                    DfLine eleLine = elementReader.ReadLineElement();
                    // 发现包含在断层内，则忽略该线.
                    if (eleLine.Points.Count < 2 || isLineInFaults(cooFaults, eleLine))
                    {
                        elementReader.CurElementType = DfdIO.Elements.ElementType.ELEMENT_NONE;
                    }
                    else
                    {
                        string strLineData = eleLine.ToString(false);
                        sw.WriteLine(strLineData);
                        elementReader.CurElementType = DfdIO.Elements.ElementType.ELEMENT_NONE;
                    }
                }
                else
                {
                    sw.WriteLine(strLine);
                }
            }
            sw.Flush();
            sw.Close();
            elementReader.EndReader();
            File.Delete(fileName);
            File.Copy(strFileBack, fileName);
            File.Delete(strFileBack);
            return true;
        }
        private bool isLineInFaults(List<Polygon> cooFaults, DfLine eleLine)
        {
            int nCount = eleLine.Points.Count;
            Coordinate[] points = new Coordinate[nCount];
            for (int i = 0; i < nCount; i++)
            {
                points[i] = new Coordinate(eleLine.Points[i].X, eleLine.Points[i].Y);
            }
            foreach (Polygon polygon in cooFaults)
            {
                LineString cooLine = new LineString(points);
                var im = RelateOp.Relate(polygon, cooLine);
                if (im.IsCovers())
                {
                    return true;
                }
            }
            return false;
        }
        private Coordinate GetCrossPt(Coordinate pt1, Coordinate pt2, Geometry fault, double offset)
        {
            double dXOffset, dYOffset;
            double dR = Math.Sqrt((pt2.Y - pt1.Y) * (pt2.Y - pt1.Y) + (pt2.X - pt1.X) * (pt2.X - pt1.X));
            double dT = dR + offset;

            dXOffset = pt1.X + (pt2.X - pt1.X) / dR * dT;
            dYOffset = pt1.Y + (pt2.Y - pt1.Y) / dR * dT;

            Coordinate[] linePts = new Coordinate[] { pt2, new Coordinate(dXOffset, dYOffset) };
            LineString linear = new LineString(linePts);
            var crossPts = EnhancedPrecisionOp.Intersection(linear, fault);
            if (crossPts.Coordinates.Count() == 0)
            {
                return linePts[0];
            }
            if (crossPts.Coordinates.Count() == 1)
            {
                return crossPts.Coordinates[0];
            }
            // 返回距离最近的点
            double dDistanceNear = double.MaxValue;
            Coordinate cooNear = crossPts.Coordinates[0];
            foreach (Coordinate coor in crossPts.Coordinates)
            {
                double dDis1 = (pt1.X - coor.X) * (pt1.X - coor.X) + (pt1.Y - coor.Y) * (pt1.Y - coor.Y);
                double dDis2 = (pt2.X - coor.X) * (pt2.X - coor.X) + (pt2.Y - coor.Y) * (pt2.Y - coor.Y);

                if (dDis1 < dDistanceNear)
                {
                    dDistanceNear = dDis1;
                    cooNear = coor;
                }
                if (dDis2 < dDistanceNear)
                {
                    dDistanceNear = dDis2;
                    cooNear = coor;
                }
            }
            return cooNear;
            //if (pt1.X > pt2.X)
            //{
            //    return crossPts.Coordinates[crossPts.Coordinates.Count() - 1];
            //}
            //else
            //{
            //    return crossPts.Coordinates[0];
            //}
        }
        public void Curve2Fault(string drawFile, string curveLayer, string faultLayer)
        {
            DfdReader faultReader = new DfdReader(drawFile);
            List<DfLine> dfFaults = faultReader.GetDfdLinesByLayer(faultLayer);
            string strDfgFile = Path.GetDirectoryName(drawFile) + "\\"
                + Path.GetFileNameWithoutExtension(drawFile) + ".cfg";
            if (!File.Exists(strDfgFile))
            {
                strDfgFile = Path.GetDirectoryName(drawFile) + "\\"
                + Path.GetFileNameWithoutExtension(drawFile) + ".dfg";
            }
            // 读取网格信息
            DfgReader dfg = new DfgReader(strDfgFile);
            dfg.ReadHead();
            double dStepX = dfg.DeltX;
            double dStepY = dfg.DeltY;
            List<DfLine> extendCurves = LineOfExtend2Fault(Math.Max(dStepX, dStepY) * 2, drawFile, drawFile, curveLayer);

            DfdWriter dfdWriter = new DfdWriter(drawFile);
            // 写背景色
            dfdWriter.WriteDfg(strDfgFile, "背景", false);
            // 写等值线
            dfdWriter.WriteDfdLine(extendCurves, true);
            // 写断层
            dfdWriter.WriteDfdLine(dfFaults, true);
        }
        //private bool GetMapRange()
        //{
        //    var vXMin = DBHelp.Db.Queryable<WellBase>().Min(w => w.X);
        //    var vXMax = DBHelp.Db.Queryable<WellBase>().Max(w => w.X);
        //    var vYMin = DBHelp.Db.Queryable<WellBase>().Min(w => w.Y);
        //    var vYMax = DBHelp.Db.Queryable<WellBase>().Max(w => w.Y);

        //    if(vXMin == null||vXMax==null||vYMin==null||vYMax==null)
        //    {
        //        return false;
        //    }

        //    _XMin =vXMin.Value;
        //    _XMax=vXMax.Value;
        //    _YMin =vYMin.Value;
        //    _YMax =vYMax.Value;
        //    return true;
        //}
        /// <summary>
        /// 转换成相对路径
        /// </summary>
        /// <param name="fullPath">绝对路径</param>
        /// <returns>相对路径</returns>
        public string Convert2RelativePath(string root, string fullPath)
        {
            if (string.IsNullOrWhiteSpace(fullPath))
            {
                return string.Empty;
            }
            string strReturn = fullPath;
            if (fullPath.StartsWith(root, StringComparison.CurrentCultureIgnoreCase))
            {
                strReturn = fullPath.Remove(0, root.Length + 1);
            }
            return strReturn;
        }
        /// <summary>
        /// 转换到绝对路径
        /// </summary>
        /// <param name="relativePath">相对路径</param>
        /// <returns>绝对路径</returns>
        public string Convert2AbsolutePath(string root, string relativePath)
        {
            if (string.IsNullOrWhiteSpace(relativePath))
            {
                return string.Empty;
            }
            if (string.IsNullOrEmpty(root))
            {
                return relativePath;
            }
            string strReturn = relativePath;
            if (!relativePath.StartsWith(root, StringComparison.CurrentCultureIgnoreCase))
            {
                strReturn = Path.Combine(root, relativePath);
            }
            return strReturn;
        }

        /// <summary>
        /// Gets the name of the backup file.
        /// </summary>
        /// <param name="sourceFile">The source file.</param>
        /// <returns>System.String.</returns>
        public static string CreateBackupFileName(string sourceFile)
        {
            try
            {
                if (string.IsNullOrEmpty(sourceFile))
                {
                    return null;
                }
                string strExt = Path.GetExtension(sourceFile);
                string strFile = Path.GetDirectoryName(sourceFile) + "\\" + Path.GetFileNameWithoutExtension(sourceFile)
                                 + "_bak" + strExt;
                return strFile;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
                return null;
            }
        }

    }

    public class LayerXyz
    {
        public double X { get; set; }
        public double Y { get; set; }
        public double Z { get; set; }
    }
}