#!/usr/bin/env python3
"""Validate the standardized DMC extxyz dataset package."""

from __future__ import annotations

import argparse
import hashlib
import re
from pathlib import Path


EXPECTED_FILES = {
    "solvent_xtb_train_200.xyz": 203,
    "solvent_xtb_test.xyz": 1000,
}
EXPECTED_ELEMENTS = {"H", "C", "O"}


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


def validate_checksum_manifest(dataset_root: Path, manifest_path: Path) -> None:
    checked = 0
    with manifest_path.open("r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            digest, rel = line.split(maxsplit=1)
            path = dataset_root / rel
            if not path.exists():
                raise SystemExit(f"[FAIL] 清单文件不存在: {path}")
            actual = sha256_file(path)
            if actual != digest:
                raise SystemExit(f"[FAIL] SHA256 不一致: {rel}")
            checked += 1
    if checked != len(EXPECTED_FILES):
        raise SystemExit(f"[FAIL] SHA256 清单文件数异常: {checked}")
    print(f"[OK] SHA256 清单验证通过: {checked} 个文件")


def parse_properties(comment: str) -> list[tuple[str, str, int]]:
    match = re.search(r'Properties=("[^"]+"|\S+)', comment)
    if not match:
        raise SystemExit("[FAIL] extxyz comment 缺少 Properties")
    raw = match.group(1).strip('"')
    parts = raw.split(":")
    if len(parts) % 3:
        raise SystemExit(f"[FAIL] Properties 格式异常: {raw}")
    parsed = []
    for i in range(0, len(parts), 3):
        name, kind, width = parts[i], parts[i + 1], int(parts[i + 2])
        parsed.append((name, kind, width))
    return parsed


def validate_xyz(path: Path, expected_frames: int) -> None:
    frames = 0
    elements: set[str] = set()
    min_atoms: int | None = None
    max_atoms = 0
    saw_molid = False

    with path.open("r", encoding="utf-8") as f:
        while True:
            first = f.readline()
            if not first:
                break
            if not first.strip():
                continue
            try:
                atom_count = int(first.strip())
            except ValueError as exc:
                raise SystemExit(f"[FAIL] 原子数行不是整数: {path}:{frames + 1}") from exc
            comment = f.readline().rstrip("\n")
            if "energy_xtb=" not in comment:
                raise SystemExit(f"[FAIL] comment 缺少 energy_xtb: {path} frame {frames}")
            if "pbc=" not in comment:
                raise SystemExit(f"[FAIL] comment 缺少 pbc: {path} frame {frames}")
            props = parse_properties(comment)
            prop_names = [p[0] for p in props]
            if prop_names[0:2] != ["species", "pos"]:
                raise SystemExit(f"[FAIL] Properties 前两项必须是 species,pos: {path} frame {frames}")
            if "forces_xtb" not in prop_names:
                raise SystemExit(f"[FAIL] Properties 缺少 forces_xtb: {path} frame {frames}")
            saw_molid = saw_molid or ("molID" in prop_names)
            expected_cols = sum(width for _, _, width in props)

            for atom_index in range(atom_count):
                atom_line = f.readline()
                if not atom_line:
                    raise SystemExit(f"[FAIL] 文件提前结束: {path} frame {frames}")
                cols = atom_line.split()
                if len(cols) != expected_cols:
                    raise SystemExit(
                        f"[FAIL] 原子列数异常: {path} frame {frames} atom {atom_index}: "
                        f"{len(cols)} != {expected_cols}"
                    )
                elements.add(cols[0])
                numeric = cols[1:]
                for value in numeric:
                    float(value)
            frames += 1
            min_atoms = atom_count if min_atoms is None else min(min_atoms, atom_count)
            max_atoms = max(max_atoms, atom_count)

    if frames != expected_frames:
        raise SystemExit(f"[FAIL] 帧数异常: {path.name}: {frames} != {expected_frames}")
    if not elements.issubset(EXPECTED_ELEMENTS):
        raise SystemExit(f"[FAIL] 元素集合异常: {sorted(elements)}")
    if path.name.endswith("test.xyz") and not saw_molid:
        raise SystemExit(f"[FAIL] 测试集未检测到 molID 字段: {path}")
    print(
        f"[OK] {path.name}: frames={frames}, atoms={min_atoms}-{max_atoms}, "
        f"elements={sorted(elements)}"
    )


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset-root", default="data/DMC")
    parser.add_argument("--checksum-manifest", default="metadata/sha256_manifest.txt")
    args = parser.parse_args()

    repo_root = Path.cwd()
    dataset_root = Path(args.dataset_root)
    if not dataset_root.is_absolute():
        dataset_root = repo_root / dataset_root
    checksum_manifest = Path(args.checksum_manifest)
    if not checksum_manifest.is_absolute():
        checksum_manifest = repo_root / checksum_manifest

    if not dataset_root.exists():
        raise SystemExit(f"[FAIL] 数据目录不存在: {dataset_root}")
    for name, expected_frames in EXPECTED_FILES.items():
        path = dataset_root / name
        if not path.exists():
            raise SystemExit(f"[FAIL] 缺少文件: {path}")
        if path.stat().st_size <= 0:
            raise SystemExit(f"[FAIL] 文件为空: {path}")
        validate_xyz(path, expected_frames)
    validate_checksum_manifest(dataset_root, checksum_manifest)
    print("[OK] DMC 数据集读取验证通过")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())