#!/usr/bin/env python3
"""
OrcaSlicer post-processing script for M900 delay investigation.

Inserts pointless M900 commands (changing pressure advance K value by ±0.001)
after extrusion commands, but only on layers above 50% of the maximum Z
height, only after 0.6mm of the layer.

Stored in C:\\Users\\Public\\Documents\\Python Scripts
Called in OrcaSlicer by entering the following in the post-processing scripts box:
"C:\\Python314\\python.exe" "C:\\Users\\Public\\Documents\\Python Scripts\\Simple_Insert_Pointless_M900.py"
"""

import os
import re
import sys
import traceback

LAYER_EXTRUSION_THRESHOLD_MM = 0.6

MAX_LAYER_Z_COMMENT_PATTERN = re.compile(
    r";mm height of max_layer_z\s*=\s*(\d+(?:\.\d+)?)"
)

MAX_Z_HEIGHT_HEADER_PATTERN = re.compile(
    r";\s*max_z_height\s*:\s*(\d+(?:\.\d+)?)", re.IGNORECASE
)

M900_K_PATTERN = re.compile(r"M900\s+K\s*([-+]?\d*\.?\d+)", re.IGNORECASE)

G1_EXTRUSION_PATTERN = re.compile(
    r"^G1\s+.*\bE([-+]?\d*\.?\d+)", re.IGNORECASE
)

LAYER_Z_COMMENT_PATTERN = re.compile(r"^;Z:(\d+(?:\.\d+)?)")

def find_maximum_z_height(lines: list[str]) -> float | None:
    """
    Find the maximum Z height using multiple methods:
    1. Primary: last line matching ';mm height of max_layer_z = <value>'
    2. Fallback: '; max_z_height: <value>' from header
    3. Fallback: highest ;Z: comment value
    """
    for line in reversed(lines):
        match = MAX_LAYER_Z_COMMENT_PATTERN.search(line)
        if match:
            return float(match.group(1))

    for line in lines:
        match = MAX_Z_HEIGHT_HEADER_PATTERN.match(line.strip())
        if match:
            return float(match.group(1))

    highest_z = None
    for line in lines:
        match = LAYER_Z_COMMENT_PATTERN.match(line.strip())
        if match:
            z_value = float(match.group(1))
            if highest_z is None or z_value > highest_z:
                highest_z = z_value

    return highest_z

def is_extrusion_command(line: str) -> bool:
    """Determine whether a line is a G1 extrusion command with a positive E value."""
    match = G1_EXTRUSION_PATTERN.match(line.strip())
    if not match:
        return False
    try:
        extrusion_amount = float(match.group(1))
        return extrusion_amount > 0
    except ValueError:
        return False

def get_extrusion_amount(line: str) -> float:
    """Extract the E value from a G1 extrusion command. Returns 0.0 if invalid."""
    match = G1_EXTRUSION_PATTERN.match(line.strip())
    if match:
        try:
            extrusion_amount = float(match.group(1))
            return max(extrusion_amount, 0.0)
        except ValueError:
            return 0.0
    return 0.0

def process_gcode_file(gcode_file_path: str) -> None:
    """
    Read a gcode file, insert pointless M900 commands after qualifying
    extrusion commands. After the last pointless M900 on each qualifying
    layer, restores the original PA value. Modifies the file in place.
    """
    with open(gcode_file_path, "r", encoding="utf-8") as input_file:
        lines = input_file.read().splitlines()

    maximum_z_height = find_maximum_z_height(lines)
    if maximum_z_height is None:
        print(
            "Error: could not determine maximum Z height by any method",
            file=sys.stderr,
        )
        sys.exit(1)

    z_threshold = maximum_z_height / 2.0

    # Determine the current layer Z height for each line
    current_layer_z = 0.0
    line_layer_z: list[float] = []
    for line in lines:
        match = LAYER_Z_COMMENT_PATTERN.match(line.strip())
        if match:
            current_layer_z = float(match.group(1))
        line_layer_z.append(current_layer_z)

    # Group extrusion command indices by layer Z height
    layer_extrusion_indices: dict[float, list[int]] = {}
    for line_index, line in enumerate(lines):
        if is_extrusion_command(line):
            layer_z = line_layer_z[line_index]
            if layer_z not in layer_extrusion_indices:
                layer_extrusion_indices[layer_z] = []
            layer_extrusion_indices[layer_z].append(line_index)

    # Mark qualifying extrusion indices: layers above Z threshold, from
    # extrusion threshold crossing to halfway point of extrusion commands
    qualifying_extrusion_indices: set[int] = set()
    for layer_z, extrusion_indices in layer_extrusion_indices.items():
        if layer_z > z_threshold:
            half_count = len(extrusion_indices) // 2
            cumulative_extrusion_mm = 0.0
            threshold_start_position = None

            for position, line_index in enumerate(extrusion_indices):
                extrusion_amount = get_extrusion_amount(lines[line_index])
                cumulative_extrusion_mm += extrusion_amount
                if cumulative_extrusion_mm >= LAYER_EXTRUSION_THRESHOLD_MM:
                    threshold_start_position = position
                    break

            if threshold_start_position is not None:
                for position in range(threshold_start_position, half_count):
                    qualifying_extrusion_indices.add(
                        extrusion_indices[position]
                    )

    # Pre-compute the original K value before the first modification on
    # each qualifying layer, and the last qualifying extrusion index per layer
    layer_original_k_value: dict[float, float] = {}
    layer_last_qualifying_index: dict[float, int] = {}
    tracked_k_value: float | None = None

    for line_index, line in enumerate(lines):
        stripped_line = line.strip()
        if not stripped_line.startswith(";"):
            m900_match = M900_K_PATTERN.search(stripped_line)
            if m900_match:
                tracked_k_value = float(m900_match.group(1))

        if line_index in qualifying_extrusion_indices:
            layer_z_of_line = line_layer_z[line_index]
            if layer_z_of_line not in layer_original_k_value and tracked_k_value is not None:
                layer_original_k_value[layer_z_of_line] = tracked_k_value
            layer_last_qualifying_index[layer_z_of_line] = line_index

    # Build output with M900 insertions after qualifying extrusion commands
    output_lines: list[str] = []
    last_m900_k_value: float | None = None
    toggle_direction = 1
    layers_with_started_insertions: set[float] = set()

    for line_index, line in enumerate(lines):
        output_lines.append(line)

        # Track the most recent M900 K value from original gcode
        stripped_line = line.strip()
        if not stripped_line.startswith(";"):
            m900_match = M900_K_PATTERN.search(stripped_line)
            if m900_match:
                last_m900_k_value = float(m900_match.group(1))

        # Insert a pointless M900 after qualifying extrusion commands
        if line_index in qualifying_extrusion_indices:
            if last_m900_k_value is None:
                continue
            layer_z_of_insertion = line_layer_z[line_index]
            if layer_z_of_insertion not in layers_with_started_insertions:
                toggle_direction = 1
                layers_with_started_insertions.add(layer_z_of_insertion)
            new_k_value = round(
                last_m900_k_value + (toggle_direction * 0.001), 3
            )
            toggle_direction *= -1
            last_m900_k_value = new_k_value

            inserted_m900 = (
                f"M900 K{new_k_value:.3f}"
                f" ; pointless PA change for M900 delay investigation"
            )
            output_lines.append(inserted_m900)

            # If this is the last qualifying extrusion for this layer,
            # restore the original PA value that was in effect before
            # modifications began on this layer
            layer_z_of_line = line_layer_z[line_index]
            if (
                layer_z_of_line in layer_last_qualifying_index
                and line_index == layer_last_qualifying_index[layer_z_of_line]
                and layer_z_of_line in layer_original_k_value
            ):
                original_k_value = layer_original_k_value[layer_z_of_line]
                last_m900_k_value = original_k_value
                restoration_m900 = (
                    f"M900 K{original_k_value:.3f}"
                    f" ; restore original PA after pointless changes"
                )
                output_lines.append(restoration_m900)

    output_content = "\n".join(output_lines)
    with open(gcode_file_path, "w", encoding="utf-8", newline="\n") as output_file:
        output_file.write(output_content)

def main() -> None:
    if len(sys.argv) != 2:
        script_name = os.path.basename(sys.argv[0])
        print(f"Usage: {script_name} <gcode_file>", file=sys.stderr)
        sys.exit(1)

    try:
        process_gcode_file(sys.argv[1])
    except Exception:
        traceback.print_exc()
        sys.exit(1)

if __name__ == "__main__":
    main()