export_utils.py

"""
Export utilities: convert text / chat history to .docx, .md, .txt files.
"""

from __future__ import annotations

import logging
import re
import tempfile

logger = logging.getLogger(__name__)


def _text_to_md(text: str) -> str:
    """Return text as-is (it may already be Markdown)."""
    return text or ""


def _text_to_txt(text: str) -> str:
    """Strip Markdown formatting for plain text."""
    if not text:
        return ""
    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
    text = re.sub(r"\*(.+?)\*", r"\1", text)
    text = re.sub(r"#{1,6}\s+", "", text)
    text = re.sub(r"`{1,3}[^`]*`{1,3}", lambda m: m.group(0).strip("`"), text)
    text = re.sub(r"\[(.+?)\]\(.+?\)", r"\1", text)
    return text


def _text_to_docx(text: str, title: str = "Export") -> str:
    """Write text to a temp .docx file, return path."""
    try:
        from docx import Document  # type: ignore[import-untyped]
    except ImportError as exc:
        raise RuntimeError(
            "python-docx nicht installiert. Bitte 'pip install python-docx' ausführen."
        ) from exc

    doc = Document()
    doc.add_heading(title, level=1)

    for line in (text or "").splitlines():
        stripped = line.strip()
        if not stripped:
            doc.add_paragraph("")
            continue
        # Headings
        m = re.match(r"^(#{1,6})\s+(.*)", stripped)
        if m:
            level = min(len(m.group(1)), 4)
            doc.add_heading(m.group(2), level=level)
            continue
        # Bold lines (e.g. **Title**)
        if stripped.startswith("**") and stripped.endswith("**"):
            p = doc.add_paragraph()
            run = p.add_run(stripped.strip("*"))
            run.bold = True
            continue
        doc.add_paragraph(stripped)

    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".docx")
    doc.save(tmp.name)
    tmp.close()
    return tmp.name


def export_text(text: str, fmt: str, title: str = "Export") -> str | None:
    """
    Export text to a temp file.
    fmt: 'docx' | 'md' | 'txt'
    Returns file path, or None if text is empty.
    """
    if not text or not text.strip():
        return None

    if fmt == "docx":
        return _text_to_docx(text, title)

    if fmt == "md":
        content = _text_to_md(text)
        suffix = ".md"
    else:
        content = _text_to_txt(text)
        suffix = ".txt"

    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, mode="w", encoding="utf-8")
    tmp.write(content)
    tmp.close()
    return tmp.name


def export_chat(history: list, fmt: str) -> str | None:
    """
    Export chat history to a temp file.
    history: list of {"role": ..., "content": ...} dicts (or Gradio tuples)
    fmt: 'docx' | 'md' | 'txt'
    Returns file path, or None if history is empty.
    """
    if not history:
        return None

    lines = []
    for turn in history:
        if isinstance(turn, dict):
            role = turn.get("role", "?")
            content = turn.get("content", "")
        elif isinstance(turn, (list, tuple)) and len(turn) == 2:
            role = "user" if turn[0] else "assistant"
            content = turn[0] or turn[1]
        else:
            continue

        # Flatten multimodal content
        if isinstance(content, list):
            parts = [
                p.get("text", "")
                for p in content
                if isinstance(p, dict) and p.get("type") == "text"
            ]
            content = "\n".join(parts)

        label = "👤 Nutzer" if role == "user" else "🤖 Assistent"
        lines.append(f"## {label}\n\n{content}\n")

    full_text = "\n---\n\n".join(lines)
    return export_text(full_text, fmt, title="Chat-Export")