from __future__ import annotations

import argparse
import hashlib
import json
import re
from collections import Counter
from pathlib import Path

from jsonschema import Draft202012Validator


FAMILIES = {
    "stale_version",
    "authority_conflict",
    "numeric_conflict",
    "entity_ambiguity",
    "no_answer",
    "multi_hop",
    "cross_lingual",
    "date_boundary",
}

COUNTRIES = {"SA", "AE", "QA", "KW", "BH", "OM"}


def canonical(x):
    return json.dumps(
        x,
        ensure_ascii=False,
        sort_keys=True,
        separators=(",", ":"),
    )


def sha(x):
    return hashlib.sha256(canonical(x).encode("utf-8")).hexdigest()


def first_int(text):
    values = re.findall(r"(?<![\d-])\d+(?![\d-])", text)
    if not values:
        raise ValueError(f"no integer found in: {text}")
    return int(values[-1])


def latest(docs):
    return max(
        docs,
        key=lambda d: (
            d["version"],
            d["effective_date"],
            d["authority_rank"],
        ),
    )


def oracle(row):
    family = row["family"]
    docs = row["documents"]

    if family == "stale_version":
        chosen = latest(docs)
        value = first_int(chosen["content"])
        return {
            "answerable": True,
            "answer": str(value),
            "supporting_doc_ids": [chosen["doc_id"]],
            "rationale_code": "latest_version",
        }

    if family == "authority_conflict":
        chosen = max(docs, key=lambda d: d["authority_rank"])
        value = first_int(chosen["content"])
        return {
            "answerable": True,
            "answer": f"{value} GCCU",
            "supporting_doc_ids": [chosen["doc_id"]],
            "rationale_code": "authority_rank",
        }

    if family == "numeric_conflict":
        chosen = latest(docs)
        value = first_int(chosen["content"])
        return {
            "answerable": True,
            "answer": f"{value} GCCU",
            "supporting_doc_ids": [chosen["doc_id"]],
            "rationale_code": "numeric_latest",
        }

    if family == "entity_ambiguity":
        q = row["query"]

        matches = []
        for d in docs:
            prefix = d["content"].split(":")[0]
            if prefix in q:
                matches.append(d)

        if len(matches) != 1:
            raise ValueError("entity resolution failure")

        chosen = matches[0]
        value = first_int(chosen["content"])

        return {
            "answerable": True,
            "answer": f"{value} days",
            "supporting_doc_ids": [chosen["doc_id"]],
            "rationale_code": "entity_exact_match",
        }

    if family == "no_answer":
        return {
            "answerable": False,
            "answer": None,
            "supporting_doc_ids": [],
            "rationale_code": "insufficient_evidence",
        }

    if family == "multi_hop":
        branch_doc = next(
            d for d in docs
            if "Branch BR-" in d["content"]
        )

        m = re.search(
            r"service plan (PLAN-[A-Z]{2}-\d{2})",
            branch_doc["content"],
        )

        if not m:
            raise ValueError("plan not found")

        plan = m.group(1)

        policy = next(
            d for d in docs
            if plan in d["content"] and d["doc_id"] != branch_doc["doc_id"]
        )

        value = first_int(policy["content"])

        return {
            "answerable": True,
            "answer": f"{value} days",
            "supporting_doc_ids": [
                branch_doc["doc_id"],
                policy["doc_id"],
            ],
            "rationale_code": "multi_hop_join",
        }

    if family == "cross_lingual":
        if len(docs) != 1:
            raise ValueError("cross linguistic fixture malformed")

        value = first_int(docs[0]["content"])

        return {
            "answerable": True,
            "answer": f"{value} days",
            "supporting_doc_ids": [docs[0]["doc_id"]],
            "rationale_code": "cross_lingual",
        }

    if family == "date_boundary":
        target = "2026-08-15"

        eligible = [
            d for d in docs
            if d["effective_date"] <= target
        ]

        chosen = max(
            eligible,
            key=lambda d: d["effective_date"],
        )

        value = first_int(chosen["content"])

        return {
            "answerable": True,
            "answer": f"{value} days",
            "supporting_doc_ids": [chosen["doc_id"]],
            "rationale_code": "effective_date",
        }

    raise ValueError(f"unknown family: {family}")


def validate(rows, schema):
    checker = Draft202012Validator(schema)

    ids = set()
    fingerprints = set()
    stats = Counter()

    for row in rows:
        checker.validate(row)

        if row["id"] in ids:
            raise ValueError("duplicate ID")

        ids.add(row["id"])

        if row["fingerprint_sha256"] in fingerprints:
            raise ValueError("duplicate fingerprint")

        fingerprints.add(row["fingerprint_sha256"])

        if row["country"] not in COUNTRIES:
            raise ValueError("country")

        if row["family"] not in FAMILIES:
            raise ValueError("family")

        if not row["provenance"]["synthetic"]:
            raise ValueError("non synthetic")

        if row["provenance"]["copied_records"] != 0:
            raise ValueError("copied records")

        if row["provenance"]["contains_pii"]:
            raise ValueError("PII flag")

        body = {
            k: v
            for k, v in row.items()
            if k not in {"id", "fingerprint_sha256"}
        }

        expected_id = sha(body)[:32]

        if row["id"] != expected_id:
            raise ValueError(f"id mismatch {row['id']}")

        body_with_id = dict(body)
        body_with_id["id"] = row["id"]

        if sha(body_with_id) != row["fingerprint_sha256"]:
            raise ValueError(f"fingerprint mismatch {row['id']}")

        calculated = oracle(row)
        expected = row["expected"]

        for key in [
            "answerable",
            "answer",
            "supporting_doc_ids",
            "rationale_code",
        ]:
            if expected[key] != calculated[key]:
                raise ValueError(
                    f"oracle mismatch {row['id']} {key}: "
                    f"{expected[key]!r} != {calculated[key]!r}"
                )

        doc_ids = [d["doc_id"] for d in row["documents"]]

        if len(doc_ids) != len(set(doc_ids)):
            raise ValueError("duplicate doc id")

        if any(
            d not in doc_ids
            for d in expected["supporting_doc_ids"]
        ):
            raise ValueError("missing support document")

        if set(expected["supporting_doc_ids"]) & set(expected["rejected_doc_ids"]):
            raise ValueError("support/reject overlap")

        stats[row["family"]] += 1

    return stats


def main():
    p = argparse.ArgumentParser()
    p.add_argument("dataset", type=Path)
    p.add_argument("--schema", type=Path, required=True)
    p.add_argument("--report", type=Path)

    a = p.parse_args()

    rows = [
        json.loads(x)
        for x in a.dataset.read_text(
            encoding="utf-8"
        ).splitlines()
        if x.strip()
    ]

    schema = json.loads(
        a.schema.read_text(encoding="utf-8")
    )

    stats = validate(rows, schema)

    report = {
        "status": "PASS",
        "validated": len(rows),
        "families": dict(stats),
        "unique_ids": len({r["id"] for r in rows}),
        "unique_fingerprints": len(
            {r["fingerprint_sha256"] for r in rows}
        ),
    }

    if a.report:
        a.report.write_text(
            json.dumps(
                report,
                indent=2,
                ensure_ascii=False,
            ),
            encoding="utf-8",
        )

    print(json.dumps(report))


if __name__ == "__main__":
    main()