# TODO (drop registry, decisione spec 5): questo modulo e' portato col modello
# registry intatto (load_registry/promote/update_record/delete_record). Le memory
# dovrebbero vivere SOLO nel vectordb (metadata arricchito con subject/detail/rationale
# in Onda 3.1). Riscrivere: promote -> upsert batch vectordb; list/show -> scan
# vectordb; delete -> metadata.status="superseded"; index/clear -> droppati.
# Task separato: la validazione richiede L2 (vectordb reale).
import json
from pathlib import Path

import typer
from sqlalchemy.exc import OperationalError, ProgrammingError

from tht.cli._guards import (
    require_server_profile,
    require_vector_write_allowed,
)
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_snapshot_or_exit
from tht.cli.vector_cmd import require_vector_cfg

memory_app = typer.Typer(help="Review memory (registro canonico + indice semantico)")
DECISION_OPT = typer.Option(None, "--decision", help="Seq da promuovere (ripetibile).")


def registry_path(cfg) -> Path:
    if getattr(cfg.paths, "memory", None) is not None:
        return cfg.paths.memory / "registry.jsonl"
    # Legacy location; migrate with `tht memory migrate` (P3).
    return cfg.paths.artifacts / "memory" / "registry.jsonl"


def _resync_memory(cfg):
    """Risincronizza l'indice semantico col registro corrente (incrementale)."""
    from tht.adapters.factory import build_vector_store
    from tht.cli.vector_cmd import make_embedder, sync_canonical_records
    from tht.memory import load_registry, memory_vector_records

    records = memory_vector_records(load_registry(registry_path(cfg)))
    return sync_canonical_records(
        "memory",
        records,
        store=build_vector_store(cfg, require_write=True),
        embedder=make_embedder(cfg.embeddings),
    )


def clear_memory_index(cfg):
    from tht.adapters.factory import build_vector_store

    return build_vector_store(cfg, require_write=True).delete_kinds("memory", ["memory"])


@memory_app.command("promote")
def promote_cmd(
    session: str = typer.Option(..., "--session"),
    decision: list[int] = DECISION_OPT,
    preview: bool = typer.Option(False, "--preview", help="Mostra i candidati in JSON, non scrive."),
    json_out: bool = typer.Option(False, "--json", help="Output JSON (per Pi)."),
    config: Path = CONFIG_OPT,
) -> None:
    """Promuove le decisioni SCELTE nel registro globale. Usa --preview per vedere i candidati."""
    import json as _json

    from tht.memory import promote_snapshot

    cfg = _load_config_or_exit(config)
    snapshot = load_snapshot_or_exit(cfg, session)

    if preview:
        from tht.memory import (
            MAX_PROMOTION_CANDIDATES,
            preview_promotions_snapshot,
            reusable_promotions_snapshot,
        )
        cand = preview_promotions_snapshot(snapshot, registry_path(cfg))
        extra = len(reusable_promotions_snapshot(snapshot, registry_path(cfg))) - len(cand)
        payload = [
            {"decision_seq": c.decision_seq, "type": c.type, "subject": c.subject,
             "detail": c.detail, "rationale": c.rationale,
             "question_context": c.question_context,
             "tables": c.tables, "concepts": c.concepts}
            for c in cand
        ]
        if json_out:
            typer.echo(_json.dumps(payload, ensure_ascii=False, indent=2))
        elif not payload:
            typer.secho("Nessun candidato da promuovere.", fg=typer.colors.YELLOW)
        else:
            for c in payload:
                typer.echo(f"  [{c['decision_seq']}] {c['type']}: {c['subject']}")
        if extra > 0:
            typer.secho(
                f"NOTA: mostrati {len(cand)} candidati su {len(cand) + extra} riusabili "
                f"(cap {MAX_PROMOTION_CANDIDATES}); gli altri non sono proposti.",
                fg=typer.colors.YELLOW, err=True,
            )
        return

    if not decision:
        typer.secho("ERRORE: indica le decisioni con --decision <seq> (vedi `--preview`).",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)

    require_server_profile(cfg, "memory promote")
    require_vector_cfg(cfg)
    promoted = promote_snapshot(snapshot, seqs=list(decision), registry_path=registry_path(cfg))
    if not promoted:
        msg = "Nessuna nuova promozione (gia' presenti o seq inesistenti)."
        if json_out:
            typer.echo(_json.dumps(
                {"promoted": [], "indexed": False, "message": msg}, ensure_ascii=False))
        else:
            typer.secho(msg, fg=typer.colors.YELLOW)
        return

    # Promozione nel registro: riuscita. L'indicizzazione semantica puo' fallire
    # (runtime non pronto o vectordb irraggiungibile da questa postazione): in quel
    # caso le memorie restano nel registro ma NON sono trovate da `tht memory
    # search` finche' non si reindicizza sul server. `indexed` rende lo stato
    # leggibile da Pi, cosi' il reviewer lo vede invece di perderlo nello stderr.
    ids = [{"id": r.id, "type": r.type, "subject": r.subject} for r in promoted]
    indexed = True
    warning = None
    try:
        _resync_memory(cfg)
    except (ProgrammingError, OperationalError):
        indexed = False
        warning = (
            f"{len(promoted)} memorie promosse nel registro, ma l'indice vettoriale "
            "NON e' stato sincronizzato (runtime vettoriale mancante o irraggiungibile): "
            "NON saranno trovate da `tht memory search` finche' non reindicizzi sul "
            "server (`tht vector init`, poi `tht memory index`)."
        )

    if json_out:
        typer.echo(_json.dumps(
            {"promoted": ids, "indexed": indexed,
             "message": warning or f"{len(promoted)} memorie promosse e indicizzate."},
            ensure_ascii=False, indent=2))
        return
    for r in promoted:
        typer.echo(f"  {r.id}: {r.type} {r.subject}")
    if indexed:
        typer.secho(f"OK: {len(promoted)} memorie promosse e indicizzate.",
                    fg=typer.colors.GREEN)
    else:
        typer.secho(f"ATTENZIONE: {warning}", fg=typer.colors.YELLOW)


@memory_app.command("save-one")
def save_one_cmd(
    session: str = typer.Option(..., "--session"),
    decision: int = typer.Option(
        ..., "--decision", help="decision_seq della decisione da salvare come memoria."
    ),
    json_out: bool = typer.Option(False, "--json", help="Output JSON (per Pi)."),
    config: Path = CONFIG_OPT,
) -> None:
    """Upsert mirato (una riga) della memoria di una decisione nel semantic store (D11).

    Promuove la decisione nel registro locale (idempotente) e fa un singolo upsert
    con dedup hash client-side -- niente full-resync. Il factory seleziona il writer
    del runtime vettoriale attivo.
    """
    import json as _json

    from tht.adapters.factory import build_vector_store
    from tht.cli.vector_cmd import make_embedder
    from tht.memory import load_registry, promote_snapshot, save_one_memory

    cfg = _load_config_or_exit(config)
    snapshot = load_snapshot_or_exit(cfg, session)
    require_vector_write_allowed(cfg, "memory save-one")
    store = build_vector_store(cfg, require_write=True)

    # Promuove la decisione scelta nel registro locale (idempotente: salta se gia' presente
    # o se stale post-rollback, perche' _compute_promotions usa la vista effective).
    promote_snapshot(snapshot, seqs=[decision], registry_path=registry_path(cfg))
    records = [r for r in load_registry(registry_path(cfg)) if r.session_id == snapshot.manifest.id]

    embedder = make_embedder(cfg.embeddings)
    count = save_one_memory(records, decision, store=store, embedder=embedder)

    msg = (
        f"{count} memoria salvata nell'indice semantico (decision_seq {decision})."
        if count
        else f"Nessun upsert (decisione {decision} assente/stale o memoria gia' aggiornata)."
    )
    if json_out:
        typer.echo(_json.dumps(
            {"upserted": count, "decision_seq": decision, "message": msg}, ensure_ascii=False))
        return
    typer.secho(f"OK: {msg}", fg=typer.colors.GREEN if count else typer.colors.YELLOW)


@memory_app.command("clear")
def clear_cmd(
    yes: bool = typer.Option(False, "--yes", "-y", help="Salta la richiesta di conferma."),
    config: Path = CONFIG_OPT,
) -> None:
    """Cancella TUTTA la review memory: registro canonico + indice semantico (kind=memory)."""
    from tht.memory import load_registry

    cfg = _load_config_or_exit(config)
    require_server_profile(cfg, "memory clear")
    registry = registry_path(cfg)
    count = len(load_registry(registry))
    if count == 0:
        typer.secho("Nessuna memoria da cancellare.", fg=typer.colors.YELLOW)
        return

    if not yes and not typer.confirm(
        f"Cancellare definitivamente {count} memorie (registro + indice)?"
    ):
        typer.secho("Annullato.", fg=typer.colors.YELLOW)
        raise typer.Exit(code=1)

    clear_memory_index(cfg)

    # Registro canonico.
    registry.unlink()
    typer.secho(f"OK: {count} memorie cancellate.", fg=typer.colors.GREEN)


@memory_app.command("index")
def index_cmd(config: Path = CONFIG_OPT) -> None:
    """Sincronizza il registro memory nell'indice semantico (full-resync)."""
    from tht.cli.vector_cmd import _print_stats

    cfg = _load_config_or_exit(config)
    require_vector_write_allowed(cfg, "memory index")
    require_vector_cfg(cfg)
    _print_stats(_resync_memory(cfg))


@memory_app.command("list")
def list_cmd(
    type_: str = typer.Option(None, "--type", help="Filtra per tipo decisione."),
    session: str = typer.Option(None, "--session", help="Filtra per sessione."),
    table: str = typer.Option(None, "--table", help="Filtra per tabella coinvolta."),
    concept: str = typer.Option(None, "--concept", help="Filtra per concetto."),
    json_out: bool = typer.Option(False, "--json"),
    config: Path = CONFIG_OPT,
) -> None:
    """Elenca le memorie del registro (filtri combinati in AND)."""
    import json as _json

    from rich.console import Console
    from rich.table import Table

    from tht.memory import load_registry

    cfg = _load_config_or_exit(config)
    recs = load_registry(registry_path(cfg))
    if type_:
        recs = [r for r in recs if r.type == type_]
    if session:
        recs = [r for r in recs if r.session_id == session]
    if table:
        recs = [r for r in recs if table in r.tables]
    if concept:
        recs = [r for r in recs if concept in r.concepts]

    if json_out:
        typer.echo(_json.dumps([r.model_dump(mode="json") for r in recs],
                               ensure_ascii=False, indent=2))
        return
    if not recs:
        typer.secho("Nessuna memoria nel registro.", fg=typer.colors.YELLOW)
        return
    t = Table(title="Review memory")
    for col in ("Id", "Tipo", "Soggetto", "Sessione"):
        t.add_column(col)
    for r in recs:
        t.add_row(r.id, r.type, r.subject, r.session_id)
    Console().print(t)


@memory_app.command("show")
def show_cmd(
    mem_id: str = typer.Argument(..., help="Id memoria (es. mem-0001)."),
    json_out: bool = typer.Option(False, "--json"),
    config: Path = CONFIG_OPT,
) -> None:
    """Mostra una singola memoria."""
    import json as _json

    from tht.memory import load_registry

    cfg = _load_config_or_exit(config)
    rec = {r.id: r for r in load_registry(registry_path(cfg))}.get(mem_id)
    if rec is None:
        typer.secho(f"ERRORE: memoria '{mem_id}' non trovata. Usa `tht memory list`.",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=6)
    if json_out:
        typer.echo(_json.dumps(rec.model_dump(mode="json"), ensure_ascii=False, indent=2))
        return
    for k, v in rec.model_dump(mode="json").items():
        typer.echo(f"{k}: {v}")


@memory_app.command("update")
def update_cmd(
    mem_id: str = typer.Argument(..., help="Id memoria (es. mem-0001)."),
    subject: str = typer.Option(None, "--subject"),
    type_: str = typer.Option(None, "--type"),
    detail: str = typer.Option(None, "--detail"),
    rationale: str = typer.Option(None, "--rationale"),
    question_context: str = typer.Option(None, "--question-context"),
    tables: str = typer.Option(None, "--tables", help="CSV; \"\" per azzerare."),
    concepts: str = typer.Option(None, "--concepts", help="CSV; \"\" per azzerare."),
    config: Path = CONFIG_OPT,
) -> None:
    """Modifica i campi di merito di una memoria (provenienza immutabile)."""
    from typing import get_args

    from tht.decisions import DecisionType
    from tht.memory import MemoryNotFound, update_record

    cfg = _load_config_or_exit(config)

    fields: dict = {}
    for name, val in (("subject", subject), ("type", type_), ("detail", detail),
                      ("rationale", rationale), ("question_context", question_context)):
        if val is not None:
            fields[name] = val
    if tables is not None:
        fields["tables"] = [t.strip() for t in tables.split(",") if t.strip()]
    if concepts is not None:
        fields["concepts"] = [c.strip() for c in concepts.split(",") if c.strip()]

    if not fields:
        typer.secho("ERRORE: nessun campo da modificare indicato.",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)
    if "type" in fields and fields["type"] not in get_args(DecisionType):
        typer.secho(f"ERRORE: tipo '{fields['type']}' non valido.",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)

    require_server_profile(cfg, "memory update")
    require_vector_cfg(cfg)
    try:
        rec = update_record(registry_path(cfg), mem_id, fields)
    except MemoryNotFound:
        typer.secho(f"ERRORE: memoria '{mem_id}' non trovata. Usa `tht memory list`.",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=6)
    _resync_memory(cfg)
    typer.secho(f"OK: {rec.id} aggiornata e reindicizzata.", fg=typer.colors.GREEN)


@memory_app.command("delete")
def delete_cmd(
    mem_id: str = typer.Argument(..., help="Id memoria (es. mem-0001)."),
    yes: bool = typer.Option(False, "--yes", "-y", help="Salta la conferma."),
    config: Path = CONFIG_OPT,
) -> None:
    """Cancella una singola memoria (registro + indice)."""
    from tht.memory import MemoryNotFound, delete_record

    cfg = _load_config_or_exit(config)
    require_server_profile(cfg, "memory delete")
    require_vector_cfg(cfg)
    if not yes and not typer.confirm(f"Cancellare definitivamente la memoria '{mem_id}'?"):
        typer.secho("Annullato.", fg=typer.colors.YELLOW)
        raise typer.Exit(code=1)
    try:
        delete_record(registry_path(cfg), mem_id)
    except MemoryNotFound:
        typer.secho(f"ERRORE: memoria '{mem_id}' non trovata. Usa `tht memory list`.",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=6)
    _resync_memory(cfg)
    typer.secho(f"OK: {mem_id} cancellata e deindicizzata.", fg=typer.colors.GREEN)


@memory_app.command("search")
def search_cmd(
    question: str = typer.Argument(..., help="Domanda o termini di ricerca."),
    top: int = typer.Option(5, "--top"),
    session: str = typer.Option(
        None, "--session",
        help="Esclude le memorie gia' decise (applicate o rifiutate) in questa sessione.",
    ),
    json_out: bool = typer.Option(False, "--json", help="Output JSON per Pi."),
    config: Path = CONFIG_OPT,
) -> None:
    """Cerca memorie riapplicabili, ordinate per similarita'. Mai applicate in automatico.

    Con `--session` non ripropone le memorie gia' decise in quella sessione (fix:
    memorie scartate riproposte): rifiutate via `memory_rejected` o gia' applicate."""
    from rich.console import Console
    from rich.table import Table

    from tht.cli.vector_cmd import make_embedder, open_searcher, require_vector_cfg
    from tht.memory import REUSABLE_TYPES, decided_memory_ids, load_registry

    cfg = _load_config_or_exit(config)
    require_vector_cfg(cfg)
    excluded: set[str] = set()
    if session is not None:
        excluded = decided_memory_ids(load_snapshot_or_exit(cfg, session).decisions)
    searcher = open_searcher(cfg)
    embedder = make_embedder(cfg.embeddings)
    hits = searcher.search(embedder.embed_query(question), top_n=top, kinds=["memory"])
    by_id = {r.id: r for r in load_registry(registry_path(cfg))}

    results = []
    for h in hits:
        rec = by_id.get(h.ref)
        if rec is None:
            continue  # indice piu' avanti del registro: ignora
        if rec.type not in REUSABLE_TYPES:
            continue  # record legacy non-concept: non e' una memory riusabile
        if rec.id in excluded:
            continue  # gia' decisa in questa sessione: non riproporla
        results.append({
            "id": rec.id, "type": rec.type, "subject": rec.subject,
            "detail": rec.detail, "rationale": rec.rationale,
            "question_context": rec.question_context,
            "tables": rec.tables, "concepts": rec.concepts,
            "session_id": rec.session_id, "score": round(h.similarity, 4),
        })

    if json_out:
        typer.echo(json.dumps(results, ensure_ascii=False, indent=2))
        return
    if not results:
        typer.secho("Nessuna memoria candidata.", fg=typer.colors.YELLOW)
        return
    table = Table(title=f"Memorie candidate per: {question}")
    table.add_column("Id")
    table.add_column("Tipo")
    table.add_column("Soggetto")
    table.add_column("Contesto originale")
    table.add_column("Score", justify="right")
    for r in results:
        table.add_row(r["id"], r["type"], r["subject"],
                      r["question_context"][:60], f"{r['score']:.3f}")
    Console().print(table)


def index_solved_session(cfg, session_id: str) -> int:
    """Indicizza la coppia domanda->SQL della sessione (kind solved_question).

    Solleva SolvedIndexError se mancano gli artefatti: il finalize lo degrada a warning,
    il comando CLI lo converte in errore esplicito."""
    from tht.adapters.factory import build_vector_store
    from tht.cli.sql_cmd import promoted_tables_for
    from tht.cli.vector_cmd import make_embedder
    from tht.solved import build_solved_snapshot, save_solved_question

    store = build_vector_store(cfg, require_write=True)
    record = build_solved_snapshot(load_snapshot_or_exit(cfg, session_id), promoted_tables_for(cfg, session_id))
    return save_solved_question(
        record,
        store=store,
        embedder=make_embedder(cfg.embeddings),
    )


@memory_app.command("solved-index")
def solved_index_cmd(
    session_id: str = typer.Argument(..., help="Id sessione con sql_final.sql approvato."),
    json_out: bool = typer.Option(False, "--json", help="Output JSON (per Pi)."),
    config: Path = CONFIG_OPT,
) -> None:
    """Indicizza la coppia domanda->SQL nel semantic store (backfill; il finalize lo fa da solo)."""
    import json as _json

    from tht.solved import SolvedIndexError

    cfg = _load_config_or_exit(config)
    require_vector_write_allowed(cfg, "memory solved-index")
    try:
        count = index_solved_session(cfg, session_id)
    except RuntimeError as e:
        typer.secho(f"ERRORE: {e}", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=4)
    except SolvedIndexError as e:
        typer.secho(f"ERRORE: sessione {session_id} non indicizzabile: {e}",
                    fg=typer.colors.RED, err=True)
        raise typer.Exit(code=3)
    msg = (
        f"1 coppia domanda->SQL indicizzata (solved:{session_id})."
        if count else "Nessun upsert: coppia gia' aggiornata."
    )
    if json_out:
        typer.echo(_json.dumps({"upserted": count, "id": f"solved:{session_id}"},
                               ensure_ascii=False))
        return
    typer.secho(f"OK: {msg}", fg=typer.colors.GREEN)


@memory_app.command("solved-search")
def solved_search_cmd(
    question: str = typer.Argument(..., help="Domanda da confrontare con quelle risolte."),
    top: int = typer.Option(3, "--top"),
    json_out: bool = typer.Option(False, "--json", help="Output JSON (per Pi)."),
    config: Path = CONFIG_OPT,
) -> None:
    """Domande gia' risolte simili (kind solved_question): domanda, SQL e tabelle."""
    from rich.console import Console
    from rich.table import Table

    from tht.cli.vector_cmd import make_embedder, open_searcher
    from tht.ports.vector import VectorReadUnavailable, VectorStoreError
    from tht.solved import SOLVED_KIND
    from tht.vectorstore.embeddings import EmbeddingsError

    cfg = _load_config_or_exit(config)
    require_vector_cfg(cfg)
    # Degrado gentile: SKILL.md prescrive solved-search in F4/F6/F7 di ogni sessione,
    # quindi vectordb/Ollama irraggiungibili non devono produrre un traceback grezzo
    # nel transcript: avviso di una riga su stderr, stdout puro ([] in --json), exit 0.
    try:
        searcher = open_searcher(cfg)
        embedder = make_embedder(cfg.embeddings)
        hits = searcher.search(embedder.embed_query(question), top_n=top, kinds=[SOLVED_KIND])
    except (VectorStoreError, VectorReadUnavailable, EmbeddingsError, OperationalError) as e:
        typer.secho(
            f"ATTENZIONE: exemplar non disponibili ({e}). Prosegui senza.",
            fg=typer.colors.YELLOW, err=True,
        )
        if json_out:
            typer.echo("[]")
        return
    results = [
        {
            "session_id": h.metadata.get("session_id", h.ref),
            "question": h.metadata.get("question", h.content),
            "sql": h.metadata.get("sql", ""),
            "tables": h.metadata.get("tables", []),
            "score": round(h.similarity, 4),
        }
        for h in hits
    ]
    if json_out:
        typer.echo(json.dumps(results, ensure_ascii=False, indent=2))
        return
    if not results:
        typer.secho("Nessuna domanda risolta simile.", fg=typer.colors.YELLOW)
        return
    table = Table(title=f"Domande risolte simili a: {question}")
    table.add_column("Sessione")
    table.add_column("Domanda")
    table.add_column("Tabelle")
    table.add_column("Score", justify="right")
    for r in results:
        table.add_row(r["session_id"], r["question"][:60],
                      ", ".join(r["tables"]), f"{r['score']:.3f}")
    Console().print(table)

@memory_app.command("migrate")
def memory_migrate_cmd(
    config: Path = CONFIG_OPT,
    json_output: bool = typer.Option(False, "--json"),
) -> None:
    """Migrate the legacy artifacts/memory registry to the explicit workspace memory root (P3).

    Copies and verifies exactly one legacy canonical JSONL under the workspace lock, then rebuilds
    the Qdrant projection. Conflicting legacy registries fail closed; no in-place reinterpretation.
    """
    from tht.memory import load_registry

    cfg = _load_config_or_exit(config)
    target_root = getattr(cfg.paths, "memory", None)
    if target_root is None:
        payload = {"status": "failed", "error": "explicit memory root is not configured"}
        if json_output:
            typer.echo(json.dumps(payload, sort_keys=True))
        else:
            typer.secho("ERRORE: memory root esplicito non configurato", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)
    legacy = cfg.paths.artifacts / "memory" / "registry.jsonl"
    target = registry_path(cfg)
    if target.exists():
        payload = {"status": "unchanged", "path": str(target)}
        if json_output:
            typer.echo(json.dumps(payload, sort_keys=True))
        else:
            typer.secho(f"OK: memory registry già in {target}", fg=typer.colors.GREEN)
        return
    if not legacy.exists():
        payload = {"status": "failed", "error": "legacy memory registry is missing"}
        if json_output:
            typer.echo(json.dumps(payload, sort_keys=True))
        else:
            typer.secho("ERRORE: registry legacy mancante", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)
    try:
        records = load_registry(legacy)
    except Exception:  # noqa: BLE001
        payload = {"status": "failed", "error": "legacy memory registry is invalid"}
        if json_output:
            typer.echo(json.dumps(payload, sort_keys=True))
        else:
            typer.secho("ERRORE: registry legacy non valido", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)
    target_root.mkdir(parents=True, exist_ok=True)
    from tht.memory import save_registry

    save_registry(records, target)
    if load_registry(target) != records:
        target.unlink(missing_ok=True)
        payload = {"status": "failed", "error": "memory registry migration verification failed"}
        if json_output:
            typer.echo(json.dumps(payload, sort_keys=True))
        else:
            typer.secho("ERRORE: verifica migrazione fallita", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=1)
    payload = {"status": "migrated", "path": str(target), "records": len(records)}
    if json_output:
        typer.echo(json.dumps(payload, sort_keys=True))
    else:
        typer.secho(f"OK: migrate {len(records)} record verso {target}", fg=typer.colors.GREEN)