3ddruckkalkulation/app.py

"""
3D-Druck Kostenkalkulation — Flask Web-App.

Ersetzt die alte Tkinter-Version (3dDruckKalkulator.py).
Bietet eine Weboberflaeche zur Eingabe von Druckparametern,
Live-Berechnung der Kosten, PDF-Rechnung und TXT-Export.
"""
import os
import yaml
import io
import tempfile
import threading
from datetime import datetime
from flask import Flask, render_template, request, jsonify, redirect, url_for, send_file
from fpdf import FPDF
from fpdf.enums import XPos, YPos

def image_dimensions(filepath):
    """Liest Pixelmasse aus PNG/JPEG/WebP ohne externe Libs."""  # noqa: E501
    with open(filepath, 'rb') as f:
        head = f.read(24)
    if head[:8] == b'\x89PNG\r\n\x1a\n':
        import struct
        return struct.unpack('>II', head[16:24])
    if head[:2] == b'\xff\xd8':
        import struct
        with open(filepath, 'rb') as f:
            data = f.read(8192)
        i = 2
        while i < len(data) - 1:
            if data[i] != 0xFF:
                i += 1
                continue
            marker = data[i+1]
            if marker in (0xC0, 0xC1, 0xC2):
                h, w = struct.unpack('>HH', data[i+5:i+9])
                return w, h
            length = struct.unpack('>H', data[i+2:i+4])[0]
            i += 2 + length
    if head[:4] == b'RIFF' and head[8:12] == b'WEBP':
        import struct
        with open(filepath, 'rb') as f:
            data = f.read(64)
        if data[12:16] == b'VP8 ' and len(data) >= 30:
            w, h = struct.unpack('<HH', data[26:30])
            return (w & 0x3FFF) * 2, (h & 0x3FFF) * 2
        if data[12:16] == b'VP8L' and len(data) >= 25:
            bits = struct.unpack('<I', data[21:25])[0]
            return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
    return None, None


# Zeichen, die die PDF-Kernfonts (latin-1) nicht darstellen koennen,
# aber regelmaessig aus Copy-Paste in Kunden- und Projektnamen landen.
_LATIN1_ERSATZ = {
    '\u2013': '-', '\u2014': '-', '\u2012': '-', '\u2212': '-',
    '\u2018': "'", '\u2019': "'", '\u201a': ',', '\u2032': "'",
    '\u201c': '"', '\u201d': '"', '\u201e': '"', '\u2033': '"',
    '\u2026': '...', '\u2022': '-', '\u00a0': ' ', '\u202f': ' ',
    '\u20ac': 'EUR', '\u2044': '/', '\u00ad': '',
}


# Die drei Faelle unterscheiden sich rechtlich grundlegend:
#   'regel'            -> Unternehmer, weist MwSt. aus
#   'kleinunternehmer' -> Unternehmer nach §19 UStG, keine MwSt., Pflichthinweis
#   'privat'           -> gar kein Unternehmer (§2 UStG); weder MwSt. noch
#                         §19-Hinweis noch Steuernummer gehoeren auf den Beleg
STEUERREGIME = ('regel', 'kleinunternehmer', 'privat')

KLEINUNTERNEHMER_HINWEIS = (
    "Gemäß § 19 UStG wird keine Umsatzsteuer berechnet."
)

PRIVAT_HINWEIS = (
    "Privatverkauf. Kein Ausweis von Umsatzsteuer."
)


def mwst_satz_label(satz):
    """Formatiert den Steuersatz ohne unnoetige Nachkommastellen (19 statt 19.0)."""
    return f"{satz:g}"


def as_stueckzahl(value):
    """Stueckzahl robust nach int, mindestens 1.

    Leere Felder oder Kommazahlen (z.B. '' oder '1.5') haben frueher
    einen ValueError und damit HTTP 500 ausgeloest.
    """
    try:
        zahl = int(float(value))
    except (TypeError, ValueError):
        return 1
    return max(1, zahl)


def pdf_text(value):
    """Macht beliebigen Text fuer die latin-1-Kernfonts von fpdf sicher.

    Ohne diese Umwandlung wirft fpdf beim Schreiben einen
    UnicodeEncodeError und die PDF-Route antwortet mit HTTP 500.
    """
    text = '' if value is None else str(value)
    for zeichen, ersatz in _LATIN1_ERSATZ.items():
        text = text.replace(zeichen, ersatz)
    # Alles weiterhin Unkodierbare faellt auf '?' zurueck, statt zu crashen.
    return text.encode('latin-1', 'replace').decode('latin-1')


app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024
CONFIG_FILE = 'druckkalkulation_config.yaml'

LOGO_EXTS = ('png', 'jpg', 'webp')

DEFAULT_VALUES = {
    'projektName': '',
    'kundenName': '',
    'kundenAdresse': '',
    'materialGewicht': 0,
    'materialPreisProKg': 25,
    'druckzeit': 0,
    'stromverbrauch': 0.15,
    'strompreis': 0.35,
    'druckerAnschaffung': 500,
    'druckerNutzungsdauer': 3,
    'druckerBetriebsstunden': 2000,
    'arbeitszeit': 0,
    'stundenlohn': 25,
    'gewinnmarge': 20,
    'stueckzahl': 1,
    # 'regel' = regelbesteuert (MwSt. wird ausgewiesen),
    # 'kleinunternehmer' = §19 UStG (keine MwSt., dafuer Pflichthinweis).
    'steuerregime': 'regel',
    'mwst_satz': 19,
    'steuernummer': '',
    'ust_id': '',
    'mwst_ausweisen': False,
    'rechnungsnummer': '',
    'datum': datetime.now().strftime('%Y-%m-%d'),
    'leistungsdatum': '',
    'dark_mode': False,
    'firmenName': '',
    'firmenAdresse': '',
    'telefon': '',
    'email': '',
    'paypal': '',
    'iban': '',
    'bankName': '',
    'logo': '',
}


# Serialisiert Read-modify-write auf der Config-Datei. Ohne Lock koennen
# zwei parallele Autosaves (Tippen in zwei Tabs) sich gegenseitig
# ueberschreiben.
_config_lock = threading.Lock()


class ConfigError(RuntimeError):
    """Die Config-Datei existiert, ist aber nicht lesbar."""


def load_config():
    """Liest die YAML-Konfiguration von Disk. Fehlt die Datei,
    werden DEFAULT_VALUES verwendet.

    Ist die Datei vorhanden aber beschaedigt, wird ConfigError geworfen,
    statt stillschweigend auf Defaults zurueckzufallen -- sonst wuerde
    der naechste Autosave die kaputte Datei mit Defaults ueberschreiben
    und alle gespeicherten Werte waeren endgueltig weg.
    """
    if not os.path.exists(CONFIG_FILE):
        return dict(DEFAULT_VALUES)
    try:
        with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
            data = yaml.safe_load(f)
    except (OSError, yaml.YAMLError) as e:
        raise ConfigError(f"{CONFIG_FILE} ist nicht lesbar: {e}") from e
    if not isinstance(data, dict):
        if data is None:
            return dict(DEFAULT_VALUES)
        raise ConfigError(f"{CONFIG_FILE} enthaelt kein YAML-Mapping")
    # Migration VOR dem Auffuellen mit Defaults: sonst hat setdefault
    # 'steuerregime' bereits gesetzt und die Ableitung liefe ins Leere.
    data = _migriere(data)
    for k, v in DEFAULT_VALUES.items():
        data.setdefault(k, v)
    return data


def _migriere(data):
    """Bringt aeltere Config-Staende auf das aktuelle Schema.

    Frueher gab es nur den Schalter 'mwst_ausweisen'. Daraus laesst sich
    das Steuerregime ableiten: wer keine MwSt. auswies, rechnete faktisch
    als Kleinunternehmer ab. Nur greifen, wenn 'steuerregime' wirklich
    fehlt -- ein leerer Wert im Feld ist etwas anderes als ein alter Stand.
    """
    if 'steuerregime' not in data:
        if 'mwst_ausweisen' in data:
            data['steuerregime'] = ('regel' if data['mwst_ausweisen']
                                    else 'kleinunternehmer')
        else:
            data['steuerregime'] = DEFAULT_VALUES['steuerregime']
    if data['steuerregime'] not in STEUERREGIME:
        data['steuerregime'] = DEFAULT_VALUES['steuerregime']
    # 'mwst_ausweisen' bleibt als abgeleitetes Feld erhalten, damit
    # Templates und Export nicht an zwei Stellen entscheiden muessen.
    data['mwst_ausweisen'] = data['steuerregime'] == 'regel'
    return data


def save_config(data):
    """Schreibt das uebergebene Dict atomar als YAML-Datei.

    Erst in eine temporaere Datei im selben Verzeichnis schreiben, dann
    os.replace() -- so bleibt bei einem Absturz mitten im Schreiben die
    alte Config intakt statt abgeschnitten zurueckzubleiben.
    """
    verzeichnis = os.path.dirname(os.path.abspath(CONFIG_FILE))
    fd, tmp_pfad = tempfile.mkstemp(
        prefix='.druckkalkulation_', suffix='.tmp', dir=verzeichnis)
    try:
        with os.fdopen(fd, 'w', encoding='utf-8') as f:
            yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
            f.flush()
            os.fsync(f.fileno())
        os.replace(tmp_pfad, CONFIG_FILE)
    except Exception:
        if os.path.exists(tmp_pfad):
            os.remove(tmp_pfad)
        raise


def calculate(data):
    """Berechnet alle Kosten aus den Formularwerten.

    Rueckgabe: Dict mit Einzelposten, Gesamtsummen und Detailwerten.
    """
    # Umrechnungen
    druckzeit_stunden = float(data.get('druckzeit', 0)) / 60
    arbeitszeit_stunden = float(data.get('arbeitszeit', 0)) / 60
    material_kg = float(data.get('materialGewicht', 0)) / 1000

    # Material-, Strom-, Abschreibungs- und Arbeitskosten
    materialkosten = material_kg * float(data.get('materialPreisProKg', 0))
    stromkosten = druckzeit_stunden * float(data.get('stromverbrauch', 0)) * float(data.get('strompreis', 0))

    anschaffung = float(data.get('druckerAnschaffung', 0))
    nutzung = float(data.get('druckerNutzungsdauer', 1))
    betrieb = float(data.get('druckerBetriebsstunden', 1))
    abschreibung_pro_stunde = anschaffung / (nutzung * betrieb) if (nutzung * betrieb) > 0 else 0
    abschreibung = abschreibung_pro_stunde * druckzeit_stunden

    arbeitskosten = arbeitszeit_stunden * float(data.get('stundenlohn', 0))

    # Gewinn, MwSt. und Bruttopreis
    gesamtkosten_netto = materialkosten + stromkosten + abschreibung + arbeitskosten
    gewinn = gesamtkosten_netto * (float(data.get('gewinnmarge', 0)) / 100)
    verkaufspreis = gesamtkosten_netto + gewinn
    # Das Steuerregime entscheidet, nicht mehr ein loser Bool-Schalter.
    regime = str(data.get('steuerregime', 'regel')).lower()
    if regime not in STEUERREGIME:
        regime = 'regel'
    mwst_ausweisen = regime == 'regel'
    try:
        mwst_satz = float(data.get('mwst_satz', 19))
    except (TypeError, ValueError):
        mwst_satz = 19.0
    if mwst_satz < 0:
        mwst_satz = 0.0
    mwst_faktor = mwst_satz / 100 if mwst_ausweisen else 0
    mwst = verkaufspreis * mwst_faktor
    gesamt_brutto = verkaufspreis + mwst

    material_preis_pro_kg = float(data.get('materialPreisProKg', 0))

    # Gesamtwerte fuer den kompletten Auftrag. Basis ist der auf Cent
    # gerundete Stueckpreis, damit die Rechnungszeile nachrechenbar
    # bleibt (Einzelpreis x Menge == Zeilensumme).
    stueckzahl = as_stueckzahl(data.get('stueckzahl', 1))
    stueckpreis_netto = round(verkaufspreis, 2)
    gesamt_netto = round(stueckpreis_netto * stueckzahl, 2)
    gesamt_mwst = round(gesamt_netto * mwst_faktor, 2)
    gesamt_endpreis = round(gesamt_netto + gesamt_mwst, 2)

    return {
        'stueckzahl': stueckzahl,
        'gewinnmarge': float(data.get('gewinnmarge', 0)),
        'steuerregime': regime,
        'mwst_satz': mwst_satz,
        'kleinunternehmer': regime == 'kleinunternehmer',
        'privat': regime == 'privat',
        # Steuernummer/USt-IdNr. gehoeren nur auf einen Unternehmer-Beleg.
        'ist_unternehmer': regime != 'privat',
        'gesamt_netto': gesamt_netto,
        'gesamt_mwst': gesamt_mwst,
        'gesamt_endpreis': gesamt_endpreis,
        'materialkosten': round(materialkosten, 2),
        'stromkosten': round(stromkosten, 2),
        'abschreibung': round(abschreibung, 2),
        'arbeitskosten': round(arbeitskosten, 2),
        'gesamtkosten_netto': round(gesamtkosten_netto, 2),
        'gewinn': round(gewinn, 2),
        'verkaufspreis': round(verkaufspreis, 2),
        'mwst': round(mwst, 2),
        'mwst_ausweisen': mwst_ausweisen,
        'gesamt_brutto': round(gesamt_brutto, 2),
        'druckzeit_stunden': round(druckzeit_stunden, 2),
        'material_kg': round(material_kg, 3),
        'abschreibung_pro_stunde': round(abschreibung_pro_stunde, 4),
        'kosten_pro_gramm': round(material_preis_pro_kg / 1000, 3),
        'strom_pro_stunde': round(float(data.get('stromverbrauch', 0)) * float(data.get('strompreis', 0)), 3),
    }


# ---------------------------------------------------------------------------
# Routes
# ---------------------------------------------------------------------------


@app.context_processor
def inject_konstanten():
    """Stellt den §19-Hinweis allen Templates zur Verfuegung."""
    return {'kleinunternehmer_hinweis': KLEINUNTERNEHMER_HINWEIS,
            'privat_hinweis': PRIVAT_HINWEIS}


@app.errorhandler(ConfigError)
def handle_config_error(e):
    """Kaputte Config-Datei: klar melden statt Daten zu ueberschreiben."""
    hinweis = (f"Konfigurationsdatei beschaedigt: {e}. "
               f"Bitte {CONFIG_FILE} reparieren oder loeschen "
               f"(dann startet die App mit Standardwerten).")
    if request.path in ('/calculate', '/save_config'):
        return jsonify({'error': hinweis}), 500
    return hinweis, 500


@app.route('/')
def index():
    """Hauptseite mit Eingabeformular und Ergebnissen."""
    config = load_config()
    calc = calculate(config)
    return render_template('index.html', config=config, calc=calc)


@app.route('/settings')
def settings():
    """Einstellungsseite fuer Druckerabschreibung, Arbeitskosten und Marge."""
    config = load_config()
    return render_template('settings.html', config=config)


@app.route('/calculate', methods=['POST'])
def calc_json():
    """AJAX-Endpunkt: Nimmt Formular-JSON entgegen, gibt Berechnung zurueck.
    Fehlende Werte werden aus der gespeicherten Config ergaenzt."""
    data = request.get_json()
    config = load_config()
    merged = {**config, **data}
    calc = calculate(merged)
    return jsonify(calc)


@app.route('/save_config', methods=['POST'])
def save_config_route():
    """AJAX-Endpunkt: Speichert aktuelle Formularwerte in YAML.
    Vorhandene Werte (z.B. aus Einstellungen) werden nicht ueberschrieben."""
    data = request.get_json(silent=True) or {}
    # Nur bekannte Schluessel uebernehmen -- sonst kann ein beliebiger
    # Client die Config mit fremden Feldern vollschreiben.
    gefiltert = {k: v for k, v in data.items() if k in DEFAULT_VALUES}
    with _config_lock:
        existing = load_config()
        existing.update(gefiltert)
        # Abgeleitete Felder neu berechnen, damit auf der Platte nie
        # 'kleinunternehmer' neben 'mwst_ausweisen: true' steht.
        existing = _migriere(existing)
        save_config(existing)
    return jsonify({'status': 'ok', 'gespeichert': len(gefiltert)})


@app.route('/upload_logo', methods=['POST'])
def upload_logo():
    """Logo-Datei hochladen, auf gueltiges Bild pruefen und speichern."""
    if 'logo' not in request.files:
        return jsonify({'error': 'Keine Datei'}), 400
    file = request.files['logo']
    if file.filename == '':
        return jsonify({'error': 'Keine Datei ausgewaehlt'}), 400

    raw = file.read()
    # Magic-Bytes-Pruefung
    if raw[:8] == b'\x89PNG\r\n\x1a\n':
        ext = 'png'
    elif raw[:2] in (b'\xff\xd8',):
        ext = 'jpg'
    elif raw[:4] == b'RIFF' and raw[8:12] == b'WEBP':
        ext = 'webp'
    else:
        return jsonify({'error': 'Nur PNG, JPEG oder WebP erlaubt'}), 400

    filename = f'logo.{ext}'
    filepath = os.path.join('static', filename)
    with open(filepath, 'wb') as f:
        f.write(raw)

    # Logos in anderen Formaten entfernen, sonst bleibt z.B. logo.png
    # liegen, wenn jetzt logo.jpg aktiv ist.
    for alt_ext in LOGO_EXTS:
        if alt_ext == ext:
            continue
        alt_pfad = os.path.join('static', f'logo.{alt_ext}')
        if os.path.exists(alt_pfad):
            os.remove(alt_pfad)

    with _config_lock:
        config = load_config()
        config['logo'] = filename
        save_config(config)
    return jsonify({'status': 'ok', 'filename': filename})


@app.route('/delete_logo', methods=['POST'])
def delete_logo():
    """Logo loeschen."""
    with _config_lock:
        config = load_config()
        # Alle bekannten Logo-Varianten entfernen, nicht nur die
        # gerade in der Config eingetragene.
        for ext in LOGO_EXTS:
            logo_path = os.path.join('static', f'logo.{ext}')
            if os.path.exists(logo_path):
                os.remove(logo_path)
        config['logo'] = ''
        save_config(config)
    return jsonify({'status': 'ok'})


@app.route('/invoice')
def invoice():
    """Rechnungsseite mit Kundendaten und Vorschau."""
    config = load_config()
    calc = calculate(config)
    return render_template('invoice.html', config=config, calc=calc)


@app.route('/invoice/pdf', methods=['POST'])
def invoice_pdf():
    """Generiert eine PDF-Rechnung via fpdf2 und sendet sie zum Download."""
    data = request.form
    config = load_config()
    calc = calculate(config)
    stueckzahl = calc['stueckzahl']
    gesamt_netto = calc['gesamt_netto']
    gesamt_mwst = calc['gesamt_mwst']
    gesamt_brutto = calc['gesamt_endpreis']

    firmen_name = pdf_text(config.get('firmenName', ''))
    firmen_adresse = pdf_text(config.get('firmenAdresse', ''))
    telefon = pdf_text(config.get('telefon', ''))
    email = pdf_text(config.get('email', ''))
    paypal = pdf_text(config.get('paypal', ''))
    iban = pdf_text(config.get('iban', ''))
    bank_name = pdf_text(config.get('bankName', ''))

    steuernummer = pdf_text(config.get('steuernummer', ''))
    ust_id = pdf_text(config.get('ust_id', ''))

    kunde = pdf_text(data.get('kundenName', config.get('kundenName', '')))
    adresse = pdf_text(data.get('kundenAdresse', config.get('kundenAdresse', '')))
    rechnungsnummer = pdf_text(data.get('rechnungsnummer', config.get('rechnungsnummer', '')))
    datum = pdf_text(data.get('datum', config.get('datum', '')))
    # §14 UStG verlangt den Leistungszeitpunkt. Fehlt er, gilt das
    # Rechnungsdatum -- dann ist der uebliche Zusatz noetig.
    leistungsdatum = pdf_text(data.get('leistungsdatum',
                                       config.get('leistungsdatum', '')))
    projekt = pdf_text(config.get('projektName', ''))

    pdf = FPDF()
    pdf.set_margins(15, 10, 15)
    pdf.add_page()

    left = 15
    col_w = 45

    # Logo rechts oben
    logo_name = config.get('logo', '')
    logo_path = os.path.join('static', logo_name) if logo_name else ''
    if logo_name and os.path.exists(logo_path):
        pdf.image(logo_path, x=175, y=12, w=20)
        img_w, img_h = image_dimensions(logo_path)
        if img_w and img_h:
            logo_bottom = 12 + 20 * (img_h / img_w) + 3
        else:
            logo_bottom = 12 + 12 + 3
    else:
        pdf.set_font("Helvetica", "B", 18)
        pdf.set_xy(150, 12)
        pdf.set_text_color(6, 111, 209)
        pdf.cell(col_w, 7, "JET", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
        pdf.set_x(150)
        pdf.cell(col_w, 7, "Design", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
        pdf.set_text_color(0, 0, 0)
        logo_bottom = pdf.get_y()

    # Firmendaten rechts unter Logo (fester Abstand)
    right_x = 150
    pdf.set_font("Helvetica", "B", 9)
    pdf.set_xy(right_x, logo_bottom)
    pdf.cell(col_w, 4, firmen_name, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    pdf.set_font("Helvetica", "", 8)
    if firmen_adresse:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, firmen_adresse, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    if telefon:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, f"Tel: {telefon}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    if email:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, email, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    if paypal:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, f"PayPal: {paypal}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    if iban:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, iban, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    if bank_name:
        pdf.set_x(right_x)
        pdf.cell(col_w, 3.5, bank_name, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    # Bei Privatverkauf gehoeren Steuernummer/USt-IdNr. nicht auf den Beleg --
    # sie wuerden eine Unternehmereigenschaft behaupten, die nicht besteht.
    if calc.get('ist_unternehmer'):
        if steuernummer:
            pdf.set_x(right_x)
            pdf.cell(col_w, 3.5, f"St.-Nr.: {steuernummer}",
                     new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
        if ust_id:
            pdf.set_x(right_x)
            pdf.cell(col_w, 3.5, f"USt-IdNr.: {ust_id}",
                     new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    right_bottom = pdf.get_y()

    # --- Rechnungsdaten & Empfaenger (links, unterhalb der rechten Spalte) ---
    content_y = max(right_bottom + 15, 80)
    pdf.set_xy(left, content_y)
    pdf.set_font("Helvetica", "", 10)
    if rechnungsnummer:
        pdf.cell(80, 5, f"Rechnungsnr.: {rechnungsnummer}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_x(left)
    pdf.cell(80, 5, f"Rechnungsdatum: {datum}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    pdf.set_x(left)
    if leistungsdatum:
        pdf.cell(80, 5, f"Leistungsdatum: {leistungsdatum}",
                 new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    elif calc.get('ist_unternehmer'):
        # Nur Unternehmer brauchen den Leistungszeitpunkt (§14 UStG).
        pdf.cell(80, 5, pdf_text("Leistungsdatum entspricht dem Rechnungsdatum."),
                 new_x=XPos.LMARGIN, new_y=YPos.NEXT)

    pdf.set_xy(left, pdf.get_y() + 8)
    pdf.set_font("Helvetica", "B", 10)
    pdf.cell(80, 5, pdf_text("Rechnungsempfänger:"), new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    pdf.set_font("Helvetica", "", 10)
    pdf.set_x(left)
    pdf.cell(80, 5, kunde, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    if adresse:
        pdf.set_x(left)
        pdf.set_font("Helvetica", "", 9)
        for line in adresse.split('\n'):
            pdf.set_x(left)
            pdf.cell(80, 4, line.strip(), new_x=XPos.LMARGIN, new_y=YPos.NEXT)

    # --- Trennlinie ---
    pdf.set_draw_color(220, 220, 220)
    pdf.line(left, pdf.get_y() + 6, 195, pdf.get_y() + 6)
    pdf.set_draw_color(0, 0, 0)

    # --- Positionstabelle ---
    table_y = pdf.get_y() + 10
    pdf.set_xy(left, table_y)
    pdf.set_font("Helvetica", "B", 10)
    pdf.cell(85, 6, "Leistungsbeschreibung")
    pdf.cell(20, 6, "Menge", align='R')
    pdf.cell(30, 6, "Einzelpreis", align='R')
    pdf.cell(30, 6, "Gesamt", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')

    pdf.set_draw_color(200, 200, 200)
    pdf.line(left, pdf.get_y() + 0.5, 195, pdf.get_y() + 0.5)
    pdf.set_draw_color(0, 0, 0)

    pdf.set_font("Helvetica", "", 10)
    pdf.set_x(left)
    pos_label = f"3D-Druck: {projekt}" if projekt else "3D-Druck"
    pdf.cell(85, 7, pos_label)
    pdf.cell(20, 7, str(stueckzahl), align='R')
    pdf.cell(30, 7, f"{calc['verkaufspreis']:.2f} EUR", align='R')
    pdf.cell(30, 7, f"{gesamt_netto:.2f} EUR", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')

    pdf.line(left, pdf.get_y() + 0.5, 195, pdf.get_y() + 0.5)

    # --- Summen (linksbundig) ---
    pdf.set_x(left)
    pdf.ln(8)
    pdf.set_font("Helvetica", "", 10)
    pdf.cell(180, 6, f"Nettobetrag: {gesamt_netto:.2f} EUR", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    if calc.get('mwst_ausweisen'):
        satz = mwst_satz_label(calc['mwst_satz'])
        pdf.cell(180, 6, f"MwSt. ({satz}%): {gesamt_mwst:.2f} EUR",
                 new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    pdf.set_font("Helvetica", "B", 12)
    label_total = "GESAMTBETRAG (brutto):" if calc.get('mwst_ausweisen') else "GESAMTBETRAG:"
    pdf.cell(180, 8, f"{label_total} {gesamt_brutto:.2f} EUR", new_x=XPos.LMARGIN, new_y=YPos.NEXT)

    # --- Steuerhinweis je nach Regime ---
    steuer_hinweis = ''
    if calc.get('kleinunternehmer'):
        steuer_hinweis = KLEINUNTERNEHMER_HINWEIS
    elif calc.get('privat'):
        steuer_hinweis = PRIVAT_HINWEIS
    if steuer_hinweis:
        pdf.set_font("Helvetica", "", 9)
        pdf.ln(4)
        pdf.multi_cell(180, 4, pdf_text(steuer_hinweis))

    # --- Zahlungsbedingungen ---
    pdf.set_font("Helvetica", "", 9)
    pdf.ln(6)
    pdf.cell(180, 4, pdf_text("Zahlbar innerhalb von 14 Tagen ohne Abzug. Vielen Dank für Ihren Auftrag!"))

    return send_file(
        io.BytesIO(bytes(pdf.output())),
        mimetype='application/pdf',
        as_attachment=True,
        download_name='rechnung.pdf'
    )


@app.route('/export', methods=['POST'])
def export():
    """Exportiert die Kalkulation als TXT-Datei."""
    data = request.get_json()
    config = load_config()
    merged = {**config, **data}
    calc = calculate(merged)

    lines = [
        "3D-DRUCK KOSTENKALKULATION",
        "=" * 50 + "\n",
        f"Projekt: {data.get('projektName', '')}",
        f"Datum: {data.get('datum', '')}\n",
        "KOSTENAUFSTELLUNG:",
        f"Materialkosten:        {calc['materialkosten']:.2f} EUR",
        f"Stromkosten:           {calc['stromkosten']:.2f} EUR",
        f"Abschreibung:          {calc['abschreibung']:.2f} EUR",
        f"Arbeitskosten:         {calc['arbeitskosten']:.2f} EUR",
        f"Gesamtkosten:          {calc['gesamtkosten_netto']:.2f} EUR",
        f"Gewinn:                {calc['gewinn']:.2f} EUR",
        f"Verkaufspreis (netto): {calc['verkaufspreis']:.2f} EUR",
    ]
    satz = mwst_satz_label(calc['mwst_satz'])
    if calc.get('mwst_ausweisen'):
        lines.append(f"MwSt. ({satz}%):{'':<{max(0, 16 - len(satz))}}{calc['mwst']:.2f} EUR")
    lines.append(f"Preis pro Stuck:       {calc['gesamt_brutto']:.2f} EUR")
    lines.append("")
    lines.append(f"Stuckzahl:             {calc['stueckzahl']}")
    lines.append(f"Auftrag netto:         {calc['gesamt_netto']:.2f} EUR")
    if calc.get('mwst_ausweisen'):
        lines.append(f"MwSt. ({satz}%) gesamt: {calc['gesamt_mwst']:.2f} EUR")
    lines.append(f"GESAMTPREIS:           {calc['gesamt_endpreis']:.2f} EUR")
    if calc.get('kleinunternehmer'):
        lines.append("")
        lines.append(KLEINUNTERNEHMER_HINWEIS)
    elif calc.get('privat'):
        lines.append("")
        lines.append(PRIVAT_HINWEIS)
    text = '\n'.join(lines)

    return send_file(
        io.BytesIO(text.encode('utf-8')),
        mimetype='text/plain',
        as_attachment=True,
        download_name='kalkulation.txt'
    )


def _env_flag(name, default=False):
    """Liest ein Boolean aus einer Umgebungsvariable."""
    raw = os.environ.get(name)
    if raw is None:
        return default
    return raw.strip().lower() in ('1', 'true', 'yes', 'on')


if __name__ == '__main__':
    # Debug-Modus NIE als Default: der Werkzeug-Debugger erlaubt
    # Codeausfuehrung ueber das Netz. Lokal per FLASK_DEBUG=1 einschalten.
    debug = _env_flag('FLASK_DEBUG', False)
    host = os.environ.get('HOST', '0.0.0.0')
    port = int(os.environ.get('PORT', '5001'))
    if debug and host == '0.0.0.0':
        # Im Debug-Modus nur lokal lauschen.
        host = '127.0.0.1'
    app.run(host=host, port=port, debug=debug)