import { CodeParams } from "./confClass"

function checkVal(val) {
    let r = true
    if ((val == undefined || val == '')) {
        r = false
    }
    return r
}

/**G代码指令
 * 目前 只需要做 G0 - G3
 */
export enum GCode {
    /**快速定位 空程移动 范例：G00 X100 Y50（刀具快速移动至X100、Y50位置） */
    G0 = 'G0',
    /**快速定位 空程移动 范例：G00 X100 Y50（刀具快速移动至X100、Y50位置）*/
    G00 = 'G00',
    /**直线 直线插补 范例：G01 X200 Y300 F150（刀具以150mm/min的进给速度直线移动至X200、Y300）*/
    G1 = 'G1',
    /**直线 范例：G01 X200 Y300 F150（刀具以150mm/min的进给速度直线移动至X200、Y300）*/
    G01 = 'G01',
    /** 顺时针 范例：G17 G02 X150 Y50 I50 J0 F100（在XY平面，以半径50mm顺时针圆弧插补至X150、Y50）*/
    G2 = 'G2',
    /** 顺时针 范例：G17 G02 X150 Y50 I50 J0 F100（在XY平面，以半径50mm顺时针圆弧插补至X150、Y50）*/
    G02 = 'G02',
    /** 逆时针 范例：G17 G03 X150 Y50 I50 J0 F100（在XY平面，以半径50mm逆时针圆弧插补至X150、Y50）*/
    G3 = 'G3',
    /** 逆时针 范例：G17 G03 X150 Y50 I50 J0 F100（在XY平面，以半径50mm逆时针圆弧插补至X150、Y50）*/
    G03 = 'G03',
    /**暂停 范例：G04 X2（暂停2秒）*/
    G4 = 'G4',
    /**暂停 范例：G04 X2（暂停2秒）*/
    G04 = 'G04',
    /** 通过中间点圆弧插补 
     * 1. 通过中间点圆弧插补
     * 示例：G05 X60 Z50 IX50 IZ60 F120 刀具从当前位置出发，经过中间点 (50, 60)，最终到达终点 (60, 50)，形成圆弧轨迹。
     * 2. 高精轨迹控制（HPCC）模式
     * 功能：G05 可启动高精轨迹控制模式（HPCC），通过曲线拟合和参数优化，实现高精度、高速度的轨迹加工，适用于复杂曲面或高精度零件。
     * 指令格式：
     * 启动：G05 P10000（P值设为10000）
     * 关闭：G05 P0（P值设为0）
     * 3、注意事项：
     * 轴类型限制：建议线性轴参与HPCC模式，旋转轴需谨慎设置。
        与其他功能冲突：
        在HPCC模式下，G61（准确停止检查）、G63（攻螺纹）等功能可能失效，需退出HPCC模式后恢复。
        启用 RTCP（旋转刀具中心点）或 STCP 模式时，禁止同时启用HPCC功能。
        不支持的功能：
        不支持单节停止（C40/M00）、反向手轮模拟、图形模拟等。
        剩余距离显示可能不准确，因显示的是离曲线终点的距离，而非单节终点。
     * */
    G5 = 'G5',
    /** 通过中间点圆弧插补 */
    G05 = 'G05',
    /** 抛物线插补 */
    G6 = 'G6',
    /** 抛物线插补 */
    G06 = 'G06',
    /** z样条曲线插补 */
    G7 = 'G7',
    /** z样条曲线插补 */
    G07 = 'G07',
    /** 进给加速 */
    G8 = 'G8',
    /** 进给加速 */
    G08 = 'G08',
    /** 进给减速 */
    G9 = 'G9',
    /** 进给减速 */
    G09 = 'G09',
    /** 参数写入方式有效 */
    G10 = 'G10',
    /** 参数写入方式取消 */
    G11 = 'G11',
    /** 极坐标变成 */
    G16 = 'G16',
    /** XY平面选择 */
    G17 = 'G17',
    /** XZ平面选择 */
    G18 = 'G18',
    /** YZ平面选择 */
    G19 = 'G19',
    /** 英制输入 */
    G20 = 'G20',
    /** 公制输入 */
    G21 = 'G21',
    /** 半径尺寸编程方式  */
    G22 = 'G22',
    /** 系统操作界面上使用 */
    G220 = 'G220',
    /** 直径尺寸编程方式 */
    G23 = 'G23',
    /** 系统操作界面上使用  */
    G230 = 'G230',
    /** 子程序结束  */
    G24 = 'G24',
    /** 跳转加工  */
    G25 = 'G25',
    /** 循环加工 */
    G26 = 'G26',
    /** 参考点返回 */
    G28 = 'G28',
    /** 倍率注销 */
    G30 = 'G30',
    /** 倍率定义 */
    G31 = 'G31',
    /** 等螺距螺纹切削，英制 */
    G32 = 'G32',
    /** 等螺距螺纹切削，公制 */
    G33 = 'G33',
    /** 增螺距螺纹切削 */
    G34 = 'G34',
    /** 减螺距螺纹切削 */
    G35 = 'G35',
    //** 刀具半径补正取消 */
    G40 = 'G40',
    //** 刀具半径补正 左*/
    G41 = 'G41',
    //** 刀具半径补正 右*/
    G42 = 'G42',
    //** 刀具长度补正+ */
    G43 = 'G43',
    //** 刀具长度补正- */
    G44 = 'G44',
    //** 道具偏置+/+ */
    G45 = 'G45',
    //** 道具偏置+/- */
    G46 = 'G46',
    //** 道具偏置-/- */
    G47 = 'G47',
    //** 道具偏置-/+ */
    G48 = 'G48',
    //** 刀具长度 补正取消 */
    G49 = 'G49',
    //** 局部坐标系设定 */
    G52 = 'G52',
    //** 机床坐标系选择 */
    G53 = 'G53',
    //** 工件坐标系选择1 */
    G54 = 'G54',
    //** 工件坐标系选择2 */
    G55 = 'G55',
    //** 工件坐标系选择3 */
    G56 = 'G56',
    //** 工件坐标系选择4 */
    G57 = 'G57',
    //** 工件坐标系选择5 */
    G58 = 'G58',
    //** 工件坐标系选择6 */
    G59 = 'G59',
    //** 坐标系旋转有效 */
    G68 = 'G68',
    //** 坐标系旋转取消 */
    G69 = 'G69',
    /** 高速深孔钻 */
    G73 = 'G73',
    /** 精搪孔 */
    G76 = 'G76',
    /** 固定循环取消/取消循环指令 */
    G80 = 'G80',
    /**程序停止 */
    M00 = 'M00',
    /**选择性停止 */
    M01 = 'M01',
    /** 程序结束 */
    M02 = 'M02',
    /**主轴正转 */
    M03 = 'M03',
    /**主轴反转 */
    M04 = 'M04',
    /**主轴停止 */
    M05 = 'M05',
    /**自动换刀 */
    M06 = 'M06',
}

/**G代码基类 */
export class GCodeAction {

    /** 空程直线 */
    G0(params: CodeParams) {
        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
        let val: string = GCode.G0
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 空程直线 */
    G00(params: CodeParams) {
        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
        let val: string = GCode.G00
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 直线 */
    G1(params: CodeParams) {
        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
        let val: string = GCode.G1
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'


        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }



        return val
    }
    /** 直线 */
    G01(params: CodeParams) {
        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
        let val: string = GCode.G01
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'


        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 顺时针 弧线 
     * @param x  x坐标
     * @param y  y坐标
     * @param z  z坐标
     * @param i  圆弧 对于起点的偏移量 x
     * @param y  圆弧 对于起点的偏移量 Y
     * @param z  圆弧 对于起点的偏移量 Y
     * @param f  速度
    */
    G2(params: CodeParams) {
        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
        let val: string = GCode.G2
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        let _iKey = iKey || 'I'
        let _jKey = jKey || 'J'
        let _kKey = kKey || 'K'

        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }
        if (checkVal(r)) {
            val += ` R${r}`
        } else {
            if (checkVal(i)) {
                val += ` ${_iKey}${i}`
            }
            if (checkVal(j)) {
                val += ` ${_jKey}${j}`
            }
            if (checkVal(k)) {
                val += ` ${_kKey}${k}`
            }
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 顺时针 弧线 
     * @param x  x坐标
     * @param y  y坐标
     * @param z  z坐标
     * @param i  圆弧 对于起点的偏移量 x
     * @param y  圆弧 对于起点的偏移量 Y
     * @param z  圆弧 对于起点的偏移量 Y
     * @param f  速度
    */
    G02(params: CodeParams) {
        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
        let val: string = GCode.G02
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        let _iKey = iKey || 'I'
        let _jKey = jKey || 'J'
        let _kKey = kKey || 'K'

        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }

        if (checkVal(r)) {
            val += ` R${r}`
        } else {
            if (checkVal(i)) {
                val += ` ${_iKey}${i}`
            }
            if (checkVal(j)) {
                val += ` ${_jKey}${j}`
            }
            if (checkVal(k)) {
                val += ` ${_kKey}${k}`
            }
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 逆时针 弧线 
     * @param x  x坐标
     * @param y  y坐标
     * @param z  z坐标
     * @param i  圆弧 对于起点的偏移量 x
     * @param y  圆弧 对于起点的偏移量 Y
     * @param z  圆弧 对于起点的偏移量 Y
     * @param f  速度
    */
    G3(params: CodeParams) {
        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
        let val: string = GCode.G3
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        let _iKey = iKey || 'I'
        let _jKey = jKey || 'J'
        let _kKey = kKey || 'K'

        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }

        if (checkVal(r)) {
            val += ` R${r}`
        } else {
            if (checkVal(i)) {
                val += ` ${_iKey}${i}`
            }
            if (checkVal(j)) {
                val += ` ${_jKey}${j}`
            }
            if (checkVal(k)) {
                val += ` ${_kKey}${k}`
            }
        }
        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 逆时针 弧线 
     * @param x  x坐标
     * @param y  y坐标
     * @param z  z坐标
     * @param i  圆弧 对于起点的偏移量 x
     * @param y  圆弧 对于起点的偏移量 Y
     * @param z  圆弧 对于起点的偏移量 Y
     * @param f  速度
    */
    G03(params: CodeParams) {
        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
        let val: string = GCode.G03
        if (typeof (codeKey) == 'string' && codeKey != '') {
            val = codeKey
        }
        let _xkey = xKey || 'X'
        let _yKey = yKey || 'Y'
        let _zKey = zKey || 'Z'
        let _fKey = fKey || 'F'
        let _iKey = iKey || 'I'
        let _jKey = jKey || 'J'
        let _kKey = kKey || 'K'

        if (checkVal(x)) {
            val += ` ${_xkey}${x}`
        }
        if (checkVal(y)) {
            val += ` ${_yKey}${y}`
        }
        if (checkVal(z)) {
            val += ` ${_zKey}${z}`
        }

        if (checkVal(r)) {
            val += ` R${r}`
        } else {
            if (checkVal(i)) {
                val += ` ${_iKey}${i}`
            }
            if (checkVal(j)) {
                val += ` ${_jKey}${j}`
            }
            if (checkVal(k)) {
                val += ` ${_kKey}${k}`
            }
        }

        if (checkVal(f)) {
            val += ` ${_fKey}${f}`
        }
        return val
    }
    /** 主轴正转 
     *  
     * @param s 转速
    */
    M03(s: any) {
        let val: string = GCode.M03
        if (checkVal(s)) {
            val += ` S${s}`
        }
        return val
    }
    /**主轴反向转 
     * @param s 转速
    */
    M04(s: any) {
        let val: string = GCode.M04
        if (checkVal(s)) {
            val += ` S${s}`
        }
        return val
    }

    /**主轴停止 */
    M05() {
        let val: string = GCode.M05

        return val
    }
    /**换刀指令 */
    M06(t: String) {
        let val: string = GCode.M06
        if (checkVal(t)) {
            val += ` T${t}`
        }
        return val
    }

}