#!/usr/bin/env python3
"""Validate the PsyAgent JSON archive and create Hugging Face Parquet files.

The source ZIP is read in place. The ZIP itself is never copied into the
publishable output directory.
"""

from __future__ import annotations

import argparse
import collections
import datetime as dt
import hashlib
import json
import re
import shutil
import sys
import zipfile
from pathlib import Path
from typing import Any, Iterable

import pyarrow as pa
import pyarrow.parquet as pq


TRAITS = (
    "Openness",
    "Conscientiousness",
    "Extraversion",
    "Agreeableness",
    "Neuroticism",
)
ALLOWED_TRAIT_VALUES = {0, 20, 40, 60, 80, 100}
EXPECTED_OUTPUTS = 13

MODEL_SPECS = {
    "output_llama_3_2_1B": {
        "config": "llama-3.2-1b-instruct",
        "model_id": "meta-llama/Llama-3.2-1B-Instruct",
    },
    "output_llama_3_2_3B": {
        "config": "llama-3.2-3b-instruct",
        "model_id": "meta-llama/Llama-3.2-3B-Instruct",
    },
    "output_llama_3_1_8B": {
        "config": "llama-3.1-8b-instruct",
        "model_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    },
}

FILE_RE = re.compile(r"^(?P<profile>\d+)_(?P<seed>\d+)\.json$")

SCAN_PATTERNS = {
    "private_key": re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
    "huggingface_token": re.compile(r"\bhf_[A-Za-z0-9]{30,}\b"),
    "openai_token": re.compile(r"\bsk-[A-Za-z0-9_-]{20,}\b"),
    "github_token": re.compile(r"\b(?:ghp|github_pat)_[A-Za-z0-9_]{20,}\b"),
    "aws_access_key": re.compile(r"\b(?:AKIA|ASIA)[A-Z0-9]{16}\b"),
    "email": re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.I),
    "ipv4": re.compile(r"(?<!\d)(?:\d{1,3}\.){3}\d{1,3}(?!\d)"),
    "local_path": re.compile(r"(?:/Users/|/home/|/scratch/|/gpfs/|[A-Z]:\\\\Users\\\\)"),
}

ARROW_SCHEMA = pa.schema(
    [
        pa.field("id", pa.string(), nullable=False),
        pa.field("profile_id", pa.int32(), nullable=False),
        pa.field("seed", pa.int16(), nullable=False),
        pa.field("generator_model", pa.string(), nullable=False),
        pa.field("openness", pa.int16(), nullable=False),
        pa.field("conscientiousness", pa.int16(), nullable=False),
        pa.field("extraversion", pa.int16(), nullable=False),
        pa.field("agreeableness", pa.int16(), nullable=False),
        pa.field("neuroticism", pa.int16(), nullable=False),
        pa.field(
            "outputs",
            pa.list_(
                pa.struct(
                    [
                        pa.field("name", pa.string(), nullable=False),
                        pa.field("content", pa.string(), nullable=False),
                    ]
                )
            ),
            nullable=False,
        ),
        pa.field("source_file", pa.string(), nullable=False),
    ]
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--archive", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--batch-size", type=int, default=256)
    return parser.parse_args()


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def write_rows(writer: pq.ParquetWriter, rows: list[dict[str, Any]]) -> None:
    if rows:
        writer.write_table(pa.Table.from_pylist(rows, schema=ARROW_SCHEMA))
        rows.clear()


def normalized_digest(payload: dict[str, Any]) -> str:
    raw = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()


def scan_text(text: str, source: str, audit: dict[str, dict[str, Any]]) -> None:
    for label, pattern in SCAN_PATTERNS.items():
        count = len(pattern.findall(text))
        if not count:
            continue
        audit[label]["matches"] += count
        audit[label]["file_names"].add(source)
        if source not in audit[label]["example_files"] and len(audit[label]["example_files"]) < 20:
            audit[label]["example_files"].append(source)


def validate_payload(payload: Any, source: str) -> tuple[dict[str, int], list[dict[str, str]]]:
    if not isinstance(payload, dict) or set(payload) != {"big5", "outputs"}:
        raise ValueError(f"{source}: top-level schema is not exactly big5 + outputs")

    big5 = payload["big5"]
    if not isinstance(big5, dict) or set(big5) != set(TRAITS):
        raise ValueError(f"{source}: invalid Big Five fields")
    for trait in TRAITS:
        value = big5[trait]
        if isinstance(value, bool) or not isinstance(value, int) or value not in ALLOWED_TRAIT_VALUES:
            raise ValueError(f"{source}: invalid {trait} value {value!r}")

    outputs = payload["outputs"]
    if not isinstance(outputs, list) or len(outputs) != EXPECTED_OUTPUTS:
        raise ValueError(f"{source}: expected {EXPECTED_OUTPUTS} outputs")
    clean_outputs: list[dict[str, str]] = []
    for index, item in enumerate(outputs):
        if not isinstance(item, dict) or set(item) != {"name", "content"}:
            raise ValueError(f"{source}: output {index} has an invalid schema")
        name = item["name"]
        content = item["content"]
        if not isinstance(name, str) or not name.strip():
            raise ValueError(f"{source}: output {index} has an empty name")
        if not isinstance(content, str):
            raise ValueError(f"{source}: output {index} content is not a string")
        clean_outputs.append({"name": name, "content": content})

    return {trait: int(big5[trait]) for trait in TRAITS}, clean_outputs


def batched(items: list[zipfile.ZipInfo], size: int) -> Iterable[list[zipfile.ZipInfo]]:
    for index in range(0, len(items), size):
        yield items[index : index + size]


def main() -> int:
    args = parse_args()
    archive = args.archive.resolve()
    output = args.output.resolve()
    if not archive.is_file():
        raise FileNotFoundError(archive)
    if args.batch_size < 1:
        raise ValueError("batch size must be positive")

    data_dir = output / "data"
    report_dir = output / ".local"
    if data_dir.exists():
        shutil.rmtree(data_dir)
    if report_dir.exists():
        shutil.rmtree(report_dir)
    data_dir.mkdir(parents=True, exist_ok=True)
    report_dir.mkdir(parents=True, exist_ok=True)

    archive_sha256 = sha256_file(archive)
    report: dict[str, Any] = {
        "release": "1.0",
        "created_utc": dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat(),
        "source_archive": archive.name,
        "source_archive_size_bytes": archive.stat().st_size,
        "source_archive_sha256": archive_sha256,
        "source_archive_published": False,
        "license": "CC BY 4.0",
        "models": {},
        "cross_model_checks": {},
    }

    mappings_by_model: dict[str, dict[int, tuple[int, ...]]] = {}

    with zipfile.ZipFile(archive) as zf:
        bad_member_names = [
            info.filename
            for info in zf.infolist()
            if info.filename.startswith("/") or ".." in Path(info.filename).parts
        ]
        if bad_member_names:
            raise ValueError(f"unsafe archive member paths detected: {len(bad_member_names)}")

        all_json_members = [info for info in zf.infolist() if info.filename.endswith(".json")]
        recognized = set()

        for source_dir, spec in MODEL_SPECS.items():
            members = []
            for info in all_json_members:
                path = Path(info.filename)
                if len(path.parts) != 2 or path.parts[0] != source_dir:
                    continue
                match = FILE_RE.match(path.name)
                if not match:
                    raise ValueError(f"unexpected filename in {source_dir}: {path.name}")
                members.append(info)
                recognized.add(info.filename)

            members.sort(
                key=lambda info: tuple(
                    int(FILE_RE.match(Path(info.filename).name).group(key))
                    for key in ("profile", "seed")
                )
            )
            if not members:
                raise ValueError(f"no JSON records found for {source_dir}")

            config = spec["config"]
            model_id = spec["model_id"]
            target_dir = data_dir / config
            target_dir.mkdir(parents=True, exist_ok=True)
            parquet_path = target_dir / "train-00000-of-00001.parquet"

            audit = {
                label: {"matches": 0, "file_names": set(), "example_files": []}
                for label in SCAN_PATTERNS
            }
            output_sequences: collections.Counter[tuple[str, ...]] = collections.Counter()
            seed_counts: collections.Counter[int] = collections.Counter()
            profile_counts: collections.Counter[int] = collections.Counter()
            trait_value_counts = {trait: collections.Counter() for trait in TRAITS}
            profile_mapping: dict[int, tuple[int, ...]] = {}
            seen_ids: set[tuple[int, int]] = set()
            seen_payload_hashes: dict[str, str] = {}
            duplicate_payloads = 0
            content_chars = 0
            empty_content_blocks = 0
            records_with_empty_content = 0
            empty_content_example_files: list[str] = []

            writer = pq.ParquetWriter(
                parquet_path,
                ARROW_SCHEMA,
                compression="zstd",
                compression_level=9,
                use_dictionary=True,
                write_statistics=True,
            )
            try:
                for member_batch in batched(members, args.batch_size):
                    rows: list[dict[str, Any]] = []
                    for info in member_batch:
                        filename = Path(info.filename).name
                        match = FILE_RE.match(filename)
                        assert match is not None
                        profile_id = int(match.group("profile"))
                        seed = int(match.group("seed"))
                        record_key = (profile_id, seed)
                        if record_key in seen_ids:
                            raise ValueError(f"duplicate profile/seed in {source_dir}: {record_key}")
                        seen_ids.add(record_key)

                        try:
                            payload = json.loads(zf.read(info).decode("utf-8"))
                        except Exception as exc:
                            raise ValueError(f"invalid UTF-8 JSON: {info.filename}: {exc}") from exc
                        big5, outputs = validate_payload(payload, info.filename)

                        trait_tuple = tuple(big5[trait] for trait in TRAITS)
                        previous = profile_mapping.setdefault(profile_id, trait_tuple)
                        if previous != trait_tuple:
                            raise ValueError(f"profile {profile_id} maps to multiple Big Five vectors")

                        payload_hash = normalized_digest(payload)
                        if payload_hash in seen_payload_hashes:
                            duplicate_payloads += 1
                        else:
                            seen_payload_hashes[payload_hash] = filename

                        output_sequences[tuple(item["name"] for item in outputs)] += 1
                        seed_counts[seed] += 1
                        profile_counts[profile_id] += 1
                        for trait in TRAITS:
                            trait_value_counts[trait][big5[trait]] += 1
                        for item in outputs:
                            content_chars += len(item["content"])
                            scan_text(item["content"], filename, audit)
                        empty_in_record = sum(not item["content"].strip() for item in outputs)
                        if empty_in_record:
                            empty_content_blocks += empty_in_record
                            records_with_empty_content += 1
                            if len(empty_content_example_files) < 20:
                                empty_content_example_files.append(filename)

                        rows.append(
                            {
                                "id": f"{config}-{profile_id:04d}-{seed:02d}",
                                "profile_id": profile_id,
                                "seed": seed,
                                "generator_model": model_id,
                                "openness": big5["Openness"],
                                "conscientiousness": big5["Conscientiousness"],
                                "extraversion": big5["Extraversion"],
                                "agreeableness": big5["Agreeableness"],
                                "neuroticism": big5["Neuroticism"],
                                "outputs": outputs,
                                "source_file": filename,
                            }
                        )
                    write_rows(writer, rows)
            finally:
                writer.close()

            unexpected_seed_values = sorted(set(seed_counts) - {1, 2, 3, 4, 5})
            bad_profile_multiplicity = sum(count != 5 for count in profile_counts.values())
            unique_vectors = set(profile_mapping.values())
            model_report = {
                "model_id": model_id,
                "config_name": config,
                "records": len(members),
                "profiles": len(profile_counts),
                "unique_big5_vectors": len(unique_vectors),
                "seeds": {str(key): seed_counts[key] for key in sorted(seed_counts)},
                "unexpected_seed_values": unexpected_seed_values,
                "profiles_without_exactly_five_seeds": bad_profile_multiplicity,
                "output_blocks_per_record": EXPECTED_OUTPUTS,
                "output_name_sequences": [
                    {"count": count, "names": list(names)}
                    for names, count in output_sequences.most_common()
                ],
                "duplicate_normalized_payloads": duplicate_payloads,
                "content_characters": content_chars,
                "empty_content_blocks": empty_content_blocks,
                "records_with_empty_content": records_with_empty_content,
                "empty_content_example_files": empty_content_example_files,
                "trait_value_counts": {
                    trait: {str(value): counts[value] for value in sorted(counts)}
                    for trait, counts in trait_value_counts.items()
                },
                "sensitive_pattern_scan": {
                    label: {
                        "matches": item["matches"],
                        "files": len(item["file_names"]),
                        "example_files": item["example_files"],
                    }
                    for label, item in audit.items()
                },
                "parquet_file": str(parquet_path.relative_to(output)),
                "parquet_size_bytes": parquet_path.stat().st_size,
                "parquet_sha256": sha256_file(parquet_path),
            }
            report["models"][config] = model_report
            mappings_by_model[config] = profile_mapping
            print(
                f"{config}: {len(members):,} records, {len(profile_counts):,} profiles, "
                f"{parquet_path.stat().st_size / (1024 * 1024):.1f} MiB",
                flush=True,
            )

        unrecognized = sorted(set(info.filename for info in all_json_members) - recognized)
        if unrecognized:
            raise ValueError(f"unrecognized JSON files in archive: {len(unrecognized)}")

    configs = list(mappings_by_model)
    base_mapping = mappings_by_model[configs[0]]
    mapping_equal = {
        config: mappings_by_model[config] == base_mapping for config in configs[1:]
    }
    report["cross_model_checks"] = {
        "total_records": sum(item["records"] for item in report["models"].values()),
        "profile_to_big5_mapping_matches_first_config": mapping_equal,
        "archive_contains_only_recognized_model_json": True,
    }

    report_path = report_dir / "validation_report.json"
    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    print(f"wrote {report_path}", flush=True)
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except Exception as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        raise