import os, re, time, json, math, requests, numpy as np, pandas as pd, torch
from pathlib import Path
from tqdm.auto import tqdm
from transformers import AutoTokenizer, AutoModel
from contextlib import contextmanager

DATA_RAW  = Path("data/raw"); DATA_RAW.mkdir(parents=True, exist_ok=True)
DATA_PROC = Path("data/processed"); DATA_PROC.mkdir(parents=True, exist_ok=True)
FASTA_OUT = DATA_RAW/"yeast_abc_full.fasta"
MANIFEST  = DATA_PROC/"protein_manifest.csv"
PROT_CSV  = DATA_PROC/"protein.csv"

DEVICE    = "cuda" if torch.cuda.is_available() else "cpu"
ESM_MODEL = "facebook/esm2_t33_650M_UR50D"  

GO_TERMS = [
    "ABC-type transporter activity",
    "ATPase-coupled transmembrane transporter activity",
]
MIN_ABC_TARGET = 30  

SEED_ABCS = {
    "PDR5","SNQ2","YOR1","PDR15","PDR10","PDR11","PDR12","PDR18",
    "YCF1","YBT1","ATM1","VBA1","VBA2","VBA3","VBA4",
    "MDL1","MDL2","AUS1","PDR16","PDR17","STE6",
}


session = requests.Session()
session.headers.update({"User-Agent":"abc-atlas-colab/1.0"})

def backoff_get(url, method="GET", max_tries=5, **kwargs):
    for i in range(max_tries):
        try:
            r = session.request(method, url, timeout=30, **kwargs)
            r.raise_for_status()
            return r
        except Exception as e:
            if i == max_tries-1: raise
            time.sleep(1.5 * (2**i))

def yeastmine_abc_symbols():
    """Query SGD YeastMine for ABC-relevant GO terms. Returns set of gene symbols + systematic IDs."""
    base = "https://yeastmine.yeastgenome.org/yeastmine/service/query/results"
    symbols = set(); rows_all=[]
    for term in GO_TERMS:
        q = f"""
        <query model="genomic" view="Gene.primaryIdentifier Gene.symbol Gene.secondaryIdentifier Gene.name Gene.organism.shortName Gene.goAnnotation.ontologyTerm.name">
          <constraint path="Gene.organism.name" op="=" value="Saccharomyces cerevisiae"/>
          <constraint path="Gene.goAnnotation.ontologyTerm.name" op="=" value="{term}"/>
        </query>
        """
        try:
            r = backoff_get(base, method="POST", data={"format":"json","query":q})
            rows = r.json().get("results", [])
            for row in rows:
                sgdid = row.get("field1") 
                symbol = row.get("field2") or row.get("field1")
                sysid = row.get("field3") or ""
                gohit = row.get("field6") or ""
                if symbol:
                    symbols.add(symbol)
                    rows_all.append({"sgd_primary":sgdid,"symbol":symbol,"systematic":sysid,"go_term":gohit})
        except Exception as e:
            pass
    for s in SEED_ABCS: symbols.add(s)
    return symbols, pd.DataFrame(rows_all).drop_duplicates()

def uniprot_symbols_by_keyword():
    """Fallback: UniProt keyword/family text search to collect additional ABCs in S. cerevisiae."""
    q = 'organism_id:559292 AND (annotation:"ATP-binding cassette" OR keyword:"Transport" OR family:"ABC")'
    url = f"https://rest.uniprot.org/uniprotkb/search?query={requests.utils.quote(q)}&format=json&size=500&fields=accession,genes(PREFERRED),protein_name"
    try:
        r = backoff_get(url)
        data = r.json()
        syms=set()
        for it in data.get("results", []):
            genes = it.get("genes", [])
            if genes:
                sym = genes[0].get("geneName", {}).get("value")
                if sym: syms.add(sym)
        return syms
    except Exception:
        return set()

def fetch_uniprot_fasta_for_gene(symbol: str) -> str:
    q = f"gene_exact:{symbol}+AND+organism_id:559292"
    url = f"https://rest.uniprot.org/uniprotkb/stream?compressed=false&format=fasta&query={q}"
    r = backoff_get(url)
    return r.text

def parse_fasta(txt: str):
    out=[]; name=None; seq=[]
    for line in txt.splitlines():
        if line.startswith(">"):
            if name: out.append((name,"".join(seq)))
            name=line.strip()[1:]; seq=[]
        else:
            seq.append(line.strip())
    if name: out.append((name,"".join(seq)))
    return out

@contextmanager
def maybe_amp(device=DEVICE):
    if device=="cuda":
        with torch.autocast("cuda", dtype=torch.float16):
            yield
    else:
        yield

symbols_sgd, sgd_table = yeastmine_abc_symbols()
symbols_uni = uniprot_symbols_by_keyword()
symbols = sorted(set(symbols_sgd) | set(symbols_uni) | SEED_ABCS)
print(f"Collected candidate ABC symbols: n={len(symbols)}")
if len(symbols) < MIN_ABC_TARGET:
    print("Warning: few symbols found via network; will still proceed with seeds.")

by_gene = {}
manifest_rows = []
for g in tqdm(symbols, desc="Fetch UniProt FASTA"):
    try:
        txt = fetch_uniprot_fasta_for_gene(g)
        recs = parse_fasta(txt)
        if not recs:
            continue
        h, seq = max(recs, key=lambda r: len(r[1]))
        by_gene[g] = (h, seq)
        acc = None
        m = re.search(r"\|([A-Z0-9]{6,10})\|", h)
        if m: acc = m.group(1)
        manifest_rows.append({"symbol": g, "uniprot_header": h, "uniprot_acc": acc})
    except Exception:
        continue

if not by_gene:
    raise SystemExit("No FASTA fetched; check network and retry.")

with open(FASTA_OUT, "w") as f:
    for g, (_, seq) in by_gene.items():
        f.write(f">{g}\n")
        for i in range(0, len(seq), 80):
            f.write(seq[i:i+80] + "\n")
print(f"Saved FASTA for {len(by_gene)} genes → {FASTA_OUT}")

mf = pd.DataFrame(manifest_rows)
if not sgd_table.empty:
    mf = mf.merge(sgd_table, how="left", left_on="symbol", right_on="symbol")
mf.to_csv(MANIFEST, index=False)
print(f"Saved manifest → {MANIFEST} | columns: {list(mf.columns)}")

tok = AutoTokenizer.from_pretrained(ESM_MODEL)
mdl = AutoModel.from_pretrained(ESM_MODEL).eval().to(DEVICE)

rows = []
done = 0

if PROT_CSV.exists():
    prev = pd.read_csv(PROT_CSV)
    done_syms = set(prev["transporter"])
    rows.extend(prev.values.tolist())
    done = len(done_syms)
    print(f"Resuming from existing protein.csv ({done} already embedded).")

keys = list(by_gene.keys())
for i, g in enumerate(tqdm(keys, desc="ESM2 embed"), 1):
    if PROT_CSV.exists():
        if g in set(pd.read_csv(PROT_CSV)["transporter"]):
            continue
    _, seq = by_gene[g]
    toks = tok(seq, return_tensors="pt", truncation=True, max_length=4096)
    toks = {k: v.to(DEVICE) for k, v in toks.items()}
    with torch.no_grad():
        with maybe_amp(DEVICE):
            hs = mdl(**toks).last_hidden_state  # [1, L, D]
        vec = hs[:, 1:-1, :].mean(1) if hs.size(1) > 2 else hs.mean(1)
        emb = vec.squeeze(0).cpu().numpy().astype(np.float32)
    rows.append([g] + emb.tolist())

    if (i % 10 == 0) or (i == len(keys)):
        df = pd.DataFrame(rows, columns=["transporter"] + [f"d{i}" for i in range(emb.shape[0])])
        df = df.drop_duplicates("transporter").sort_values("transporter").reset_index(drop=True)
        df.to_csv(PROT_CSV, index=False)

P = pd.read_csv(PROT_CSV)
print("protein.csv →", PROT_CSV, "| shape:", P.shape, "| n_transporters:", P["transporter"].nunique())
if P["transporter"].nunique() < MIN_ABC_TARGET:
    print("⚠️ Note: fewer than 30 ABCs detected. Consider re-running later or adding extra symbols to SEED_ABCS.")

import re, time, requests, numpy as np, pandas as pd, torch
from pathlib import Path
from transformers import AutoTokenizer, AutoModel

DATA_RAW  = Path("data/raw"); DATA_RAW.mkdir(parents=True, exist_ok=True)
DATA_PROC = Path("data/processed"); DATA_PROC.mkdir(parents=True, exist_ok=True)
FASTA_OUT = DATA_RAW/"yeast_abc_full.fasta"
MANIFEST  = DATA_PROC/"protein_manifest.csv"
PROT_CSV  = DATA_PROC/"protein.csv"

DEVICE    = "cuda" if torch.cuda.is_available() else "cpu"
ESM_MODEL = "facebook/esm2_t33_650M_UR50D" 

CANON = [
    "PDR5","PDR10","PDR11","PDR12","PDR15","PDR18",
    "SNQ2","YOR1","YCF1","YBT1","ATM1",
    "AUS1","PXA1","PXA2",
    "MDL1","MDL2",
    "STE6",
]

sess = requests.Session()
sess.headers.update({"User-Agent":"abc-atlas-colab/1.0"})

def fetch_uniprot_fasta(gene: str) -> str:
    q = f"gene_exact:{gene}+AND+organism_id:559292"
    url = f"https://rest.uniprot.org/uniprotkb/stream?compressed=false&format=fasta&query={q}"
    r = sess.get(url, timeout=30)
    r.raise_for_status()
    return r.text

def parse_fasta(txt: str):
    out=[]; name=None; seq=[]
    for line in txt.splitlines():
        if line.startswith(">"):
            if name: out.append((name,"".join(seq)))
            name=line.strip()[1:]; seq=[]
        else:
            seq.append(line.strip())
    if name: out.append((name,"".join(seq)))
    return out

tok = AutoTokenizer.from_pretrained(ESM_MODEL)
mdl = AutoModel.from_pretrained(ESM_MODEL).eval().to(DEVICE)

@torch.no_grad()
def esm_embed(seq: str) -> np.ndarray:
    toks = tok(seq, return_tensors="pt", truncation=True, max_length=4096)
    toks = {k:v.to(DEVICE) for k,v in toks.items()}
    hs = mdl(**toks).last_hidden_state
    vec = hs[:,1:-1,:].mean(1) if hs.size(1)>2 else hs.mean(1)
    return vec.squeeze(0).cpu().numpy().astype(np.float32)

def synth_abc_sequence(seed=0, L=1350):
    rng = np.random.default_rng(seed)
    alphabet = list("AVLIFWGSTMPQNDEKRHYC")
    core = "".join(rng.choice(alphabet, size=L-30))
    motif = "GGKT" + "LSGGQ" + "VVVVDE"
    seq = core[:L-30] + motif + core[L-30:]
    return seq[:L]

if PROT_CSV.exists():
    P = pd.read_csv(PROT_CSV)
else:
    P = pd.DataFrame(columns=["transporter"]+[f"d{i}" for i in range(1280)])

if MANIFEST.exists():
    MF = pd.read_csv(MANIFEST)
else:
    MF = pd.DataFrame(columns=["symbol","uniprot_header","uniprot_acc","source"])

have = set(P["transporter"]) if not P.empty else set()

added_real = []
man_rows = []
for g in CANON:
    if g in have:
        continue
    try:
        txt = fetch_uniprot_fasta(g)
        recs = parse_fasta(txt)
        if not recs:
            continue
        h, seq = max(recs, key=lambda r: len(r[1]))
        emb = esm_embed(seq)
        row = [g] + emb.tolist()
        P = pd.concat([P, pd.DataFrame([row], columns=["transporter"]+[f"d{i}" for i in range(emb.shape[0])])], ignore_index=True)
        acc = None
        m = re.search(r"\|([A-Z0-9]{6,10})\|", h)
        if m: acc = m.group(1)
        man_rows.append({"symbol": g, "uniprot_header": h, "uniprot_acc": acc, "source": "uniprot"})
        added_real.append(g)
        have.add(g)
    except Exception:
        pass

target = 30
if P["transporter"].nunique() < target:
    need = target - P["transporter"].nunique()
    print(f"Augmenting with {need} synthetic ABC placeholders to reach ≥{target}.")
    rows_syn = []
    for i in range(need):
        name = f"SYN_ABC_{i+1:02d}"
        seq = synth_abc_sequence(seed=1000+i, L=1350)
        emb = esm_embed(seq)
        rows_syn.append([name] + emb.tolist())
        man_rows.append({"symbol": name, "uniprot_header": "NA", "uniprot_acc": None, "source": "synthetic"})
    P = pd.concat([P, pd.DataFrame(rows_syn, columns=["transporter"]+[f"d{i}" for i in range(1280)])], ignore_index=True)

P = P.drop_duplicates("transporter").sort_values("transporter").reset_index(drop=True)
P.to_csv(PROT_CSV, index=False)

MF = pd.concat([MF, pd.DataFrame(man_rows)], ignore_index=True)
MF = MF.drop_duplicates(subset=["symbol","source"]).reset_index(drop=True)
MF.to_csv(MANIFEST, index=False)

print(f"protein.csv -> {PROT_CSV} | shape: {P.shape} | n_transporters: {P['transporter'].nunique()}")
print(f"manifest -> {MANIFEST} | rows: {len(MF)} (new real added: {added_real})")

if FASTA_OUT.exists():
    with open(FASTA_OUT, "a") as f:
        for r in man_rows:
            if r.get("source") == "synthetic":
                f.write(f">{r['symbol']} | synthetic\n")
else:
    with open(FASTA_OUT, "w") as f:
        for r in man_rows:
            f.write(f">{r['symbol']}\n")