#!/usr/bin/env python3
"""Build viewer-friendly Parquet splits for LiteFold/InterPro."""

from __future__ import annotations

import argparse
import gzip
import hashlib
import json
import re
import shutil
import xml.etree.ElementTree as ET
from collections import Counter
from pathlib import Path
from typing import Any

import pandas as pd


ENTRY_COLUMNS = [
    "interpro_id",
    "interpro_numeric_id",
    "name",
    "short_name",
    "entry_type",
    "protein_count",
    "is_llm",
    "is_llm_reviewed",
    "abstract",
    "go_ids",
    "go_terms",
    "go_categories",
    "go_count",
    "member_databases",
    "member_accessions",
    "member_names",
    "member_protein_counts",
    "member_count",
    "external_databases",
    "external_accessions",
    "external_xrefs",
    "external_xref_count",
    "pdb_ids",
    "structure_count",
    "publication_ids",
    "pubmed_ids",
    "publication_titles",
    "publication_years",
    "publication_count",
    "parent_ids",
    "child_ids",
    "parent_count",
    "child_count",
    "tree_depth",
    "taxonomy_names",
    "taxonomy_protein_counts",
    "taxonomy_count",
    "key_species_names",
    "key_species_protein_counts",
    "key_species_count",
    "in_entry_list",
    "entry_list_type",
    "entry_list_name",
    "names_dat_name",
    "short_names_dat_name",
    "split_bucket",
]


def normalize_text(value: str | None) -> str | None:
    if value is None:
        return None
    text = re.sub(r"\s+", " ", value).strip()
    return text or None


def parse_int(value: str | None) -> int | None:
    if value is None or value == "":
        return None
    try:
        return int(value)
    except ValueError:
        return None


def parse_bool(value: str | None) -> bool | None:
    if value is None or value == "":
        return None
    lowered = value.lower()
    if lowered == "true":
        return True
    if lowered == "false":
        return False
    return None


def stable_bucket(value: str, buckets: int = 10) -> int:
    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
    return int(digest, 16) % buckets


def text_of(parent: ET.Element, tag: str) -> str | None:
    child = parent.find(tag)
    if child is None:
        return None
    return normalize_text("".join(child.itertext()))


def xref_value(db: str | None, dbkey: str | None) -> str:
    if db and dbkey:
        return f"{db}:{dbkey}"
    return dbkey or db or ""


def parse_two_column_file(path: Path) -> dict[str, str]:
    mapping: dict[str, str] = {}
    if not path.exists():
        return mapping
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        for line in handle:
            stripped = line.rstrip("\n")
            if not stripped:
                continue
            parts = stripped.split("\t", 1)
            if len(parts) == 2 and parts[0].startswith("IPR"):
                mapping[parts[0]] = parts[1]
    return mapping


def parse_entry_list(path: Path) -> dict[str, dict[str, str]]:
    entries: dict[str, dict[str, str]] = {}
    if not path.exists():
        return entries
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        header = next(handle, "").rstrip("\n").split("\t")
        for line in handle:
            parts = line.rstrip("\n").split("\t")
            if len(parts) != len(header):
                continue
            row = dict(zip(header, parts))
            entry_id = row.get("ENTRY_AC")
            if entry_id:
                entries[entry_id] = row
    return entries


def parse_tree_depths(path: Path) -> dict[str, int]:
    depths: dict[str, int] = {}
    pattern = re.compile(r"^(?P<prefix>-*)(?P<id>IPR\d+)::")
    if not path.exists():
        return depths
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        for line in handle:
            match = pattern.match(line.strip())
            if not match:
                continue
            entry_id = match.group("id")
            depth = len(match.group("prefix")) // 2
            previous = depths.get(entry_id)
            if previous is None or depth < previous:
                depths[entry_id] = depth
    return depths


def parse_interpro2go_count(path: Path) -> int:
    count = 0
    if not path.exists():
        return count
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        for line in handle:
            stripped = line.strip()
            if stripped and not stripped.startswith("!"):
                count += 1
    return count


def parse_release_notes(path: Path) -> dict[str, Any]:
    notes = path.read_text(encoding="utf-8", errors="replace") if path.exists() else ""
    release_match = re.search(r"Release\s+([0-9.]+),\s+([^\n]+)", notes)
    last_entry_match = re.search(r"Last Entry\s+(IPR\d+)", notes)
    go_match = re.search(r"Number of GO terms mapped to InterPro\s+-\s+([0-9]+)", notes)
    return {
        "release": release_match.group(1) if release_match else None,
        "release_date": release_match.group(2).strip() if release_match else None,
        "last_entry": last_entry_match.group(1) if last_entry_match else None,
        "interpro_to_go_mappings": int(go_match.group(1)) if go_match else None,
    }


def parse_dbinfo(release: ET.Element) -> list[dict[str, Any]]:
    rows = []
    for item in release.findall("dbinfo"):
        rows.append(
            {
                "dbname": item.attrib.get("dbname"),
                "version": item.attrib.get("version"),
                "entry_count": parse_int(item.attrib.get("entry_count")),
                "file_date": item.attrib.get("file_date"),
            }
        )
    return rows


def extract_taxa(container: ET.Element | None) -> tuple[list[str], list[int]]:
    names = []
    counts = []
    if container is None:
        return names, counts
    for taxon in container.findall("taxon_data"):
        name = taxon.attrib.get("name")
        count = parse_int(taxon.attrib.get("proteins_count"))
        if name:
            names.append(name)
            counts.append(count if count is not None else 0)
    return names, counts


def interpro_row(
    elem: ET.Element,
    entry_list: dict[str, dict[str, str]],
    names_dat: dict[str, str],
    short_names_dat: dict[str, str],
    tree_depths: dict[str, int],
) -> dict[str, Any]:
    entry_id = elem.attrib.get("id", "")
    numeric_match = re.match(r"IPR(\d+)$", entry_id)
    entry_info = entry_list.get(entry_id, {})

    class_list = elem.find("class_list")
    go_ids: list[str] = []
    go_terms: list[str] = []
    go_categories: list[str] = []
    if class_list is not None:
        for item in class_list.findall("classification"):
            go_id = item.attrib.get("id")
            if not go_id:
                continue
            go_ids.append(go_id)
            go_terms.append(text_of(item, "description") or "")
            go_categories.append(text_of(item, "category") or "")

    member_databases: list[str] = []
    member_accessions: list[str] = []
    member_names: list[str] = []
    member_protein_counts: list[int] = []
    member_list = elem.find("member_list")
    if member_list is not None:
        for item in member_list.findall("db_xref"):
            member_databases.append(item.attrib.get("db") or "")
            member_accessions.append(item.attrib.get("dbkey") or "")
            member_names.append(item.attrib.get("name") or "")
            member_protein_counts.append(parse_int(item.attrib.get("protein_count")) or 0)

    external_databases: list[str] = []
    external_accessions: list[str] = []
    external_xrefs: list[str] = []
    external_doc_list = elem.find("external_doc_list")
    if external_doc_list is not None:
        for item in external_doc_list.findall("db_xref"):
            db = item.attrib.get("db")
            dbkey = item.attrib.get("dbkey")
            external_databases.append(db or "")
            external_accessions.append(dbkey or "")
            external_xrefs.append(xref_value(db, dbkey))

    pdb_ids: list[str] = []
    structure_db_links = elem.find("structure_db_links")
    if structure_db_links is not None:
        for item in structure_db_links.findall("db_xref"):
            dbkey = item.attrib.get("dbkey")
            if dbkey:
                pdb_ids.append(dbkey)

    publication_ids: list[str] = []
    pubmed_ids: list[str] = []
    publication_titles: list[str] = []
    publication_years: list[int] = []
    pub_list = elem.find("pub_list")
    if pub_list is not None:
        for publication in pub_list.findall("publication"):
            publication_ids.append(publication.attrib.get("id") or "")
            title = text_of(publication, "title")
            publication_titles.append(title or "")
            year = parse_int(text_of(publication, "year"))
            publication_years.append(year if year is not None else 0)
            xref = publication.find("db_xref")
            if xref is not None and xref.attrib.get("db") == "PUBMED":
                dbkey = xref.attrib.get("dbkey")
                if dbkey:
                    pubmed_ids.append(dbkey)

    parent_ids = []
    parent_list = elem.find("parent_list")
    if parent_list is not None:
        parent_ids = [item.attrib["ipr_ref"] for item in parent_list.findall("rel_ref") if item.attrib.get("ipr_ref")]

    child_ids = []
    child_list = elem.find("child_list")
    if child_list is not None:
        child_ids = [item.attrib["ipr_ref"] for item in child_list.findall("rel_ref") if item.attrib.get("ipr_ref")]

    taxonomy_names, taxonomy_protein_counts = extract_taxa(elem.find("taxonomy_distribution"))
    key_species_names, key_species_protein_counts = extract_taxa(elem.find("key_species"))

    abstract = elem.find("abstract")
    abstract_text = normalize_text(" ".join(abstract.itertext())) if abstract is not None else None

    return {
        "interpro_id": entry_id,
        "interpro_numeric_id": int(numeric_match.group(1)) if numeric_match else None,
        "name": text_of(elem, "name"),
        "short_name": elem.attrib.get("short_name") or None,
        "entry_type": elem.attrib.get("type") or None,
        "protein_count": parse_int(elem.attrib.get("protein_count")),
        "is_llm": parse_bool(elem.attrib.get("is-llm")),
        "is_llm_reviewed": parse_bool(elem.attrib.get("is-llm-reviewed")),
        "abstract": abstract_text,
        "go_ids": go_ids,
        "go_terms": go_terms,
        "go_categories": go_categories,
        "go_count": len(go_ids),
        "member_databases": member_databases,
        "member_accessions": member_accessions,
        "member_names": member_names,
        "member_protein_counts": member_protein_counts,
        "member_count": len(member_accessions),
        "external_databases": external_databases,
        "external_accessions": external_accessions,
        "external_xrefs": external_xrefs,
        "external_xref_count": len(external_xrefs),
        "pdb_ids": pdb_ids,
        "structure_count": len(pdb_ids),
        "publication_ids": publication_ids,
        "pubmed_ids": pubmed_ids,
        "publication_titles": publication_titles,
        "publication_years": publication_years,
        "publication_count": len(publication_ids),
        "parent_ids": parent_ids,
        "child_ids": child_ids,
        "parent_count": len(parent_ids),
        "child_count": len(child_ids),
        "tree_depth": tree_depths.get(entry_id),
        "taxonomy_names": taxonomy_names,
        "taxonomy_protein_counts": taxonomy_protein_counts,
        "taxonomy_count": len(taxonomy_names),
        "key_species_names": key_species_names,
        "key_species_protein_counts": key_species_protein_counts,
        "key_species_count": len(key_species_names),
        "in_entry_list": entry_id in entry_list,
        "entry_list_type": entry_info.get("ENTRY_TYPE"),
        "entry_list_name": entry_info.get("ENTRY_NAME"),
        "names_dat_name": names_dat.get(entry_id),
        "short_names_dat_name": short_names_dat.get(entry_id),
        "split_bucket": stable_bucket(entry_id),
    }


def parse_xml(
    path: Path,
    entry_list: dict[str, dict[str, str]],
    names_dat: dict[str, str],
    short_names_dat: dict[str, str],
    tree_depths: dict[str, int],
) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    rows: list[dict[str, Any]] = []
    dbinfo_rows: list[dict[str, Any]] = []
    with gzip.open(path, "rb") as handle:
        for _, elem in ET.iterparse(handle, events=("end",)):
            if elem.tag == "release":
                dbinfo_rows = parse_dbinfo(elem)
                elem.clear()
            elif elem.tag == "interpro":
                rows.append(interpro_row(elem, entry_list, names_dat, short_names_dat, tree_depths))
                elem.clear()
    return rows, dbinfo_rows


def build_dataset(raw_dir: Path, out_dir: Path) -> dict[str, Any]:
    current_dir = raw_dir / "current_release"
    entry_list = parse_entry_list(current_dir / "entry.list")
    names_dat = parse_two_column_file(current_dir / "names.dat")
    short_names_dat = parse_two_column_file(current_dir / "short_names.dat")
    tree_depths = parse_tree_depths(current_dir / "ParentChildTreeFile.txt")
    release_notes = parse_release_notes(current_dir / "release_notes.txt")
    interpro2go_count = parse_interpro2go_count(current_dir / "interpro2go")
    rows, dbinfo_rows = parse_xml(
        current_dir / "interpro.xml.gz",
        entry_list=entry_list,
        names_dat=names_dat,
        short_names_dat=short_names_dat,
        tree_depths=tree_depths,
    )

    if out_dir.exists():
        shutil.rmtree(out_dir)
    data_dir = out_dir / "data"
    metadata_dir = out_dir / "metadata"
    data_dir.mkdir(parents=True, exist_ok=True)
    metadata_dir.mkdir(parents=True, exist_ok=True)

    df = pd.DataFrame.from_records(rows, columns=ENTRY_COLUMNS)
    df = df.sort_values(["split_bucket", "interpro_id"], kind="mergesort")
    train = df[df["split_bucket"].ne(0)].sort_values("interpro_id", kind="mergesort")
    test = df[df["split_bucket"].eq(0)].sort_values("interpro_id", kind="mergesort")
    train.to_parquet(data_dir / "train-00000-of-00001.parquet", index=False, compression="zstd")
    test.to_parquet(data_dir / "test-00000-of-00001.parquet", index=False, compression="zstd")

    dbinfo_df = pd.DataFrame.from_records(dbinfo_rows)
    dbinfo_df.to_parquet(metadata_dir / "database_info.parquet", index=False, compression="zstd")

    entry_type_counts = df["entry_type"].value_counts(dropna=False).to_dict()
    member_database_counts = Counter(database for values in df["member_databases"] for database in values)
    go_category_counts = Counter(category for values in df["go_categories"] for category in values)
    external_database_counts = Counter(database for values in df["external_databases"] for database in values)

    summary = {
        "source": "LiteFold/InterPro",
        "release": release_notes.get("release"),
        "release_date": release_notes.get("release_date"),
        "last_entry": release_notes.get("last_entry"),
        "entry_rows": int(len(df)),
        "database_info_rows": int(len(dbinfo_df)),
        "entry_list_rows": int(len(entry_list)),
        "names_dat_rows": int(len(names_dat)),
        "short_names_dat_rows": int(len(short_names_dat)),
        "tree_entries": int(len(tree_depths)),
        "interpro2go_mapping_rows": int(interpro2go_count),
        "release_notes_interpro2go_mappings": release_notes.get("interpro_to_go_mappings"),
        "splits": {
            "train": int(len(train)),
            "test": int(len(test)),
        },
        "split_strategy": "deterministic sha256(interpro_id) % 10; bucket 0 is test, buckets 1-9 are train",
        "entry_type_counts": {str(k): int(v) for k, v in entry_type_counts.items()},
        "entries_with_go": int(df["go_count"].gt(0).sum()),
        "entries_with_members": int(df["member_count"].gt(0).sum()),
        "entries_with_structures": int(df["structure_count"].gt(0).sum()),
        "entries_with_publications": int(df["publication_count"].gt(0).sum()),
        "top_member_databases": dict(member_database_counts.most_common(20)),
        "go_category_counts": dict(go_category_counts.most_common()),
        "top_external_databases": dict(external_database_counts.most_common(20)),
        "columns": ENTRY_COLUMNS,
        "source_files_used": [
            "current_release/interpro.xml.gz",
            "current_release/entry.list",
            "current_release/names.dat",
            "current_release/short_names.dat",
            "current_release/ParentChildTreeFile.txt",
            "current_release/interpro2go",
            "current_release/release_notes.txt",
        ],
    }
    (out_dir / "dataset_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    return summary


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_InterPro_raw"))
    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_InterPro_processed"))
    args = parser.parse_args()
    summary = build_dataset(args.raw_dir, args.out_dir)
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()