#!/usr/bin/env python3
"""Train and run a reproducible non-graph FinGovBench text baseline.

The baseline uses only public development labels and a flat serialization of each
public workflow record.  It deliberately excludes dependency edges.  A predicted
review therefore covers every auditable component rather than a graph-derived path.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline


ROOT = Path(__file__).resolve().parents[1]
AUDITABLE = {
    "configuration", "evidence", "claim", "claim_evidence_relation", "model",
    "tool", "workflow_state", "decision", "action", "control", "governance",
}


def release_path(relative: str) -> Path:
    """Resolve both the source-tree and stand-alone Hugging Face layouts."""
    direct = ROOT / relative
    return direct if direct.exists() else ROOT / "hf" / relative


def load_jsonl(path: Path) -> list[dict]:
    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]


def load_inputs() -> dict[str, list[dict]]:
    return {
        split: load_jsonl(release_path(f"closed_loop_inputs/{split}.jsonl"))
        for split in ("development", "validation", "test")
    }


def load_development_labels() -> dict[str, dict]:
    path = release_path("public_labels/development.jsonl")
    return {row["case_id"]: row for row in load_jsonl(path)}


def flat_text(row: dict) -> str:
    """Serialize public content while intentionally discarding graph edges."""
    workflow = row["workflow"]
    public = {
        "domain": row["domain"],
        "as_of": row["as_of"],
        "workflow_context": row["workflow_context"],
        "event": row["event"],
        "assurance_claims": row.get("assurance_claims", []),
        "red_line_controls": row.get("red_line_controls", []),
        "components": workflow["components"],
    }
    return json.dumps(public, sort_keys=True, separators=(",", ":"))


def auditable_ids(row: dict) -> list[str]:
    return sorted(
        node["node_id"]
        for node in row["workflow"]["components"]
        if node["node_type"] in AUDITABLE
    )


def make_classifier() -> Pipeline:
    return Pipeline([
        ("tfidf", TfidfVectorizer(
            lowercase=True,
            ngram_range=(1, 2),
            min_df=2,
            max_features=50_000,
            sublinear_tf=True,
        )),
        ("classifier", LogisticRegression(
            C=1.0,
            class_weight="balanced",
            max_iter=2_000,
            random_state=20260922,
        )),
    ])


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--output",
        type=Path,
        default=ROOT / "results/reference_baselines/flat_text.jsonl",
    )
    args = parser.parse_args()
    inputs = load_inputs()
    labels = load_development_labels()
    development = inputs["development"]
    x_train = [flat_text(row) for row in development]
    release_train = [
        int(labels[row["case_id"]]["gold"]["release_permitted"])
        for row in development
    ]
    action_train = [
        labels[row["case_id"]]["gold"]["governance_action"]
        for row in development
    ]
    release_model = make_classifier().fit(x_train, release_train)
    action_model = make_classifier().fit(x_train, action_train)

    rows = [row for split in ("development", "validation", "test") for row in inputs[split]]
    text = [flat_text(row) for row in rows]
    release_probability = release_model.predict_proba(text)[:, list(release_model.classes_).index(1)]
    predicted_actions = action_model.predict(text)
    predictions = []
    for row, probability, action in zip(rows, release_probability, predicted_actions):
        release = bool(probability >= 0.5)
        action = "release" if release else (str(action) if action != "release" else "escalate")
        scope = [] if release else auditable_ids(row)
        predictions.append({
            "case_id": row["case_id"],
            "method": "flat_text",
            "model": "tfidf-logistic-regression",
            "measurement_channel": "flat public-record text; dependency edges excluded",
            "iceberg_detected": not release,
            "governance_action": action,
            "affected_components": scope,
            "revalidation_components": scope,
            "reviewed_components": scope,
            "release_permitted": release,
            "diagnostic": {"release_probability": float(probability)},
        })
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(
        "".join(json.dumps(row, sort_keys=True) + "\n" for row in sorted(predictions, key=lambda x: x["case_id"]))
    )
    print(json.dumps({
        "method": "flat_text",
        "training_cases": len(development),
        "predictions": len(predictions),
        "output": str(args.output),
        "uses_dependencies": False,
        "uses_language_model": False,
    }, indent=2))


if __name__ == "__main__":
    main()