import sys
import math
import re

# Dateinamen für Ein- und Ausgabe erhalten
inFile = sys.argv[1]

# Funktion zur Extraktion der Druckzeit definieren
def extract_printing_time(input_string):
    parts = input_string.split()
    days, hours, minutes = 0, 0, 0

    # Durchlaufe die Teile der Eingabezeichenkette
    for part in parts:
        if 'd' in part:
            days = int(part[:-1])
        elif 'h' in part:
            hours = int(part[:-1])
        elif 'm' in part:
            minutes = int(part[:-1])
        elif 's' in part:
            seconds = int(part[:-1])
            # Runde Sekunden auf Minuten
            minutes += math.ceil(seconds / 60)

    # Formatiere die Zeit entsprechend dem Format
    time_str = ""
    if days > 0:
        time_str += str(days) + "d"
    if hours > 0:
        time_str += str(hours) + "h"
    if minutes > 0:
        time_str += str(minutes) + "m"

    return time_str

# Öffne die Eingabedatei und lese den gesamten G-Code
with open(inFile, "r", encoding="utf-8") as f:
    lines = f.readlines()

# Variablen für Werte initialisieren
Filament = None
Zeit = None
external_perim_width = 0.00
LayerAnycubic = 0.00
z_size = 0.00
y_size = 0.00
x_size = 0.00
LH = None
FLH = None

# Initialisierung der Variablen für die Größenberechnung
x_min = float('inf')
x_max = float('-inf')
y_min = float('inf')
y_max = float('-inf')

# Durchsuche den G-Code nach den angegebenen Informationen
search_external_perimeter = False  # Variable, um zu überprüfen, ob wir uns im Abschnitt "External perimeter" befinden

# Suche nach anderen Informationen
for line in lines:
    if "; external perimeters extrusion width = " in line:
        external_perim_width = float(re.search(r'(\d+\.\d+)', line).group(1))
    elif "; filament used [mm] = " in line:
        Filament = str(float(line.split("= ")[1].strip()) / 1000)
    elif "; estimated printing time (normal mode) = " in line:
        Zeit = extract_printing_time(line.split("= ")[1].strip())
    elif ";TYPE:External perimeter" in line:
        search_external_perimeter = True  # Beginn des Abschnitts "External perimeter"
    elif search_external_perimeter and line.startswith("G1"):
        match_x = re.search(r'X([\d.]+)', line)
        match_y = re.search(r'Y([\d.]+)', line)
        if match_x and match_y:
            x_value = float(match_x.group(1))
            y_value = float(match_y.group(1))

            # X-Min und X-Max aktualisieren
            x_min = min(x_min, x_value)
            x_max = max(x_max, x_value)

            # Y-Min und Y-Max aktualisieren
            y_min = min(y_min, y_value)
            y_max = max(y_max, y_value)
    elif ";TYPE:" in line:
        search_external_perimeter = False  # Verlassen des Abschnitts "External perimeter"

# Berechnung der Größen
x_size = round(x_max - x_min + external_perim_width, 3)
y_size = round(y_max - y_min + external_perim_width, 3)

# Rückwärtssuche nach der ersten Zeile mit "; layer_height = "
for line in reversed(lines):
    if "; layer_height = " in line:
        LH = float(line.split('=')[1])
        break

# Rückwärtssuche nach der ersten Zeile mit "; first_layer_height = "
for line in reversed(lines):
    if "; first_layer_height = " in line:
        FLH = float(line.split('=')[1])
        break

# Calculate DLH
if LH is not None and FLH is not None:
    DLH = FLH - LH
else:
    DLH = None

# Rückwärtssuche nach der ersten Zeile mit ; AFTER_LAYER_CHANGE
max_layer_anycubic = 0
max_z_size = 0

for line in reversed(lines):
    if line.startswith("; AFTER_LAYER_CHANGE") and not line.startswith("; layer_gcode = ; AFTER_LAYER_CHANGE"):
        # Suche den Zahlenwert zwischen "CHANGE " und " @"
        match_layer = re.search(r'CHANGE (\d+) @', line)
        match_z = re.search(r'@ (\d+\.\d+)mm', line)
        if match_layer and match_z:
            current_layer_anycubic = float(match_layer.group(1))
            current_z_size = float(match_z.group(1))
            # Wenn die Werte größer als die bisherigen Maxima sind, aktualisiere sie
            max_layer_anycubic = max(max_layer_anycubic, current_layer_anycubic)
            max_z_size = max(max_z_size, current_z_size)

# Überprüfen, ob gültige Werte gefunden wurden (größer als 0)
if max_layer_anycubic > 0 and max_z_size > 0:
    # Formatierung der Werte
    LayerAnycubic = "{:4d}".format(int(max_layer_anycubic))
    z_size = "{:.2f}".format(max_z_size - DLH)

# Öffne die Ausgabedatei und schreibe den bearbeiteten G-Code
with open(inFile, 'w', encoding="utf-8") as out:
    for line in lines:
        out.write(line)
        if "; prusaslicer_config = end" in line:
            out.write("\n; Anycubic config begin\n")
            out.write("\n; statistics = begin\n")
            out.write("; processor = begin\n")
            out.write("; model_size = " + str(x_size) + "," + str(y_size) + "," + str(z_size) + "\n")
            out.write("; print_time = " + str(Zeit) + "\n")
            # LayerAnycubic um 1 erhöhen und in die Datei schreiben
            out.write("; total_layers = " + str(int(LayerAnycubic) + 1) + "\n")
            out.write("; used_filament = " + str(Filament) + "\n")
            out.write("; processor = end\n")
            out.write("; statistics = end\n\n")
            out.write("Anycubic config End")

# print("Post-processing complete. Input file overwritten.\n")
# print("The Anycubic configuration was added following the PrusaSlicer configuration data.\n\n")
# print("Anycubic config begin\n")
# print("; statistics = begin")
# print("; processor = begin")
# print("; model_size = " + str(x_size) + "," + str(y_size) + "," + str(z_size))
# print("; print_time = " + str(Zeit))
# print("; total_layers = " + str(int(LayerAnycubic) + 1))
# print("; used_filament = " + str(Filament))
# print("; processor = end")
# print("; statistics = end\n")
# print("Anycubic config End")
# input("Press Enter to close Window")