rar-autopass/app/api/v1/router.py

"""API v1 — suprafata gateway (schelet).

Endpointuri din plan.md sect. 4. In schelet:
  - POST /v1/prezentari: enqueue cu idempotenta (dedup pe idempotency_key UNIQUE).
  - GET  /v1/prezentari, /v1/prezentari/{id}: monitorizare coada.
  - GET  /v1/nomenclator: cache local.
  - GET  /v1/mapari: listare mapari cont.
Validarea completa (T3), maparea op->cod, auth API-key, redactarea creds in
middleware (CORE) si exportul CSV vin ulterior — marcate TODO unde lipsesc.
"""

from __future__ import annotations

import csv
import io
import json

from fastapi import APIRouter, Depends, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field

from ...auth import resolve_account_id
from ...crypto import encrypt_creds
from ...db import get_connection
from ...errors import eroare as err_eroare
from ...idempotency import build_key, canonicalize_row
from ...mapping import (
    account_or_default,
    account_scope_clause,
    classify_prezentare,
    load_mapping_meta,
    pending_unmapped,
    reresolve_account,
    save_mapping,
)
from ...models import (
    PrezentareRequest,
    PrezentariResponse,
    SubmissionResult,
    ValidarePrezentariRequest,
    ValidareResponse,
    ValidareResult,
)
from ...payload_view import prezentare_din_payload

router = APIRouter(prefix="/v1", tags=["v1"])


@router.post("/prezentari", response_model=PrezentariResponse)
def create_prezentari(
    req: PrezentareRequest,
    account_id: int = Depends(resolve_account_id),
) -> PrezentariResponse:
    """Enqueue una/mai multe prezentari. Idempotent: continut identic -> acelasi submission.

    Validarea de continut (T3, app.validation) ruleaza inainte de enqueue:
    esecurile NU resping cererea, ci enqueue-aza cu status `needs_data` + motiv
    (plan.md sect. 3). JSON malformat -> 422 din Pydantic (validare de shape).
    account_id vine din cheia API (resolve_account_id): cont real cu cheie,
    implicit id=1 in dev fara cheie, 401 fara cheie valida in prod.
    Nota: rar_credentials NU se persista (zero-storage) — worker-ul le va primi
          pe alt canal (T2); in schelet enqueue-ul doar stocheaza prezentarea.
    Cand rar_credentials lipseste, submission-ul intra fara creds efemere: worker-ul
    cade pe creds-urile durabile ale contului (`accounts.rar_creds_enc`).
    """
    acct = account_or_default(account_id)
    # Creds RAR efemere: criptate si lipite de fiecare submission nou pana la
    # primul login reusit pentru cont (worker le sterge atunci). Zero-storage at
    # rest — niciodata in clar in DB/loguri (plan sect. 5). Optional: cand lipsesc,
    # creds_enc=NULL si worker-ul foloseste creds-urile durabile ale contului.
    creds_enc = encrypt_creds(req.rar_credentials.model_dump()) if req.rar_credentials else None
    conn = get_connection()
    results: list[SubmissionResult] = []
    try:
        # T6/OV-1: load_mapping_meta include auto_send per op (gate pentru coduri noi).
        mapping_meta = load_mapping_meta(conn, acct)
        mapping = {op: meta["cod_prestatie"] for op, meta in mapping_meta.items()}
        for prez in req.prezentari:
            content = prez.model_dump()
            # T9/OV-2: canonicalize_row inaintea build_key (odometru strip ".0", VIN upper).
            # build_key aplica account_or_default(account_id) inainte de hash:
            # None si 1 colapseaza la aceeasi cheie (canal API + canal import).
            canon = canonicalize_row(content)
            key = build_key(account_id, canon)
            # Aplica normalizarea si in content (odometru canonicalizat inainte de validare, §3.4bis)
            content.update({
                "vin": canon["vin"],
                "nr_inmatriculare": canon["nr_inmatriculare"],
                "odometru_final": canon["odometru_final"],
            })
            existing = conn.execute(
                "SELECT id, status, id_prezentare FROM submissions WHERE idempotency_key=?",
                (key,),
            ).fetchone()
            if existing:
                results.append(
                    SubmissionResult(
                        submission_id=existing["id"],
                        status=existing["status"],
                        id_prezentare=existing["id_prezentare"],
                        deduped=True,
                    )
                )
                continue

            # Helper pur partajat cu dry-run (PRD 5.2): reproduce EXACT clasificarea
            # (canonicalize + mapare op->cod + validare + auto_send gate).
            cl = classify_prezentare(content, mapping, mapping_meta)
            cur = conn.execute(
                "INSERT INTO submissions (idempotency_key, account_id, status, payload_json, rar_error, rar_creds_enc) "
                "VALUES (?, ?, ?, ?, ?, ?)",
                (key, acct, cl["status"], json.dumps(cl["content"], ensure_ascii=False), cl["rar_error"], creds_enc),
            )
            results.append(SubmissionResult(submission_id=int(cur.lastrowid), status=cl["status"]))
    finally:
        conn.close()
    return PrezentariResponse(results=results)


@router.post("/prezentari/valideaza", response_model=ValidareResponse)
def valideaza_prezentari(
    req: ValidarePrezentariRequest,
    account_id: int = Depends(resolve_account_id),
) -> ValidareResponse:
    """Dry-run: valideaza payload exact ca POST /prezentari, fara enqueue si fara efecte secundare.

    Intoarce pentru fiecare prezentare: verdictul (status_estimat), erorile de
    continut si codurile nemapate — exact ce ar obtine trimiterea reala pe acelasi
    payload + aceeasi mapare de cont. rar_credentials ignorat complet (PRD 5.2).
    """
    acct = account_or_default(account_id)
    conn = get_connection()
    results: list[ValidareResult] = []
    try:
        mapping_meta = load_mapping_meta(conn, acct)
        mapping = {op: meta["cod_prestatie"] for op, meta in mapping_meta.items()}
        for i, prez in enumerate(req.prezentari):
            content = prez.model_dump()
            res = classify_prezentare(content, mapping, mapping_meta)
            # US-003: imbogatim fiecare element nemapat cu 3 niveluri COD_NEMAPAT
            nemapate = [
                {**u, **err_eroare("COD_NEMAPAT", cauza=f"cod {u.get('cod_op_service')} fara mapare RAR")}
                for u in res["unmapped"]
            ]
            results.append(ValidareResult(
                index=i,
                valid=(res["status"] == "queued"),
                status_estimat=res["status"],
                erori=res["errors"],
                nemapate=nemapate,
                prestatii_rezolvate=res["resolved"],
            ))
    finally:
        conn.close()
    return ValidareResponse(results=results)


@router.get("/prezentari")
def list_prezentari(
    status: str | None = None,
    limit: int = 100,
    account_id: int = Depends(resolve_account_id),
) -> dict:
    conn = get_connection()
    try:
        scope_sql, scope_params = account_scope_clause(account_id)
        # payload_json e plaintext (vezi submissions.payload_json); il citim doar ca
        # sa derivam campurile afisabile prin helper-ul partajat (US-003, DRY), nu il expunem.
        cols = (
            "id, status, id_prezentare, rar_status_code, retry_count, "
            "created_at, updated_at, payload_json"
        )
        if status:
            rows = conn.execute(
                f"SELECT {cols} FROM submissions WHERE {scope_sql} AND status=? "
                f"ORDER BY id DESC LIMIT ?",
                scope_params + [status, limit],
            ).fetchall()
        else:
            rows = conn.execute(
                f"SELECT {cols} FROM submissions WHERE {scope_sql} ORDER BY id DESC LIMIT ?",
                scope_params + [limit],
            ).fetchall()
        out = []
        for r in rows:
            d = dict(r)
            # Campuri afisabile derivate din payload (acelasi helper ca dashboardul web);
            # payload_json brut nu se intoarce in raspuns.
            d["prezentare"] = prezentare_din_payload(d.pop("payload_json", None))
            out.append(d)
        return {"submissions": out}
    finally:
        conn.close()


# Campuri expuse de GET /v1/prezentari/{id} — allowlist explicita (B4).
# Exclude: rar_creds_enc, payload_json, idempotency_key, rar_error, sending_since.
_PREZENTARE_FIELDS = frozenset({
    "id", "status", "id_prezentare", "rar_status_code", "retry_count",
    "next_attempt_at", "created_at", "updated_at", "account_id",
    "batch_id", "row_index", "purge_after",
})


@router.get("/prezentari/{submission_id}")
def get_prezentare(
    submission_id: int,
    account_id: int = Depends(resolve_account_id),
) -> dict:
    conn = get_connection()
    try:
        scope_sql, scope_params = account_scope_clause(account_id)
        row = conn.execute(
            f"SELECT * FROM submissions WHERE id=? AND {scope_sql}",
            [submission_id] + scope_params,
        ).fetchone()
        if not row:
            # B3: acelasi mesaj indiferent daca randul exista dar apartine altui cont
            # sau nu exista deloc — nu confirmam existenta.
            raise HTTPException(status_code=404, detail="submission inexistent")
        row_dict = dict(row)
        return {k: v for k, v in row_dict.items() if k in _PREZENTARE_FIELDS}
    finally:
        conn.close()


@router.get("/nomenclator")
def get_nomenclator() -> dict:
    conn = get_connection()
    try:
        rows = conn.execute(
            "SELECT cod_prestatie, nume_prestatie, updated_at FROM nomenclator_rar ORDER BY cod_prestatie"
        ).fetchall()
        return {"nomenclator": [dict(r) for r in rows]}
    finally:
        conn.close()


AUDIT_COLUMNS = [
    "submission_id",
    "status",
    "id_prezentare",
    "account_id",
    "vin",
    "nr_inmatriculare",
    "data_prestatie",
    "odometru_final",
    "prestatii",
    "rar_status_code",
    "created_at",
    "updated_at",
    "purge_after",
]


def _audit_rows(conn, date_from: str | None, date_to: str | None, status: str, account_id: int):
    """Randuri audit filtrate pe cont + data(updated_at) in [from, to].

    account_id = contul cheii API (scope obligatoriu — PII in CSV). Randuri cu
    account_id IS NULL apartin contului 1 (legacy/OV-2). payload_json e text in
    schelet; b64_image NU intra in CSV.
    """
    scope_sql, scope_params = account_scope_clause(account_id)
    sql = (
        "SELECT id, status, id_prezentare, account_id, payload_json, rar_status_code, "
        "created_at, updated_at, purge_after FROM submissions"
    )
    where = [scope_sql]
    params: list = list(scope_params)
    if status != "all":
        where.append("status=?")
        params.append(status)
    if date_from:
        where.append("date(updated_at) >= date(?)")
        params.append(date_from)
    if date_to:
        where.append("date(updated_at) <= date(?)")
        params.append(date_to)
    sql += " WHERE " + " AND ".join(where)
    sql += " ORDER BY id"

    for r in conn.execute(sql, params).fetchall():
        try:
            p = json.loads(r["payload_json"]) if r["payload_json"] else {}
        except (ValueError, TypeError):
            p = {}
        codes = ",".join(
            (it.get("cod_prestatie") or it.get("cod_op_service") or "")
            for it in (p.get("prestatii") or [])
            if isinstance(it, dict)
        )
        yield {
            "submission_id": r["id"],
            "status": r["status"],
            "id_prezentare": r["id_prezentare"] or "",
            # NULL→cont 1 (OV-2): coloana reflecta invariantul de scope, nu "" ambiguu.
            "account_id": account_or_default(r["account_id"]),
            "vin": p.get("vin") or "",
            "nr_inmatriculare": p.get("nr_inmatriculare") or "",
            "data_prestatie": p.get("data_prestatie") or "",
            "odometru_final": p.get("odometru_final") or "",
            "prestatii": codes,
            "rar_status_code": r["rar_status_code"] or "",
            "created_at": r["created_at"],
            "updated_at": r["updated_at"],
            "purge_after": r["purge_after"] or "",
        }


@router.get("/audit/export")
def audit_export(
    date_from: str | None = None,
    date_to: str | None = None,
    status: str = "sent",
    account_id: int = Depends(resolve_account_id),
) -> StreamingResponse:
    """CSV audit scoped pe contul cheii API. Filtre optionale `date_from`/`date_to` (YYYY-MM-DD)

    pe data(updated_at). `status` implicit `sent` (ce a ajuns efectiv la RAR);
    `status=all` exporta toata coada contului. Leaga retinerea 90 zile prin coloana
    `purge_after` (plan.md sect. 4 + 8). b64_image nu se exporta.
    """
    conn = get_connection()
    try:
        buf = io.StringIO()
        writer = csv.DictWriter(buf, fieldnames=AUDIT_COLUMNS)
        writer.writeheader()
        for row in _audit_rows(conn, date_from, date_to, status, account_id):
            writer.writerow(row)
        data = buf.getvalue()
    finally:
        conn.close()

    fname = f"audit_{status}_{date_from or 'inceput'}_{date_to or 'azi'}.csv"
    return StreamingResponse(
        iter([data]),
        media_type="text/csv",
        headers={"Content-Disposition": f'attachment; filename="{fname}"'},
    )


@router.get("/mapari")
def get_mapari(
    key_account: int = Depends(resolve_account_id),
    account_id: int | None = None,
) -> dict:
    """Maparile operatie->cod ale contului curent.

    Parametrul `account_id` din query e pastrat pentru compatibilitate, dar contul
    efectiv vine MEREU din cheia API (TD-3.2). Daca e prezent si difera -> 400.
    """
    if account_id is not None and account_id != key_account:
        raise HTTPException(
            status_code=400,
            detail="account_id din query nu corespunde contului cheii API",
        )
    conn = get_connection()
    try:
        rows = conn.execute(
            "SELECT * FROM operations_mapping WHERE account_id=? ORDER BY cod_op_service",
            (key_account,),
        ).fetchall()
        return {"mapari": [dict(r) for r in rows]}
    finally:
        conn.close()


@router.get("/mapari/pending")
def get_mapari_pending(
    account_id: int = Depends(resolve_account_id),
) -> dict:
    """Operatii ROAAUTO nemapate (din submission-uri needs_mapping) + sugestii fuzzy.

    Filtrate pe contul cheii API. Fiecare intrare: {account_id, cod_op_service,
    denumire, blocked, suggestions:[{cod_prestatie, nume_prestatie, score}]}.
    """
    conn = get_connection()
    try:
        return {"pending": pending_unmapped(conn, account_id=account_id)}
    finally:
        conn.close()


class MapareIn(BaseModel):
    cod_op_service: str = Field(..., min_length=1)
    cod_prestatie: str = Field(..., min_length=1)
    auto_send: bool = True


@router.post("/mapari")
def create_mapare(
    req: MapareIn,
    account_id: int = Depends(resolve_account_id),
) -> dict:
    """Salveaza/actualizeaza o mapare op->cod si re-rezolva submission-urile blocate.

    Contul vine din cheia API (NU din body) — un cont nu poate edita maparile
    altuia. Verifica intai ca `cod_prestatie` exista in nomenclator (nu lasam
    mapari catre coduri inexistente). Apoi upsert + re-rezolvare `needs_mapping`.
    """
    conn = get_connection()
    try:
        cod = req.cod_prestatie.strip().upper()
        exists = conn.execute(
            "SELECT 1 FROM nomenclator_rar WHERE cod_prestatie=?", (cod,)
        ).fetchone()
        if not exists:
            raise HTTPException(status_code=422, detail=f"cod_prestatie '{cod}' nu exista in nomenclator")
        save_mapping(conn, account_id, req.cod_op_service, cod, req.auto_send)
        stats = reresolve_account(conn, account_id)
        return {"saved": {"cod_op_service": req.cod_op_service.strip(), "cod_prestatie": cod}, "reresolve": stats}
    finally:
        conn.close()


class RarCredsIn(BaseModel):
    """Creds RAR durabile per-cont (D4). Stocate criptate (Fernet) in accounts.rar_creds_enc."""

    email: str = Field(..., min_length=1)
    password: str = Field(..., min_length=1, repr=False)


@router.post("/conturi/rar-creds")
def set_rar_creds(
    req: RarCredsIn,
    account_id: int = Depends(resolve_account_id),
) -> dict:
    """Seteaza creds RAR durabile per-cont (D4/T1).

    Criptate Fernet in accounts.rar_creds_enc. Worker-ul le foloseste ca fallback
    cand submission-ul nu mai are creds (canal web fara re-pusher, restart worker).
    Contul vine din cheia API.
    """
    acct = account_or_default(account_id)
    enc = encrypt_creds({"email": req.email, "password": req.password})
    conn = get_connection()
    try:
        conn.execute(
            "UPDATE accounts SET rar_creds_enc=? WHERE id=?",
            (enc, acct),
        )
        return {"ok": True, "account_id": acct}
    finally:
        conn.close()


@router.delete("/conturi/rar-creds")
def delete_rar_creds(
    account_id: int = Depends(resolve_account_id),
) -> dict:
    """Sterge creds RAR durabile per-cont (revenire la modelul efemer Treapta 1)."""
    acct = account_or_default(account_id)
    conn = get_connection()
    try:
        conn.execute("UPDATE accounts SET rar_creds_enc=NULL WHERE id=?", (acct,))
        return {"ok": True, "account_id": acct}
    finally:
        conn.close()