statements.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""
statement_import_cli.py — PDF-Kontoauszüge → CSV (Import + Review)
------------------------------------------------------------------
Pipeline:
  [Extraktion] -> [Normalisierung] -> [Validierung] -> [Export]

Ausgabe:
  - paypal_import.csv, paypal_review.csv
  - haspa_import.csv, haspa_review.csv

CSV-Format (Semikolon):
  Datum;Empfänger/Zahlungspflichtiger;Betrag in Euro;Verwendungszweck
Review-CSV enthält zusätzlich: ;Kommentar
"""
from __future__ import annotations

import argparse
import csv
import importlib
import os
import re
import subprocess
import sys
from dataclasses import dataclass, replace
from pathlib import Path
from typing import Iterable, List, Optional, Sequence, Tuple

# ---- Optionale Abhängigkeiten (PayPal-Tabellen via Camelot)
_CAMELOT_MODULE = None
_PYPDF_MODULE = None
_TRIED_PIP_PACKAGES: set[str] = set()


# --------------------- Dependency Helpers ---------------------
def install_python_package(package: str) -> bool:
    if package in _TRIED_PIP_PACKAGES:
        return False
    _TRIED_PIP_PACKAGES.add(package)
    try:
        print(f"[INFO] Installiere fehlendes Paket '{package}' …", file=sys.stderr)
        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
        return True
    except Exception as exc:  # pragma: no cover - nur im Fehlerfall relevant
        print(f"[WARN] Installation von '{package}' fehlgeschlagen: {exc}", file=sys.stderr)
        return False


def ensure_module(name: str, pip_name: Optional[str], auto_install: bool):
    try:
        return importlib.import_module(name)
    except ImportError:
        if not auto_install:
            return None
        pkg = pip_name or name
        if install_python_package(pkg):
            try:
                return importlib.import_module(name)
            except ImportError as exc:
                print(f"[WARN] Modul '{name}' trotz Installation nicht verfügbar: {exc}", file=sys.stderr)
    return None


def check_system_dependency(cmd: str) -> bool:
    """Prüft, ob ein System-Kommando verfügbar ist."""
    try:
        subprocess.run([cmd, "--version"], 
                      stdout=subprocess.PIPE, 
                      stderr=subprocess.PIPE,
                      check=False)
        return True
    except FileNotFoundError:
        return False


def detect_os() -> str:
    """Erkennt das Betriebssystem."""
    if sys.platform == "darwin":
        return "macos"
    elif sys.platform.startswith("linux"):
        # Versuche Distribution zu erkennen
        if os.path.isfile("/etc/os-release"):
            with open("/etc/os-release") as f:
                content = f.read().lower()
                if any(x in content for x in ["ubuntu", "debian", "mint", "pop"]):
                    return "debian"
                elif any(x in content for x in ["fedora", "rhel", "centos", "rocky", "alma"]):
                    return "redhat"
                elif any(x in content for x in ["arch", "manjaro", "endeavour"]):
                    return "arch"
        return "linux-unknown"
    else:
        return "unknown"


def get_install_command(os_type: str, package: str) -> Optional[str]:
    """Gibt den passenden Installationsbefehl für ein System-Paket zurück."""
    commands = {
        "debian": f"sudo apt update && sudo apt install -y {package}",
        "redhat": f"sudo dnf install -y {package}",
        "arch": f"sudo pacman -S --noconfirm {package}",
        "macos": f"brew install {package}",
    }
    return commands.get(os_type)


def check_and_install_system_dependencies(auto_install: bool = True) -> bool:
    """
    Prüft System-Abhängigkeiten (pdftotext) und bietet Installation an.
    Gibt True zurück wenn alle Dependencies verfügbar sind.
    """
    # pdftotext ist essentiell für PDF-Verarbeitung
    if check_system_dependency("pdftotext"):
        return True
    
    print("[WARN] 'pdftotext' nicht gefunden (Teil von poppler-utils)", file=sys.stderr)
    
    if not auto_install:
        print("[INFO] Bitte installiere poppler-utils manuell oder nutze ./install_dependencies.sh", file=sys.stderr)
        return False
    
    os_type = detect_os()
    
    # Für macOS: Homebrew-Check
    if os_type == "macos":
        if not check_system_dependency("brew"):
            print("[ERROR] Homebrew nicht gefunden. Bitte installiere erst Homebrew:", file=sys.stderr)
            print("  /bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"", file=sys.stderr)
            print("[INFO] Oder nutze: ./install_dependencies.sh", file=sys.stderr)
            return False
    
    # Installations-Hinweis
    package_map = {
        "debian": "poppler-utils",
        "redhat": "poppler-utils",
        "arch": "poppler",
        "macos": "poppler",
    }
    
    package = package_map.get(os_type, "poppler-utils")
    install_cmd = get_install_command(os_type, package)
    
    if install_cmd:
        print(f"[INFO] Empfohlene Installation für {os_type}:", file=sys.stderr)
        print(f"  {install_cmd}", file=sys.stderr)
        print("[INFO] Oder nutze das automatische Setup-Skript:", file=sys.stderr)
        print("  ./install_dependencies.sh", file=sys.stderr)
    else:
        print("[INFO] Bitte installiere poppler-utils für dein System", file=sys.stderr)
        print("[INFO] Oder nutze: ./install_dependencies.sh", file=sys.stderr)
    
    # Biete direkte Installation an (nur für nicht-interaktive Skripte sinnvoll)
    if os_type in ["debian", "redhat", "arch", "macos"]:
        print("[INFO] Automatische Installation wird versucht...", file=sys.stderr)
        try:
            if os_type == "macos":
                subprocess.check_call(["brew", "install", "poppler"])
            else:
                # Für Linux: Nutzer muss sudo rechte haben
                print("[WARN] Root-Rechte erforderlich. Bitte Installation manuell durchführen.", file=sys.stderr)
                return False
            
            # Erneut prüfen
            if check_system_dependency("pdftotext"):
                print("[OK] poppler-utils erfolgreich installiert", file=sys.stderr)
                return True
        except Exception as e:
            print(f"[ERROR] Automatische Installation fehlgeschlagen: {e}", file=sys.stderr)
    
    return False


# --------------------- Datenmodell ---------------------
@dataclass
class Tx:
    """
    Transaktion mit OCR-Metadaten für bessere Nachvollziehbarkeit.
    """
    datum: str
    empfaenger: str
    betrag: float
    verwendungszweck: str
    kommentar: str = ""
    
    # Optionale Metadaten (für erweiterte CSV-Ausgabe)
    confidence_datum: int = 100      # 0-100: Wie sicher ist das Datum?
    confidence_betrag: int = 100     # 0-100: Wie sicher ist der Betrag?
    confidence_empfaenger: int = 100 # 0-100: Wie sicher ist der Empfänger?
    ocr_raw_date: str = ""           # Original OCR-Datum (falls korrigiert)
    ocr_raw_amount: str = ""         # Original OCR-Betrag (falls korrigiert)

    def key(self) -> Tuple[str, str, float, str]:
        return (self.datum, self.empfaenger, self.betrag, self.verwendungszweck)

# --------------------- Regex/Utils ---------------------
_WS = re.compile(r"\s+")
_DATE_FULL = re.compile(r"(?<!\d)(\d{2})\.(\d{2})\.(\d{4})(?!\d)")
_DATE_DDMM  = re.compile(r"(?<!\d)(\d{2})\.(\d{2})(?![\d.])")
_MONEY = re.compile(r"[-−–—]?\s*(?:\d{1,3}(?:\.\d{3})*|\d+),\d{2}-?")
_DATE_START = re.compile(r"^[\\'\"`~_%\-\s]*\d{2}[.,]\d{2}(?:[.,]\d{4})?")
_NUM_GAP1 = re.compile(r"(\d)\s+([.,])")
_NUM_GAP2 = re.compile(r"([.,])\s+(\d)")
# VERBESSERUNG: Auch Beträge mit nur 1 Dezimalstelle oder OCR-Müll akzeptieren
_AMOUNT_TOKEN = re.compile(r"[+−–—-]?\s*(?:\d{1,3}(?:[.\s]\d{3})*|\d+),\s*\d{1,2}(?:\s*[!;:=A-Z]+)?")
_AMOUNT_SKIP = re.compile(r"(übertra\w*|ubertra\w*|kontostand|saldo|abrechnung|auszug|anfangsbestand)", re.I)
_EMPFAENGER_SKIP = re.compile(
    r"(wert:|iban|bic|konto|kontostand|übertrag|gläubiger-id|rn:|datum|tan|rechnung|ust-)",
    re.I,
)

# === GENERISCHE BUCHUNGSTYP-ERKENNUNG ===
# Statt fixer Listen: Fuzzy-Pattern mit OCR-Toleranz
def _make_fuzzy_pattern(base: str) -> re.Pattern[str]:
    """Erstellt OCR-tolerantes Regex-Pattern (o→0, l→1, etc.)"""
    # Häufige OCR-Verwechslungen
    ocr_map = {"o": "[o0q]", "l": "[l1i]", "i": "[i1l]", "s": "[s5]"}
    pattern = ""
    for char in base.lower():
        pattern += ocr_map.get(char, char)
    return re.compile(pattern, re.I)

_HASPA_TYPE_PATTERNS: List[Tuple[re.Pattern[str], str]] = [
    (_make_fuzzy_pattern("zahlungseingang"), "Zahlungseingang"),
    (_make_fuzzy_pattern("lastschrift"), "Lastschrift"),
    (_make_fuzzy_pattern("kartenzahlung"), "Kartenzahlung"),
    (re.compile(r"überw[.\s]*(?:[o0q]n[l1i]ine)?banking", re.I), "Überw. OnlineBanking"),
    (_make_fuzzy_pattern("überweisung"), "Überweisung"),
    (_make_fuzzy_pattern("einzahlung"), "Einzahlung"),
    (_make_fuzzy_pattern("auszahlung"), "Auszahlung"),
    (_make_fuzzy_pattern("entgeltabrechnung"), "Entgeltabrechnung"),
    (_make_fuzzy_pattern("gutschrift"), "Gutschrift"),
    (re.compile(r"[l1i][o0q]hn.?/?.?gehalt", re.I), "Lohn/Gehalt"),
    (_make_fuzzy_pattern("dauerauftrag"), "Dauerauftrag"),
]

_PAYPAL_TYPE_TOKENS = {
    "paypal", "express", "zahlung", "allgemeine", "gemeine", "handyzahlung",
    "bankgutschrift", "abbuchung", "rückbuchung", "rueckbuchung", "einbehaltung",
    "einbehalt", "gutschrift", "transaktion"
}
_PAYPAL_STOPWORDS = {
    "datum", "typ", "name", "e-mail-adresse", "transaktionscode", "brutto",
    "gebühr", "netto", "zahlung", "gmbh", "kg", "ag", "digital", "services",
    "technology", "payment", "gbr", "kg.", "ltd", "co.", "co", "llc", "de",
    "emailadresse", "händlerkonto-id", "transaktionsübersicht"
}
_PAYPAL_COMMON_TLDS = {
    "de", "com", "net", "org", "info", "io", "co", "uk", "co.uk", "fr", "es",
    "it", "ch", "at", "nl", "be", "pl", "us", "ca"
}


def normalize_paypal_line(line: str) -> str:
    if not line:
        return ""
    line = line.replace("\u00ad", "")
    line = line.replace("–", "-").replace("—", "-")
    line = line.replace("|", " ")
    line = line.replace("°", " ")
    # Entfernt nicht druckbare Zeichen (OCR-Artefakte)
    line = re.sub(r"[^\x20-\x7E]", " ", line)
    return norm_ws(line)


def sanitize_token(token: str) -> str:
    if not token:
        return ""
    cleaned = re.sub(r"[.,;:<>\"'()\\[\\]{}]", "", token)
    cleaned = cleaned.replace("/", "").replace("\\", "").replace("'", "").replace("`", "")
    return cleaned.strip()


def sanitize_email(raw: str) -> str:
    raw = raw.strip()
    if not raw:
        return ""
    raw = raw.strip("<>[]()\"' ")
    if "@" not in raw:
        return ""
    local, _, domain = raw.partition("@")
    local = re.sub(r"[^A-Za-z0-9._%+-]", "", local)
    domain = re.sub(r"[^A-Za-z0-9.-]", "", domain)
    domain = domain.lstrip(".")
    email = f"{local}@{domain}" if local and domain else ""
    return email.lower()


def extract_paypal_email(tokens: List[str]) -> Tuple[str, int]:
    def _domain_complete(dom: str) -> bool:
        stripped = dom.strip(".-")
        return bool(stripped) and "." in stripped

    for idx, tok in enumerate(tokens):
        if "@" not in tok:
            continue
        email = sanitize_email(tok)
        if not email:
            continue
        local, _, domain = email.partition("@")
        domain = domain.rstrip("-")
        
        # VERBESSERUNG: Wenn Domain nur ein Buchstabe ist (z.B. "@g"), versuche nächsten Token
        # Beispiel: "nataliya.ttusova@g mx.de" → sollte "gmx.de" werden
        if len(domain) == 1 and idx + 1 < len(tokens):
            next_tok = sanitize_token(tokens[idx + 1]).lower()
            # Wenn nächster Token wie Domain-Teil aussieht (mx, mail, etc.)
            if next_tok in {"mx", "mail", "web", "yahoo", "hotmail"} or next_tok.endswith(".de") or next_tok.endswith(".com"):
                if domain in {"g", "m", "w", "y", "h"}:
                    # Kombiniere: "g" + "mx" → "gmx"
                    domain = domain + next_tok
                    idx_offset = 2
                    # Prüfe ob danach noch ".de" oder ".com" kommt
                    if idx + idx_offset < len(tokens):
                        next2 = sanitize_token(tokens[idx + idx_offset]).lower()
                        if next2 in {"de", "com", "net", "org"}:
                            domain = domain + "." + next2
                    email = f"{local}@{domain}"
                    return (sanitize_email(email), idx)
        
        j = idx + 1
        limit = min(len(tokens), idx + 12)
        while not _domain_complete(domain) and j < limit:
            cand = sanitize_token(tokens[j])
            if not cand:
                j += 1
                continue
            if "@" in cand:
                break
            if _TXID17.search(cand.replace(" ", "")):
                j += 1
                continue
            if re.match(r"^-?\d+[.,]\d+$", cand):
                j += 1
                continue
            lower = cand.lower()
            lower_clean = lower.strip("-")
            if lower_clean in _PAYPAL_TYPE_TOKENS or lower_clean in {"auf", "konto", "bankkonto", "bankgutschrift"}:
                j += 1
                continue
            if lower_clean in {"gmbh", "kg", "ag"}:
                j += 1
                continue
            if "." in cand:
                fragment = cand
            elif lower_clean in _PAYPAL_COMMON_TLDS:
                fragment = "." + lower_clean if not lower_clean.startswith(".") else lower_clean
            else:
                j += 1
                continue
            if domain.endswith("-"):
                domain = domain[:-1] + fragment
            elif domain and fragment and not fragment.startswith(".") and not domain.endswith("."):
                domain = f"{domain}.{fragment}"
            else:
                domain += fragment
            if "." in fragment:
                break
            j += 1
        domain = domain.replace("..", ".").strip(".-")
        email = f"{local}@{domain}" if domain else email
        return (sanitize_email(email), idx)
    return ("", -1)


def extract_paypal_name(tokens: List[str], email_idx: int) -> str:
    if email_idx < 0:
        return ""
    name_parts: List[str] = []
    i = email_idx - 1
    while i > 0 and len(name_parts) < 4:
        cand = sanitize_token(tokens[i])
        if not cand:
            i -= 1
            continue
        if "@" in cand:
            break
        if re.match(r"^-?\d+[.,]\d+$", cand):
            break
        if _TXID17.search(cand.replace(" ", "")):
            break
        low_clean = cand.lower().strip("-")
        if low_clean in _PAYPAL_TYPE_TOKENS or low_clean in _PAYPAL_STOPWORDS:
            break
        if any(ch.isdigit() for ch in cand):
            break
        name_parts.append(cand)
        i -= 1
    name_parts.reverse()
    name = norm_ws(" ".join(name_parts))
    return name
_TXID17 = re.compile(r"\b[A-Z0-9]{17}\b")

def norm_ws(s: str) -> str:
    return _WS.sub(" ", (s or "").strip())

def clean_str(s: str) -> str:
    # Entfernt weiche Trennstriche & normalisiert WS
    return norm_ws(s).replace("\u00ad", "")

def to_float_de(num: str) -> float:
    s = num.strip()
    neg = s.endswith("-") or s.startswith(("-", "−", "–", "—"))
    s = s.replace("-", "").replace("−", "").replace("–", "").replace("—", "")
    try:
        val = float(s.replace(".", "").replace(",", "."))
    except ValueError:
        return 0.0
    return -val if neg else val

def parse_last_amount(text: str) -> Optional[float]:
    """Findet den letzten gültigen Betrag im Text, auch mit OCR-Müll."""
    candidate = None
    
    # Erst Standard-Regex (mit 2 Dezimalstellen)
    for m in _MONEY.finditer(text):
        token = m.group(0)
        value = to_float_de(token)
        if abs(value) > 1_000_000:
            continue
        candidate = token
    
    # VERBESSERUNG: Wenn nichts gefunden, suche nach Beträgen mit OCR-Müll
    # z.B. "26, !G =" sollte als "26,XX" interpretiert werden
    if candidate is None:
        # Suche nach Muster: Zahl + Komma + optionale Ziffer(n) + OCR-Müll
        pattern = re.compile(r'(\d{1,6})\s*,\s*(\d{0,2})\s*[!;:=A-Z]+')
        matches = list(pattern.finditer(text))
        if matches:
            m = matches[-1]  # letzter Match
            integer = m.group(1)
            frac = m.group(2) if m.group(2) else "00"
            # Wenn nur 1 Ziffer, zweite mit 0 auffüllen
            if len(frac) == 1:
                frac = frac + "0"
            elif len(frac) == 0:
                frac = "00"
            candidate = f"{integer},{frac}"
    
    return to_float_de(candidate) if candidate else None



def normalize_amount_line(line: str) -> str:
    """Schiebt Dezimaltrennzeichen dichter an die Ziffern (entfernt OCR-Zwischenräume)."""
    s = line
    for _ in range(3):
        new = _NUM_GAP1.sub(r"\1\2", s)
        new = _NUM_GAP2.sub(r"\1\2", new)
        if new == s:
            break
        s = new
    return s


def line_starts_with_date(line: str) -> bool:
    stripped = line.lstrip(" '\\\"`~_%\t-–—")
    if not stripped:
        return False
    probe = stripped.replace(",", ".", 2)
    m = re.match(r"(\d{2})\.(\d{2})(?:\.(\d{2,4}))?", probe)
    if not m:
        return False
    day = int(m.group(1))
    month = int(m.group(2))
    if not (1 <= day <= 31 and 1 <= month <= 12):
        return False
    return True

def eur(x: float) -> str:
    return f"{x:.2f}".replace(".", ",")

def fix_date_ddmmyyyy(dd: str, mm: str, yyyy: str, clamp_to: Optional[int] = None) -> str:
    """
    Intelligente OCR-Datumskorrektur mit Kontext-Validierung.
    Statt fixer Regeln: Plausibilitätsprüfung gegen Kalender.
    """
    day = int(dd)
    month = int(mm)
    year = int(yyyy)
    
    # === STRATEGIE 1: Tag-Korrektur (OCR verwechselt oft 1↔4, 1↔7, 3↔8) ===
    # Mapping häufiger OCR-Fehler bei Tagen
    ocr_day_corrections = {
        # 40er → 10er (4→1)
        40: 10, 41: 11, 42: 12, 43: 13, 44: 14, 45: 15, 46: 16, 47: 17, 48: 18, 49: 19,
        # 50er → 20er (5→2)
        50: 20, 51: 21, 52: 22, 53: 23, 54: 24, 55: 25, 56: 26, 57: 27, 58: 28, 59: 29,
        # 60er → 20er (6→2)  
        60: 20, 61: 21, 62: 22, 63: 23, 64: 24, 65: 25, 66: 26, 67: 27, 68: 28, 69: 29,
        # 70er → 10er (7→1)
        70: 10, 71: 11, 72: 12, 73: 13, 74: 14, 75: 15, 76: 16, 77: 17, 78: 18, 79: 19,
        # 80er → 20er (8→2)
        80: 20, 81: 21, 82: 22, 83: 23, 84: 24, 85: 25, 86: 26, 87: 27, 88: 28, 89: 29,
        # 90er → 20er (9→2)
        90: 20, 91: 21, 92: 22, 93: 23, 94: 24, 95: 25, 96: 26, 97: 27, 98: 28, 99: 29,
    }
    
    if day in ocr_day_corrections:
        day = ocr_day_corrections[day]
    elif day > 31:
        # Generische Fallback-Logik
        day = day % 31
        if day == 0:
            day = 1
    
    # === STRATEGIE 2: Monat-Validierung ===
    month = max(1, min(12, month))
    
    # === STRATEGIE 3: Kalender-Validierung (Schaltjahre, Monatslängen) ===
    # Max Tage pro Monat
    days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    
    # Schaltjahr-Check
    is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
    if is_leap and month == 2:
        max_day = 29
    else:
        max_day = days_in_month[month - 1]
    
    # Tag auf gültigen Bereich begrenzen
    day = min(day, max_day)
    day = max(1, day)
    
    # === STRATEGIE 4: Jahr-Clamping (gegen Ausreißer) ===
    if clamp_to is not None and (year < clamp_to - 1 or year > clamp_to + 1):
        year = clamp_to
    
    return f"{day:02d}.{month:02d}.{year:04d}"

def fix_date_any(s: str, default_year: Optional[int]) -> Optional[str]:
    m = _DATE_FULL.search(s)
    if m:
        return fix_date_ddmmyyyy(m.group(1), m.group(2), m.group(3), clamp_to=default_year)
    m2 = _DATE_DDMM.search(s)
    if m2 and default_year:
        return fix_date_ddmmyyyy(m2.group(1), m2.group(2), str(default_year))
    return None


def extract_date_from_block(block: Sequence[str], default_year: Optional[int]) -> str:
    for candidate in block[:3]:
        date = fix_date_any(candidate.replace(",", "."), default_year)
        if date:
            return date
    joined = "\n".join(block)
    return fix_date_any(joined.replace(",", "."), default_year) or ""


def parse_amount_token(token: str) -> Optional[float]:
    raw = token.strip()
    if not raw:
        return None
    neg = False
    if raw.endswith(("-", "−", "–", "—")):
        neg = True
        raw = raw[:-1]
    if raw.startswith(("−", "–", "—", "-")):
        neg = True
        raw = raw[1:]
    raw = raw.lstrip("+")
    raw = raw.replace(" ", "")
    raw = raw.replace("’", "").replace("`", "")
    filtered = re.sub(r"[^0-9,\.]", "", raw)
    if not filtered:
        return None
    if filtered.count(",") > 1 and filtered.count(".") == 0:
        return None
    if "," in filtered:
        parts = filtered.split(",")
        if len(parts) > 2:
            return None
    elif "." in filtered:
        parts = filtered.split(".")
        if len(parts) > 2:
            return None
    else:
        return None
    if len(parts) < 2:
        return None
    integer_raw = "".join(parts[:-1]) or "0"
    frac_raw = parts[-1]
    integer_digits = re.sub(r"\D", "", integer_raw)
    frac_digits = re.sub(r"\D", "", frac_raw)
    if not frac_digits:
        return None
    # Wenn nur 1 Dezimalstelle, mit 0 auffüllen
    if len(frac_digits) == 1:
        frac_digits = frac_digits + "0"
    elif len(frac_digits) > 2:
        frac_digits = frac_digits[:2]
    if not integer_digits:
        integer_digits = "0"
    if len(integer_digits) > 7:
        return None
    value = float(integer_digits + "." + frac_digits)
    return -value if neg else value


def extract_amount_candidates(block: Sequence[str]) -> List[float]:
    """
    Extrahiert ALLE Betrags-Kandidaten aus einem Block mit SCORING.
    Gibt sortierte Liste zurück (beste zuerst).
    """
    candidates: List[Tuple[float, int, int]] = []  # (betrag, score, position)
    skip_following = 0
    
    for line_idx, line in enumerate(block):
        if _AMOUNT_SKIP.search(line):
            skip_following = 2
            continue
        if skip_following:
            skip_following -= 1
            continue
        
        norm_line = normalize_amount_line(line)
        for token in _AMOUNT_TOKEN.findall(norm_line):
            amount = parse_amount_token(token)
            if amount is None:
                continue
            
            # === SCORING-SYSTEM ===
            score = 100  # Basis-Score
            
            # 1. Position: Letzte Zeilen bevorzugen (+30 für letzte 3 Zeilen)
            if line_idx >= len(block) - 3:
                score += 30
            
            # 2. Plausibilität: Typische Betragsgrößen bevorzugen
            abs_amount = abs(amount)
            if 0.01 <= abs_amount <= 10000:
                score += 20
            elif abs_amount > 1_000_000:
                score -= 50  # Sehr unwahrscheinlich
            
            # 3. Format-Qualität: Mit 2 Dezimalstellen bevorzugen
            if re.search(r',\d{2}(?:[^0-9]|$)', token):
                score += 15
            
            # 4. Kontext: Betrag am Ende der Zeile bevorzugen
            if line.strip().endswith(token.strip()) or line.strip().endswith(token.strip() + "-"):
                score += 10
            
            # 5. Minuspunkte für OCR-Müll in der Nähe
            if re.search(r'[!@#$%^&*]', token):
                score -= 10
            
            candidates.append((amount, score, line_idx))
    
    # Sortiere nach Score (höchster zuerst)
    candidates.sort(key=lambda x: x[1], reverse=True)
    
    # Gebe nur die Beträge zurück (ohne Score)
    return [amount for amount, score, pos in candidates]


def select_haspa_amount(block: Sequence[str]) -> Optional[float]:
    """Wählt den besten Betrags-Kandidaten mit Scoring-System."""
    candidates = extract_amount_candidates(block)
    if candidates:
        return candidates[0]  # Bester Kandidat
    
    # Fallback: Alte Logik
    joined = "\n".join(block)
    amount = parse_last_amount(joined)
    return amount


def should_skip_empfaenger_line(line: str) -> bool:
    """
    Filtert Header/Footer/Tabellen-Müll aus OCR-Erkennung.
    
    Best Practice: Tesseract hat Schwierigkeiten mit Tabellen-Layout.
    → Aggressive Filterung von technischen Zeilen, Timestamps, Codes.
    """
    if not line:
        return True
    if _EMPFAENGER_SKIP.search(line):
        return True
    
    # Reine Zahlen/Zeichen-Zeilen (Tabellen-Separatoren)
    if re.fullmatch(r"[\d\s,.\-+/:%]+", line):
        return True
    
    # OCR-Müll mit vielen gleichen Zeichen (z.B. "XXXML99XXX", "||||", "----")
    if re.search(r"(X{3,}|[|]{3,}|[-]{5,}|[_]{5,})", line):
        return True
    
    # Timestamp-Zeilen (z.B. "2020-01-11718:07 Debitk.8 2022-12")
    if re.search(r"\d{4}-\d{2}-\d{2}[T\d]", line):
        return True
    
    # ISO-Timestamps mit Uhrzeit
    if re.search(r"\d{2}:\d{2}:\d{2}", line):
        return True
    
    # Technische Codes (z.B. "Debitk.8", "SEPA-ELV", "2022-12")
    if re.search(r"(Debitk\.|SEPA-|Kreditk\.|BIC:|IBAN:|\d{4}-\d{2}$)", line):
        return True
    
    # Tabellen-Header (häufig in PayPal-PDFs)
    if re.search(r"(Datum\s+Beschreibung|Name\s+Betrag|Transaktionscode)", line, re.IGNORECASE):
        return True
    
    # Seitenzahlen und Footer
    if re.search(r"(Seite\s+\d+|Page\s+\d+|\d+\s+von\s+\d+)", line, re.IGNORECASE):
        return True
    
    # Zu wenig Buchstaben = wahrscheinlich kein Empfänger-Name
    alpha = re.sub(r"[^A-Za-zÄÖÜäöüß]", "", line)
    return len(alpha) < 2


def should_merge_name_line(line: str) -> bool:
    if not line or should_skip_empfaenger_line(line):
        return False
    if re.search(r"\d", line):
        return False
    return len(line) <= 6


def format_name(name: str) -> str:
    name = norm_ws(name)
    name = re.sub(r"\s+,", ",", name)
    name = re.sub(r"[ ,;/]+$", "", name)
    
    # Unvollständige Namen bereinigen (z.B. "LUKU Roh" → wahrscheinlich abgeschnitten)
    # Wenn Name zu kurz/kryptisch, als "Unbekannt" markieren
    alpha_only = re.sub(r"[^A-Za-zÄÖÜäöüß]", "", name)
    if len(alpha_only) < 3:
        return "Unbekannt"
    
    return name.strip()


def resolve_empfaenger(block: Sequence[str], start_idx: int) -> str:
    for idx in range(start_idx, min(len(block), start_idx + 8)):
        candidate = block[idx]
        if should_skip_empfaenger_line(candidate):
            continue
        name = candidate
        merge_idx = idx + 1
        while merge_idx < len(block) and should_merge_name_line(block[merge_idx]):
            name = f"{name} {block[merge_idx]}"
            merge_idx += 1
        return format_name(name)
    return "Unbekannt"
def parse_date_for_sort(d: str) -> Tuple[int,int,int]:
    m = _DATE_FULL.fullmatch(d.strip())
    if not m:
        return (0,0,0)
    return (int(m.group(3)), int(m.group(2)), int(m.group(1)))

def sort_txs(rows: List[Tx]) -> List[Tx]:
    return sorted(rows, key=lambda t: (parse_date_for_sort(t.datum), t.empfaenger, t.verwendungszweck, t.betrag))

def dedupe(rows: List[Tx]) -> List[Tx]:
    seen = set()
    out: List[Tx] = []
    for tx in rows:
        k = tx.key()
        if k in seen:
            continue
        seen.add(k)
        out.append(tx)
    return out

def autofix_email_domain(email: str) -> str:
    """
    GENERISCHE Email-Domain-Korrektur mit Pattern-Matching statt Hardcoding.
    Erkennt häufige Provider automatisch und korrigiert OCR-Fehler.
    """
    if not email or "@" not in email:
        return email
    local, dom = email.split("@", 1)
    dom = dom.lower().replace(" ", "").replace("..", ".")
    
    # === STRATEGIE 1: Bekannte Provider mit Levenshtein-ähnlicher Logik ===
    # Definiere Kern-Provider-Namen (ohne TLD)
    known_providers = {
        "gmail": ["gmail", "gmai", "gmall", "gmalle", "g.mail", "gma.il", "gmaile"],
        "gmx": ["gmx", "g.mx", "gmxde"],
        "yahoo": ["yahoo", "yaho0", "ya.hoo", "yaoo", "yaahoo"],
        "hotmail": ["hotmail", "hotm.ail", "hotmai"],
        "web": ["web"],
        "googlemail": ["googlemail", "googl.email"],
    }
    
    # Provider-TLD-Mapping
    provider_tlds = {
        "gmail": "com",
        "googlemail": "com",
        "yahoo": "com",
        "hotmail": "com",
        "gmx": "de",
        "web": "de",
    }
    
    # Extrahiere Domain-Basis (ohne TLD)
    domain_parts = dom.split(".")
    domain_base = domain_parts[0] if domain_parts else dom
    
    # Versuche Provider zu matchen
    matched_provider = None
    for provider, variants in known_providers.items():
        for variant in variants:
            # Exakter Match oder sehr ähnlich
            if domain_base == variant or domain_base.replace(".", "") == variant.replace(".", ""):
                matched_provider = provider
                break
            # Fuzzy-Match: mindestens 70% der Buchstaben stimmen überein
            if len(variant) >= 3 and len(domain_base) >= 3:
                common = sum(1 for a, b in zip(domain_base, variant) if a == b)
                if common / max(len(domain_base), len(variant)) >= 0.7:
                    matched_provider = provider
                    break
        if matched_provider:
            break
    
    if matched_provider:
        tld = provider_tlds.get(matched_provider, "com")
        dom = f"{matched_provider}.{tld}"
    else:
        # === STRATEGIE 2: OCR-Fehler-Patterns ===
        # Häufige Einzelfehler korrigieren
        dom = dom.replace(".dee", ".de").replace(".co", ".com")
        dom = dom.replace("media-saturn.com", "mediasaturn.com")
        
        # Wenn Domain nur Einzelbuchstabe: Rate häufigsten Provider
        if len(dom) == 1:
            provider_guess = {"g": "gmail.com", "m": "gmx.de", "y": "yahoo.com", 
                            "h": "hotmail.com", "w": "web.de"}.get(dom)
            if provider_guess:
                dom = provider_guess
        
        # Wenn keine TLD vorhanden und bekannter Name: Ergänze .com/.de
        if "." not in dom:
            if dom in {"gmail", "yahoo", "hotmail", "googlemail"}:
                dom = f"{dom}.com"
            elif dom in {"gmx", "web"}:
                dom = f"{dom}.de"
    
    return f"{local}@{dom}"

def shutil_which(name: str) -> Optional[str]:
    for p in os.environ.get("PATH", "").split(os.pathsep):
        cand = Path(p) / name
        if cand.exists() and os.access(cand, os.X_OK):
            return str(cand)
    return None

# --------------------- CSV Writer ----------------------
def write_csv(rows: Sequence[Tx], out_path: Path, encoding: str, review: bool, extended: bool = False):
    """
    CSV-Export mit optionalen erweiterten Metadaten.
    
    Args:
        rows: Transaktionen
        out_path: Ausgabepfad
        encoding: Zeichensatz
        review: Review-CSV (mit Kommentar-Spalte)?
        extended: Erweiterte Metadaten ausgeben? (Confidence-Scores, OCR-Rohdaten)
    """
    out_path.parent.mkdir(parents=True, exist_ok=True)
    headers = ["Datum", "Empfänger/Zahlungspflichtiger", "Betrag in Euro", "Verwendungszweck"]
    
    if review:
        headers += ["Kommentar"]
    
    if extended:
        headers += ["Confidence Datum", "Confidence Betrag", "Confidence Empfänger", 
                   "OCR Raw Datum", "OCR Raw Betrag"]
    
    with open(out_path, "w", encoding=encoding, newline="") as f:
        w = csv.writer(f, delimiter=";")
        w.writerow(headers)
        for tx in rows:
            base = [tx.datum, tx.empfaenger, eur(tx.betrag), tx.verwendungszweck]
            
            if review:
                base.append(tx.kommentar)
            
            if extended:
                base.extend([
                    str(tx.confidence_datum),
                    str(tx.confidence_betrag),
                    str(tx.confidence_empfaenger),
                    tx.ocr_raw_date or "",
                    tx.ocr_raw_amount or ""
                ])
            
            w.writerow(base)

# --------------------- Common Validation ----------------------
def calculate_ocr_quality_score(text: str) -> int:
    """
    Bewertet die OCR-Qualität eines Textes (0-100).
    Basierend auf Tesseract Best Practices: Weniger OCR-Artefakte = höhere Qualität.
    
    Indikatoren für schlechte OCR-Qualität:
    - Viele Sonderzeichen (!?@#$%^&*~)
    - Viele einzelne Großbuchstaben (z.B. "D E U T S C H E B A N K")
    - Wiederholte gleiche Zeichen (|||, ---, XXX)
    - Ungewöhnlich viele Zahlen-Buchstaben-Mischungen (O→0, I→1 Fehler)
    """
    if not text:
        return 0
    
    score = 100
    length = len(text)
    
    # Sonderzeichen-Anteil (OCR-Müll wie !?@#$%^&*)
    special_chars = len(re.findall(r"[!?@#$%^&*~°|]", text))
    if length > 0:
        special_ratio = special_chars / length
        score -= int(special_ratio * 100)  # Max -100
    
    # Einzelne Großbuchstaben mit Leerzeichen (typisch für schlechte OCR)
    single_caps = len(re.findall(r"\b[A-Z]\b", text))
    if single_caps > 3:
        score -= min(20, single_caps * 2)
    
    # Wiederholte Zeichen (|||, ---, XXX, etc.)
    repeated_chars = len(re.findall(r"(.)\1{2,}", text))
    score -= min(15, repeated_chars * 5)
    
    # Zahlen-Buchstaben-Chaos (z.B. "0CT0BER" statt "OCTOBER")
    num_letter_mix = len(re.findall(r"\d[A-Za-z]|[A-Za-z]\d", text))
    if num_letter_mix > 2:
        score -= min(10, num_letter_mix * 2)
    
    return max(0, min(100, score))


def needs_review_common(tx: Tx) -> List[str]:
    """
    Gemeinsame Validierung mit adaptiver Confidence-Score-Berechnung.
    Aktualisiert automatisch die Confidence-Werte basierend auf:
    - OCR-Korrekturen (fix_date, autofix_email, etc.)
    - Datenqualität (Vollständigkeit, Format)
    - OCR-Qualitätsindikatoren (Sonderzeichen, Müll)
    """
    reasons: List[str] = []
    
    # === Datum-Validierung mit Confidence ===
    if not _DATE_FULL.fullmatch(tx.datum.strip()):
        reasons.append("Datum unvollständig/fehlerhaft")
        tx.confidence_datum = 0
    elif tx.ocr_raw_date and tx.ocr_raw_date != tx.datum:
        # Datum wurde korrigiert → moderate Confidence
        tx.confidence_datum = 70
    else:
        # Datum sieht gut aus
        tx.confidence_datum = 100
    
    # === Betrag-Validierung mit Confidence ===
    if abs(tx.betrag) < 0.005:
        reasons.append("Betrag nicht erkannt/0,00")
        tx.confidence_betrag = 0
    elif tx.ocr_raw_amount:
        # OCR-Müll gefiltert → gute Confidence
        tx.confidence_betrag = 80
    else:
        # Betrag sauber erkannt
        tx.confidence_betrag = 100
    
    # === Empfänger-Validierung mit adaptiver Confidence ===
    if not tx.empfaenger or tx.empfaenger.strip().lower() in {"", "unbekannt"}:
        reasons.append("Empfänger unklar")
        tx.confidence_empfaenger = 0
    elif len(tx.empfaenger) < 5:
        # Sehr kurzer Name → niedrige Confidence
        tx.confidence_empfaenger = 50
    else:
        # Bewerte OCR-Qualität des Empfänger-Namens
        ocr_quality = calculate_ocr_quality_score(tx.empfaenger)
        tx.confidence_empfaenger = ocr_quality
        
        # Wenn OCR-Qualität schlecht (<60), zur Review markieren
        if ocr_quality < 60:
            reasons.append(f"Empfänger enthält OCR-Artefakte (Qualität: {ocr_quality}%)")
    
    # Verwendungszweck-Validierung
    if not tx.verwendungszweck or len(tx.verwendungszweck.strip()) < 3:
        reasons.append("Verwendungszweck unklar")
    
    return reasons

# --------------------- PDF Reader Helpers ---------------------
def get_pypdf(auto_install: bool):
    global _PYPDF_MODULE
    if _PYPDF_MODULE is not None:
        return _PYPDF_MODULE
    _PYPDF_MODULE = ensure_module("PyPDF2", "PyPDF2", auto_install)
    return _PYPDF_MODULE


def extract_with_pypdf(pdf: Path, auto_install: bool) -> Optional[str]:
    mod = get_pypdf(auto_install)
    if mod is None:
        return None
    try:
        with pdf.open("rb") as fh:
            reader = mod.PdfReader(fh)
            parts = []
            for page in reader.pages:
                try:
                    text = page.extract_text() or ""
                except Exception:
                    text = ""
                parts.append(text)
    except Exception as exc:
        print(f"[WARN] Konnte Text nicht via PyPDF2 extrahieren: {exc}", file=sys.stderr)
        return None
    return "\n".join(parts)


def ensure_pdf_text_backend(auto_install: bool):
    if shutil_which("pdftotext"):
        return
    if get_pypdf(auto_install) is not None:
        return
    sys.exit("Fehlt: 'pdftotext' (poppler-utils) und PyPDF2 konnte nicht importiert werden. Bitte installieren und erneut versuchen.")


def run_pdftotext_layout(pdf: Path, auto_install: bool) -> str:
    # pdftotext -layout -nopgbrk pdf -  (schreibt nach stdout)
    if shutil_which("pdftotext"):
        cmd = ["pdftotext", "-layout", "-nopgbrk", str(pdf), "-"]
        try:
            out = subprocess.check_output(cmd, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            # Detaillierte Fehleranalyse
            stderr_msg = e.stderr.decode("utf-8", errors="ignore") if e.stderr else ""
            print(f"[ERROR] pdftotext konnte '{pdf}' nicht verarbeiten:", file=sys.stderr)
            print(f"  Fehlercode: {e.returncode}", file=sys.stderr)
            if stderr_msg:
                print(f"  Details: {stderr_msg.strip()}", file=sys.stderr)
            
            # Häufige Ursachen
            if not pdf.exists():
                print(f"  → Datei nicht gefunden: {pdf}", file=sys.stderr)
                sys.exit(1)
            elif pdf.stat().st_size == 0:
                print(f"  → Datei ist leer", file=sys.stderr)
                sys.exit(1)
            elif "encrypted" in stderr_msg.lower() or "password" in stderr_msg.lower():
                print(f"  → PDF ist passwortgeschützt", file=sys.stderr)
                print(f"  → Bitte Passwort entfernen oder PDF entsperren", file=sys.stderr)
                sys.exit(1)
            elif "damaged" in stderr_msg.lower() or "corrupt" in stderr_msg.lower():
                print(f"  → PDF scheint beschädigt zu sein", file=sys.stderr)
                print(f"  → Versuche das PDF neu zu speichern oder zu reparieren", file=sys.stderr)
                sys.exit(1)
            else:
                # Fallback versuchen
                print(f"  → Versuche PyPDF2-Fallback...", file=sys.stderr)
                fallback = extract_with_pypdf(pdf, auto_install)
                if fallback is not None:
                    print("[OK] PyPDF2-Fallback erfolgreich (Layout kann abweichen).", file=sys.stderr)
                    return fallback
                
                print(f"  → Auch PyPDF2-Fallback fehlgeschlagen", file=sys.stderr)
                print(f"  → Mögliche Lösungen:", file=sys.stderr)
                print(f"    1. PDF mit Preview/Acrobat öffnen und neu speichern", file=sys.stderr)
                print(f"    2. PDF mit 'gs' (Ghostscript) reparieren:", file=sys.stderr)
                print(f"       gs -o repaired.pdf -sDEVICE=pdfwrite {pdf}", file=sys.stderr)
                print(f"    3. Wenn gescannt: OCR durchführen mit ocrmypdf", file=sys.stderr)
                sys.exit(1)
        return out.decode("utf-8", errors="ignore")
    
    # pdftotext nicht gefunden
    fallback = extract_with_pypdf(pdf, auto_install)
    if fallback is not None:
        print("[WARN] pdftotext fehlt - verwende PyPDF2-Fallback (Layout kann abweichen).", file=sys.stderr)
        return fallback
    sys.exit("Fehlt: 'pdftotext' (poppler-utils). Bitte installieren (siehe Manpage) und erneut versuchen.")


def text_seems_empty(raw: str) -> bool:
    if not raw or not raw.strip():
        return True
    if not (_DATE_FULL.search(raw) or _DATE_DDMM.search(raw)):
        return True
    if not _MONEY.search(raw):
        return True
    return False


def check_ocrmypdf_available() -> bool:
    """Prüft ob ocrmypdf verfügbar ist."""
    try:
        subprocess.run(["ocrmypdf", "--version"], 
                      stdout=subprocess.PIPE, 
                      stderr=subprocess.PIPE,
                      check=False)
        return True
    except FileNotFoundError:
        return False


def run_ocr_on_pdf(pdf_path: Path, auto_install: bool) -> Optional[Path]:
    """
    Führt OCR auf einem PDF durch, falls es ein Scan ohne Text ist.
    Gibt den Pfad zum OCR-PDF zurück oder None bei Fehler.
    
    Best Practices implementiert:
    - Mindestens 300 DPI für beste Erkennung
    - Deskew (Schräglage korrigieren)
    - Rotate-pages (Seitenausrichtung korrigieren)
    - Clean-final (Bildqualität verbessern)
    - Remove-background (Hintergrund entfernen für besseren Kontrast)
    - Optimize (Dateigröße reduzieren)
    """
    # Prüfe ob ocrmypdf verfügbar ist
    if not check_ocrmypdf_available():
        if auto_install:
            print("[INFO] ocrmypdf nicht gefunden - installiere es...", file=sys.stderr)
            os_type = detect_os()
            if os_type == "macos":
                try:
                    print("[INFO] Installiere ocrmypdf via Homebrew...", file=sys.stderr)
                    subprocess.check_call(["brew", "install", "ocrmypdf"], 
                                        stdout=subprocess.DEVNULL)
                    print("[OK] ocrmypdf erfolgreich installiert", file=sys.stderr)
                except Exception as e:
                    print(f"[ERROR] ocrmypdf-Installation fehlgeschlagen: {e}", file=sys.stderr)
                    print("[INFO] Bitte manuell installieren: brew install ocrmypdf", file=sys.stderr)
                    return None
            else:
                print("[INFO] Bitte ocrmypdf manuell installieren:", file=sys.stderr)
                print("  Linux: sudo apt install ocrmypdf tesseract-ocr-deu", file=sys.stderr)
                print("  macOS: brew install ocrmypdf", file=sys.stderr)
                return None
        else:
            return None
    
    # OCR durchführen
    ocr_path = pdf_path.parent / f"{pdf_path.stem}-ocr.pdf"
    print(f"[INFO] Führe OCR durch: {pdf_path} → {ocr_path}", file=sys.stderr)
    print("[INFO] Das kann 10-30 Sekunden dauern...", file=sys.stderr)
    
    try:
        # Prüfe dass Tesseract und das deutsche Sprachpaket vorhanden sind
        try:
            langs_proc = subprocess.run(["tesseract", "--list-langs"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
            langs_out = langs_proc.stdout.decode("utf-8", errors="ignore")
            if "deu" not in langs_out.split():
                print("[WARN] Tesseract 'deu' Sprachpaket nicht gefunden.", file=sys.stderr)
                print("[INFO] Versuche automatische Installation oder folge den Anweisungen in README.", file=sys.stderr)
                # Auf macOS versuchen wir brew zu verwenden
                if detect_os() == "macos":
                    print("[INFO] macOS erkannt: versuche 'brew install tesseract-lang'...", file=sys.stderr)
                    try:
                        subprocess.check_call(["brew", "install", "tesseract-lang"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                    except Exception:
                        print("[WARN] Automatische Installation von tessdata fehlgeschlagen. Bitte manuell: brew install tesseract-lang", file=sys.stderr)
                else:
                    print("[INFO] Linux: bitte Paket 'tesseract-ocr-deu' / 'tesseract-langpack-deu' installieren (z.B. apt/dnf/pacman)", file=sys.stderr)

        except FileNotFoundError:
            print("[ERROR] Tesseract nicht gefunden (tesseract --version fehlgeschlagen). Bitte installieren.", file=sys.stderr)
            return None

        # Baue ocrmypdf Kommando
        cmd = [
            "ocrmypdf",
            "--language", "deu",
            "--deskew",
            "--rotate-pages",
            "--clean-final",
            "--remove-background",
            "--oversample", "300",
            "--skip-text",
            "--optimize", "1",
            "--pdfa-image-compression", "lossless",
            str(pdf_path),
            str(ocr_path)
        ]

        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
        if proc.returncode != 0:
            stderr = proc.stderr.decode("utf-8", errors="ignore")
            raise subprocess.CalledProcessError(proc.returncode, cmd, output=proc.stdout, stderr=proc.stderr)
        print(f"[OK] OCR erfolgreich: {ocr_path}", file=sys.stderr)
        return ocr_path
    except subprocess.CalledProcessError as e:
        stderr = e.stderr.decode("utf-8", errors="ignore") if e.stderr else ""
        if "already has text" in stderr.lower():
            print("[INFO] PDF enthält bereits Text (kein OCR nötig)", file=sys.stderr)
            return pdf_path  # Original-PDF verwenden
        # Spezifische Hinweise
        if "is encrypted" in stderr.lower() or "password" in stderr.lower():
            print("[ERROR] PDF scheint passwortgeschützt zu sein. Bitte Passwort entfernen (qpdf --decrypt).", file=sys.stderr)
        elif "not installed" in stderr.lower() and "deu" in stderr.lower():
            print("[ERROR] Deutsches Tesseract Sprachpaket fehlt. Bitte installieren: apt install tesseract-ocr-deu", file=sys.stderr)
        else:
            print(f"[ERROR] OCR fehlgeschlagen: {e}", file=sys.stderr)
            if stderr:
                print(f"  Details: {stderr.strip()}", file=sys.stderr)
            print("[INFO] Versuche PDF zu reparieren oder manuell OCR auszuführen:", file=sys.stderr)
            print("  gs -o repaired.pdf -sDEVICE=pdfwrite haspa.pdf", file=sys.stderr)
            print("  ocrmypdf --language deu haspa.pdf haspa-ocr.pdf", file=sys.stderr)
        return None
    except FileNotFoundError:
        print("[ERROR] ocrmypdf nicht gefunden", file=sys.stderr)
        return None


def warn_no_transactions(label: str, pdf_path: Optional[Path] = None, auto_install: bool = True):
    """
    Warnt wenn keine Transaktionen erkannt wurden und bietet automatisches OCR an.
    """
    print(
        f"[WARN] {label}: keine erkennbaren Buchungen im extrahierten Text.",
        file=sys.stderr,
    )
    
    if pdf_path:
        print(f"[INFO] Vermutlich ist '{pdf_path}' ein Scan ohne Text.", file=sys.stderr)
        print(f"[INFO] Versuche automatisches OCR...", file=sys.stderr)
        
        ocr_pdf = run_ocr_on_pdf(pdf_path, auto_install)
        if ocr_pdf and ocr_pdf != pdf_path:
            print(f"[OK] OCR-PDF erstellt: {ocr_pdf}", file=sys.stderr)
            print(f"[INFO] Bitte erneut ausführen mit: --haspa-pdf {ocr_pdf}", file=sys.stderr)
        elif not ocr_pdf:
            print("[INFO] Manuelle OCR-Durchführung:", file=sys.stderr)
            print("  brew install ocrmypdf  # Falls noch nicht installiert", file=sys.stderr)
            print(f"  ocrmypdf --language deu {pdf_path} {pdf_path.stem}-ocr.pdf", file=sys.stderr)
            print(f"  python3 statements.py --haspa-pdf {pdf_path.stem}-ocr.pdf --year 2020", file=sys.stderr)

# --------------------- PayPal -------------------------
def get_camelot(auto_install: bool):
    global _CAMELOT_MODULE
    if _CAMELOT_MODULE is not None:
        return _CAMELOT_MODULE
    _CAMELOT_MODULE = ensure_module("camelot", "camelot-py[cv]", auto_install)
    return _CAMELOT_MODULE


def paypal_from_camelot(pdf_path: Path, auto_install: bool) -> List[Tx]:
    camelot = get_camelot(auto_install)
    if camelot is None:
        return []
    tables = []
    try:
        tables = camelot.read_pdf(str(pdf_path), flavor="lattice", pages="all")
    except Exception:
        tables = []
    if not tables or getattr(tables, "n", 0) == 0:
        try:
            tables = camelot.read_pdf(str(pdf_path), flavor="stream", pages="all")
        except Exception:
            tables = []
    if not tables or getattr(tables, "n", 0) == 0:
        return []

    rows: List[Tx] = []
    for t in tables:
        df = t.df
        if df.shape[0] < 2:
            continue
        header = [clean_str(x).lower() for x in df.iloc[0].tolist()]
        def col_idx(*keys: str) -> Optional[int]:
            for k in keys:
                for i, h in enumerate(header):
                    if k in h:
                        return i
            return None
        i_datum = col_idx("datum")
        i_typ   = col_idx("typ")
        i_name  = col_idx("name")
        i_mail  = col_idx("mail", "e-mail")
        i_txid  = col_idx("transaktions")
        i_brut  = col_idx("brutto")
        i_geb   = col_idx("gebühr", "gebuhr")
        i_netto = col_idx("netto")

        for r in range(1, df.shape[0]):
            row = [clean_str(x) for x in df.iloc[r].tolist()]
            if i_datum is None or i_txid is None:
                continue
            datum = row[i_datum] if i_datum is not None else ""
            if not _DATE_FULL.search(datum):
                continue  # Seitenkopf/-fuß

            typ = row[i_typ] if i_typ is not None else ""
            name = row[i_name] if i_name is not None else ""
            mail = row[i_mail] if i_mail is not None else ""
            txid = row[i_txid] if i_txid is not None else ""

            # Betrag: Netto bevorzugen, sonst Brutto - Gebühr
            betrag = 0.0
            if i_netto is not None and row[i_netto]:
                betrag = to_float_de(row[i_netto])
            else:
                brut = to_float_de(row[i_brut]) if i_brut is not None and row[i_brut] else 0.0
                geb  = to_float_de(row[i_geb])  if i_geb  is not None and row[i_geb]  else 0.0
                betrag = brut - geb

            empfaenger = norm_ws(f"{name} <{mail}>") if mail else norm_ws(name)
            verwendungszweck = norm_ws(f"{typ} {txid}".strip())
            rows.append(Tx(datum=datum, empfaenger=empfaenger, betrag=betrag,
                           verwendungszweck=verwendungszweck))
    return rows

def paypal_from_text(text: str) -> List[Tx]:
    drop_rx = re.compile(
        r"(Händlerkonto-ID:|Transaktionsübersicht|PayPal-ID:|Copyright|Seite \d+ von \d+|Hinweis:|Datum Typ Name E-Mail-Adresse Transak)",
        re.I
    )
    lines: List[str] = []
    for raw in text.splitlines():
        line = normalize_paypal_line(raw)
        if not line:
            continue
        if drop_rx.search(line):
            continue
        lines.append(line)

    rows: List[Tx] = []
    block: List[str] = []

    def flush(bl: List[str]):
        if not bl:
            return
        txt = " ".join(bl)
        
        # VERBESSERUNG: Datumsbereich-Header filtern (z.B. "01.01.2019 - 31.12.2019")
        if re.search(r"\d{2}\.\d{2}\.\d{4}\s*-\s*\d{2}\.\d{2}\.\d{4}", txt):
            return
        
        mdate = _DATE_FULL.search(txt)
        if not mdate:
            return
        amt = parse_last_amount(txt)
        txid_m = _TXID17.search(txt.replace(" ", ""))
        if (amt is None) and (txid_m is None):
            return

        datum = fix_date_ddmmyyyy(mdate.group(1), mdate.group(2), mdate.group(3))

        tokens: List[str] = []
        for ln in bl:
            tokens.extend(ln.split())

        mail, mail_idx = extract_paypal_email(tokens)
        name = extract_paypal_name(tokens, mail_idx)

        txid = txid_m.group(0) if txid_m else ""
        mtyp = re.search(r"(Express|Allgemeine|Gemeine|Bankgutschrift|Handyzahlung|Abbuchung|Rückbuchung|Einbehaltung|Gutschrift)", txt, re.I)
        typ = "PayPal Transaktion"
        if mtyp:
            t = mtyp.group(0)
            if "Express" in t:
                typ = "PayPal Express-Zahlung"
            elif t.lower().startswith("gemeine"):
                typ = "Allgemeine Zahlung"
            else:
                typ = norm_ws(t).title()

        betrag = amt if amt is not None else 0.0
        if not name and mail:
            name = mail.split("@", 1)[0].replace(".", " ")
        empf = norm_ws(f"{name} <{mail}>") if mail else (name or "Unbekannt")
        vz   = norm_ws(f"{typ} {txid}".strip())
        rows.append(Tx(datum=datum, empfaenger=empf, betrag=betrag, verwendungszweck=vz))

    for ln in lines:
        if _DATE_FULL.search(ln):
            flush(block)
            block = [ln]
        else:
            block.append(ln)
    flush(block)
    return rows

def normalize_paypal_rows(rows: List[Tx], autofix_domains: bool) -> List[Tx]:
    fixed: List[Tx] = []
    for tx in rows:
        if autofix_domains and "<" in tx.empfaenger and ">" in tx.empfaenger:
            name, mail = tx.empfaenger.split("<", 1)
            mail = mail.rstrip(">")
            clean_name = re.sub(r"^[&/\\'`]+", "", name).strip()
            tx.empfaenger = norm_ws(f"{clean_name} <{autofix_email_domain(mail.strip())}>")
        vz_lower = tx.verwendungszweck.lower()
        if "allallgemeine" in vz_lower:
            tx.verwendungszweck = re.sub(r"allallgemeine", "Allgemeine", tx.verwendungszweck, flags=re.I)
            vz_lower = tx.verwendungszweck.lower()
        if "gemeine zahlung" in vz_lower:
            tx.verwendungszweck = re.sub(r"gemeine zahlung", "Allgemeine Zahlung", tx.verwendungszweck, flags=re.I)
            vz_lower = tx.verwendungszweck.lower()
        tx.verwendungszweck = tx.verwendungszweck.replace("AllAllgemeine", "Allgemeine")
        tx.empfaenger = norm_ws(tx.empfaenger)
        fixed.append(tx)
    return fixed

def needs_review_paypal(tx: Tx) -> List[str]:
    reasons = needs_review_common(tx)
    if "Unbekannt" in tx.empfaenger:
        reasons.append("PayPal: Empfänger/Email unlesbar")
    if "Transaktion" in tx.verwendungszweck and not _TXID17.search(tx.verwendungszweck):
        reasons.append("PayPal: Transaktionscode fehlt")
    return reasons

# --------------------- HASPA --------------------------
def parse_haspa_text(text: str, default_year: Optional[int]) -> List[Tx]:
    lines: List[str] = []
    for raw in text.splitlines():
        cleaned = clean_str(raw)
        if cleaned:
            lines.append(normalize_amount_line(cleaned))
    drop_rx = re.compile(
        r"(Geschäftsgirokonto|Hamburger Sparkasse|IBAN:|SWIFT-BIC|www\.haspa\.de|^Blatt\b|^Kontoauszug\b|Kontostand in EUR|Übertrag in EUR)",
        re.I,
    )
    # VERBESSERUNG: Zusätzliche Filter für Metadaten-Zeilen
    timestamp_rx = re.compile(r"\d{4}-\d{2}-\d{2}[T]\d{2}:\d{2}")  # z.B. "2020-01-30T09:28"
    
    seq: List[str] = []
    for l in lines:
        if not l:
            continue
        if drop_rx.search(l):
            continue
        # Timestamp-Zeilen überspringen (sind Metadaten)
        if timestamp_rx.search(l):
            continue
        seq.append(l)

    rows: List[Tx] = []
    block: List[str] = []

    def flush(bl: List[str]):
        if not bl:
            return
        
        # VERBESSERUNG: Übertrag-Zeilen aus dem Block entfernen (aber vorsichtig!)
        filtered_block = []
        for line in bl:
            # Zeilen die wie "HamburgerKino e.V, 4,875,06r" aussehen UND nach Übertrag-Summen aussehen
            # Nur wenn sie einen Namen + unrealistisch hohen Betrag mit "r" oder "+" Suffix haben
            if re.search(r'(e\.V\.|GmbH|Kino)\s+[\d.,]{5,}[r\+]+\s*$', line, re.I):
                continue
            filtered_block.append(line)
        
        if not filtered_block:
            return
        bl = filtered_block
        
        joined = "\n".join(bl)
        datum = extract_date_from_block(bl, default_year)
        amount = select_haspa_amount(bl)
        betrag = amount if amount is not None else 0.0

        low = joined.lower()
        if any(k in low for k in ["lastschrift", "kartenzahlung", "abbuchung", "überw.", "überweis"]):
            if betrag > 0:
                betrag = -abs(betrag)
        elif "zahlungseingang" in low or "gutschrift" in low:
            betrag = abs(betrag)

        type_idx: Optional[int] = None
        vz_label: Optional[str] = None
        for i, ln in enumerate(bl):
            low_ln = ln.lower()
            for rx, label in _HASPA_TYPE_PATTERNS:
                if rx.search(low_ln):
                    type_idx = i
                    vz_label = label
                    break
            if type_idx is not None:
                break

        start_idx = 0
        if type_idx is not None:
            start_idx = type_idx + 1
        else:
            for i, ln in enumerate(bl):
                if _DATE_DDMM.search(ln) or _DATE_FULL.search(ln):
                    start_idx = i + 1
                    break
        empfaenger = resolve_empfaenger(bl, start_idx)

        vz = ""
        if type_idx is not None:
            base_line = norm_ws(bl[type_idx])
            if "wert" in base_line.lower():
                base_line = base_line.split("wert", 1)[0].strip()
            if base_line:
                vz = base_line
        if not vz and vz_label:
            vz = vz_label
        if not vz:
            vz_match = re.search(
                r"(Zahlungseingang|Lastschrift|Kartenzahlung|Überw\.\s*OnlineBanking|Einzahlung|Auszahlung|Entgeltabrechnung|Überweisung|Gutschrift)",
                joined,
                re.I,
            )
            vz = vz_match.group(0) if vz_match else "HASPA Buchung"
        extra = []
        for tag in [r"RN:\s*\S+", r"Gläubiger-ID:\s*\S+", r"PP\.[^\s]+", r"INV/\S+"]:
            m = re.search(tag, joined, re.I)
            if m:
                extra.append(m.group(0))
        if extra:
            vz = f"{vz} — {'; '.join(extra)}"

        rows.append(Tx(datum=datum, empfaenger=empfaenger, betrag=betrag, verwendungszweck=vz))

    for ln in seq:
        if line_starts_with_date(ln):
            flush(block)
            block = [ln]
        elif block:
            block.append(ln)
    flush(block)
    return rows

def needs_review_haspa(tx: Tx) -> List[str]:
    reasons = needs_review_common(tx)
    if tx.verwendungszweck.startswith("HASPA Buchung"):
        reasons.append("HASPA: Buchungstext unklar")
    return reasons

# --------------------- Orchestrierung ------------------
def split_good_and_review(rows: List[Tx], per_bank_checker) -> Tuple[List[Tx], List[Tx]]:
    good: List[Tx] = []
    review: List[Tx] = []
    for tx in rows:
        reasons = per_bank_checker(tx)
        if reasons:
            review.append(replace(tx, kommentar="; ".join(dict.fromkeys(reasons))))
        else:
            good.append(tx)
    return (sort_txs(dedupe(good)), sort_txs(dedupe(review)))

# --------------------- CLI -----------------------------
def main(argv: Optional[Sequence[str]] = None) -> int:
    ap = argparse.ArgumentParser(description="PDF/Kontoauszug → Import-CSV + Review-CSV")
    ap.add_argument("--paypal-pdf", help="PayPal OCR-PDF")
    ap.add_argument("--paypal-text", help="PayPal Text (pdftotext -layout)")
    ap.add_argument("--haspa-pdf", help="HASPA OCR-PDF (wird via pdftotext -layout gelesen)")
    ap.add_argument("--haspa-text", help="HASPA Text (pdftotext -layout)")
    ap.add_argument("--year", type=int, help="Fallback-Jahr (z.B. 2020) für Datumsangaben dd.mm + Jahr-Clamp")
    ap.add_argument("--out-dir", default=".", help="Ausgabeverzeichnis")
    ap.add_argument("--encoding", default="utf-8", help="CSV-Encoding (z.B. utf-8 oder latin-1)")
    ap.add_argument("--autofix-domains", action="store_true", help="E-Mail-Domains (gmail/gmx/yahoo/…) korrigieren")
    ap.add_argument("--no-auto-install", dest="auto_install", action="store_false",
                    help="Fehlende Python-Abhängigkeiten nicht automatisch via pip installieren.")
    ap.set_defaults(auto_install=True)
    args = ap.parse_args(argv)

    # System-Dependencies prüfen (pdftotext etc.)
    any_pdf = args.paypal_pdf or args.haspa_pdf
    if any_pdf:
        if not check_and_install_system_dependencies(args.auto_install):
            print("[ERROR] Erforderliche System-Dependencies fehlen.", file=sys.stderr)
            print("[INFO] Bitte führe das Setup-Skript aus: ./install_dependencies.sh", file=sys.stderr)
            return 1

    outdir = Path(args.out_dir)
    outdir.mkdir(parents=True, exist_ok=True)

    if any_pdf:
        ensure_pdf_text_backend(args.auto_install)  # wir benötigen Text-Extraktion für PDFs

    # ---- PayPal ----
    if args.paypal_pdf or args.paypal_text:
        rows_pp: List[Tx] = []
        if args.paypal_pdf:
            pdf = Path(args.paypal_pdf)
            rows_pp = paypal_from_camelot(pdf, args.auto_install)
            if not rows_pp:  # Fallback: pdftotext -layout
                txt = run_pdftotext_layout(pdf, args.auto_install)
                if text_seems_empty(txt):
                    warn_no_transactions(f"PayPal PDF '{pdf}'", pdf, args.auto_install)
                    # Wenn OCR durchgeführt wurde, beenden wir hier
                    if not (args.haspa_pdf or args.haspa_text):
                        return 0
                rows_pp = paypal_from_text(txt)
        else:
            txt = Path(args.paypal_text).read_text(encoding="utf-8", errors="ignore")
            if text_seems_empty(txt):
                warn_no_transactions(f"PayPal Text '{args.paypal_text}'")
            rows_pp = paypal_from_text(txt)

        rows_pp = normalize_paypal_rows(rows_pp, autofix_domains=args.autofix_domains)
        good, review = split_good_and_review(rows_pp, needs_review_paypal)
        write_csv(good,   outdir / "paypal_import.csv", args.encoding, review=False)
        write_csv(review, outdir / "paypal_review.csv", args.encoding, review=True, extended=True)
        print(f"[OK] PayPal: {len(good)} gut / {len(review)} review → {outdir/'paypal_import.csv'} / {outdir/'paypal_review.csv'}")

    # ---- HASPA ----
    if args.haspa_pdf or args.haspa_text:
        if args.haspa_pdf:
            pdf_path = Path(args.haspa_pdf)
            txt = run_pdftotext_layout(pdf_path, args.auto_install)
            if text_seems_empty(txt):
                warn_no_transactions(f"HASPA PDF '{pdf_path}'", pdf_path, args.auto_install)
                # OCR wurde durchgeführt, beende hier
                return 0
        else:
            txt = Path(args.haspa_text).read_text(encoding="utf-8", errors="ignore")
            if text_seems_empty(txt):
                warn_no_transactions(f"HASPA Text '{args.haspa_text}'")
        rows_hh = parse_haspa_text(txt, default_year=args.year)
        good, review = split_good_and_review(rows_hh, needs_review_haspa)
        write_csv(good,   outdir / "haspa_import.csv", args.encoding, review=False)
        write_csv(review, outdir / "haspa_review.csv", args.encoding, review=True, extended=True)
        print(f"[OK] HASPA: {len(good)} gut / {len(review)} review → {outdir/'haspa_import.csv'} / {outdir/'haspa_review.csv'}")

    if not (args.paypal_pdf or args.paypal_text or args.haspa_pdf or args.haspa_text):
        print("Hinweis: Bitte --paypal-pdf/--paypal-text oder --haspa-pdf/--haspa-text angeben.")
        return 2
    return 0

if __name__ == "__main__":
    sys.exit(main())