"""Orchestrierung der kompletten Import-Pipeline."""

from __future__ import annotations

import logging
import uuid
from datetime import datetime
from pathlib import Path

from app.excel_io import ExcelReadError, load_source, load_template, write_workbook
from app.matching import deduplicate_records, fill_missing_addresses, match_and_enrich
from app.models import ProcessResult
from app.salutation import apply_salutations
from app.validator import validate_import

logger = logging.getLogger("kundenimport")


class ProcessLog:
    def __init__(self) -> None:
        self.lines: list[str] = []

    def add(self, message: str) -> None:
        stamp = datetime.now().strftime("%H:%M:%S")
        line = f"{stamp} {message}"
        self.lines.append(line)
        logger.info(message)


def process_import(table_a: Path, template_b: Path, output_dir: Path) -> ProcessResult:
    log = ProcessLog()
    log.add("Import gestartet")

    try:
        source = load_source(table_a)
    except ExcelReadError as exc:
        log.add(exc.message)
        return ProcessResult(success=False, message=exc.message, log=log.lines)

    log.add(f"Tabelle A gelesen: {len(source.records)} Datensätze")

    try:
        template = load_template(template_b)
    except ExcelReadError as exc:
        log.add(exc.message)
        return ProcessResult(success=False, message=exc.message, log=log.lines)

    log.add("Vorlage B gelesen")

    if not source.records:
        message = "Tabelle A konnte nicht erkannt werden."
        log.add(message)
        return ProcessResult(success=False, message=message, log=log.lines)

    source_count = len(source.records)
    log.add("Mapping abgeschlossen")

    unique, conflicts = deduplicate_records(source.records)
    lookup_pool = list(source.records) + list(template.records)
    match_and_enrich(unique, template.records)
    fill_missing_addresses(unique, lookup_pool)

    log.add(f"{len(unique)} Kunden verarbeitet")
    log.add("Adressprüfung abgeschlossen")

    apply_salutations(unique)
    log.add("Briefanreden generiert")

    report = validate_import(unique, source_count, conflicts)
    if not report.success:
        log.add("Validierung fehlgeschlagen")
        return ProcessResult(
            success=False,
            message=report.message,
            stats=report.stats,
            issues=report.issues,
            log=log.lines,
        )

    log.add("Validierung erfolgreich")
    output_dir.mkdir(parents=True, exist_ok=True)
    output_path = output_dir / f"FINAL_Import_{uuid.uuid4().hex}.xlsx"
    write_workbook(
        template_b,
        output_path,
        unique,
        template,
        report.summary_rows,
        report.detail_rows,
    )
    log.add("Excel erstellt")

    return ProcessResult(
        success=True,
        message=report.message,
        stats=report.stats,
        issues=[],
        log=log.lines,
        output_path=str(output_path),
    )