#!/usr/bin/env python3
"""Validate SAEI-CLINDDx JSONL structure, corpus integrity, and provisional release QA.

Usage (from repository root):
    python scripts/validate_dataset.py
    python scripts/validate_dataset.py --schema-only
    python scripts/validate_dataset.py --report reports/validation_results.json
    python scripts/validate_dataset.py --expected-count 251

Exit codes: 0 = checks passing; 1 = errors found; 2 = input/usage failure.
Requires: pip install 'jsonschema>=4.18'
"""
import argparse
import json
import re
import sys
from collections import Counter
from pathlib import Path

from jsonschema import Draft202012Validator

ERROR_MARKER = re.compile(r"(?<![A-Za-z])#(?:ERROR!|REF!|VALUE!|N/A|NAME\?|DIV/0!|NUM!|NULL!)(?![A-Za-z])", re.I)


def finding(severity, code, file, line=None, case_id=None, field=None, message=""):
    return {"severity": severity, "code": code, "file": str(file), "line": line,
            "case_id": case_id, "field": field, "message": message}


def read_records(path, validator, language, out):
    records = {}
    if not path.is_file():
        out.append(finding("error", "missing_file", path, message="Expected JSONL file does not exist"))
        return records
    with path.open("r", encoding="utf-8-sig") as fh:
        for line_no, raw in enumerate(fh, 1):
            if not raw.strip():
                out.append(finding("error", "empty_line", path, line_no, message="Blank JSONL line"))
                continue
            try:
                rec = json.loads(raw)
            except json.JSONDecodeError as exc:
                out.append(finding("error", "invalid_json", path, line_no, message=str(exc)))
                continue
            if not isinstance(rec, dict):
                out.append(finding("error", "not_object", path, line_no, message="Each JSONL line must be an object"))
                continue
            case_id = rec.get("id") if isinstance(rec.get("id"), str) else None
            for err in sorted(validator.iter_errors(rec), key=lambda e: list(map(str,e.absolute_path))):
                field = ".".join(map(str, err.absolute_path)) or None
                out.append(finding("error", "schema", path, line_no, case_id, field, err.message))
            if rec.get("language") != language:
                out.append(finding("error", "language_folder", path, line_no, case_id,
                                   "language", f"Expected {language!r} for this directory"))
            if case_id is not None:
                if case_id in records:
                    out.append(finding("error", "duplicate_id", path, line_no, case_id,
                                       "id", "Duplicate case ID within language"))
                else:
                    records[case_id] = (rec, line_no)
            if isinstance(rec.get("year"), int) and not isinstance(rec.get("year"), bool) and case_id:
                m = re.fullmatch(r"saei-(\d{4})-\d{4,}", case_id)
                if m and int(m.group(1)) != rec["year"]:
                    out.append(finding("error", "year_id_conflict", path, line_no, case_id,
                                       "year", "ID year differs from record year"))
    return records


def integrity_checks(es, en, es_path, en_path, out, expected_count):
    for lang, records, path in [("es", es, es_path), ("en", en, en_path)]:
        if expected_count is not None and len(records) != expected_count:
            out.append(finding("error", "record_count", path,
                               message=f"Expected {expected_count} unique IDs; found {len(records)}"))
    for lang, records, path, other in [("es", es, es_path, en), ("en", en, en_path, es)]:
        for case_id in sorted(records.keys() - other.keys()):
            out.append(finding("error", "unpaired_case", path, records[case_id][1], case_id,
                               "id", f"No corresponding record in {('en' if lang == 'es' else 'es')}"))
    for case_id in sorted(es.keys() & en.keys()):
        es_rec, es_line = es[case_id]
        en_rec, en_line = en[case_id]
        for field in ("year", "authors"):
            if es_rec.get(field) != en_rec.get(field):
                out.append(finding("error", "alignment_metadata", en_path, en_line, case_id,
                                   field, f"{field} differs between es and en"))


def content_checks(records_by_lang, out):
    """Heuristics, not an MQM judgment. Keep source text unchanged."""
    for lang, (records, path) in records_by_lang.items():
        for case_id, (rec, line) in records.items():
            for field, value in rec.items():
                if not isinstance(value, str) or field in {"id", "language"}:
                    continue
                if ERROR_MARKER.search(value):
                    out.append(finding("error", "spreadsheet_error_marker", path, line,
                                       case_id, field, "Spreadsheet/formula error token in text"))
            if rec.get("differential_diagnosis") == "":
                out.append(finding("warning", "missing_differential", path, line,
                                   case_id, "differential_diagnosis", "Empty in source; keep but exclude from DDX-only evaluations"))


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1],
                    help="Repository root containing schema.json and data/{es,en}/test.jsonl")
    ap.add_argument("--schema", type=Path, help="Schema path (default: ROOT/schema.json)")
    ap.add_argument("--report", type=Path, help="Write full machine-readable JSON findings report")
    ap.add_argument("--schema-only", action="store_true", help="Skip translation/content quality flags; still enforce structural and alignment checks")
    ap.add_argument("--expected-count", type=int, default=None,
                    help="Optional fixed count per language; omit for extensible dataset")
    args = ap.parse_args()
    root = args.root.resolve()
    schema_path = (args.schema or root / "schema.json").resolve()
    try:
        schema = json.loads(schema_path.read_text(encoding="utf-8"))
        Draft202012Validator.check_schema(schema)
    except (OSError, ValueError, Exception) as exc:
        print(f"Cannot load valid schema: {exc}", file=sys.stderr)
        return 2
    validator = Draft202012Validator(schema)
    findings = []
    es_path, en_path = (root / "data" / "es" / "test.jsonl", root / "data" / "en" / "test.jsonl")
    es = read_records(es_path, validator, "es", findings)
    en = read_records(en_path, validator, "en", findings)
    integrity_checks(es, en, es_path, en_path, findings, args.expected_count)
    if not args.schema_only:
        content_checks({"es": (es, es_path), "en": (en, en_path)}, findings)
    counts = Counter(f["severity"] for f in findings)
    result = {
        "dataset": "SAEI-CLINDDx", "mode": "schema_and_alignment" if args.schema_only else "schema_alignment_and_content",
        "records": {"es": len(es), "en": len(en)},
        "findings_by_severity": {"error": counts["error"], "warning": counts["warning"]},
        "findings_by_code": dict(Counter(f["code"] for f in findings)),
        "status": "fail" if counts["error"] else "pass",
        "findings": findings,
    }
    print(f"SAEI-CLINDDx: es={len(es)}, en={len(en)}, errors={counts['error']}, warnings={counts['warning']}, status={result['status']}")
    for code, n in sorted(result["findings_by_code"].items()):
        print(f"  {code}: {n}")
    if args.report:
        args.report.parent.mkdir(parents=True, exist_ok=True)
        args.report.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        print(f"Report: {args.report}")
    return 1 if counts["error"] else 0


if __name__ == "__main__":
    sys.exit(main())