import os
import sys
import time
import requests
from dotenv import load_dotenv
from datetime import datetime, timedelta
import fitz  # PyMuPDF
import win32print
import win32ui
from PIL import Image, ImageWin

# .env laden
load_dotenv()

# .ENV Import
url = os.getenv('API_URL')
label_printer = os.getenv('LABEL_DRUCKER')  # Name des Labels-Druckers
order_printer = os.getenv('ORDER_DRUCKER')  # Name des Order-Druckers

# Log-Dateipfad
log_dir = "logs"
os.makedirs(log_dir, exist_ok=True)

def get_log_filename():
    """Erstellt einen Dateinamen für das Log basierend auf dem aktuellen Datum."""
    return os.path.join(log_dir, f"{datetime.now().strftime('%Y-%m-%d')}.log")

def setup_logging():
    """Erstellt eine Log-Datei und löscht alte Log-Dateien, die älter als 7 Tage sind."""
    # Logdatei für den aktuellen Tag
    log_file = get_log_filename()

    # Log-Datei öffnen
    sys.stdout = open(log_file, 'a')
    sys.stderr = sys.stdout

    # Alte Log-Dateien löschen (älter als 7 Tage)
    delete_old_logs()

def delete_old_logs():
    """Löscht Log-Dateien, die älter als 7 Tage sind."""
    for filename in os.listdir(log_dir):
        file_path = os.path.join(log_dir, filename)
        if os.path.isfile(file_path):
            file_age = datetime.now() - datetime.fromtimestamp(os.path.getmtime(file_path))
            if file_age > timedelta(days=7):
                os.remove(file_path)
                print(f"Altes Log gelöscht: {filename}")

def log_message(message):
    """Schreibt eine Nachricht ins Log."""
    print(f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - {message}")

# Verbesserte Druckfunktion
def print_pdf(file_path, printer_name):
    if not os.path.exists(file_path):
        log_message(f'Datei nicht gefunden: {file_path}')
        return False

    try:
        hprinter = win32print.OpenPrinter(printer_name)
        hdc = win32ui.CreateDC()
        hdc.CreatePrinterDC(printer_name)
        hdc.StartDoc(file_path)

        pdf_document = fitz.open(file_path)
        printer_size = hdc.GetDeviceCaps(8), hdc.GetDeviceCaps(10)  # Horizontale/Vertikale Größe in Pixel

        for page_number in range(len(pdf_document)):
            page = pdf_document.load_page(page_number)

            zoom = 3.0
            mat = fitz.Matrix(zoom, zoom)
            pix = page.get_pixmap(matrix=mat, alpha=False)

            image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
            dib = ImageWin.Dib(image)

            scale_x = printer_size[0] / pix.width
            scale_y = printer_size[1] / pix.height
            scale = min(scale_x, scale_y)

            x_pos = int((printer_size[0] - (pix.width * scale)) // 2)
            y_pos = int((printer_size[1] - (pix.height * scale)) // 2)
            width = int(pix.width * scale)
            height = int(pix.height * scale)

            hdc.StartPage()
            try:
                dib.draw(hdc.GetHandleOutput(), (x_pos, y_pos, x_pos + width, y_pos + height))
            except Exception as draw_error:
                log_message(f"Zeichenfehler: {draw_error}")
                dib.draw(hdc.GetHandleOutput(), (0, 0, printer_size[0], printer_size[1]))
            hdc.EndPage()

        hdc.EndDoc()
        hdc.DeleteDC()
        win32print.ClosePrinter(hprinter)
        log_message(f"Erfolgreich gedruckt: {file_path}")
        return True

    except Exception as e:
        log_message(f"Fehler beim Drucken von {file_path}: {str(e)}")
        import traceback
        traceback.print_exc()
        return False

# Debug-Funktion aktivieren
setup_logging()

# Einzeldatei-Druck prüfen
if len(sys.argv) > 1:
    file_to_print = sys.argv[1]

    if "label" in file_to_print.lower():
        printer = label_printer
    else:
        printer = order_printer

    log_message(f"Einzeldatei-Modus: {file_to_print} → {printer}")
    print_pdf(file_to_print, printer)
    sys.exit(0)

# KEIN Dateiname angegeben → Standard-Workflow (Download, Aufteilen, Drucken)

# Zeitstempel für die Dateien
timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')

# Pfad der Dateien
original_storage_path = "./original"
order_storage_path = "./orders"
label_storage_path = "./label"

# Verzeichnisse erstellen
os.makedirs(original_storage_path, exist_ok=True)
os.makedirs(order_storage_path, exist_ok=True)
os.makedirs(label_storage_path, exist_ok=True)

# PDF von der API herunterladen
if url:
    response = requests.get(url)
    if response.status_code == 200:
        file_name = f'{original_storage_path}/original_{timestamp}.pdf'
        with open(file_name, 'wb') as file:
            file.write(response.content)
        log_message(f'PDF erfolgreich heruntergeladen: "{file_name}"')
    else:
        log_message(f'Fehler beim Herunterladen. Statuscode: {response.status_code}')
        exit(1)
else:
    log_message('API-URL nicht in .env gefunden.')
    exit(1)

# Dokument verarbeiten
doc = fitz.open(f'{original_storage_path}/original_{timestamp}.pdf')

label_sections = {}
current_label = None
start_page = None
order_end_page = None

markers = {
    "########## DHL LABELS ##########": "DHL",
    "########## DPD LABELS ##########": "DPD",
    "########## UPS LABELS ##########": "UPS"
}

# Dokument in Abschnitte teilen
for page_number in range(len(doc)):
    page = doc.load_page(page_number)
    text = page.get_text()

    found_label = None
    for marker_text, label_name in markers.items():
        if marker_text in text:
            found_label = label_name
            break

    if found_label:
        if current_label is None:
            order_end_page = page_number - 1

        if current_label is not None and start_page is not None:
            section_doc = fitz.open()
            section_doc.insert_pdf(doc, from_page=start_page, to_page=page_number - 1)
            label_sections.setdefault(current_label, []).append(section_doc)

        current_label = found_label
        start_page = page_number + 1

# Letzten Abschnitt speichern
if current_label is not None and start_page is not None and start_page < len(doc):
    section_doc = fitz.open()
    section_doc.insert_pdf(doc, from_page=start_page, to_page=len(doc) - 1)
    label_sections.setdefault(current_label, []).append(section_doc)

# Bestellung speichern
if order_end_page is not None and order_end_page >= 0:
    order_doc = fitz.open()
    order_doc.insert_pdf(doc, from_page=0, to_page=order_end_page)
    order_filename = f"{order_storage_path}/order_{timestamp}.pdf"
    order_doc.save(order_filename)
    log_message(f"Bestellung gespeichert als {order_filename}")

# Labels speichern
for label, docs in label_sections.items():
    for idx, pdf in enumerate(docs, start=1):
        filename = f"{label_storage_path}/{label}_label_{idx}_{timestamp}.pdf"
        pdf.save(filename)
        log_message(f"{label} Label gespeichert als {filename}")

# Druckvorgang
log_message("\nStarte Druckvorgang:")

# Labels drucken
for label in label_sections:
    for idx, pdf in enumerate(label_sections[label], start=1):
        label_filename = f"{label_storage_path}/{label}_label_{idx}_{timestamp}.pdf"
        log_message(f"Drucke {label} Label {idx}...")
        print_pdf(label_filename, label_printer)
        time.sleep(1)  # Kurze Pause zwischen den Druckaufträgen

# Bestellung drucken
if order_end_page is not None:
    log_message("\nDrucke Bestellung...")
    order_filename = f"{order_storage_path}/order_{timestamp}.pdf"
    print_pdf(order_filename, order_printer)

log_message("\nDruckvorgang abgeschlossen.")