"""Source adapters: read each source's native annotation format into one row per image.

Every adapter returns a DataFrame with columns
    rel_path      path relative to <raw_root>/<source_id>
    native_label  native tokens joined by '|' (kept verbatim next to the harmonized label)
    patient_id    patient / exam identifier when the source provides one, else ''
    eye           left / right / ''
    dr_grade      ICDR grade 0-4 as string when available, else ''
"""
import re
from pathlib import Path

import pandas as pd

IMG_EXT = {".jpg", ".jpeg", ".png", ".tif", ".tiff", ".bmp"}
COLS = ["rel_path", "native_label", "patient_id", "eye", "dr_grade"]


def _norm(v):
    if v is None or (isinstance(v, float) and pd.isna(v)):
        return ""
    s = str(v).strip()
    if s.lower() == "nan":
        return ""
    if re.fullmatch(r"-?\d+\.0+", s):
        s = s.split(".")[0]
    return s


def _first(row, cols):
    for c in [cols] if isinstance(cols, str) else cols:
        v = _norm(row.get(c))
        if v:
            return v
    return ""


def _need(df, cols, where):
    cols = [c for c in cols if c]
    missing = [c for c in cols if c not in df.columns]
    if missing:
        raise KeyError(f"{where}: missing columns {missing}; found {list(df.columns)[:30]}")


def _read_table(path, sep=",", header=True, names=None):
    path = Path(path)
    if path.suffix.lower() in {".xlsx", ".xls"}:
        df = pd.read_excel(path, dtype=str)
    else:
        df = pd.read_csv(path, sep=sep, header=0 if header else None, names=names, dtype=str,
                         skipinitialspace=True, engine="python")
    df.columns = [str(c).strip() for c in df.columns]
    return df


def _flatten(x):
    if not x:
        return []
    return [x] if isinstance(x, str) else list(x)


def adapter_csv(src_dir, cfg):
    rows = []
    for t in cfg["tables"]:
        df = _read_table(src_dir / t["file"], t.get("sep", ","), t.get("header", True), t.get("names"))
        label_cols = _flatten(cfg.get("label_col"))
        mh = cfg.get("multihot_cols")
        if mh is None and cfg.get("multihot_exclude_cols") is not None:
            mh = [c for c in df.columns if c not in cfg["multihot_exclude_cols"]]
        _need(df, [cfg["image_col"], cfg.get("patient_col"), cfg.get("eye_col"), *label_cols,
                   *_flatten(cfg.get("grade_col")), *(mh or []), *(cfg.get("keep_if") or {})], t["file"])
        for _, r in df.iterrows():
            if any(_norm(r[c]) != _norm(v) for c, v in (cfg.get("keep_if") or {}).items()):
                continue
            img = _norm(r[cfg["image_col"]])
            if not img:
                continue
            if label_cols:
                tokens = [_first(r, label_cols)]
            else:
                tokens = [c for c in mh if _norm(r[c]) == "1"]
                if not tokens and cfg.get("normal_if_all_zero"):
                    tokens = ["NORMAL"]
            patient = _norm(r[cfg["patient_col"]]) if cfg.get("patient_col") else ""
            if not patient and cfg.get("patient_regex"):
                m = re.search(cfg["patient_regex"], img)
                patient = m.group(1) if m else ""
            eye = _norm(r[cfg["eye_col"]]) if cfg.get("eye_col") else ""
            if not eye and cfg.get("eye_regex"):
                m = re.search(cfg["eye_regex"], img)
                eye = m.group(1) if m else ""
            rel = Path(t["image_dir"]) / cfg.get("path_template", "{image}").format(image=img, patient=patient)
            grade = _first(r, cfg["grade_col"]) if cfg.get("grade_col") else ""
            rows.append([str(rel), "|".join(tokens), patient, eye.lower(), grade])
    return pd.DataFrame(rows, columns=COLS)


def _images_under(base, pattern="**/*"):
    return sorted(p for p in base.glob(pattern) if p.is_file() and p.suffix.lower() in IMG_EXT)


def adapter_folders(src_dir, cfg):
    """Class = name of the image's parent folder (e.g. train/glaucoma/x.png -> 'glaucoma')."""
    base = src_dir / cfg.get("subdir", "")
    rows = [[str(p.relative_to(src_dir)), p.parent.name, "", "", ""] for p in _images_under(base)]
    return pd.DataFrame(rows, columns=COLS)


def adapter_filename(src_dir, cfg):
    """Class from regex rules on the file name; first matching rule wins, unmatched files get no label."""
    rules = [(re.compile(p), tok) for p, tok in cfg["rules"]]
    rows = []
    for p in _images_under(src_dir, cfg.get("glob", "**/*")):
        tok = next((tok for rx, tok in rules if rx.search(p.name)), "")
        rows.append([str(p.relative_to(src_dir)), tok, "", "", ""])
    return pd.DataFrame(rows, columns=COLS)


def adapter_odir(src_dir, cfg):
    """ODIR-5K: one row per patient, per-eye diagnostic keywords separated by Chinese or ASCII commas."""
    df = _read_table(src_dir / cfg["file"])
    rows = []
    for side in ("Left", "Right"):
        fcol, kcol = f"{side}-Fundus", f"{side}-Diagnostic Keywords"
        _need(df, ["ID", fcol, kcol], cfg["file"])
        for _, r in df.iterrows():
            kws = [k.strip() for k in re.split(r"[，,]", _norm(r[kcol])) if k.strip()]
            rows.append([str(Path(cfg["image_dir"]) / _norm(r[fcol])), "|".join(kws), _norm(r["ID"]), side.lower(), ""])
    return pd.DataFrame(rows, columns=COLS)


def adapter_labels_csv(src_dir, cfg):
    """Manually converted sources: <source>/labels.csv with image,label[,patient,eye,grade]; label tokens '|'-separated."""
    df = _read_table(src_dir / cfg.get("file", "labels.csv"))
    _need(df, ["image", "label"], "labels.csv")
    get = lambda r, c: _norm(r[c]) if c in df.columns else ""
    rows = [[get(r, "image"), get(r, "label"), get(r, "patient"), get(r, "eye").lower(), get(r, "grade")]
            for _, r in df.iterrows()]
    return pd.DataFrame(rows, columns=COLS)


ADAPTERS = {
    "csv": adapter_csv,
    "folders": adapter_folders,
    "filename": adapter_filename,
    "odir": adapter_odir,
    "labels_csv": adapter_labels_csv,
}


def run_adapter(src, raw_root):
    cfg = src["adapter"]
    return ADAPTERS[cfg["type"]](Path(raw_root) / src["id"], cfg)