from pathlib import Path
from typing import get_args

import typer

from tht.cli.config_cmd import CONFIG_OPT
from tht.cli.schema_cmd import _load_config_or_exit
from tht.cli.session_cmd import load_session_or_exit, session_dir

decision_app = typer.Typer(help="Decisioni del reviewer (per sessione, append-only)")


@decision_app.command("add")
def add_cmd(
    session: str = typer.Option(..., "--session", help="Id della sessione."),
    type: str = typer.Option(..., "--type", help="Tipo di decisione."),
    subject: str = typer.Option(..., "--subject", help="Oggetto (tabella, colonna, concetto)."),
    detail: str = typer.Option("", "--detail"),
    rationale: str = typer.Option("", "--rationale"),
    retracts: int = typer.Option(
        None, "--retracts",
        help="Solo per type=decision_retracted: seq della decisione da ritirare (D15).",
    ),
    config: Path = CONFIG_OPT,
) -> None:
    """Registra una decisione del reviewer nella sessione."""
    from tht.decisions import DecisionType, append_decision

    cfg = _load_config_or_exit(config)
    load_session_or_exit(cfg, session)
    valid = get_args(DecisionType)
    if type not in valid:
        typer.secho(
            f"ERRORE: tipo '{type}' non valido. Tipi: {', '.join(valid)}",
            fg=typer.colors.RED, err=True,
        )
        raise typer.Exit(code=1)
    if type == "decision_retracted" and retracts is None:
        typer.secho(
            "ERRORE: decision_retracted richiede --retracts <seq> (la decisione da ritirare).",
            fg=typer.colors.RED, err=True,
        )
        raise typer.Exit(code=1)
    from tht.cli.phase_cmd import require_phase_or_exit
    from tht.workflow import load_workflow

    require_phase_or_exit(cfg, session, load_workflow().decision_min_phase(type))
    sdir = session_dir(cfg, session)
    if type == "cte_approved":
        # Un CTE si approva solo se appartiene al piano persistito. Senza piano
        # (o con subject fuori piano) l'approvazione e' priva di significato:
        # rifiutala (exit 5) invece di sporcare il ledger. Regressione quo-8,
        # dove fu registrato un cte_approved:cte_plan senza alcun cte_plan.json.
        from tht.phase import cte_plan

        plan = cte_plan(sdir)
        if not plan:
            typer.secho(
                "ERRORE: nessun piano CTE (cte_plan.json) in sessione. Persisti prima "
                "il piano con reviewer_confirm kind:'cte_plan', poi approva i CTE.",
                fg=typer.colors.RED, err=True,
            )
            raise typer.Exit(code=5)
        if subject not in plan:
            typer.secho(
                f"ERRORE: '{subject}' non e' un CTE del piano ({', '.join(plan)}). "
                "Usa un nome di CTE del piano.",
                fg=typer.colors.RED, err=True,
            )
            raise typer.Exit(code=5)
    record = append_decision(
        sdir, type=type, subject=subject,
        detail=detail, rationale=rationale, retracts=retracts,
    )
    typer.secho(f"OK: decisione [{record.seq}] {record.type}: {record.subject}",
                fg=typer.colors.GREEN)


@decision_app.command("retract")
def retract_cmd(
    session: str = typer.Option(..., "--session", help="Id della sessione."),
    config: Path = CONFIG_OPT,
) -> None:
    """Ritira l'ultima decisione sostanziale della fase corrente (D15 granularita' step).

    Granularita' (a) del rollback §4.8: 'rispondi di nuovo a questa domanda'. Scrive un
    marker decision_retracted (append-only, l'audit resta) che effective_decisions onora;
    il widget corrente puo' essere riproposto. Non cambia la fase."""
    from tht.decisions import append_decision
    from tht.phase import effective_decisions

    cfg = _load_config_or_exit(config)
    load_session_or_exit(cfg, session)
    sdir = session_dir(cfg, session)

    # Ultima decisione NON-meta della vista effective = quella associata al widget corrente.
    meta = {
        "phase_approved", "phase_auto_approved", "phase_reopened",
        "phase_skipped", "decision_retracted",
    }
    substantive = [d for d in effective_decisions(sdir) if d.type not in meta]
    if not substantive:
        typer.secho(
            "Nessuna decisione sostanziale da ritirare nella fase corrente.",
            fg=typer.colors.YELLOW, err=True,
        )
        raise typer.Exit(code=6)
    target = substantive[-1]
    record = append_decision(
        sdir, type="decision_retracted", subject=target.subject,
        rationale=f"ritira [{target.seq}] {target.type}", retracts=target.seq,
    )
    typer.secho(
        f"OK: ritirata decisione [{target.seq}] {target.type}: {target.subject} "
        f"(marker #{record.seq}).",
        fg=typer.colors.GREEN,
    )


@decision_app.command("list")
def list_cmd(
    session: str = typer.Option(..., "--session"),
    config: Path = CONFIG_OPT,
) -> None:
    """Elenca le decisioni della sessione."""
    from tht.decisions import list_decisions

    cfg = _load_config_or_exit(config)
    load_session_or_exit(cfg, session)
    decisions = list_decisions(session_dir(cfg, session))
    if not decisions:
        typer.echo("Nessuna decisione registrata.")
        return
    for d in decisions:
        line = f"[{d.seq}] {d.ts:%Y-%m-%d %H:%M} {d.type}: {d.subject}"
        if d.detail:
            line += f" — {d.detail}"
        if d.rationale:
            line += f" ({d.rationale})"
        typer.echo(line)