#!/usr/bin/env python
"""
Prepare JSONL for Spectra-Reason-GCD: peaks (list of [mz, int]) + smiles.
Input: TSV with columns mzs, intensities, smiles (e.g. MassSpecGym) or MGF + metadata.
"""
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))


def parse_spec_array(s: str) -> list[float]:
    if isinstance(s, (list, tuple)):
        return [float(x) for x in s]
    return [float(x) for x in str(s).split(",") if x.strip()]


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Prepare peaks+smiles JSONL for CoT training.")
    p.add_argument("--tsv", default=None, help="TSV with mzs, intensities, smiles columns")
    p.add_argument("--mgf", default=None, help="MGF file (requires smiles in TITLE or separate mapping)")
    p.add_argument("--output-jsonl", required=True)
    p.add_argument("--max-peaks", type=int, default=60)
    p.add_argument("--fold", default=None, help="If TSV has 'fold', filter to this (e.g. train)")
    return p.parse_args()


def main() -> None:
    args = parse_args()
    out_path = Path(args.output_jsonl)
    out_path.parent.mkdir(parents=True, exist_ok=True)
    records = []

    if args.tsv:
        import csv
        with open(args.tsv, "r", encoding="utf-8") as f:
            reader = csv.DictReader(f, delimiter="\t")
            rows = list(reader)
        if not rows or "mzs" not in rows[0] or "intensities" not in rows[0] or "smiles" not in rows[0]:
            raise ValueError("TSV must have mzs, intensities, smiles columns")
        for row in rows:
            if args.fold and "fold" in row and row.get("fold") != args.fold:
                continue
            mzs = parse_spec_array(row["mzs"])
            intens = parse_spec_array(row["intensities"])
            peaks = [[m, i] for m, i in zip(mzs, intens)]
            peaks = sorted(peaks, key=lambda x: x[1], reverse=True)[: args.max_peaks]
            rec = {
                "peaks": peaks,
                "smiles": str(row["smiles"]).strip(),
            }
            if "formula" in row and row["formula"]:
                rec["formula"] = str(row["formula"]).strip()
            if "precursor_mz" in row and row["precursor_mz"]:
                try:
                    rec["precursor_mz"] = float(row["precursor_mz"])
                except (ValueError, TypeError):
                    pass
            if "precursor_formula" in row and row["precursor_formula"] and "formula" not in rec:
                rec["formula"] = str(row["precursor_formula"]).strip()
            records.append(rec)
    elif args.mgf:
        try:
            from pyteomics import mgf
        except ImportError:
            raise ImportError("pyteomics required for MGF: pip install pyteomics")
        with mgf.MGF(args.mgf) as reader:
            for spec in reader:
                mz = spec.get("m/z array", [])
                iarr = spec.get("intensity array", [])
                peaks = [[float(m), float(i)] for m, i in zip(mz, iarr)]
                peaks = sorted(peaks, key=lambda x: x[1], reverse=True)[: args.max_peaks]
                smiles = spec.get("params", {}).get("SMILES", spec.get("params", {}).get("smiles", ""))
                if not smiles and "TITLE" in spec.get("params", {}):
                    smiles = spec["params"]["TITLE"]
                records.append({"peaks": peaks, "smiles": str(smiles).strip()})
    else:
        raise ValueError("Provide --tsv or --mgf")

    with open(out_path, "w") as f:
        for r in records:
            f.write(json.dumps(r) + "\n")
    print(f"Wrote {len(records)} records to {out_path}")


if __name__ == "__main__":
    main()