app.py

from __future__ import annotations

import os
import re
import subprocess
from pathlib import Path
from typing import Optional

import pandas as pd
import streamlit as st
import altair as alt

# ============================
# Git helpers (use THIS repo)
# ============================

def run_git(repo_dir: Path, args: list[str]) -> str:
    p = subprocess.run(
        ["git", "-C", str(repo_dir), *args],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        check=False,
        env={**dict(os.environ), "GIT_TERMINAL_PROMPT": "0"},
    )
    if p.returncode != 0:
        raise RuntimeError(p.stderr.strip() or "git command failed")
    return p.stdout


def resolve_repo_root() -> Path:
    """
    Use the dashboard repo itself as the git root.
    This works locally and on Streamlit Community Cloud.
    """
    cwd = Path.cwd().resolve()
    try:
        p = subprocess.run(
            ["git", "-C", str(cwd), "rev-parse", "--show-toplevel"],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            check=True,
        )
        return Path(p.stdout.strip())
    except subprocess.CalledProcessError as e:
        raise RuntimeError(
            "This app must be run from a git checkout.\n"
            f"cwd={cwd}\n{e.stderr}"
        )


_RE_LS_TREE_BLOB = re.compile(r"^\d+\s+blob\s+([0-9a-f]{40})\t(.+)$")


def report_set_commits(repo_dir: Path, reports_dir: str, max_sets: int) -> list[str]:
    out = run_git(repo_dir, ["log", f"--max-count={max_sets}", "--pretty=format:%H", "--", reports_dir])
    return [x.strip() for x in out.splitlines() if x.strip()]


def report_blobs_at_commit(repo_dir: Path, commit: str, reports_dir: str) -> list[tuple[str, str]]:
    out = run_git(repo_dir, ["ls-tree", "-r", commit, reports_dir])
    pairs: list[tuple[str, str]] = []
    for line in out.splitlines():
        m = _RE_LS_TREE_BLOB.match(line.strip())
        if not m:
            continue
        oid, path = m.group(1), m.group(2)
        if path.endswith(".md"):
            pairs.append((path, oid))
    return pairs


def cat_blobs(repo_dir: Path, oids: list[str]) -> dict[str, str]:
    if not oids:
        return {}

    proc = subprocess.Popen(
        ["git", "-C", str(repo_dir), "cat-file", "--batch"],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    assert proc.stdin and proc.stdout

    proc.stdin.write(("\n".join(oids) + "\n").encode("utf-8"))
    proc.stdin.flush()

    out: dict[str, str] = {}

    for _ in oids:
        header_b = proc.stdout.readline()
        if not header_b:
            break
        header = header_b.decode("utf-8", errors="replace").strip()
        parts = header.split()
        if len(parts) < 3:
            continue

        got_oid, typ, size_s = parts[0], parts[1], parts[2]
        size = int(size_s) if size_s.isdigit() else 0
        content = proc.stdout.read(size)
        proc.stdout.read(1)  # trailing newline

        if typ == "blob":
            out[got_oid] = content.decode("utf-8", errors="replace")

    proc.stdin.close()
    proc.wait(timeout=120)
    return out


# ============================
# Parsing (based on actual report format)
# ============================

RE_GENERATED_ON = re.compile(r"_Generated on\s+(\d{4}-\d{2}-\d{2})_", re.IGNORECASE)
RE_WINDOW_HEADER = re.compile(r"^###\s+(3m|6m|12m)\b", re.MULTILINE)

RE_RELEASES = re.compile(r"Releases .*?:\s*(\d+)\s*\|\s*Median gap \(days\):\s*([0-9.]+|—)")
RE_CONTRIB = re.compile(r"New contributors:\s*(\d+)\s*\|\s*Unique committers:\s*(\d+)\s*\|\s*Commits:\s*(\d+)")
RE_ISSUES = re.compile(r"Issues:\s*opened\s*(\d+)\s*/\s*closed\s*(\d+)")
RE_PRS = re.compile(r"PRs:\s*opened\s*(\d+)\s*/\s*merged\s*(\d+)\s*\|\s*Median merge time \(days\):\s*([0-9.]+|—)")
RE_REVIEWS = re.compile(
    r"Reviews \(sampled\):.*?median reviewers/PR\s*([0-9.]+|—).*?"
    r"reviewer diversity \(eff\.\#\)\s*([0-9.]+|—).*?"
    r"PR author diversity \(eff\.\#\)\s*([0-9.]+|—).*?"
    r"unique reviewers\s*(\d+|—),\s*unique authors\s*(\d+|—)"
)
RE_BUS = re.compile(r"Bus factor proxy \(50%\s*/\s*75%\):\s*(\d+|—)\s*/\s*(\d+|—)")
RE_REPORTS = re.compile(r"Incubator reports:\s*(\d+|—)\s*\|\s*Avg mentor sign-offs:\s*([0-9.]+|—)")
RE_MAIL = re.compile(r"Mailing lists:\s*dev messages\s*(\d+|—),\s*dev unique posters\s*(\d+|—)")


def _to_int(s: Optional[str]) -> Optional[int]:
    if s is None or s == "—":
        return None
    return int(s)


def _to_float(s: Optional[str]) -> Optional[float]:
    if s is None or s == "—":
        return None
    return float(s)


def strip_md(line: str) -> str:
    return line.replace("**", "").strip()


def parse_window_details_block(bullet_lines: list[str]) -> dict:
    row: dict = {}
    for raw in bullet_lines:
        line = strip_md(raw)
        line = line[2:].strip() if line.startswith("- ") else line

        if line.startswith("Releases "):
            m = RE_RELEASES.search(line)
            if m:
                row["releases"] = _to_int(m.group(1))
                row["median_gap_days"] = _to_float(m.group(2))

        elif line.startswith("New contributors:"):
            m = RE_CONTRIB.search(line)
            if m:
                row["new_contributors"] = _to_int(m.group(1))
                row["unique_committers"] = _to_int(m.group(2))
                row["commits"] = _to_int(m.group(3))

        elif line.startswith("Issues:"):
            m = RE_ISSUES.search(line)
            if m:
                row["issues_opened"] = _to_int(m.group(1))
                row["issues_closed"] = _to_int(m.group(2))

        elif line.startswith("PRs:"):
            m = RE_PRS.search(line)
            if m:
                row["prs_opened"] = _to_int(m.group(1))
                row["prs_merged"] = _to_int(m.group(2))
                row["median_merge_days"] = _to_float(m.group(3))

        elif line.startswith("Reviews (sampled):"):
            m = RE_REVIEWS.search(line)
            if m:
                row["median_reviewers_per_pr"] = _to_float(m.group(1))
                row["reviewer_div_eff"] = _to_float(m.group(2))
                row["pr_author_div_eff"] = _to_float(m.group(3))
                row["unique_reviewers"] = _to_int(m.group(4))
                row["unique_authors"] = _to_int(m.group(5))

        elif line.startswith("Bus factor proxy"):
            m = RE_BUS.search(line)
            if m:
                row["bus50"] = _to_int(m.group(1))
                row["bus75"] = _to_int(m.group(2))

        elif line.startswith("Incubator reports:"):
            m = RE_REPORTS.search(line)
            if m:
                row["reports_count"] = _to_int(m.group(1))
                row["avg_mentor_signoffs"] = _to_float(m.group(2))

        elif line.startswith("Mailing lists:"):
            m = RE_MAIL.search(line)
            if m:
                row["dev_msgs"] = _to_int(m.group(1))
                row["dev_unique_posters"] = _to_int(m.group(2))

    return row


def parse_report(text: str, podling_stem: str) -> list[dict]:
    m = RE_GENERATED_ON.search(text)
    if not m:
        return []
    snapshot_date = m.group(1)

    wd_idx = text.find("## Window Details")
    if wd_idx == -1:
        return []
    wd = text[wd_idx:]

    matches = list(RE_WINDOW_HEADER.finditer(wd))
    out: list[dict] = []

    for i, mm in enumerate(matches):
        window = mm.group(1)
        start = mm.end()
        end = matches[i + 1].start() if i + 1 < len(matches) else len(wd)
        block = wd[start:end]

        bullet_lines = [ln for ln in block.splitlines() if ln.strip().startswith("- ")]
        metrics = parse_window_details_block(bullet_lines)

        out.append(
            {
                "podling_key": podling_stem.casefold(),  # merge Hamalton/hamalton/etc
                "podling_display": podling_stem,         # keep original for display; latest wins
                "snapshot_date": snapshot_date,
                "window": window,
                **metrics,
            }
        )

    return out


# ============================
# Dataset build (git history)
# ============================

@st.cache_data(show_spinner=True)
def build_dataset(repo_root: str, reports_dir: str, max_commits: int) -> pd.DataFrame:
    repo_dir = Path(repo_root)
    rows: list[dict] = []

    commits = report_set_commits(repo_dir, reports_dir, max_sets=max_commits)
    for commit in commits:
        pairs = report_blobs_at_commit(repo_dir, commit, reports_dir)
        if not pairs:
            continue

        oids = [oid for (_path, oid) in pairs]
        blob_text = cat_blobs(repo_dir, oids)

        for path, oid in pairs:
            text = blob_text.get(oid)
            if not text:
                continue

            podling_stem = Path(path).stem
            for r in parse_report(text, podling_stem):
                r["commit"] = commit
                r["path"] = path
                rows.append(r)

    df = pd.DataFrame(rows)
    if df.empty:
        return df

    df["snapshot_date"] = pd.to_datetime(df["snapshot_date"], errors="coerce")
    df = df.dropna(subset=["snapshot_date"])

    # de-dupe
    df = df.sort_values(["podling_key", "window", "snapshot_date", "commit"])
    df = df.drop_duplicates(["podling_key", "window", "snapshot_date"], keep="last")

    # ensure one display name per key: latest snapshot wins
    latest_name = (
        df.sort_values(["podling_key", "snapshot_date", "commit"])
        .groupby("podling_key", as_index=False)
        .tail(1)[["podling_key", "podling_display"]]
    )
    df = df.drop(columns=["podling_display"]).merge(latest_name, on="podling_key", how="left")

    return df.reset_index(drop=True)


# ============================
# Latest-only combined snapshot (STRICT)
# - availability and signals come ONLY from the latest snapshot per podling_key
# - windows count ONLY if present in that latest snapshot (no inference)
# ============================

def latest_combo(df: pd.DataFrame) -> pd.DataFrame:
    if df.empty:
        return df

    # latest snapshot_date per podling_key
    latest_dates = df.groupby("podling_key", as_index=False)["snapshot_date"].max()
    latest = df.merge(latest_dates, on=["podling_key", "snapshot_date"], how="inner")

    # if multiple commits same day, keep latest commit row per (key, window)
    latest = latest.sort_values(["podling_key", "window", "snapshot_date", "commit"]).groupby(
        ["podling_key", "window"], as_index=False
    ).tail(1)

    keep = ["podling_key", "podling_display", "window", "snapshot_date"]
    metrics = [c for c in latest.columns if c not in (keep + ["commit", "path"])]

    wide = latest.pivot(index="podling_key", columns="window", values=metrics)
    wide.columns = [f"{m}_{w}" for (m, w) in wide.columns]
    wide = wide.reset_index()

    dates = latest.pivot(index="podling_key", columns="window", values="snapshot_date")
    dates.columns = [f"snapshot_date_{w}" for w in dates.columns]
    dates = dates.reset_index()

    names = latest.groupby("podling_key", as_index=False).tail(1)[["podling_key", "podling_display"]]
    out = wide.merge(dates, on="podling_key", how="left").merge(names, on="podling_key", how="left")

    # add single "latest_snapshot_date" (for info / debugging if needed)
    out["latest_snapshot_date"] = latest.groupby("podling_key")["snapshot_date"].max().reindex(out["podling_key"]).values
    return out


# ============================
# Signals + commentary (STRICT latest-only windows)
# ============================

PRIMARY = "primary"
SECONDARY = "secondary"
FYI = "fyi"


def _val(row: pd.Series, key: str) -> Optional[float]:
    v = row.get(key)
    if v is None:
        return None
    if isinstance(v, float) and pd.isna(v):
        return None
    if isinstance(v, (int, float)):
        return float(v)
    return None


def _has_window(row: pd.Series, w: str) -> bool:
    d = row.get(f"snapshot_date_{w}")
    return d is not None and not pd.isna(d)


def window_availability_messages(row: pd.Series) -> list[str]:
    # STRICT: only based on latest snapshot (presence of ### window section in that latest file)
    msgs: list[str] = []
    for w in ["12m", "6m", "3m"]:
        msgs.append(f"- **{w}**: {'available' if _has_window(row, w) else 'not available'}")
    return msgs


def build_signals_latest_only(row: pd.Series) -> list[dict]:
    sig: list[dict] = []

    def add(level: str, text: str):
        sig.append({"level": level, "text": text})

    has3 = _has_window(row, "3m")
    has6 = _has_window(row, "6m")
    has12 = _has_window(row, "12m")

    # pull values ONLY if the window exists
    r6 = _val(row, "releases_6m") if has6 else None
    r12 = _val(row, "releases_12m") if has12 else None

    p3 = _val(row, "dev_unique_posters_3m") if has3 else None
    p12 = _val(row, "dev_unique_posters_12m") if has12 else None

    m3 = _val(row, "dev_msgs_3m") if has3 else None
    m12 = _val(row, "dev_msgs_12m") if has12 else None

    bus3 = _val(row, "bus50_3m") if has3 else None
    committers12 = _val(row, "unique_committers_12m") if has12 else None

    merge3 = _val(row, "median_merge_days_3m") if has3 else None
    merge12 = _val(row, "median_merge_days_12m") if has12 else None

    prs3 = _val(row, "prs_merged_3m") if has3 else None
    revdiv3 = _val(row, "reviewer_div_eff_3m") if has3 else None
    authdiv3 = _val(row, "pr_author_div_eff_3m") if has3 else None

    commits3 = _val(row, "commits_3m") if has3 else None

    # Releases checks: only when the relevant windows exist in the LATEST report
    if has12 and r12 is not None and r12 == 0:
        add(PRIMARY, "No releases in 12m — likely needs mentor/IPMC attention (blockers/ownership/process).")
    elif has6 and has12 and r6 is not None and r6 == 0 and (r12 is not None and r12 > 0):
        add(SECONDARY, "No releases in 6m but releases exist in 12m — check-in: planned pause or emerging blockers?")

    # Participation vs baseline: only compare if BOTH windows exist in the LATEST report
    if has3 and has12 and p3 is not None and p12 is not None and p12 > 0:
        ratio = p3 / p12
        if p12 >= 15 and p3 <= 6 and ratio <= 0.25:
            add(
                SECONDARY,
                "Recent dev@ participation (3m) is materially lower than the 12m baseline — confirm whether discussion moved channels or participation narrowed."
            )

    if has3 and has12 and m3 is not None and m12 is not None and m12 > 0:
        drop = (m12 - m3) / m12
        if m3 <= 20 and drop >= 0.50:
            add(
                FYI,
                "Recent dev@ message volume (3m) is lower than the 12m baseline — interpret alongside other indicators (releases/review activity)."
            )

    # Bus factor: needs 3m and 12m in the LATEST report
    if has3 and has12 and bus3 is not None and bus3 <= 2 and committers12 is not None and committers12 <= 10:
        add(SECONDARY, "Contribution concentration signal (bus50 ≤ 2) with small 12m committer base — check dominance risk.")

    # PR throughput concentration: only needs 3m
    if has3 and prs3 is not None and prs3 >= 50:
        if revdiv3 is not None and revdiv3 <= 3.0:
            add(SECONDARY, "High PR throughput but low reviewer diversity (3m) — are reviews concentrated?")
        if authdiv3 is not None and authdiv3 <= 3.0:
            add(SECONDARY, "Activity concentrated among few PR authors (3m) — is funnel broadening?")

    # Merge time baseline comparison: only if BOTH windows exist in the LATEST report
    if has3 and has12 and merge3 is not None and merge12 is not None and merge12 > 0:
        ch = (merge3 - merge12) / merge12
        if ch >= 0.50 and merge3 >= 7:
            add(SECONDARY, "3m PR merge time much slower than 12m baseline — backlog/review capacity/process change?")
        elif ch >= 0.25 and merge3 >= 7:
            add(FYI, "3m PR merge time trending slower than 12m baseline — FYI (watch next snapshot).")

    # Commit activity vs participation: only needs 3m
    if has3 and commits3 is not None and commits3 >= 100 and (p3 is not None and p3 <= 5):
        add(FYI, "High commit activity with low dev@ participation (3m) — FYI: check on-list socialisation norms.")

    return sig


def signals_summary(sig: list[dict]) -> str:
    if not sig:
        return "—"
    order = {PRIMARY: 0, SECONDARY: 1, FYI: 2}
    sig = sorted(sig, key=lambda x: order.get(x["level"], 9))
    return " • ".join([f"[{s['level']}] {s['text']}" for s in sig])


def draft_commentary_from_latest(pod_display: str, row: pd.Series) -> str:
    sigs = row.get("signals") or []
    order = {PRIMARY: 0, SECONDARY: 1, FYI: 2}
    sigs = sorted(sigs, key=lambda x: order.get(x["level"], 9))

    primary = [s for s in sigs if s["level"] == PRIMARY]
    secondary = [s for s in sigs if s["level"] == SECONDARY]
    fyi = [s for s in sigs if s["level"] == FYI]

    lines: list[str] = []
    lines.append(f"### {pod_display} — health cross-check summary")
    lines.append("")
    lines.append("**Data availability:**")
    lines.extend(window_availability_messages(row))
    lines.append("")
    lines.append("**Indicators:**")

    if not (primary or secondary or fyi):
        lines.append("- —")
        return "\n".join(lines)

    if primary:
        lines.append("- **Primary:**")
        for s in primary:
            lines.append(f"  - {s['text']}")
    if secondary:
        lines.append("- **Secondary:**")
        for s in secondary:
            lines.append(f"  - {s['text']}")
    if fyi:
        lines.append("- **FYI:**")
        for s in fyi:
            lines.append(f"  - {s['text']}")

    return "\n".join(lines)


# ============================
# Charts
# ============================

def altair_metric_chart(pod_df: pd.DataFrame, metric: str, title: str):
    if metric not in pod_df.columns:
        return

    d = pod_df[["snapshot_date", "window", metric]].dropna().copy()
    if d.empty:
        return

    c = (
        alt.Chart(d)
        .mark_line(point=True)
        .encode(
            x=alt.X("snapshot_date:T", title="Snapshot date"),
            y=alt.Y(f"{metric}:Q", title=metric),
            color=alt.Color(
                "window:N",
                title=None,
                legend=alt.Legend(orient="bottom", direction="horizontal"),
            ),
            tooltip=[
                alt.Tooltip("snapshot_date:T", title="Snapshot"),
                alt.Tooltip("window:N", title="Window"),
                alt.Tooltip(f"{metric}:Q", title=metric),
            ],
        )
        .properties(title=title)
    )
    st.altair_chart(c, use_container_width=True)


def charts_panel(pod_df: pd.DataFrame):
    c1, c2, c3 = st.columns(3)
    with c1:
        altair_metric_chart(pod_df, "commits", "Commits (3m/6m/12m)")
    with c2:
        altair_metric_chart(pod_df, "prs_merged", "PRs merged (3m/6m/12m)")
    with c3:
        altair_metric_chart(pod_df, "dev_unique_posters", "Dev unique posters (3m/6m/12m)")

    c4, c5, c6 = st.columns(3)
    with c4:
        altair_metric_chart(pod_df, "releases", "Releases (3m/6m/12m)")
    with c5:
        altair_metric_chart(pod_df, "median_merge_days", "Median PR merge time (days) (3m/6m/12m)")
    with c6:
        altair_metric_chart(pod_df, "bus50", "Bus factor proxy 50% (3m/6m/12m)")

    c7, c8, c9 = st.columns(3)
    with c7:
        altair_metric_chart(pod_df, "issues_opened", "Issues opened (3m/6m/12m)")
    with c8:
        altair_metric_chart(pod_df, "issues_closed", "Issues closed (3m/6m/12m)")
    with c9:
        altair_metric_chart(pod_df, "dev_msgs", "Dev messages (3m/6m/12m)")


# ============================
# UI (same layout)
# ============================

st.set_page_config(layout="wide")
st.title("Incubator Health — combined view (3m/6m/12m)")

if "selected_podling_key" not in st.session_state:
    st.session_state["selected_podling_key"] = None

with st.sidebar:
    reports_dir = st.text_input("Reports directory", "reports")
    max_commits = st.slider("Max report runs (commits touching reports/)", 10, 300, 120, 10)
    rebuild = st.button("Rebuild dataset (clear cache)")

try:
    repo_root = resolve_repo_root()
except RuntimeError as e:
    st.error(str(e))
    st.stop()

if rebuild:
    build_dataset.clear()

df = build_dataset(str(repo_root), reports_dir, max_commits)

if df.empty:
    st.warning("No data parsed. Check reports_dir.")
    try:
        st.write("cwd:", str(Path.cwd().resolve()))
        st.write("repo_root:", str(repo_root))
        st.write("reports_dir:", reports_dir)
        st.write("reports_dir exists on disk:", (Path(repo_root) / reports_dir).exists())
        out = run_git(repo_root, ["ls-tree", "-r", "--name-only", "HEAD", reports_dir])
        st.write("git ls-tree (first 20 lines):", out.splitlines()[:20])
    except Exception as e:
        st.error(f"Debug: {e}")
    st.stop()

# STRICT latest-only combo for indicators/availability
combo = latest_combo(df)
combo["signals"] = combo.apply(build_signals_latest_only, axis=1)
combo["primary_count"] = combo["signals"].apply(lambda xs: sum(1 for x in xs if x["level"] == PRIMARY))
combo["secondary_count"] = combo["signals"].apply(lambda xs: sum(1 for x in xs if x["level"] == SECONDARY))
combo["fyi_count"] = combo["signals"].apply(lambda xs: sum(1 for x in xs if x["level"] == FYI))
combo["signal_summary"] = combo["signals"].apply(signals_summary)

tabs = st.tabs(["📋 Podling queue", "📈 Charts", "📝 Commentary builder"])

with tabs[0]:
    st.subheader("Podling queue (latest report per podling)")

    c1, c2, c3 = st.columns(3)
    with c1:
        show_level = st.selectbox(
            "Show",
            ["Primary only", "Primary + Secondary", "All (incl FYI)"],
            index=1,
        )
    with c2:
        contains = st.text_input("Filter signals containing (optional)", value="")
    with c3:
        sort_by = st.selectbox("Sort by", ["Most primary", "Most secondary", "Podling name"], index=0)

    q = combo.copy()

    if show_level == "Primary only":
        q = q[q["primary_count"] >= 1]
    elif show_level == "Primary + Secondary":
        q = q[(q["primary_count"] + q["secondary_count"]) >= 1]
    else:
        # All projects (no filtering-out by default would also be fine, but keep your UI)
        q = q.copy()

    if contains.strip():
        needle = contains.strip().lower()
        q = q[q["signal_summary"].str.lower().str.contains(needle, na=False)]

    if sort_by == "Most primary":
        q = q.sort_values(["primary_count", "secondary_count", "podling_display"], ascending=[False, False, True])
    elif sort_by == "Most secondary":
        q = q.sort_values(["secondary_count", "primary_count", "podling_display"], ascending=[False, False, True])
    else:
        q = q.sort_values(["podling_display"], ascending=[True])

    cols = [
        "podling_display",
        "primary_count",
        "secondary_count",
        "fyi_count",
        "signal_summary",
        "releases_3m", "releases_6m", "releases_12m",
        "commits_3m", "commits_6m", "commits_12m",
        "prs_merged_3m", "prs_merged_6m", "prs_merged_12m",
        "dev_unique_posters_3m", "dev_unique_posters_6m", "dev_unique_posters_12m",
        "dev_msgs_3m", "dev_msgs_6m", "dev_msgs_12m",
        "median_merge_days_3m", "median_merge_days_6m", "median_merge_days_12m",
        "bus50_3m", "bus50_6m", "bus50_12m",
    ]
    present = [c for c in cols if c in q.columns]

    try:
        event = st.dataframe(
            q[present],
            use_container_width=True,
            height=520,
            selection_mode="single-row",
            on_select="rerun",
        )
        sel_rows = event.selection.rows
        if sel_rows:
            # map selected display back to key deterministically via the selected row in q
            st.session_state["selected_podling_key"] = q.iloc[sel_rows[0]]["podling_key"]
    except Exception:
        st.info(
            "Row selection isn’t available in this Streamlit version. "
            "Use the dropdown below."
        )
        # fallback list: ALL projects
        pods_all = (
            combo[["podling_key", "podling_display"]]
            .drop_duplicates()
            .sort_values("podling_display")
            .reset_index(drop=True)
        )
        display = pods_all["podling_display"].tolist()
        # no extra widgets elsewhere; only used when dataframe selection is unavailable
        chosen_display = st.selectbox("Select podling", display, key="fallback_pod_select")
        chosen_key = pods_all[pods_all["podling_display"] == chosen_display].iloc[0]["podling_key"]
        st.session_state["selected_podling_key"] = chosen_key

with tabs[1]:
    st.subheader("Charts")

    pods_all = (
        combo[["podling_key", "podling_display"]]
        .drop_duplicates()
        .sort_values("podling_display")
        .reset_index(drop=True)
    )
    options = pods_all["podling_key"].tolist()
    fmt = dict(zip(pods_all["podling_key"], pods_all["podling_display"]))

    sel_key = st.session_state.get("selected_podling_key")
    if sel_key is None and options:
        sel_key = options[0]
        st.session_state["selected_podling_key"] = sel_key

    # keep the charts selectbox in sync WITHOUT warnings: set session_state value, do not pass index
    if "charts_pod_key" not in st.session_state:
        st.session_state["charts_pod_key"] = sel_key
    elif sel_key is not None and st.session_state["charts_pod_key"] != sel_key and sel_key in options:
        st.session_state["charts_pod_key"] = sel_key

    chosen_key = st.selectbox(
        "Podling",
        options,
        format_func=lambda k: fmt.get(k, k),
        key="charts_pod_key",
    )
    st.session_state["selected_podling_key"] = chosen_key

    pod_df = df[df["podling_key"] == chosen_key].sort_values("snapshot_date")
    charts_panel(pod_df)

with tabs[2]:
    st.subheader("Commentary builder (copyable)")

    pods_all = (
        combo[["podling_key", "podling_display"]]
        .drop_duplicates()
        .sort_values("podling_display")
        .reset_index(drop=True)
    )
    options = pods_all["podling_key"].tolist()
    fmt = dict(zip(pods_all["podling_key"], pods_all["podling_display"]))

    sel_key = st.session_state.get("selected_podling_key")
    if sel_key is None and options:
        sel_key = options[0]
        st.session_state["selected_podling_key"] = sel_key

    if "commentary_pod_key" not in st.session_state:
        st.session_state["commentary_pod_key"] = sel_key
    elif sel_key is not None and st.session_state["commentary_pod_key"] != sel_key and sel_key in options:
        st.session_state["commentary_pod_key"] = sel_key

    chosen_key = st.selectbox(
        "Podling",
        options,
        format_func=lambda k: fmt.get(k, k),
        key="commentary_pod_key",
    )
    st.session_state["selected_podling_key"] = chosen_key

    row = combo[combo["podling_key"] == chosen_key].iloc[0]
    pod_display = fmt.get(chosen_key, chosen_key)
    st.code(draft_commentary_from_latest(pod_display, row), language="markdown")