using System.Collections.Generic;
using System.Text;
using XYCAM.Entites;
using System;
using System.IO;
using System.Windows.Forms;
using Microsoft.Win32;
using Autodesk.AutoCAD.Windows;


namespace XYCAM.Script
{
    public class XycamScriptClass : ScriptBase
    {

        //主界面自定义变量V37=2时上下异形为为斜退 
        //注意斜退外形第二刀补正量必须为负数
        //当附加斜度打开 自定义变量=6时不输出开粗第一刀斜度
        // 做开形状时输入自定义变量=延时的时间
        // 本后处理自动修改模拟器补正值 
        #region 自定义方法
        /// <summary>
        /// 运行2d轨迹
        /// </summary>
        /// <returns></returns>
        private void Run2()
        {
            //if (V87 == 14)
            //{
            //    AddL("清角开始");
            //}
            //else if (V87 == 15)
            //{
            //    AddL("清角结束");
            //}
            //锥度输出,不为同R且与上一个锥度不同时
            if (NoCut)
            {
                return;
            }
            else
            {
                if (T != LastT && V36 != 3)
                {
                    AddL(G41orG42 ? G52 : G51, T);
                }
                if (V36 == 3)
                {
                    if (T != LastT)
                    {
                        AddL((G41orG42 ? G52 : G51) + "A0.");
                    }
                }
                //判断当前模式是G01或者G00
                if (Cut == G1 || Cut == G0)
                    //加入加工直线的机器指令
                    Add(Cut + X + Y);
                //否则一定是G02 G03 ,圆弧指令
                else
                {
                    //加入加工圆弧的机器指令
                    Add(Cut + X + Y + I + J);
                    //为圆孔试输出直径
                    if (IsCircle)
                    {
                        //Fmt是一个快速定义字符格式的方法,第一个参数是前缀字符,第二个参数是数值,第三个参数是小数位数,默认3位,可以省略
                        Add("( ", Fmt("D", (R * 2).Value), " )");
                    }
                    //否则输出半径
                    else
                    {
                        Add("( ", Fmt("R", R.Value), " )");
                    }
                }
                //同R处理逻辑
                string RA = R3;
                string RB = RA.Replace(R3, "R" + V37);
                string RC = R3;
                string RD = RC.Replace("R", "CC");
                //同R处理逻辑
                if (V87 == 9 && V37 < 10)
                {
                    if (V37 != 0)
                    {
                        Add(R3, RB);
                    }
                    else
                    {
                        Add(R3, R3);//沙迪克模式
                    }
                    //牧野机同R格式为G24L + 半径值
                    //Fmt是一个快速定义字符格式的方法,第一个参数是前缀字符,第二个参数是数值,第三个参数是小数位数,默认3位,可以省略
                    // Add(Fmt("G24L", R.Value));
                }
                if (V87 == 9 && V37 > 10)
                {
                    Add(RD);//沙迪克模式
                            //牧野机同R格式为G24L + 半径值
                            //Fmt是一个快速定义字符格式的方法,第一个参数是前缀字符,第二个参数是数值,第三个参数是小数位数,默认3位,可以省略
                            // Add(Fmt("G24L", R.Value));
                }
                AddL();
                if (V36 == 3)
                {
                    if (T != LastT)
                    {
                        AddL(T);
                    }
                }
            }

        }
        /// <summary>
        /// 运行3d轨迹
        /// </summary>
        /// <returns></returns>
        string Run3d
        {
            get
            {
                if (Cut == G1 || Cut == G0)
                {
                    return Cut + X + Y + ":" + Cut + X2 + Y2;  //两平面格式
                }
                else
                {
                    return "(R" + R + ") " + Cut + X + Y + I + J + ":" + Cut + X2 + Y2 + I2 + J2;  //两平面格式
                }
            }
        }
        /// <summary>
        /// 用变量记录特殊标签,方便之后统一修改
        /// </summary>
        private const string title1 = "顶针孔";
        /// <summary>
        /// 记录上一个标签
        /// </summary>
        string preTitle = "顶针孔";
        /// <summary>
        /// 程序面字典, 查询键为字符(程序面+辅助面) ,对应的值为 整数类型(子程序面呼叫号码)
        /// </summary>
        Dictionary<string, int> progamPlaneDictionary = new Dictionary<string, int>();
        /// <summary>
        /// 子程序面集合字符,最后加入到程序结尾操作区域
        /// </summary>
        string progamPlanes = "";
        #endregion
        /// <summary>
        /// 初始化参数
        /// </summary>
        protected override void Init()
        {


            V55 = 1;//沙迪克模式
            V4 = 0;
            V11 = 1;
            D.Set(3, "H");
            D1.Set(3, "H");
            Dv.Set(3, "");
            E.Set(4, "C");
            E1.Set(4, "C");

            N.Set(4, "N");
            F.Set(3, "F");
            T.Set(3, "A");
            T1.Set(3, "A");
            X.Set(4, "X");
            Y.Set(4, "Y");
            U.Set(4, "U");
            V.Set(4, "V");
            US.Set(4, "U");
            VS.Set(4, "V");
            W.Set(3, "W");
            I.Set(4, "I");
            J.Set(4, "J");
            X2.Set(4, "X");//两平面时的辅助面X
            Y2.Set(4, "Y");//两平面时的辅助面Y
            I2.Set(4, "I");//两平面时的辅助面I
            J2.Set(4, "J");//两平面时的辅助面J
            R.Set(4, "");
            R3.Set(4, "R");
            K.Set(4, "K");
            L.Set(4, "L");
            Z1.Set(3, "TP");
            Z2.Set(3, "TN");
            StartX.Set(4, "X");
            StartY.Set(4, "Y");
            XS.Set(4, "X");
            YS.Set(4, "Y");
            XS1.Set(4, "X");
            YS1.Set(4, "Y");
            XS2.Set(4, "X");
            YS2.Set(4, "Y");
            G41orG42 = false;
            MachineType = "沙迪克";

        }



        //string filePath = "D:\\NcViewer \\Tools\\沙迪克1.TDL";
        //string newTxtPath = "D:\\NcViewer \\Tools\\沙迪克.TDL";//此处改为自己电脑上模拟器的路径
        bool 无屑外部路径
        {
            get { return !V34 && V39 && V1 == 0 && V12 == 1; }
        }

        bool 自动化内孔开粗
        {
            get
            {
                return V1 == 0 && V5 == 2 && V12 == 1 && V36 != 4;
            }
        }

        bool C1
        {
            get { return V12 == 1 || V36 == 1 && !V47; }
        }
        bool C2
        {
            get { return V12 == 2; }
        }
        bool C3
        {
            get { return V12 == 3; }
        }
        bool C4
        {
            get { return V12 == 4; }
        }
        bool NoCut
        {
            get { return (Title == "修刀" && V12 == 1) || (V36 == 5 && C1 && Title == "修斜度") || (Title == "抓位") || (Title == "返修" && V12 < 3) || (Title == "主程式"); }
        }
        Dp TT
        {
            get { return new Dp("A", 3, V28); }
        }
        Dp LL
        {
            get { return new Dp("L", 2, V41); }
        }
        int 修刀次数
        {
            get { return V27 < 0 ? (int)V27 * -1 : (int)V27; }
        }
        /// <summary>
        /// 重写条件头 标题内容
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        protected override string DischageRow(EntityDischarge e)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("( 高度:" + e.Height);
            sb.Append(" 线径:" + e.Diameter);
            sb.Append(" 材料:" + e.Materials);
            sb.Append(" 加工类型:" + e.Type + ")");
            return sb.ToString();
        }
        /// <summary>
        /// 重写条件头 组内容
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        protected override string DischageItem(EntityDischarge e)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(e.U1);
            sb.Append(e.U2);
            sb.Append(e.U3);
            return sb.ToString();
        }
        /// <summary>
        /// 补偿列
        /// </summary>
        /// <param name="i">补偿组编号</param>
        /// <returns></returns>
        protected override string OffsetRow(int i)
        {
            return "(" + (char)(i + 'A') + ")" + QN;
        }


        /// <summary>
        /// 补正项
        /// </summary>
        /// <param name="d">补偿编号</param>
        /// <param name="dv">补偿值</param>
        /// <returns></returns>
        protected override string OffsetItem(int d, double dv)
        {

            return string.Format("H{0:D3}={1:F4}", d, dv);

        }

        /// <summary>
        /// 程序开始
        /// </summary>
        /// <returns></returns>
        public override void ProgamStart()
        {

            // 弹出一个消息框
            //  System.Windows.Forms.MessageBox.Show("程序可能有问题，请仔细检查。挂壁了别找我啊");
            ////  弹出一个确定 / 取消的消息框
            // System.Windows.Forms.DialogResult result = System.Windows.Forms.MessageBox.Show("是否输出条件头", "警告", System.Windows.Forms.MessageBoxButtons.OKCancel, System.Windows.Forms.MessageBoxIcon.Warning);
            // // 处理用户的选择
            // if (result == System.Windows.Forms.DialogResult.OK)
            // {
            //     AddL(DischageGroup());//加入自定义条件头
            //     System.Console.WriteLine("输出");
            // }
            // else if (result == System.Windows.Forms.DialogResult.Cancel)
            // {
            //     System.Console.WriteLine("不输出");
            // }

            AddL("(" + Name + ")");//文件名
                                   //  AddL("(" + NCFilePath + ")");
                                   //AddL("(WIRE=SODICK-3D.wdl)");
            AddL("(WIRE=Sodick-3D)");
            AddL("(" + Date + ")");//路径
            AddL("(TP" + V29.ToString("0.0000") + "TN" + V31.ToString("0.0000") + "W-TOP30.0)");
            AddL(AH);

            AddL("H000=0.0000");
            string offsetGroup = OffsetGroup().Replace("H002=", "H002=-");
            string offsetGroupB = OffsetGroup().Replace("H002=", "H002=-").Replace("H004=", "H004=-").Replace("H005=", "H005=-");
            if (V37 == 2 && V1 != 0 && V27 != 3)
            {
                AddL(offsetGroup);
            }
            else if (V27 == 3 && V37 == 2)
            {
                AddL(offsetGroupB);
            }
            else
            {
                AddL(OffsetGroup());
            }
            //// 打印修改后的字符串数组
            //foreach (string str in offsetGroup)
            //{
            //    Console.WriteLine(str);
            //}
            AddL(CutMOED);
            if (V29 == 0 && V31 == 0)
            {
                AddL("TP" + V25.ToString("0.0000"));
                AddL("TN" + V31.ToString("0.0000"));
            }
            else
            {
                AddL("TP" + V29.ToString("0.0000"));
                AddL("TN" + V31.ToString("0.0000"));
            }
        }

        System.IO.StreamWriter writer = null;
        System.IO.StreamWriter sw = null;
        System.IO.FileStream fileStream = null;
        System.IO.StreamReader reader = null;

        //StreamWriter sw = null;
        //StreamWriter swA = null;
        /// <summary>
        /// 程序结束
        /// </summary>
        /// <returns></returns>
        public override void ProgamEnd()
        {

            if (Title == "主程式" || Title == "副程式")
            {

                AddL("M99");

            }
            else
            {
                AddL(M02);
            }

            AddL(troubleshooting);
            AddL(progamPlanes);
            string offsetGroup = OffsetGroup();
            string[] lines = offsetGroup.Split('\n');

            // 创建一个列表来保存需要保留的行
            List<string> remainingLines = new List<string>();

            for (int i = 0; i < lines.Length; i++)
            {
                // 在这里添加任何条件以确定是否删除当前行
                if (lines[i].Contains("H"))
                {
                    remainingLines.Add(lines[i]);
                }
            }

            // 将剩余的行重新合并成一个字符串
            string result = string.Join("\n", remainingLines);
            StringBuilder outputBuilder = new StringBuilder();
            // AddL(result);
            string[] liness = result.Split('\n'); // 将result按换行符拆分成字符串数组

            for (int i = 0; i < liness.Length; i++)
            {
                string[] parts = liness[i].Split('=');

                // 确保 parts 数组的长度至少为 2，以避免超出数组界限
                if (parts.Length >= 2)
                {
                    string code = parts[0];
                    string value = parts[1].Trim();
                    int index = int.Parse(code.Substring(1));
                    string item = "Item" + i + "=\"[" + index.ToString("D2") + "][" + value + "]\"";
                    outputBuilder.AppendLine(item);
                }
                else
                {
                    // 如果数组长度不足 2，则输出警告或采取适当的错误处理
                    //  Console.WriteLine("Warning: Line " + (i + 1) + " does not contain valid key-value pair.");
                }
            }

            string outputText = outputBuilder.ToString();

            //  string resultB = strB.Replace(".NC", "");




            if (Registry.CurrentUser.OpenSubKey(@"SOFTWARE\CW") == null)
            {
                RegistryKey key1 = Registry.CurrentUser.CreateSubKey(@"SOFTWARE\CW", true);
                var path = new System.Windows.Forms.OpenFileDialog();
                path.Title = "选择目标文件保存位置";
                path.Filter = "TDL 文件 (*.TDL)|*.TDL|所有文件 (*.*)|*.*";
                path.ShowDialog();
                var txtPath = path.FileName;
                key1.SetValue("LOADER", txtPath, RegistryValueKind.String);
                key1.Close();
            }


            RegistryKey key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\CW");
            var tdl = key.GetValue("LOADER").ToString();


            string[] text = File.ReadAllLines(tdl);
            var sb = new StringBuilder();

            for (int i = 0; i < text.Length; i++)
            {
                sb.Append(text[i] + "\n");
                if (text[i] == "[Dcode]") { break; }
            }
            sb.AppendLine(outputText);

            var sw = new StreamWriter(tdl, false, Encoding.Default);
            sw.Write(sb);
            sw.Close();


            //try
            //{
            //    // 指定外部文件的路径


            //    // 创建文件流
            //    fileStream = new System.IO.FileStream(filePath, System.IO.FileMode.Open);

            //    // 创建StreamReader来读取文件内容
            //    reader = new System.IO.StreamReader(fileStream);

            //    // 读取文件内容
            //    string line;
            //    while ((line = reader.ReadLine()) != null)
            //    {
            //        //  Console.WriteLine(line); // 处理每一行的数据，可以根据需要修改
            //    }
            //    // 实例化 StreamWriter，覆盖已存在的文件，使用默认字符编码
            //    sw = new System.IO.StreamWriter(newTxtPath, false, System.Text.Encoding.Default);

            //    // 将内容写入文件

            //    sw.Write(line + outputText);
            //    // AddL(outputText);
            //    //  System.Threading.Thread.Sleep(1000);

            //}
            //catch (Exception ex)
            //{
            //    // 处理异常
            //}
            //finally
            //{
            //    // 在 finally 块中确保关闭文件流
            //    if (sw != null)
            //    {
            //        sw.Close();
            //    }
            //    // 确保关闭文件流和StreamReader以释放资源
            //    if (reader != null)
            //    {
            //        reader.Close();
            //    }
            //    if (fileStream != null)
            //    {
            //        fileStream.Close();
            //    }
            //}

        }
        // 假设 V37 和 V31 是整数类型的变量



        short LastG = 1;
        string lastOutput = ""; // 用于跟踪上一次输出的结果
        double LastV37 = 0; // 用于跟踪上一次输出的V37值
        bool OutputM02 = false;
        bool firstOutput = true; // 标志是否为第一次输出
        bool firstOutputA = true; // 标志是否为第一次输出
        /// <summary>
        /// 孔开始
        /// </summary>
        /// <returns></returns>
        protected override void Start()
        {


            AddL("");





            if (Title == "副程式")
            {

                if (!OutputM02)
                {
                    AddL("T83\r\nT97\r\nC777\r\nM02");
                    OutputM02 = true; // 设置标志为已输出



                }
                // AddL("");

                // 判断V37是否与上一次相同
                if (V37 != LastV37)
                {
                    if (!firstOutput) // 如果不是第一次输出
                    {
                        AddL("M99");
                    }
                    AddL("N00" + V37);


                    if (Title == "副程式")
                    {
                        if (firstOutputA)
                        {
                            AddL("G59G92", X, Y);


                        }

                        else

                        {
                            AddL("G00", X, Y);

                        }

                        LastV37 = V37; // 更新上一次输出的V37值
                        firstOutput = false; // 设置标志为不是第一次输出
                    }
                }

            }




            else
            {
                AddL(N);

            }



            if (HasAngle || Is3d)
            {
                if (IsDistinctPlane)
                {
                    //将当前孔的程序面+辅助面组合成字符,用做key查询字典
                    string key = V29 + "," + V31;
                    int index;
                    //查询字典中有没有存在对应的元素,如果没有
                    if (!progamPlaneDictionary.ContainsKey(key))
                    {
                        //记录字典中元素的数量
                        int count = progamPlaneDictionary.Count;
                        //设置子程序号
                        index = count + 8001;
                        //存入 程序面+辅助面组合 作为键   , 子程序号码 作为值
                        progamPlaneDictionary.Add(key, index);
                        //设置程序面的字符
                        //Dp TP = new Dp("TP", 3, V29);
                        ////设置辅助面(原清角值)的字符
                        //Dp TN = new Dp("TN", 3, V31);
                        //这里的QN是换行符
                        //这个progamPlanes是一个自定义变量,在上面的用户自定义变量中,
                        //用变量承载子程序的字符,最后加入到程序结尾操作区域
                        progamPlanes += QN;
                        progamPlanes += "( Plane " + (count + 1) + " )" + QN;
                        progamPlanes += "N" + index + ("(设程序面)") + QN;
                        progamPlanes += TP + QN;
                        progamPlanes += TN + QN;
                        progamPlanes += "M99" + QN + QN;
                    }
                    //如果有对应的元素,则获取对应的子程序号码
                    else
                    {
                        index = progamPlaneDictionary[key];
                    }
                    //在当前程序执行处加入呼叫子程序的代码
                    AddL("M98P", index);
                }

            }
            if (V37 == 2 && Is3d)
            {
                if (U == 0 && V == 0)
                {
                    AddL(G0, X, Y);
                    AddL("T91");
                    AddL(V7 == 0 ? "G142H000" : "G141H000"); ;
                }
                else
                {
                    AddL(G0, X, Y);
                    AddL(V7 == 0 ? "G142H000" : "G141H000"); ;
                    AddL(G0, X, Y, ":", G0, X2, Y2);
                    AddL("HOLD(手动穿线)");


                }


            }
            else
            {
                if (Title == "主程式")
                {
                    AddL("G54", G0, X, Y);
                    // AddL("T91");
                    AddL("M98P00" + V37);
                }
                else
                {
                    AddL(G0, X, Y);
                    AddL("T91");

                }



            }

        }
        /// <summary>
        /// CRT()
        /// </summary>
        /// <returns></returns>
        private void ExecuteOperation()
        {
            string operation;
            if (V12 == 1 && V36 != 1)
            {
                operation = "开 粗";
            }
            else if (V36 == 1)
            {
                operation = "切 断";
            }
            else if (V12 == 2 && V36 == 5)
            {
                operation = "修斜度";
            }
            else if (V12 == 2)
            {
                operation = "粗 修";
            }

            else if (V12 > 2 && V36 != 1)
            {
                operation = "精 修";
            }
            else
            {
                operation = " 精 修 ";
            }

            if (IsCircle)
            {
                double radius = System.Math.Sqrt(V42 / System.Math.PI);
                // 计算直径
                double diameter = 2 * radius;
                //AddL("直径" + diameter.ToString("0.000"));
                if (Is3d)
                {
                    AddL("CRT(-" + N + "-3d-" + operation + "D" + diameter.ToString("0.000") + " -)");

                }
                else
                {
                    AddL("CRT(-" + N + "-2d-" + operation + "D" + diameter.ToString("0.000") + " -)");

                }
            }
            else
            {
                if (Is3d)
                {
                    AddL("CRT(-" + N + "-3d-" + operation + LL + " -)");

                }
                else
                {
                    AddL("CRT(-" + N + "-2d-" + operation + LL + " -)");

                }
            }
        }

        /// <summary>
        /// 进刀点
        /// </summary>
        /// <returns></returns>
        protected override void Offset()
        {
            if (NoCut)
            {
                return;
            }
            if (V1 == 0)
            {
                //修刀次数等于2,从第3刀开始加
                //修刀次数大于2,从倒数第2刀开始加
                if (V12 == 3)
                {
                    AddL(Fmt("N", BuilderIndex + 9000));

                    if (V13 == 1 && V5 != 1)
                    {

                        AddL("T91");
                    }

                }
            }
        }

        /// <summary>
        /// 补正偏移
        /// </summary>
        /// <returns></returns>
        protected override void Feed()
        {




            if (NoCut)
            {
                return;
            }

            ExecuteOperation();
            if (C1)
            {
                if (V34)
                {
                    AddL("T84C000 WP45");

                }
                else if (无屑外部路径)
                {
                    AddL("T85C001");
                }
                else
                {
                    AddL("T84", E);

                }
            }

            else//修刀条件
            {
                AddL("T85", E);

            }
            if (V36 == 3)
            {
                AddL("/M98P8888");
                AddL("G149G249G349G449G549G649G749");
            }
            else
            {
            }
            if (V12 == 1 && V36 != 5 && !V39 && V36 != 1 && Title != "仅修刀")
            {
                AddL("/M98P8888");
            }
            if (Title == "内孔线在外" || Title == "外形线在内")
            {
                Add(G41orG42 ? G41 : G42 + "H000");
            }
            else if (V36 == 3)
            {
                Add("G40H000");
            }
            else
            {
                Add(G41orG42 ? G42 + "H000" : G41 + "H000");
            }
            if (HasAngle)
            {
                Add(G41orG42 ? G52 : G51, T);
            }
            else
            {
                if (Title == "内孔线在外" || Title == "外形线在内")
                {
                    Add(G41orG42 ? G51 : G52);
                }
                else
                {
                    Add(G41orG42 ? G52 : G51);
                }

            }
            AddL(Cut + X + Y);
            if (V34)
            {
                AddL("T84", E);

            }
            if (V36 == 3)
            {
                AddL("H000");
            }
            else if (V36 == 5)
            {
                AddL(D + 100);
            }
            else
            {
                AddL(D);
            }
            //if (V39 && V36 != 3 && V12 == 1 && V1 == 0)
            //{
            //    AddL("T85 ");

            //}


            if (!HasAngle && V36 != 3)
            {

                if (V1 == 0)
                {
                    if (!C1 && V36 != 3)
                    {
                        AddL("AH997");
                    }
                    else if (C1)
                    {
                        AddL("AH996");
                    }
                }
                else // V1 != 0
                {
                    AddL((C1 || V36 == 1) ? "AH998" : "AH999");
                }
            }
        }
        /// <summary>
        /// 暂停点
        /// </summary>
        /// <returns></returns>
        protected override void M01()
        {
            if (NoCut)
            {
                return;
            }

            Run2();
            AddL("M00C000");


        }
        /// <summary>
        /// 闭合点
        /// </summary>
        /// <returns></returns>
        protected override void Close()
        {

            if (NoCut)
            {

                return;
            }
            if (V5 == 2 && N > 3000 && V12 == 1)
            {
                AddL("M00C000");

            }
            Run2();
            // if (C1&&V43)
            // {
            //  AddL("M00C000BACK0.5");

            // }


        }
        /// <summary>
        /// 过切点
        /// </summary>
        /// <returns></returns>
        protected override void OverCut()
        {

            if (NoCut)
            {
                return;
            }

            Run2();



        }



        /// <summary>
        /// 脱离点
        /// </summary>
        /// <returns></returns>
        protected override void Out()
        {
            if (NoCut)
            {
                return;
            }
            if (自动化内孔开粗)
            {
                AddL("T90");
            }
            Add("G40H000G50A0.0");
            if (V1 == 0 && !V34 && V5 != 2)
            {
                Add("M05");

                AddL(G0, XS1, YS1);


            }
            else
            {
                if (V5 == 2 && V1 == 0)
                {
                    Add("M05");

                    AddL(G0, X, Y);
                }
                else
                {
                    AddL(G1, X, Y);
                }


            }




            if (V1 == 2 && V12 == 1)
            {
                AddL("G04X" + V37.ToString("0.0"));
            }
            else if (V1 == 1 && V12 == 1)
            {
                AddL("G04X5.");

            }
        }



        /// <summary>
        /// 常规加工
        /// </summary>
        /// <returns></returns>
        protected override void Default()
        {
            if (NoCut)
            {
                return;
            }

            if (V54 == 0)
            {
                if (V87 == 14)
                {
                    AddL("H000");
                }
                else if (V87 == 15)
                {
                    Run2();
                    AddL(D);
                }
            }
            else
            {
            }
            Run2();


        }
        /// <summary>
        /// 同一个孔中的跳步(如内孔旋转进刀,外形多线头)
        /// </summary>
        /// <returns></returns>
        protected override void Move()
        {
            if (V1 != 1)
            {
                if (Is3d)
                {
                    AddL(G0, X, Y, ":", G0, X2, Y2);
                }
                else
                {
                    if (V1 == 2 && C1)
                    {
                        AddL("FLAG4D0");

                    }
                    Run2();
                }

            }
            else
            {

                AddL("T90");
                AddL(G0 + X + Y);
                AddL("T91");
            }
        }
        /// <summary>
        /// 上下异形补正
        /// </summary>
        /// <returns></returns>
        protected override void Offset3d()
        {
        }
        /// <summary>
        /// 上下异形进刀
        /// </summary>
        /// <returns></returns>
        protected override void Feed3d()
        {
            string G142 = "G142";
            string G141 = "G141";
            ExecuteOperation();
            if (C1)
            {
                if (V34)
                {
                    AddL("T84C000 WP45");

                }
                else if (无屑外部路径)
                {
                    AddL("T85C001");
                }
                else
                {
                    AddL("T84", E);

                }
            }

            else//修刀条件
            {
                AddL("T85", E);

            }
            if (V37 == 2)
            {

            }
            else
            {
                AddL(G41orG42 ? G142 : G141, "H000");
            }
            AddL(Run3d);
            if (V36 == 3)
            {
                AddL("H000");
            }
            else
            {
                AddL(D);
            }

        }
        /// <summary>
        /// 常规路径
        /// </summary>
        /// <returns></returns>
        protected override void Default3d()
        {
            if (V54 == 0 || V54 == 4)
            {
                if (V87 == 14)
                {

                    AddL("H000");


                }
                else if (V87 == 15)
                {
                    AddL(Run3d);
                    AddL(D);
                }
            }
            else
            {

            }

            AddL(Run3d);
        }
        /// <summary>
        /// 上下异形前置暂停点
        /// </summary>
        protected override void M013d()
        {
            AddL(Run3d);
            AddL("M00C000");
        }
        /// <summary>
        /// 上下异形过切点
        /// </summary>
        protected override void OverCut3d()
        {
            AddL(Run3d);
        }
        /// <summary>
        /// 上下异形闭合点
        /// </summary>
        protected override void Close3d()
        {
            AddL(Run3d);
        }
        /// <summary>
        /// 上下异形脱离
        /// </summary>
        /// <returns></returns>
        protected override void Out3d()
        {
            if (自动化内孔开粗)
            {
                AddL("T90");
            }

            AddL("H000");
            if (V37 == 2)
            {
                if (V1 == 0)
                {
                    AddL("M05", G0, X, Y, ":", G0, X2, Y2);
                }
                else
                {
                    AddL(G1, X, Y, ":", G1, X2, Y2);

                }
            }
            else
            {
                if (V1 == 0 && !V35)
                {
                    AddL("M05", G0, XS - 0.001, YS, ":", G0, XS - 0.001, YS);
                    AddL("G140");
                    AddL("M05", G0, XS, YS);
                }
                else if (V1 == 0 && V35)
                {
                    AddL("M05", G0, X - 0.001, Y, ":", G0, X - 0.001, Y);
                    AddL("G140");
                    AddL("M05", G0, X, Y);
                }
                else
                {
                    AddL(G1, X - 0.001, Y, ":", G1, X - 0.001, Y);
                    AddL("G140");
                    AddL(G1, X, Y);

                }
            }








            if (V1 == 1 && V12 == 1 && V36 != 1)
            {
                AddL("G4X5.");
            }
        }
        public override void StartProcess1()
        {

            //AddL("(开粗工序开始:)");
        }
        public override void StartProcess2()
        {
            //AddL("(粗修工序开始:)");
        }
        public override void StartProcess3()
        {
            //AddL("(精修工序开始:)");
        }
        public override void StartProcess4()
        {
            //AddL("(切断工序开始:)");
        }
        class Dp
        {
            public string Name { get; set; }
            public int Precision { get; set; }
            public double Value { get; set; }
            public Dp(string name, int precision, double value)
            {
                Name = name;
                Precision = precision;
                Value = value;
            }
            public override string ToString()
            {
                string format = "0." + new string('0', Precision);
                return string.Format("{0}{1}", Name, Value.ToString(format));
            }
        }
        Dp TP
        {
            get { return new Dp("TP", 4, V29); }
        }
        Dp TN
        {
            get { return new Dp("TN", 4, V31); }
        }
        protected override void WireOn()
        {

        }

        /// <summary>
        /// 在剪线之前的动作
        /// </summary>
        protected override void BeforeWireOff()
        {
            if (preTitle != title1)
            {
                AddL("M00");

            }
            if (Is3d)
            {
                if (V37 == 2)
                {
                    if (V1 == 0)
                    {
                        if (!V46)
                        {

                            AddL("T90");
                        }
                        AddL("M05", G0, XS - 0.001, YS, ":", G0, XS - 0.001, YS);
                        AddL("G140", G0, XS, YS);
                    }
                    else
                    {
                        AddL("T90");
                        AddL("M05", G0, X - 0.001, Y, ":", G0, X - 0.001, Y);
                        AddL("G140", G0, X, Y);
                    }
                }
            }

        }
        protected override void WireOff()
        {
            if (Title == "主程式")
            {
                return;
            }
            if (!自动化内孔开粗)
            {
                AddL("T90");
            }




        }
        /// <summary>
        /// 进刀分段
        /// </summary>
        protected override void SegmentFeed()
        {
            AddL("T84C000");
            AddL(G1, X, Y);

        }
        /// <summary>
        /// 上下异形进刀分段
        /// </summary>
        protected override void SegmentFeed3d()
        {
            AddL("T84C000");
            AddL(Run3d);
            //AddL(G41orG42 ? "G140" : "G140", Run3d);
            //AddL(G41orG42 ? "G142" : "G141", Run3d);
        }



        /// <summary>
        /// 返回线的进刀点
        /// </summary>
        protected override void BackLineFeed()
        {
            //空跑参数
            AddL("FLAG4D1");
            AddL("T91");
            AddL(G41orG42 ? G42 + G52 : G41 + G51, T);
            Run2();
            AddL(D);
        }
        /// <summary>
        /// 返回线的结束点
        /// </summary>
        protected override void BackLineEnd()
        {
            Default();
            //正常参数

            AddL("T84C001");
        }
        /// <summary>
        /// 返回线的结束前的过渡区域
        /// </summary>
        protected override void TransitionZoneBeforeBackLineEnd()
        {
            Default();
            //过渡的弱参数
            AddL("FLAG4D0");
            AddL("T84C000");
        }
        /// <summary>
        /// 返回线的进刀点
        /// </summary>
        protected override void NoOffsetFeed()
        {
            //无补正参数




            AddL("T84C000");
            Run2();
        }






        string CutMOED = @"T94
G90
G54
G136(干涉检测改成G137关闭干涉检测)
G27
G26RA00.0000
G11(改成G12开启自动排短路)";
        string AH = @"
(BSA）
H996=0.0000  (HOLE-1)
H997=0.0000  (HOLE-X)
H998=0.0000  (PUNCH-1)
H999=0.0000  (PUNCH-X)
(附件斜度H+100)
";
        string M02 = @"
T83
T97
C777
M02";
        string troubleshooting = @"N8888
G91
WT0 WS33 MAO333
G01X0.001
G04X4.0
WT22 WS33
G01X-0.001
G04X4.0
WT160 WS70 MAO264
G90
M99";

    }

}