# -*- coding: utf-8 -*-
# *****************************************************************************
# *                                                                           *
# *   (c) sliptonic (shopinthewoods@gmail.com) 2014                           *
# *   (c) Gauthier Briere - 2018, 2019                                        *
# *   (c) Schildkroet - 2019-2020                                             *
# *   (c) Gary L Hasson - 2020                                                *
# *                                                                           *
# *   This file is part of the FreeCAD CAx development system.                *
# *                                                                           *
# *   This program is free software; you can redistribute it and/or modify    *
# *   it under the terms of the GNU Lesser General Public License (LGPL)      *
# *   as published by the Free Software Foundation; either version 2 of       *
# *   the License, or (at your option) any later version.                     *
# *   for detail see the LICENCE text file.                                   *
# *                                                                           *
# *   FreeCAD is distributed in the hope that it will be useful,              *
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
# *   GNU Lesser General Public License for more details.                     *
# *                                                                           *
# *   You should have received a copy of the GNU Library General Public       *
# *   License along with FreeCAD; if not, write to the Free Software          *
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307    *
# *   USA                                                                     *
# *                                                                           *
# *****************************************************************************


from datetime import datetime
import argparse
import shlex
import FreeCAD
from FreeCAD import Units
import PathScripts.PathUtil as PathUtil
import PathScripts.PostUtils as PostUtils

Revised = "2020-11-03"  # Revision date for this file.

# *****************************************************************************
# *   Due to the fundamentals of the FreeCAD pre-processor,                   *
# *   this post processor can only operate in the following modes:            *
# *   G90 Absolute positions                                                  *
# *   G21 Metric units (mm)                                                   *
# *   G17 XY plane (3 axis vertical milling only)                             *
# *                                                                           *
# *****************************************************************************


TOOLTIP = """
Generate g-code from a Path that is compatible with the Marlin controller.
import marlin_post
marlin_post.export(object, "/path/to/file.nc")
"""

# *****************************************************************************
# * Initial configuration, not changeable                                     *
# *****************************************************************************
MOTION_MODE = "G90"  # G90 only, for absolute moves
WORK_PLANE = "G17"  # G17 only, XY plane, for vertical milling
UNITS = "G21"  # G21 only, for metric
UNIT_FORMAT = "mm"
UNIT_FEED_FORMAT = "mm/min"

# *****************************************************************************
# * Initial configuration, changeable via command line arguments              *
# *****************************************************************************
PRECISION = 3  # Decimal places displayed for metric
DRILL_RETRACT_MODE = "G98"  # End of drill-cycle retractation type. G99
# is the alternative.
TRANSLATE_DRILL_CYCLES = True  # If true, G81, G82, and G83 are translated
# into G0/G1 moves
OUTPUT_TOOL_CHANGE = False  # Do not output M6 tool change (comment it)
RETURN_TO = None  # None = No movement at end of program
SPINDLE_WAIT = 3  # 0 == No waiting after M3 / M4
MODAL = False  # True: Commands are suppressed if they are
# the same as the previous line
LINENR = 100  # Line number starting value
LINEINCR = 10  # Line number increment
PRE_OPERATION = """"""  # Pre operation text will be inserted before
# every operation
POST_OPERATION = """"""  # Post operation text will be inserted after
# every operation
TOOL_CHANGE = """"""  # Tool Change commands will be inserted
# before a tool change

# *****************************************************************************
# * Initial gcode output options, changeable via command line arguments       *
# *****************************************************************************
OUTPUT_HEADER = True  # Output header in output gcode file
OUTPUT_COMMENTS = True  # Comments in output gcode file
OUTPUT_FINISH = False  # Include an operation finished comment
OUTPUT_PATH = False  # Include a Path: comment
OUTPUT_MARLIN_CONFIG = False  # Display expected #defines for Marlin config
OUTPUT_LINE_NUMBERS = False  # Output line numbers in output gcode file
OUTPUT_BCNC = False  # Add bCNC operation block headers in output
# gcode file
SHOW_EDITOR = True  # Display the resulting gcode file

# *****************************************************************************
# * Command line arguments                                                    *
# *****************************************************************************
parser = argparse.ArgumentParser(prog="marlin", add_help=False)
parser.add_argument("--header", action="store_true", help="output headers (default)")
parser.add_argument("--no-header", action="store_true", help="suppress header output")
parser.add_argument("--comments", action="store_true", help="output comment (default)")
parser.add_argument(
    "--no-comments", action="store_true", help="suppress comment output"
)
parser.add_argument(
    "--finish-comments", action="store_true", help="output finish-comment"
)
parser.add_argument(
    "--no-finish-comments",
    action="store_true",
    help="suppress finish-comment output (default)",
)
parser.add_argument("--path-comments", action="store_true", help="output path-comment")
parser.add_argument(
    "--no-path-comments",
    action="store_true",
    help="suppress path-comment output (default)",
)
parser.add_argument(
    "--marlin-config", action="store_true", help="output #defines for Marlin"
)
parser.add_argument(
    "--no-marlin-config",
    action="store_true",
    help="suppress output #defines for Marlin (default)",
)
parser.add_argument(
    "--line-numbers", action="store_true", help="prefix with line numbers"
)
parser.add_argument(
    "--no-line-numbers",
    action="store_true",
    help="do not prefix with line numbers (default)",
)
parser.add_argument(
    "--show-editor",
    action="store_true",
    help="pop up editor before writing output (default)",
)
parser.add_argument(
    "--no-show-editor",
    action="store_true",
    help="do not pop up editor before writing output",
)
parser.add_argument(
    "--precision", default="3", help="number of digits of precision, default=3"
)
parser.add_argument(
    "--translate_drill",
    action="store_true",
    help="translate drill cycles G81, G82, G83 into G0/G1 movements (default)",
)
parser.add_argument(
    "--no-translate_drill",
    action="store_true",
    help="do not translate drill cycles G81, G82, G83 into G0/G1 movements",
)
parser.add_argument(
    "--preamble", help='set commands to be issued before the first command, default=""'
)
parser.add_argument(
    "--postamble", help='set commands to be issued after the last command, default="M5"'
)
parser.add_argument(
    "--tool-change", action="store_true", help="Insert M6 for all tool changes"
)
parser.add_argument(
    "--wait-for-spindle",
    type=int,
    default=3,
    help="Wait for spindle to reach desired speed after M3 or M4, default=0",
)
parser.add_argument(
    "--return-to",
    default="",
    help='When done, move to, e.g. --return-to="3.175, 4.702, 50.915"',
)
parser.add_argument(
    "--bcnc",
    action="store_true",
    help="Add Job operations as bCNC block headers. \
    Consider suppressing existing comments: Add argument --no-comments",
)
parser.add_argument(
    "--no-bcnc", action="store_true", help="suppress bCNC block header output (default)"
)
TOOLTIP_ARGS = parser.format_help()

# *****************************************************************************
# * Marlin 2.x:                                                               *
# * Ignores commands that it does not implement.                              *
# * Some machining-related commands may conflict with gcodes that Marlin      *
# * has assigned to 3D printing commands.                                     *
# * Therefore, check FreeCAD gcodes for conflicts with Marlin.                *
# * Marlin 2.x ignores the ENTIRE COMMAND LINE if there is more than          *
# * one command per line.                                                     *
# *****************************************************************************

# Default preamble text will appear at the beginning of the gcode output file.
PREAMBLE = """"""

# Default postamble text will appear following the last operation.
POSTAMBLE = """M5
"""

# *****************************************************************************
# * Internal global variables                                                 *
# *****************************************************************************
MOTION_COMMANDS = ["G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"]
RAPID_MOVES = ["G0", "G00"]  # Rapid moves gcode commands definition
SUPPRESS_COMMANDS = [""]  # These commands are ignored by commenting them out
COMMAND_SPACE = " "
# Global variables storing current position (Use None for safety.)
CURRENT_X = None
CURRENT_Y = None
CURRENT_Z = None


def processArguments(argstring):
    global OUTPUT_HEADER
    global OUTPUT_COMMENTS
    global OUTPUT_FINISH
    global OUTPUT_PATH
    global OUTPUT_MARLIN_CONFIG
    global OUTPUT_LINE_NUMBERS
    global SHOW_EDITOR
    global PREAMBLE
    global POSTAMBLE
    global UNITS
    global UNIT_FEED_FORMAT
    global UNIT_FORMAT
    global TRANSLATE_DRILL_CYCLES
    global OUTPUT_TOOL_CHANGE
    global SPINDLE_WAIT
    global RETURN_TO
    global OUTPUT_BCNC
    global PRECISION

    try:
        args = parser.parse_args(shlex.split(argstring))
        if args.no_header:
            OUTPUT_HEADER = False
        if args.header:
            OUTPUT_HEADER = True
        if args.no_comments:
            OUTPUT_COMMENTS = False
        if args.comments:
            OUTPUT_COMMENTS = True
        if args.no_finish_comments:
            OUTPUT_FINISH = False
        if args.finish_comments:
            OUTPUT_FINISH = True
        if args.no_path_comments:
            OUTPUT_PATH = False
        if args.path_comments:
            OUTPUT_PATH = True
        if args.no_marlin_config:
            OUTPUT_MARLIN_CONFIG = False
        if args.marlin_config:
            OUTPUT_MARLIN_CONFIG = True
        if args.no_line_numbers:
            OUTPUT_LINE_NUMBERS = False
        if args.line_numbers:
            OUTPUT_LINE_NUMBERS = True
        if args.no_show_editor:
            SHOW_EDITOR = False
        if args.show_editor:
            SHOW_EDITOR = True
        if args.preamble is not None:
            PREAMBLE = args.preamble
        if args.postamble is not None:
            POSTAMBLE = args.postamble
        if args.no_translate_drill:
            TRANSLATE_DRILL_CYCLES = False
        if args.translate_drill:
            TRANSLATE_DRILL_CYCLES = True
        if args.tool_change:
            OUTPUT_TOOL_CHANGE = True
        if args.return_to:
            RETURN_TO = args.return_to
            if RETURN_TO.find(",") == -1:
                RETURN_TO = None
                print("--return-to coordinates must be specified as:")
                print('--return-to "x.n,y.n,z.n"')
        if args.bcnc:
            OUTPUT_BCNC = True
        if args.no_bcnc:
            OUTPUT_BCNC = False
        SPINDLE_WAIT = args.wait_for_spindle
        PRECISION = args.precision

    except Exception as e:
        return False

    return True


# For debug...
def dump(obj):
    for attr in dir(obj):
        try:
            if attr.startswith("__"):
                continue
            print(">" + attr + "<")
            attr_text = "%s = %s" % (attr, getattr(obj, attr))
            if attr in ["HorizFeed", "VertFeed"]:
                print("==============\n", attr_text)
                if "mm/s" in attr_text:
                    print("===> metric values <===")
        except Exception:  # Insignificant errors
            # print('==>', obj, attr)
            pass


def export(objectslist, filename, argstring):
    if not processArguments(argstring):
        return None

    global UNITS
    global UNIT_FORMAT
    global UNIT_FEED_FORMAT
    global MOTION_MODE
    global SUPPRESS_COMMANDS

    print("Post Processor: " + __name__ + " postprocessing...")
    gcode = ""

    # Write header:
    if OUTPUT_HEADER:
        gcode += linenumber() + "(Exported by FreeCAD)\n"
        gcode += linenumber() + "(Post Processor: " + __name__
        gcode += ".py, version: " + Revised + ")\n"
        gcode += linenumber() + "(Output Time:" + str(datetime.now()) + ")\n"

    # Suppress drill-cycle commands:
    if TRANSLATE_DRILL_CYCLES:
        SUPPRESS_COMMANDS += ["G80", "G98", "G99"]

    # Write the preamble:
    if OUTPUT_COMMENTS:
        gcode += linenumber() + "(Begin preamble)\n"
    for line in PREAMBLE.splitlines(True):
        gcode += linenumber() + line

    # Write these settings AFTER the preamble,
    # to prevent the preamble from changing these:
    if OUTPUT_COMMENTS:
        gcode += linenumber() + "(Default Configuration)\n"
    gcode += linenumber() + MOTION_MODE + "\n"
    gcode += linenumber() + UNITS + "\n"
    gcode += linenumber() + WORK_PLANE + "\n"

    for obj in objectslist:
        # Debug...
        # print('\n' + '*'*70 + '\n')
        # dump(obj)
        # print('\n' + '*'*70 + '\n')
        if not hasattr(obj, "Path"):
            print(
                "The object "
                + obj.Name
                + " is not a path. Please select only path and Compounds."
            )
            return

        # Skip inactive operations:
        if PathUtil.opProperty(obj, "Active") is False:
            continue

        # Do the pre_op:
        if OUTPUT_BCNC:
            gcode += linenumber() + "(Block-name: " + obj.Label + ")\n"
            gcode += linenumber() + "(Block-expand: 0)\n"
            gcode += linenumber() + "(Block-enable: 1)\n"
        if OUTPUT_COMMENTS:
            gcode += linenumber() + "(Begin operation: " + obj.Label + ")\n"
        for line in PRE_OPERATION.splitlines(True):
            gcode += linenumber() + line

        # Get coolant mode:
        coolantMode = "None"  # None is the word returned from the operation
        if (
            hasattr(obj, "CoolantMode")
            or hasattr(obj, "Base")
            and hasattr(obj.Base, "CoolantMode")
        ):
            if hasattr(obj, "CoolantMode"):
                coolantMode = obj.CoolantMode
            else:
                coolantMode = obj.Base.CoolantMode

        # Turn coolant on if required:
        if OUTPUT_COMMENTS:
            if not coolantMode == "None":
                gcode += linenumber() + "(Coolant On:" + coolantMode + ")\n"
        if coolantMode == "Flood":
            gcode += linenumber() + "M8\n"
        if coolantMode == "Mist":
            gcode += linenumber() + "M7\n"

        # Parse the op:
        gcode += parse(obj)

        # Do the post_op:
        if OUTPUT_COMMENTS and OUTPUT_FINISH:
            gcode += linenumber() + "(Finish operation: " + obj.Label + ")\n"
        for line in POST_OPERATION.splitlines(True):
            gcode += linenumber() + line

        # Turn coolant off if previously enabled:
        if not coolantMode == "None":
            if OUTPUT_COMMENTS:
                gcode += linenumber() + "(Coolant Off:" + coolantMode + ")\n"
            gcode += linenumber() + "M9\n"

    # Do the post_amble:
    if OUTPUT_BCNC:
        gcode += linenumber() + "(Block-name: post_amble)\n"
        gcode += linenumber() + "(Block-expand: 0)\n"
        gcode += linenumber() + "(Block-enable: 1)\n"
    if OUTPUT_COMMENTS:
        gcode += linenumber() + "(Begin postamble)\n"
    for line in POSTAMBLE.splitlines(True):
        gcode += linenumber() + line

    # Optionally add a final XYZ position to the end of the gcode:
    if RETURN_TO:
        first_comma = RETURN_TO.find(",")
        last_comma = RETURN_TO.rfind(",")  # == first_comma if only one comma
        ref_X = " X" + RETURN_TO[0:first_comma].strip()

        # Z is optional:
        if last_comma != first_comma:
            ref_Z = " Z" + RETURN_TO[last_comma + 1 :].strip()
            ref_Y = " Y" + RETURN_TO[first_comma + 1 : last_comma].strip()
        else:
            ref_Z = ""
            ref_Y = " Y" + RETURN_TO[first_comma + 1 :].strip()

        gcode += linenumber() + "G0" + ref_X + ref_Y + ref_Z + "\n"

    # Optionally add recommended Marlin 2.x configuration to gcode file:
    if OUTPUT_MARLIN_CONFIG:
        gcode += linenumber() + "(Marlin 2.x Configuration)\n"
        gcode += linenumber() + "(The following should be enabled in)\n"
        gcode += linenumber() + "(the configuration files of Marlin 2.x)\n"
        gcode += linenumber() + "(#define ARC_SUPPORT)\n"
        gcode += linenumber() + "(#define CNC_COORDINATE_SYSTEMS)\n"
        gcode += linenumber() + "(#define PAREN_COMMENTS)\n"
        gcode += linenumber() + "(#define GCODE_MOTION_MODES)\n"
        gcode += linenumber() + "(#define G0_FEEDRATE)\n"
        gcode += linenumber() + "(define VARIABLE_G0_FEEDRATE)\n"

    # Show the gcode result dialog:
    if FreeCAD.GuiUp and SHOW_EDITOR:
        dia = PostUtils.GCodeEditorDialog()
        dia.editor.setText(gcode)
        result = dia.exec_()
        if result:
            final = dia.editor.toPlainText()
        else:
            final = gcode
    else:
        final = gcode

    print("Done postprocessing.")

    # Write the file:
    with open(filename, "w") as fp:
        fp.write(final)


def linenumber():
    if not OUTPUT_LINE_NUMBERS:
        return ""
    global LINENR
    global LINEINCR
    LINENR += LINEINCR
    return "N" + str(LINENR) + " "


def format_outlist(strTable):
    # construct the line for the final output
    global COMMAND_SPACE
    s = ""
    for w in strTable:
        s += w + COMMAND_SPACE
    return s.strip()


def parse(pathobj):
    global DRILL_RETRACT_MODE
    global MOTION_MODE
    global CURRENT_X
    global CURRENT_Y
    global CURRENT_Z

    out = ""
    lastcommand = None
    precision_string = "." + str(PRECISION) + "f"

    params = [
        "X",
        "Y",
        "Z",
        "A",
        "B",
        "C",
        "U",
        "V",
        "W",
        "I",
        "J",
        "K",
        "F",
        "S",
        "T",
        "Q",
        "R",
        "L",
        "P",
    ]

    if hasattr(pathobj, "Group"):  # We have a compound or project.
        if OUTPUT_COMMENTS:
            out += linenumber() + "(Compound: " + pathobj.Label + ")\n"
        for p in pathobj.Group:
            out += parse(p)
        return out

    else:  # Parsing simple path
        # groups might contain non-path things like stock.
        if not hasattr(pathobj, "Path"):
            return out

        if OUTPUT_COMMENTS and OUTPUT_PATH:
            out += linenumber() + "(Path: " + pathobj.Label + ")\n"

        for c in pathobj.Path.Commands:
            outlist = []
            command = c.Name
            outlist.append(command)
            # Debug:
            # print('pathobj.Path.Commands:', c)

            # If modal is True, delete duplicate commands:
            if MODAL:
                if command == lastcommand:
                    outlist.pop(0)

            # Add the remaining parameters in order:
            for param in params:
                if param in c.Parameters:
                    if param == "F":
                        if command not in RAPID_MOVES:
                            feedRate = Units.Quantity(
                                c.Parameters["F"], FreeCAD.Units.Velocity
                            )
                            if feedRate.getValueAs(UNIT_FEED_FORMAT) > 0.0:
                                outlist.append(
                                    param
                                    + format(
                                        float(feedRate.getValueAs(UNIT_FEED_FORMAT)),
                                        precision_string,
                                    )
                                )
                    elif param in ["T", "H", "D", "S", "P", "L"]:
                        outlist.append(param + str(c.Parameters[param]))
                    elif param in ["A", "B", "C"]:
                        outlist.append(
                            param + format(c.Parameters[param], precision_string)
                        )
                    # [X, Y, Z, U, V, W, I, J, K, R, Q]
                    else:
                        pos = Units.Quantity(c.Parameters[param], FreeCAD.Units.Length)
                        outlist.append(
                            param
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            )
                        )

            # Store the latest command:
            lastcommand = command

            # Capture the current position for subsequent calculations:
            if command in MOTION_COMMANDS:
                if "X" in c.Parameters:
                    CURRENT_X = Units.Quantity(c.Parameters["X"], FreeCAD.Units.Length)
                if "Y" in c.Parameters:
                    CURRENT_Y = Units.Quantity(c.Parameters["Y"], FreeCAD.Units.Length)
                if "Z" in c.Parameters:
                    CURRENT_Z = Units.Quantity(c.Parameters["Z"], FreeCAD.Units.Length)

            if command in ("G98", "G99"):
                DRILL_RETRACT_MODE = command

            if TRANSLATE_DRILL_CYCLES:
                if command in ("G81", "G82", "G83"):
                    out += drill_translate(outlist, command, c.Parameters)
                    # Erase the line just translated:
                    outlist = []

            if SPINDLE_WAIT > 0:
                if command in ("M3", "M03", "M4", "M04"):
                    out += linenumber() + format_outlist(outlist) + "\n"
                    # Marlin: P for milliseconds, S for seconds, change P to S
                    out += linenumber()
                    out += format_outlist(["G4", "S%s" % SPINDLE_WAIT])
                    out += "\n"
                    outlist = []

            # Check for Tool Change:
            if command in ("M6", "M06"):
                if OUTPUT_COMMENTS:
                    out += linenumber() + "(Begin toolchange)\n"
                if OUTPUT_TOOL_CHANGE:
                    for line in TOOL_CHANGE.splitlines(True):
                        out += linenumber() + line
                if not OUTPUT_TOOL_CHANGE and OUTPUT_COMMENTS:
                    outlist[0] = "(" + outlist[0]
                    outlist[-1] = outlist[-1] + ")"
                if not OUTPUT_TOOL_CHANGE and not OUTPUT_COMMENTS:
                    outlist = []

            if command == "message":
                if OUTPUT_COMMENTS:
                    outlist.pop(0)  # remove the command
                else:
                    out = []

            if command in SUPPRESS_COMMANDS:
                outlist[0] = "(" + outlist[0]
                outlist[-1] = outlist[-1] + ")"

            # Remove embedded comments:
            if not OUTPUT_COMMENTS:
                tmplist = []
                list_index = 0
                while list_index < len(outlist):
                    left_index = outlist[list_index].find("(")
                    if left_index == -1:  # Not a comment
                        tmplist.append(outlist[list_index])
                    else:  # This line contains a comment, and possibly more
                        right_index = outlist[list_index].find(")")
                        comment_area = outlist[list_index][left_index : right_index + 1]
                        line_minus_comment = (
                            outlist[list_index].replace(comment_area, "").strip()
                        )
                        if line_minus_comment:
                            # Line contained more than just a comment
                            tmplist.append(line_minus_comment)
                    list_index += 1
                # Done removing comments
                outlist = tmplist

            # Prepend a line number and append a newline
            if len(outlist) >= 1:
                out += linenumber() + format_outlist(outlist) + "\n"

    return out


# *****************************************************************************
# * As of Marlin 2.0.7.bugfix, canned drill cycles do not exist.              *
# * The following code converts FreeCAD's canned drill cycles into            *
# * gcode that Marlin can use.                                                *
# *****************************************************************************
def drill_translate(outlist, cmd, params):
    global DRILL_RETRACT_MODE
    global MOTION_MODE
    global CURRENT_X
    global CURRENT_Y
    global CURRENT_Z
    global UNITS
    global UNIT_FORMAT
    global UNIT_FEED_FORMAT

    class Drill:  # Using a class is necessary for the nested functions.
        gcode = ""

    strFormat = "." + str(PRECISION) + "f"

    if OUTPUT_COMMENTS:  # Comment the original command
        outlist[0] = "(" + outlist[0]
        outlist[-1] = outlist[-1] + ")"
        Drill.gcode += linenumber() + format_outlist(outlist) + "\n"

    # Cycle conversion only converts the cycles in the XY plane (G17).
    # --> ZX (G18) and YZ (G19) planes produce false gcode.
    drill_X = Units.Quantity(params["X"], FreeCAD.Units.Length)
    drill_Y = Units.Quantity(params["Y"], FreeCAD.Units.Length)
    drill_Z = Units.Quantity(params["Z"], FreeCAD.Units.Length)
    drill_R = Units.Quantity(params["R"], FreeCAD.Units.Length)
    drill_F = Units.Quantity(params["F"], FreeCAD.Units.Velocity)
    if cmd == "G82":
        drill_DwellTime = params["P"]
    elif cmd == "G83":
        drill_Step = Units.Quantity(params["Q"], FreeCAD.Units.Length)

    # R less than Z is error
    if drill_R < drill_Z:
        Drill.gcode += linenumber() + "(drill cycle error: R less than Z )\n"
        return Drill.gcode

    # Z height to retract to when drill cycle is done:
    if DRILL_RETRACT_MODE == "G98" and CURRENT_Z > drill_R:
        RETRACT_Z = CURRENT_Z
    else:
        RETRACT_Z = drill_R

    # Z motion nested functions:
    def rapid_Z_to(new_Z):
        Drill.gcode += linenumber() + "G0 Z"
        Drill.gcode += format(float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + "\n"

    def feed_Z_to(new_Z):
        Drill.gcode += linenumber() + "G1 Z"
        Drill.gcode += format(float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + " F"
        Drill.gcode += format(float(drill_F.getValueAs(UNIT_FEED_FORMAT)), ".2f") + "\n"

    # Make sure that Z is not below RETRACT_Z:
    if CURRENT_Z < RETRACT_Z:
        rapid_Z_to(RETRACT_Z)

    # Rapid to hole position XY:
    Drill.gcode += linenumber() + "G0 X"
    Drill.gcode += format(float(drill_X.getValueAs(UNIT_FORMAT)), strFormat) + " Y"
    Drill.gcode += format(float(drill_Y.getValueAs(UNIT_FORMAT)), strFormat) + "\n"

    # Rapid to R:
    rapid_Z_to(drill_R)

    # *************************************************************************
    # * Drill cycles:                                                         *
    # * G80 Cancel the drill cycle                                            *
    # * G81 Drill full depth in one pass                                      *
    # * G82 Drill full depth in one pass, and pause at the bottom             *
    # * G83 Drill in pecks, raising the drill to R height after each peck     *
    # * In preparation for a rapid to the next hole position:                 *
    # * G98 After the hole has been drilled, retract to the initial Z value   *
    # * G99 After the hole has been drilled, retract to R height              *
    # * Select G99 only if safe to move from hole to hole at the R height     *
    # *************************************************************************
    if cmd in ("G81", "G82"):
        feed_Z_to(drill_Z)  # Drill hole in one step
        if cmd == "G82":  # Dwell time delay at the bottom of the hole
            Drill.gcode += linenumber() + "G4 S" + str(drill_DwellTime) + "\n"
            # Marlin uses P for milliseconds, S for seconds, change P to S

    elif cmd == "G83":  # Peck drill cycle:
        chip_Space = drill_Step * 0.5
        next_Stop_Z = drill_R - drill_Step
        while next_Stop_Z >= drill_Z:
            feed_Z_to(next_Stop_Z)  # Drill one peck of depth

            # Set next depth, next_Stop_Z is still at the current hole depth
            if (next_Stop_Z - drill_Step) >= drill_Z:
                # Rapid up to clear chips:
                rapid_Z_to(drill_R)
                # Rapid down to just above last peck depth:
                rapid_Z_to(next_Stop_Z + chip_Space)
                # Update next_Stop_Z to next depth:
                next_Stop_Z -= drill_Step
            elif next_Stop_Z == drill_Z:
                break  # Done
            else:  # More to drill, but less than drill_Step
                # Rapid up to clear chips:
                rapid_Z_to(drill_R)
                # Rapid down to just above last peck depth:
                rapid_Z_to(next_Stop_Z + chip_Space)
                # Dril remainder of the hole depth:
                feed_Z_to(drill_Z)
                break  # Done
    rapid_Z_to(RETRACT_Z)  # Done, retract the drill

    return Drill.gcode


# print(__name__ + ': GCode postprocessor loaded.')

# PEP8 format passed using: http://pep8online.com/, which primarily covers
# indentation and line length. Some other aspects of PEP8 which have not
# been applied yet may be applied in future updates.
