demo/src/ui.py

from __future__ import annotations

import json
import tempfile
from pathlib import Path
from zipfile import ZipFile

import gradio as gr
import pandas as pd

from src.domain import PolicyAction
from src.generator import scenario_by_id, scenarios
from src.i18n import TEXTS, t
from src.pipeline import result_to_downloads, run_pipeline
from src.plots import compare_figure, empty_plot, kpi_html, leftover_figure, type_figure

ROOT = Path(__file__).resolve().parents[1]
SAMPLE_PREVIEW = ROOT / "examples" / "sample_preview.json"
CSS = """
.gradio-container {max-width: 1360px !important; margin: 0 auto;}
.aria-header h1 {margin-bottom: 0.2rem;}
.aria-header p {opacity: 0.85;}
.kpi-grid {display:grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px;}
.kpi-card {background: linear-gradient(180deg, #eef2ff, #ffffff); border: 1px solid #c7d2fe; border-radius: 16px; padding: 14px 16px;}
.kpi-label {font-size: 0.8rem; color: #3730a3; margin: 0;}
.kpi-value {font-size: 1.55rem; font-weight: 700; color: #1e1b4b; margin: 4px 0;}
.kpi-sub {margin: 0; font-size: 0.78rem; color: #334155;}
.rtl-mode {direction: rtl; text-align: right;}
.ltr-id {direction: ltr; text-align: left; font-family: ui-monospace, Consolas, monospace;}
.doc-view {white-space: pre-wrap; font-family: ui-monospace, Consolas, Tahoma, sans-serif; font-size: 0.92rem; line-height: 1.5;}
.pii-span {background: #fde68a; padding: 0 2px; border-radius: 4px;}
.redact-span {background: #c7d2fe; padding: 0 2px; border-radius: 4px;}
"""


def _preview_payload() -> dict:
    if SAMPLE_PREVIEW.exists():
        return json.loads(SAMPLE_PREVIEW.read_text(encoding="utf-8"))
    return {}


def _scenario_choices() -> list[str]:
    return ["S00"] + [item.scenario_id for item in scenarios()]


def _feedback_choices(lang: str) -> list[str]:
    return [t(lang, "correct"), t(lang, "false_positive"), t(lang, "insufficient"), t(lang, "needs_review")]


def _scenario_meta(scenario_id: str) -> tuple[str, str]:
    if scenario_id == "S00":
        return (
            "Interactive editor. Paste laboratory text or upload a text/CSV/text PDF.",
            "ویرایشگر تعاملی. متن آزمایشگاهی بچسبانید یا فایل متنی/CSV/PDF متن‌دار بارگذاری کنید.",
        )
    item = scenario_by_id(scenario_id)
    return item.description, item.description_fa


def apply_language(lang: str):
    rtl = lang == "fa"
    preview = _preview_payload()
    header = (
        f"<div class='aria-header {'rtl-mode' if rtl else ''}'>"
        f"<h1>{t(lang, 'title')}</h1><p>{t(lang, 'subtitle')}</p><p>{t(lang, 'kind')}</p></div>"
    )
    return (
        gr.update(value=header),
        gr.update(value=t(lang, "run_sample")),
        gr.update(value=t(lang, "cancel")),
        gr.update(value=t(lang, "reset")),
        gr.update(value=t(lang, "load_sample")),
        gr.update(value=t(lang, "apply_review")),
        gr.update(label=t(lang, "scenario")),
        gr.update(label=t(lang, "policy")),
        gr.update(value=t(lang, "sample_note")),
        gr.update(value=preview.get("kpi_html") or kpi_html(preview.get("kpis") or {}, lang)),
        gr.update(open=False, label=t(lang, "advanced")),
        gr.update(value=t(lang, "method_body"), rtl=rtl),
        gr.update(value=t(lang, "upload_hint")),
        gr.update(label=t(lang, "uploads")),
        gr.update(label=t(lang, "editor_text")),
        gr.update(label=t(lang, "feedback"), choices=_feedback_choices(lang), value=_feedback_choices(lang)[3]),
    )


def load_sample_ui(scenario_id: str):
    desc_en, desc_fa = _scenario_meta(scenario_id)
    sample = ""
    if scenario_id == "S00":
        sample = "From: Ava Labian <ava.labian01@aria-lab.test>\nPhone: 09121234567\n"
    return desc_en, desc_fa, sample


def reset_defaults():
    desc_en, desc_fa = _scenario_meta("S01")
    return desc_en, desc_fa, "", "S01", "mask", None


def _suppressed_from_table(table) -> list[str]:
    if table is None:
        return []
    frame = table if isinstance(table, pd.DataFrame) else pd.DataFrame(table)
    if frame.empty or "finding_id" not in frame.columns:
        return []
    keep_col = frame["keep"] if "keep" in frame.columns else True
    suppressed = []
    for finding_id, keep in zip(frame["finding_id"], keep_col if "keep" in frame.columns else [True] * len(frame)):
        flag = str(keep).strip().lower()
        if flag in {"false", "0", "no", ""}:
            suppressed.append(str(finding_id))
    return suppressed


def _detail_markdown(state: dict, finding_id: str, lang: str) -> str:
    result = (state or {}).get("result") or {}
    findings = result.get("findings") or []
    item = next((row for row in findings if row.finding_id == finding_id), None)
    if item is None:
        if findings:
            item = findings[0]
        else:
            return t(lang, "empty")
    return (
        f"**{item.finding_id}** · `{item.doc_id}`\n\n"
        f"`{item.entity_type}` · `{item.rule_id}` · {item.workflow}\n\n"
        f"**{t(lang, 'observed')}.** {item.observed}\n\n"
        f"**{t(lang, 'inference')}.** {item.inference}\n\n"
        f"**{t(lang, 'action')}.** {item.action}"
    )


def _pack_result(result: dict) -> dict:
    files = result_to_downloads(result, Path(tempfile.mkdtemp(prefix="dlp-")))
    zip_path = Path(files["report"]).parent / f"{result['run_id']}_bundle.zip"
    with ZipFile(zip_path, "w") as zipped:
        for path in files.values():
            zipped.write(path, arcname=Path(path).name)
    return files, str(zip_path)


def run_live(lang, scenario_id, pasted, policy, uploads, span_table, previous_state, apply_edits):
    suppressed = _suppressed_from_table(span_table) if apply_edits else []
    result = run_pipeline(
        scenario_id=scenario_id,
        pasted=pasted or "",
        uploads=uploads,
        lang=lang,
        action=PolicyAction(policy),
        suppressed=suppressed,
    )
    if result.get("error") and result["verdict"].value == "invalid_input":
        raise gr.Error(result["error"])
    reason_md = "\n".join(f"- {line}" for line in result["reasons"] if line)
    status = (
        f"**{t(lang, 'status')}:** {result['status_label']}\n\n"
        f"{t(lang, 'live_note')}\n\n{result['narrative']}\n\n{t(lang, 'preview_note')}"
    )
    files, zip_path = _pack_result(result)
    history = pd.DataFrame()
    if previous_state:
        history = pd.DataFrame(
            [
                {"run": "previous", **previous_state.get("kpis", {})},
                {"run": "current", **result["kpis"].model_dump()},
            ]
        )
    finding_ids = [item.finding_id for item in result["findings"]] or ["—"]
    preview = _preview_payload()
    return (
        kpi_html(result["kpis"], lang),
        status,
        reason_md,
        result["before_html"],
        result["after_html"],
        pd.DataFrame(result["span_rows"]),
        pd.DataFrame(result["doc_rows"]),
        pd.DataFrame(result["finding_rows"]),
        pd.DataFrame(result["comparison"]),
        pd.DataFrame(preview.get("catalog") or []),
        compare_figure(result["scores"], t(lang, "compare_plot")),
        type_figure(next(score for key, score in result["scores"].items() if str(getattr(key, "value", key)) == "checksum_policy"), t(lang, "type_plot")),
        leftover_figure(result["doc_rows"], t(lang, "left_plot")),
        gr.update(choices=finding_ids, value=finding_ids[0]),
        _detail_markdown({"result": result}, finding_ids[0], lang),
        zip_path,
        files["report"],
        history,
        {"kpis": result["kpis"].model_dump(), "result": result},
        json.dumps([item.model_dump() for item in result["validation"].issues], indent=2),
        json.dumps(result.get("challenger_notes") or [], indent=2, ensure_ascii=False),
        f"run `{result['run_id']}` · hash `{result['input_hash']}` · policy `{result['policy_action']}`",
        result.get("redacted_text") or "",
    )


def select_finding(lang, finding_id, state):
    return _detail_markdown(state or {}, finding_id, lang)


def build_demo() -> gr.Blocks:
    preview = _preview_payload()
    first = scenarios()[0]
    preview_kpis = preview.get("kpis") or {
        "n_docs": 20,
        "n_spans": 60,
        "policy_precision": 1.0,
        "policy_recall": 1.0,
        "baseline_precision": 0.6,
        "baseline_recall": 0.5,
        "leftover_exports": 0,
        "elapsed_ms": 40,
        "engine_profile": "presidio-style-checksum-policy",
    }

    with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="blue"), css=CSS) as demo:
        lang = gr.Radio(["en", "fa"], value="en", label=TEXTS["en"]["language"])
        header = gr.HTML()
        with gr.Row():
            run_btn = gr.Button(t("en", "run_sample"), variant="primary")
            cancel_btn = gr.Button(t("en", "cancel"), variant="stop")
            reset_btn = gr.Button(t("en", "reset"))
            load_btn = gr.Button(t("en", "load_sample"))
            apply_btn = gr.Button(t("en", "apply_review"))
        note = gr.Markdown(t("en", "sample_note"))
        kpis = gr.HTML(preview.get("kpi_html") or kpi_html(preview_kpis, "en"))
        status = gr.Markdown(t("en", "empty"))
        run_md = gr.Markdown("run —")

        with gr.Row():
            with gr.Column(scale=1):
                scenario = gr.Dropdown(choices=_scenario_choices(), value=first.scenario_id, label=t("en", "scenario"))
                policy = gr.Radio(["mask", "remove"], value="mask", label=t("en", "policy"))
                desc_en = gr.Textbox(value=first.description, label="Scenario (EN)", lines=4)
                desc_fa = gr.Textbox(value=first.description_fa, label="سناریو", lines=3, rtl=True)
                findings = gr.Dataframe(label="Span review (toggle keep)")
                finding_pick = gr.Dropdown(choices=["—"], value="—", label="Finding")
            with gr.Column(scale=1):
                reasons = gr.Markdown()
                before = gr.HTML()
            with gr.Column(scale=1):
                after = gr.HTML()
                detail = gr.Markdown()
                redacted_box = gr.Textbox(label="Redacted preview (plain)", lines=8)
                feedback = gr.Radio(choices=_feedback_choices("en"), value=_feedback_choices("en")[3], label=t("en", "feedback"))
                with gr.Row():
                    zip_out = gr.File(label="CSV / JSON / PDF bundle")
                    json_out = gr.File(label="JSON report")

        with gr.Tabs():
            with gr.Tab("Data"):
                hint = gr.Markdown(t("en", "upload_hint"))
                with gr.Accordion(t("en", "advanced"), open=False) as advanced:
                    uploads = gr.File(
                        label=t("en", "uploads"),
                        file_count="multiple",
                        file_types=[".txt", ".csv", ".pdf", ".json", ".jsonl"],
                    )
                    pasted = gr.Textbox(value="", label=t("en", "editor_text"), lines=8)
            with gr.Tab("Findings"):
                docs = gr.Dataframe(label="Documents")
                finding_table = gr.Dataframe(label="Findings")
                type_plot = gr.Plot(value=empty_plot("—"))
            with gr.Tab("Evidence"):
                leftover_plot = gr.Plot(value=empty_plot("—"))
            with gr.Tab("Compare"):
                compare_plot = gr.Plot(value=empty_plot("—"))
                comparison = gr.Dataframe(label="Regex-only vs checksum policy")
                catalog = gr.Dataframe(label="Recorded catalog")
                history = gr.Dataframe(label="Previous vs current KPIs")
            with gr.Tab("Method and limits"):
                method_md = gr.Markdown(t("en", "method_body"))
                issues = gr.Code(language="json", label="Validation issues")
                challenger = gr.Code(language="json", label="Review-list challenger (no paid API)")
                gr.Markdown(
                    "Organization: [AriaAICompany](https://huggingface.co/AriaAICompany) · "
                    "Dataset: [dlp-lab](https://huggingface.co/datasets/AriaAICompany/dlp-lab) · "
                    "Site: [aria-ai.ir](https://aria-ai.ir/) · "
                    "Not secret scanning (project 8), not tenant ACL (project 23)."
                )

        previous = gr.State(None)
        outputs_lang = [
            header, run_btn, cancel_btn, reset_btn, load_btn, apply_btn, scenario, policy,
            note, kpis, advanced, method_md, hint, uploads, pasted, feedback,
        ]
        lang.change(apply_language, inputs=[lang], outputs=outputs_lang)
        demo.load(apply_language, inputs=[lang], outputs=outputs_lang)
        scenario.change(load_sample_ui, inputs=[scenario], outputs=[desc_en, desc_fa, pasted])
        load_btn.click(load_sample_ui, inputs=[scenario], outputs=[desc_en, desc_fa, pasted])
        reset_btn.click(reset_defaults, outputs=[desc_en, desc_fa, pasted, scenario, policy, uploads])

        outputs_run = [
            kpis, status, reasons, before, after, findings, docs, finding_table, comparison, catalog,
            compare_plot, type_plot, leftover_plot, finding_pick, detail, zip_out, json_out,
            history, previous, issues, challenger, run_md, redacted_box,
        ]
        click = run_btn.click(
            lambda lang, scenario, pasted, policy, uploads, findings, previous: run_live(
                lang, scenario, pasted, policy, uploads, findings, previous, False
            ),
            inputs=[lang, scenario, pasted, policy, uploads, findings, previous],
            outputs=outputs_run,
        )
        apply_click = apply_btn.click(
            lambda lang, scenario, pasted, policy, uploads, findings, previous: run_live(
                lang, scenario, pasted, policy, uploads, findings, previous, True
            ),
            inputs=[lang, scenario, pasted, policy, uploads, findings, previous],
            outputs=outputs_run,
        )
        cancel_btn.click(None, cancels=[click, apply_click])
        finding_pick.change(select_finding, inputs=[lang, finding_pick, previous], outputs=[detail])

    return demo