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

from __future__ import annotations

import argparse
import json
import re
import shutil
from pathlib import Path

import duckdb
import pandas as pd
import pyarrow.parquet as pq


CSV_COLUMNS_SQL = (
    "{"
    "'uniprot_accession':'VARCHAR',"
    "'first_residue_index':'BIGINT',"
    "'last_residue_index':'BIGINT',"
    "'alphafold_id':'VARCHAR',"
    "'latest_version':'BIGINT'"
    "}"
)


def sql_string(path: Path) -> str:
    return "'" + path.as_posix().replace("'", "''") + "'"


def entry_source_sql(accession_csv: Path) -> str:
    source = (
        f"read_csv({sql_string(accession_csv)}, "
        f"header=false, columns={CSV_COLUMNS_SQL}, sample_size=100000, "
        f"strict_mode=false, parallel=false)"
    )
    return f"""
        SELECT
          uniprot_accession,
          alphafold_id,
          latest_version,
          first_residue_index,
          last_residue_index,
          sequence_length,
          fragment_number,
          coalesce(fragment_number > 1, false) AS is_fragmented_prediction,
          split_bucket
        FROM (
          SELECT
            uniprot_accession,
            alphafold_id,
            latest_version::UTINYINT AS latest_version,
            first_residue_index::INTEGER AS first_residue_index,
            last_residue_index::INTEGER AS last_residue_index,
            (last_residue_index - first_residue_index + 1)::INTEGER AS sequence_length,
            try_cast(nullif(regexp_extract(alphafold_id, '-F([0-9]+)$', 1), '') AS INTEGER) AS fragment_number,
            (hash(uniprot_accession) % 10)::UTINYINT AS split_bucket
          FROM {source}
        )
    """


def copy_split(
    con: duckdb.DuckDBPyConnection,
    base_sql: str,
    split: str,
    condition: str,
    split_dir: Path,
    target_file_size: str,
    row_group_size: int,
) -> None:
    split_dir.mkdir(parents=True, exist_ok=True)
    copy_sql = f"""
        COPY (
          SELECT *
          FROM ({base_sql})
          WHERE {condition}
        )
        TO {sql_string(split_dir)}
        (
          FORMAT PARQUET,
          COMPRESSION ZSTD,
          ROW_GROUP_SIZE {row_group_size},
          FILE_SIZE_BYTES {sql_string(Path(target_file_size))}
        )
    """
    con.execute(copy_sql)

    files = sorted(
        split_dir.glob("data_*.parquet"),
        key=lambda path: int(re.search(r"data_(\d+)\.parquet$", path.name).group(1)),
    )
    total = len(files)
    for index, path in enumerate(files):
        path.rename(split_dir / f"{split}-{index:05d}-of-{total:05d}.parquet")


def write_archive_metadata(raw_dir: Path, out_dir: Path) -> dict:
    metadata_path = raw_dir / "download_metadata.json"
    if not metadata_path.exists():
        return {}

    records = json.loads(metadata_path.read_text(encoding="utf-8"))
    df = pd.DataFrame.from_records(records)
    if df.empty:
        return {}

    for column in [
        "archive_name",
        "species",
        "common_name",
        "reference_proteome",
        "label",
        "type",
    ]:
        if column not in df.columns:
            df[column] = None
    if "latin_common_name" not in df.columns:
        df["latin_common_name"] = None

    df["archive_path"] = "latest/" + df["archive_name"]
    df["size_gb"] = df["size_bytes"].astype("float64") / 1_000_000_000
    ordered_columns = [
        "archive_name",
        "archive_path",
        "type",
        "species",
        "common_name",
        "latin_common_name",
        "reference_proteome",
        "label",
        "num_predicted_structures",
        "size_bytes",
        "size_gb",
    ]
    df = df[ordered_columns]

    metadata_dir = out_dir / "metadata"
    metadata_dir.mkdir(parents=True, exist_ok=True)
    df.to_parquet(metadata_dir / "archive_metadata.parquet", index=False, compression="zstd")

    return {
        "archive_rows": int(len(df)),
        "archive_types": df["type"].value_counts(dropna=False).to_dict(),
        "archive_predicted_structures": int(df["num_predicted_structures"].sum()),
        "archive_size_bytes": int(df["size_bytes"].sum()),
    }


def parquet_row_count(paths: list[Path]) -> int:
    return sum(pq.ParquetFile(path).metadata.num_rows for path in paths)


def build_dataset(raw_dir: Path, out_dir: Path, target_file_size: str, row_group_size: int) -> dict:
    accession_csv = raw_dir / "accession_ids.csv"
    if not accession_csv.exists():
        raise FileNotFoundError(f"Missing {accession_csv}")

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

    con = duckdb.connect()
    con.execute("SET preserve_insertion_order=false")
    con.execute("PRAGMA disable_progress_bar")
    base_sql = entry_source_sql(accession_csv)

    copy_split(
        con,
        base_sql,
        "train",
        "split_bucket <> 0",
        data_dir / "train",
        target_file_size,
        row_group_size,
    )
    copy_split(
        con,
        base_sql,
        "test",
        "split_bucket = 0",
        data_dir / "test",
        target_file_size,
        row_group_size,
    )

    archive_summary = write_archive_metadata(raw_dir, out_dir)
    train_files = sorted((data_dir / "train").glob("*.parquet"))
    test_files = sorted((data_dir / "test").glob("*.parquet"))
    split_counts = {
        "train": parquet_row_count(train_files),
        "test": parquet_row_count(test_files),
    }

    parquet_glob = sql_string(data_dir / "*" / "*.parquet")
    stats_row = con.execute(
        f"""
        SELECT
          count(*)::UBIGINT AS total_rows,
          min(sequence_length)::INTEGER AS min_sequence_length,
          approx_quantile(sequence_length, 0.5)::INTEGER AS median_sequence_length,
          avg(sequence_length)::DOUBLE AS mean_sequence_length,
          max(sequence_length)::INTEGER AS max_sequence_length,
          sum(CASE WHEN is_fragmented_prediction THEN 1 ELSE 0 END)::UBIGINT AS fragmented_predictions,
          sum(CASE WHEN fragment_number IS NULL THEN 1 ELSE 0 END)::UBIGINT AS rows_without_fragment_number,
          min(latest_version)::UTINYINT AS min_latest_version,
          max(latest_version)::UTINYINT AS max_latest_version
        FROM read_parquet({parquet_glob})
        """
    ).fetchone()
    version_counts = {
        str(version): int(count)
        for version, count in con.execute(
            f"""
            SELECT latest_version, count(*) AS row_count
            FROM read_parquet({parquet_glob})
            GROUP BY 1
            ORDER BY 1
            """
        ).fetchall()
    }

    summary = {
        "source": "LiteFold/AlphaFoldDB",
        "table_source_file": "accession_ids.csv",
        "split_strategy": "deterministic hash(uniprot_accession) % 10; bucket 0 is test, buckets 1-9 are train",
        "splits": {
            "train": split_counts.get("train", 0),
            "test": split_counts.get("test", 0),
        },
        "total_rows": int(stats_row[0]),
        "sequence_length": {
            "min": int(stats_row[1]),
            "median_approx": int(stats_row[2]),
            "mean": float(stats_row[3]),
            "max": int(stats_row[4]),
        },
        "fragmented_predictions": int(stats_row[5]),
        "rows_without_fragment_number": int(stats_row[6]),
        "latest_version": {
            "min": int(stats_row[7]),
            "max": int(stats_row[8]),
            "counts": version_counts,
        },
        "parquet_files": {
            "train": len(train_files),
            "test": len(test_files),
        },
        "columns": [
            "uniprot_accession",
            "alphafold_id",
            "latest_version",
            "first_residue_index",
            "last_residue_index",
            "sequence_length",
            "fragment_number",
            "is_fragmented_prediction",
            "split_bucket",
        ],
        "archive_metadata": archive_summary,
    }
    (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_AlphaFoldDB_raw"))
    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_AlphaFoldDB_processed"))
    parser.add_argument("--target-file-size", default="256MB")
    parser.add_argument("--row-group-size", type=int, default=1_000_000)
    args = parser.parse_args()

    summary = build_dataset(args.raw_dir, args.out_dir, args.target_file_size, args.row_group_size)
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()