#!/usr/bin/env python3
"""
caption_v2.py — disease/lesion-centric caption generator (caption v2).

A PURE FUNCTION of a manifest row -> specificity-tiered caption rows.
Used to REGENERATE captions from existing *_images_v1.parquet WITHOUT
re-running extraction (same idea as regen_oct_captions.py), so it works
uniformly for the private, public-fundus and public-OCT cohorts.

Schema (EyeDiff-aligned):  {modality}, {region}, {diagnosis[+severity]}, {lesions...}

Tiers (Brack et al. 2025 — vary SPECIFICITY, not wording):
  short  : {modality}, {diagnosis}                       (no region / severity / lesion)
  medium : {modality}, {region}, {diagnosis+severity}
  dense  : {modality}, {region}, {diagnosis+severity}, {lesions}
Identical tiers are de-duplicated (a normal, lesion-free image collapses to one
short caption). The ~10% empty-caption dropout for classifier-free guidance is a
TRAINING-loader concern and is intentionally NOT stored as data rows.

Acquisition metadata (device, dataset name, quality score, slice index, bbox,
exact µm thickness, eye laterality) stays in the image parquet — it is
deliberately kept OUT of the prompt text.

Region rule: emitted for OCT / SLO (macula vs optic disc matters); omitted for
color fundus (inherently posterior-pole, EyeDiff-style "color fundus, <disease>").
"""
import disease_dict as dd

CAP_COLS = ["caption_id", "image_id", "level", "prompt_text",
            "language", "generator", "grounded_in"]


def _get(row, k, default=None):
    if hasattr(row, "get"):
        return row.get(k, default)
    return getattr(row, k, default)


def _as_list(x):
    if x is None:
        return []
    if isinstance(x, (list, tuple)):
        return list(x)
    if hasattr(x, "tolist"):
        try:
            return list(x.tolist())
        except Exception:
            pass
    return [x]


def caption_rows_for(row):
    """row: dict-like with modality, anatomy, diagnosis_group, severity,
    lesion_tags, image_id. Returns a list of caption-row dicts (CAP_COLS)."""
    image_id = _get(row, "image_id")
    mod = _get(row, "modality")
    anat = _get(row, "anatomy") or "macula"
    sev = _get(row, "severity")
    raw_dx = _as_list(_get(row, "diagnosis_group"))
    raw_les = _as_list(_get(row, "lesion_tags"))

    # Normalize old-mapping diagnosis tokens through the v2 dictionary
    # (CNV -> nAMD + lesion CNV; DRUSEN -> AMD + lesion drusen; CSR -> CSC; ...)
    codes, lesions = [], []
    for t in raw_dx:
        c, _s, l = dd.normalize_diagnosis(t)
        codes += c
        lesions += l
    for lt in raw_les:
        cc = dd.normalize_lesion(lt)
        if cc:
            lesions.append(cc)
    codes = list(dict.fromkeys(codes))        # dedup, keep order
    lesions = list(dict.fromkeys(lesions))

    # CONFIRMED normal only when there is no diagnosis AND severity says 'none'.
    is_normal = (len(raw_dx) == 0 and str(sev) == "none")

    mod_s = dd.modality_phrase(mod)
    region_s = dd.anatomy_phrase(anat) if mod in ("oct_bscan", "slo_gray") else None

    dx_short = dd.compose_disease_segment(codes, None, [],
                                          include_lesions=False, is_normal=is_normal)
    dx_med = dd.compose_disease_segment(codes, sev, lesions,
                                        include_lesions=False, is_normal=is_normal)
    dx_dense = dd.compose_disease_segment(codes, sev, lesions,
                                          include_lesions=True, is_normal=is_normal)

    def join(parts):
        return ", ".join([p for p in parts if p])

    tiers = [
        ("short",  join([mod_s] + dx_short)),
        ("medium", join([mod_s, region_s] + dx_med)),
        ("dense",  join([mod_s, region_s] + dx_dense)),
    ]

    out, seen = [], set()
    for lvl, txt in tiers:                     # first (least specific) wins on dup
        if not txt or txt in seen:
            continue
        seen.add(txt)
        out.append({"caption_id": f"{image_id}_{lvl}", "image_id": image_id,
                    "level": lvl, "prompt_text": txt, "language": "en",
                    "generator": "caption_v2", "grounded_in": "manifest_fields"})
    return out


# --------------------------------------------------------------------------- #
# preview: sample real manifest rows and print v2 captions (no writes)          #
# --------------------------------------------------------------------------- #
if __name__ == "__main__":
    import argparse
    import pandas as pd
    ap = argparse.ArgumentParser()
    ap.add_argument("--manifest", required=True)
    ap.add_argument("--n-per-group", type=int, default=2)
    ap.add_argument("--group-col", default="cohort")
    args = ap.parse_args()

    df = pd.read_parquet(args.manifest)
    print(f"loaded {len(df)} rows from {args.manifest}\n")
    # show a spread: a few rows per (cohort) and ensure disease variety
    shown = 0
    for _, g in df.groupby(args.group_col):
        # prefer rows with a diagnosis, fall back to any
        nz = g[g["diagnosis_group"].apply(lambda x: x is not None and len(_as_list(x)) > 0)]
        pick = pd.concat([nz.head(args.n_per_group), g.head(1)]).drop_duplicates("image_id")
        for _, r in pick.head(args.n_per_group).iterrows():
            dxs = _as_list(r.get("diagnosis_group"))
            print(f"[{r.get('cohort')}] modality={r.get('modality')} anat={r.get('anatomy')} "
                  f"dx={dxs} sev={r.get('severity')} les={_as_list(r.get('lesion_tags'))}")
            for c in caption_rows_for(r):
                print(f"    {c['level']:6s}| {c['prompt_text']}")
            shown += 1
            print()
    print(f"shown {shown} sample images")