"""CLI: stt — statement to TikZ."""

from __future__ import annotations

import json
from pathlib import Path
from typing import Optional

import typer

from statement_to_tikz.pipeline import load_ir, run_pipeline

app = typer.Typer(
    add_completion=False,
    help="Convert geometry statements into constraint-solved TikZ diagrams.",
)


def _split_out(out: Path) -> tuple[Path, str]:
    """Interpret --out out/fig as directory out, basename fig."""
    if out.suffix in {".tex", ".pdf", ".json"}:
        return out.parent or Path("."), out.stem
    parent = out.parent
    name = out.name or "fig"
    if parent == Path(""):
        parent = Path(".")
    return parent, name


@app.command()
def main(
    statement: Optional[str] = typer.Argument(
        None,
        help="Geometry statement text, or path to a .txt file",
    ),
    out: Path = typer.Option(
        Path("out/fig"),
        "--out",
        "-o",
        help="Output path prefix (directory/basename without extension)",
    ),
    ir_path: Optional[Path] = typer.Option(
        None,
        "--ir",
        help="Load GeometryIR JSON instead of formalizing a statement",
    ),
    emit_only: bool = typer.Option(
        False,
        "--emit-only",
        help="With --ir: solve and emit without calling the LLM",
    ),
    no_compile: bool = typer.Option(
        False,
        "--no-compile",
        help="Skip pdflatex/latexmk",
    ),
    schematic: bool = typer.Option(
        False,
        "--schematic",
        help="Force schematic layout",
    ),
    no_offline: bool = typer.Option(
        False,
        "--no-offline",
        help="Disable offline pattern formalizer; require LLM",
    ),
    tol: float = typer.Option(1e-4, "--tol", help="Exact-mode residual tolerance"),
) -> None:
    """Generate TikZ from a statement or IR file."""
    if statement is None and ir_path is None:
        typer.echo(
            "Usage: stt STATEMENT [-o out/fig] | stt --ir scene.ir.json --emit-only"
        )
        raise typer.Exit(code=1)

    text: str | None = None
    ir = None

    if ir_path is not None:
        ir = load_ir(ir_path)
        if not emit_only and statement:
            text = statement
        else:
            text = ir.statement or None
    elif statement is not None:
        p = Path(statement)
        if p.is_file():
            text = p.read_text(encoding="utf-8").strip()
        else:
            text = statement

    out_dir, basename = _split_out(out)

    result = run_pipeline(
        text,
        ir=ir,
        out_dir=out_dir,
        basename=basename,
        tol=tol,
        compile_pdf=not no_compile,
        allow_offline_formalizer=not no_offline,
        force_schematic=schematic,
    )

    typer.echo(f"mode: {result['mode']}")
    typer.echo(f"max_residual: {result['max_residual']:.6g}")
    if result.get("paths"):
        for k, v in result["paths"].items():
            if v:
                typer.echo(f"{k}: {v}")
    compile_info = (result.get("report") or {}).get("compile")
    if compile_info:
        if compile_info.get("skipped"):
            typer.echo(f"compile skipped: {compile_info.get('error')}")
        elif compile_info.get("ok"):
            typer.echo("compile: ok")
        else:
            typer.echo(
                f"compile: failed "
                f"({compile_info.get('error') or compile_info.get('returncode')})"
            )
            raise typer.Exit(code=2)

    summary = {
        "mode": result["mode"],
        "max_residual": result["max_residual"],
        "paths": result.get("paths"),
    }
    typer.echo(json.dumps(summary))


if __name__ == "__main__":
    app()