Add double-click drill-down navigation, complaint sites filtering, multi-KPI comparison with normalization, and LRU caching for drill-down figures with pagination support across all tables

panel_app/kpi_health_check_panel.py

@@ -1,6 +1,8 @@
 import io
 import os
 import sys
+import time
+from collections import OrderedDict
 from datetime import date, timedelta
 
 import numpy as np
@@ -13,9 +15,11 @@ ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if ROOT_DIR not in sys.path:
     sys.path.insert(0, ROOT_DIR)
 
+from panel_app.convert_to_excel_panel import write_dfs_to_excel
 from process_kpi.kpi_health_check.engine import (
     evaluate_health_check,
     is_bad,
+    max_consecutive_days,
     window_bounds,
 )
 from process_kpi.kpi_health_check.export import build_export_bytes
@@ -62,6 +66,21 @@ current_top_anomalies_df: pd.DataFrame | None = None
 current_top_anomalies_raw: pd.DataFrame | None = None
 current_export_bytes: bytes | None = None
 
+complaint_sites: set[int] = set()
+
+_daily_version: int = 0
+_rules_version: int = 0
+_healthcheck_version: int = 0
+
+_DRILLDOWN_CACHE_MAX: int = 64
+_drilldown_fig_cache: "OrderedDict[tuple, tuple]" = OrderedDict()
+
+_DOUBLE_CLICK_S: float = 0.35
+_last_click_state: dict[str, tuple[float, int | None]] = {
+    "top": (0.0, None),
+    "multirat": (0.0, None),
+}
+
 _applying_profile: bool = False
 _loading_datasets: bool = False
 _updating_drilldown: bool = False
@@ -101,10 +120,177 @@ def _schedule_drilldown_update(fn) -> None:
         _wrapped()
 
 
+def _invalidate_drilldown_cache(
+    *,
+    data_changed: bool = False,
+    rules_changed: bool = False,
+    healthcheck_changed: bool = False,
+) -> None:
+    global _daily_version, _rules_version, _healthcheck_version
+    if data_changed:
+        _daily_version += 1
+    if rules_changed:
+        _rules_version += 1
+    if healthcheck_changed:
+        _healthcheck_version += 1
+    try:
+        _drilldown_fig_cache.clear()
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _drilldown_cache_key(site_code: int, rat: str, kpi: str) -> tuple:
+    ar = analysis_range.value
+    ar_key = (
+        str(ar[0]) if ar and len(ar) == 2 and ar[0] else None,
+        str(ar[1]) if ar and len(ar) == 2 and ar[1] else None,
+    )
+    compare_kpis_key = tuple(sorted([str(x) for x in (kpi_compare_select.value or [])]))
+    norm_key = str(kpi_compare_norm.value or "None")
+    return (
+        int(_daily_version),
+        int(_rules_version),
+        int(_healthcheck_version),
+        int(site_code),
+        str(rat or ""),
+        str(kpi or ""),
+        compare_kpis_key,
+        norm_key,
+        ar_key,
+        int(baseline_days.value),
+        int(recent_days.value),
+        float(rel_threshold_pct.value),
+        int(min_consecutive_days.value),
+    )
+
+
+def _drilldown_cache_get(key: tuple):
+    v = _drilldown_fig_cache.get(key)
+    if v is not None:
+        _drilldown_fig_cache.move_to_end(key)
+    return v
+
+
+def _drilldown_cache_set(key: tuple, value) -> None:
+    _drilldown_fig_cache[key] = value
+    _drilldown_fig_cache.move_to_end(key)
+    while len(_drilldown_fig_cache) > int(_DRILLDOWN_CACHE_MAX):
+        _drilldown_fig_cache.popitem(last=False)
+
+
+def _table_row_as_dict(table: pn.widgets.Tabulator, row_idx: int) -> dict | None:
+    try:
+        v = getattr(table, "current_view", None)
+        df = v if isinstance(v, pd.DataFrame) else table.value
+        if not isinstance(df, pd.DataFrame) or df.empty:
+            return None
+        if row_idx < 0 or row_idx >= len(df):
+            return None
+        return dict(df.iloc[int(row_idx)].to_dict())
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _apply_drilldown_selection(*, site_code, rat=None, kpi=None) -> None:
+    try:
+        if site_code is None:
+            return
+        try:
+            site_code_int = int(site_code)
+        except Exception:  # noqa: BLE001
+            return
+
+        if rat and rat in list(rat_select.options or []):
+            _set_widget_value(rat_select, str(rat))
+
+        _update_kpi_options()
+
+        if site_select.options and site_code_int not in site_select.options.values():
+            pass
+        _set_widget_value(site_select, site_code_int)
+
+        if kpi and str(kpi) in list(kpi_select.options or []):
+            _set_widget_value(kpi_select, str(kpi))
+
+        if kpi and str(kpi) in list(kpi_compare_select.options or []):
+            cur = list(kpi_compare_select.value or [])
+            if str(kpi) not in cur:
+                _set_widget_value(
+                    kpi_compare_select, [str(kpi)] + cur if cur else [str(kpi)]
+                )
+
+        _schedule_drilldown_update(_update_site_view)
+    except Exception:  # noqa: BLE001
+        return
+
+
+def _handle_double_click(table_key: str, table: pn.widgets.Tabulator, event) -> None:
+    try:
+        row = getattr(event, "row", None)
+        if row is None:
+            return
+        row = int(row)
+    except Exception:  # noqa: BLE001
+        return
+
+    now = float(time.monotonic())
+    last_t, last_row = _last_click_state.get(table_key, (0.0, None))
+    if last_row == row and (now - float(last_t)) <= float(_DOUBLE_CLICK_S):
+        _last_click_state[table_key] = (0.0, None)
+        data = _table_row_as_dict(table, row)
+        if not data:
+            return
+
+        if table_key == "top":
+            _apply_drilldown_selection(
+                site_code=data.get("site_code"),
+                rat=data.get("RAT"),
+                kpi=data.get("KPI"),
+            )
+            try:
+                status_pane.alert_type = "primary"
+                status_pane.object = f"Drill-down: site {int(data.get('site_code'))} | {data.get('RAT')} | {data.get('KPI')}"
+            except Exception:  # noqa: BLE001
+                pass
+            return
+
+        if table_key == "multirat":
+            site_code = data.get("site_code")
+            best_rat = rat_select.value
+            try:
+                best_score = -1
+                for r in list(rat_select.options or []):
+                    p = pd.to_numeric(data.get(f"persistent_{r}", 0), errors="coerce")
+                    d = pd.to_numeric(data.get(f"degraded_{r}", 0), errors="coerce")
+                    p = int(p) if pd.notna(p) else 0
+                    d = int(d) if pd.notna(d) else 0
+                    score = p * 2 + d
+                    if score > best_score:
+                        best_score = score
+                        best_rat = r
+            except Exception:  # noqa: BLE001
+                best_rat = rat_select.value
+
+            _apply_drilldown_selection(site_code=site_code, rat=best_rat)
+            try:
+                status_pane.alert_type = "primary"
+                status_pane.object = f"Drill-down: site {int(site_code)} | {best_rat}"
+            except Exception:  # noqa: BLE001
+                pass
+            return
+    else:
+        _last_click_state[table_key] = (now, row)
+
+
 file_2g = pn.widgets.FileInput(name="2G KPI report", accept=".csv,.zip")
 file_3g = pn.widgets.FileInput(name="3G KPI report", accept=".csv,.zip")
 file_lte = pn.widgets.FileInput(name="LTE KPI report", accept=".csv,.zip")
 
+complaint_sites_file = pn.widgets.FileInput(
+    name="Complaint sites list (optional)", accept=".csv,.txt,.xlsx"
+)
+only_complaint_sites = pn.widgets.Checkbox(name="Only complaint sites", value=False)
+
 analysis_range = pn.widgets.DateRangePicker(name="Analysis date range (optional)")
 baseline_days = pn.widgets.IntInput(name="Baseline window (days)", value=30)
 recent_days = pn.widgets.IntInput(name="Recent window (days)", value=7)
@@ -160,6 +346,23 @@ rules_table = pn.widgets.Tabulator(
     height=260, sizing_mode="stretch_width", layout="fit_data_table"
 )
 
+
+def _set_tabulator_pagination(table: pn.widgets.Tabulator, page_size: int = 50) -> None:
+    try:
+        table.pagination = "local"
+        table.page_size = int(page_size)
+        return
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        cfg = dict(table.configuration or {})
+        cfg["pagination"] = "local"
+        cfg["paginationSize"] = int(page_size)
+        table.configuration = cfg
+    except Exception:  # noqa: BLE001
+        pass
+
+
 try:
     rules_table.editable = True
 except Exception:  # noqa: BLE001
@@ -193,10 +396,24 @@ rat_select = pn.widgets.RadioButtonGroup(
     name="RAT", options=["2G", "3G", "LTE"], value="LTE"
 )
 kpi_select = pn.widgets.Select(name="KPI", options=[])
+kpi_compare_select = pn.widgets.MultiChoice(name="Compare KPIs", options=[], value=[])
+kpi_compare_norm = pn.widgets.Select(
+    name="Normalization", options=["None", "Min-Max", "Z-score"], value="None"
+)
+drilldown_export_button = pn.widgets.FileDownload(
+    label="Download drill-down",
+    filename="KPI_Drilldown.xlsx",
+    button_type="primary",
+)
 
 site_kpi_table = pn.widgets.Tabulator(
     height=260, sizing_mode="stretch_width", layout="fit_data_table"
 )
+
+_set_tabulator_pagination(site_summary_table, page_size=50)
+_set_tabulator_pagination(multirat_summary_table, page_size=50)
+_set_tabulator_pagination(top_anomalies_table, page_size=50)
+_set_tabulator_pagination(site_kpi_table, page_size=50)
 trend_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
 heatmap_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
 hist_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
@@ -284,6 +501,12 @@ def _update_kpi_options() -> None:
         kpi_select.options = kpis
         if kpis and kpi_select.value not in kpis:
             kpi_select.value = kpis[0]
+
+        kpi_compare_select.options = kpis
+        cur = list(kpi_compare_select.value or [])
+        cur2 = [str(x) for x in cur if str(x) in kpis]
+        if cur2 != cur:
+            kpi_compare_select.value = cur2
     finally:
         _updating_drilldown = False
 
@@ -386,10 +609,53 @@ def _update_site_view(event=None) -> None:
         hist_plot_pane.object = None
         return
 
-    title = f"{rat} - {kpi} - site {int(code)}"
-    fig = px.line(s, x="date_only", y=kpi, markers=True)
-    fig.update_layout(template="plotly_white", title=title)
-    trend_plot_pane.object = fig
+    cache_key = _drilldown_cache_key(int(code), str(rat), str(kpi))
+    cached = _drilldown_cache_get(cache_key)
+    if cached is not None:
+        trend_plot_pane.object, heatmap_plot_pane.object, hist_plot_pane.object = cached
+        return
+
+    selected_kpis = [str(x) for x in (kpi_compare_select.value or []) if str(x)]
+    if not selected_kpis:
+        selected_kpis = [str(kpi)] if kpi else []
+    else:
+        if kpi and str(kpi) not in selected_kpis:
+            selected_kpis = [str(kpi)] + selected_kpis
+
+    selected_kpis = [x for x in selected_kpis if x in s.columns]
+    if not selected_kpis:
+        trend_plot_pane.object = None
+    else:
+        plot_df = s[["date_only"] + selected_kpis].copy()
+        for col in selected_kpis:
+            plot_df[col] = pd.to_numeric(plot_df[col], errors="coerce")
+
+        norm_mode = str(kpi_compare_norm.value or "None")
+        if norm_mode != "None":
+            for col in selected_kpis:
+                vals = pd.to_numeric(plot_df[col], errors="coerce")
+                if norm_mode == "Min-Max":
+                    vmin = float(vals.min()) if vals.notna().any() else 0.0
+                    vmax = float(vals.max()) if vals.notna().any() else 0.0
+                    denom = vmax - vmin
+                    plot_df[col] = (vals - vmin) / denom if denom else 0.0
+                elif norm_mode == "Z-score":
+                    mean = float(vals.mean()) if vals.notna().any() else 0.0
+                    std = float(vals.std()) if vals.notna().any() else 0.0
+                    plot_df[col] = (vals - mean) / std if std else 0.0
+
+        df_long = plot_df.melt(
+            id_vars=["date_only"],
+            value_vars=selected_kpis,
+            var_name="KPI",
+            value_name="value",
+        )
+        title = f"{rat} - site {int(code)}"
+        if norm_mode != "None" and len(selected_kpis) > 1:
+            title = f"{title} (compare, {norm_mode})"
+        fig = px.line(df_long, x="date_only", y="value", color="KPI", markers=True)
+        fig.update_layout(template="plotly_white", title=title)
+        trend_plot_pane.object = fig
 
     rules_df = (
         rules_table.value
@@ -429,6 +695,16 @@ def _update_site_view(event=None) -> None:
     )
     hist_plot_pane.object = _build_baseline_recent_hist(d, int(code), str(kpi))
 
+    try:
+        drilldown_export_button.filename = f"KPI_Drilldown_{rat}_site_{int(code)}.xlsx"
+    except Exception:  # noqa: BLE001
+        pass
+
+    _drilldown_cache_set(
+        cache_key,
+        (trend_plot_pane.object, heatmap_plot_pane.object, hist_plot_pane.object),
+    )
+
 
 def _apply_city_filter(df: pd.DataFrame) -> pd.DataFrame:
     if df is None or df.empty:
@@ -439,6 +715,127 @@ def _apply_city_filter(df: pd.DataFrame) -> pd.DataFrame:
     return df[df["City"].astype(str).str.contains(q, case=False, na=False)].copy()
 
 
+def _extract_site_codes_from_any(df: pd.DataFrame) -> set[int]:
+    if df is None or df.empty:
+        return set()
+
+    candidates = [
+        "site_code",
+        "site",
+        "site id",
+        "site_id",
+        "code",
+        "code_site",
+        "id",
+    ]
+    col = None
+    cols_lower = {str(c).strip().lower(): c for c in df.columns}
+    for c in candidates:
+        if c in cols_lower:
+            col = cols_lower[c]
+            break
+    if col is None:
+        col = df.columns[0]
+
+    raw = df[col].astype(str).str.strip()
+    nums = pd.to_numeric(raw, errors="coerce")
+    if nums.isna().all():
+        extracted = raw.str.extract(r"(\d{3,})")[0]
+        nums = pd.to_numeric(extracted, errors="coerce")
+
+    out = nums.dropna().astype(int).tolist()
+    return set(out)
+
+
+def _load_complaint_sites_from_bytes(content: bytes, filename: str) -> set[int]:
+    name = str(filename or "").lower()
+    if name.endswith(".xlsx") or name.endswith(".xls"):
+        try:
+            df = pd.read_excel(io.BytesIO(content))
+        except Exception:  # noqa: BLE001
+            return set()
+        return _extract_site_codes_from_any(df)
+
+    if name.endswith(".txt"):
+        try:
+            lines = content.decode("utf-8", errors="ignore").splitlines()
+        except Exception:  # noqa: BLE001
+            return set()
+        df = pd.DataFrame({"site_code": lines})
+        return _extract_site_codes_from_any(df)
+
+    try:
+        df = pd.read_csv(io.BytesIO(content), sep=None, engine="python")
+    except Exception:  # noqa: BLE001
+        try:
+            df = pd.read_csv(io.BytesIO(content))
+        except Exception:  # noqa: BLE001
+            return set()
+    return _extract_site_codes_from_any(df)
+
+
+def _refresh_complaint_sites(event=None) -> None:
+    global complaint_sites
+
+    if complaint_sites_file.value:
+        complaint_sites = _load_complaint_sites_from_bytes(
+            complaint_sites_file.value, complaint_sites_file.filename or ""
+        )
+    else:
+        default_paths = [
+            os.path.join(ROOT_DIR, "data", "complaint_sites.csv"),
+            os.path.join(ROOT_DIR, "data", "complaint_sites.xlsx"),
+            os.path.join(ROOT_DIR, "data", "sites_plaintes.csv"),
+            os.path.join(ROOT_DIR, "data", "sites_plaintes.xlsx"),
+        ]
+        loaded = False
+        for p in default_paths:
+            if not os.path.exists(p):
+                continue
+            try:
+                if p.lower().endswith((".xlsx", ".xls")):
+                    df = pd.read_excel(p)
+                else:
+                    df = pd.read_csv(p, sep=None, engine="python")
+                complaint_sites = _extract_site_codes_from_any(df)
+                loaded = True
+                break
+            except Exception:  # noqa: BLE001
+                continue
+        if not loaded:
+            complaint_sites = set()
+
+    _apply_complaint_flags()
+
+    _invalidate_drilldown_cache(healthcheck_changed=True)
+
+
+def _apply_complaint_flags() -> None:
+    global current_multirat_raw, current_top_anomalies_raw
+    if complaint_sites:
+        if current_multirat_raw is not None and not current_multirat_raw.empty:
+            current_multirat_raw["is_complaint_site"] = (
+                current_multirat_raw["site_code"].astype(int).isin(complaint_sites)
+            )
+        if (
+            current_top_anomalies_raw is not None
+            and not current_top_anomalies_raw.empty
+        ):
+            current_top_anomalies_raw["is_complaint_site"] = (
+                current_top_anomalies_raw["site_code"].astype(int).isin(complaint_sites)
+            )
+    else:
+        if current_multirat_raw is not None and not current_multirat_raw.empty:
+            current_multirat_raw["is_complaint_site"] = False
+        if (
+            current_top_anomalies_raw is not None
+            and not current_top_anomalies_raw.empty
+        ):
+            current_top_anomalies_raw["is_complaint_site"] = False
+
+    _refresh_filtered_results()
+
+
 def _infer_rule_row(rules_df: pd.DataFrame, rat: str, kpi: str) -> dict:
     if rules_df is None or rules_df.empty:
         return {}
@@ -710,6 +1107,12 @@ def _refresh_filtered_results(event=None) -> None:
 
     if current_multirat_raw is not None and not current_multirat_raw.empty:
         m = _apply_city_filter(current_multirat_raw)
+        if (
+            bool(only_complaint_sites.value)
+            and "is_complaint_site" in m.columns
+            and not m.empty
+        ):
+            m = m[m["is_complaint_site"] == True]  # noqa: E712
         score_col = (
             "criticality_score_weighted"
             if "criticality_score_weighted" in m.columns
@@ -729,6 +1132,12 @@ def _refresh_filtered_results(event=None) -> None:
 
     if current_top_anomalies_raw is not None and not current_top_anomalies_raw.empty:
         t = _apply_city_filter(current_top_anomalies_raw)
+        if (
+            bool(only_complaint_sites.value)
+            and "is_complaint_site" in t.columns
+            and not t.empty
+        ):
+            t = t[t["is_complaint_site"] == True]  # noqa: E712
         if top_rat_filter.value:
             t = t[t["RAT"].isin(list(top_rat_filter.value))]
         if top_status_filter.value and "status" in t.columns:
@@ -795,6 +1204,7 @@ def _current_profile_config() -> dict:
     cfg["min_criticality"] = int(min_criticality.value)
     cfg["min_anomaly_score"] = int(min_anomaly_score.value)
     cfg["city_filter"] = str(city_filter.value or "")
+    cfg["only_complaint_sites"] = bool(only_complaint_sites.value)
     cfg["top_rat_filter"] = list(top_rat_filter.value) if top_rat_filter.value else []
     cfg["top_status_filter"] = (
         list(top_status_filter.value) if top_status_filter.value else []
@@ -806,6 +1216,10 @@ def _current_profile_config() -> dict:
         "site_code": int(site_select.value) if site_select.value is not None else None,
         "rat": str(rat_select.value or ""),
         "kpi": str(kpi_select.value or ""),
+        "compare_kpis": (
+            list(kpi_compare_select.value) if kpi_compare_select.value else []
+        ),
+        "compare_norm": str(kpi_compare_norm.value or "None"),
     }
     return cfg
 
@@ -844,6 +1258,15 @@ def _apply_profile_config(cfg: dict) -> None:
             except Exception:  # noqa: BLE001
                 pass
 
+        try:
+            if (
+                "only_complaint_sites" in cfg
+                and cfg["only_complaint_sites"] is not None
+            ):
+                only_complaint_sites.value = bool(cfg["only_complaint_sites"])
+        except Exception:  # noqa: BLE001
+            pass
+
         try:
             city_filter.value = str(cfg.get("city_filter", "") or "")
         except Exception:  # noqa: BLE001
@@ -901,6 +1324,19 @@ def _apply_profile_config(cfg: dict) -> None:
                 kpi_select.value = kpi
         except Exception:  # noqa: BLE001
             pass
+        try:
+            norm = str(drill.get("compare_norm", "None") or "None")
+            if norm in list(kpi_compare_norm.options):
+                kpi_compare_norm.value = norm
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            ck = drill.get("compare_kpis", [])
+            if isinstance(ck, list):
+                opts = list(kpi_compare_select.options or [])
+                kpi_compare_select.value = [str(x) for x in ck if str(x) in opts]
+        except Exception:  # noqa: BLE001
+            pass
     finally:
         _applying_profile = False
 
@@ -996,6 +1432,8 @@ def _apply_preset(event=None) -> None:
     status_pane.object = f"Preset applied: {preset_select.value}"
     current_export_bytes = None
 
+    _invalidate_drilldown_cache(rules_changed=True)
+
 
 def _save_current_rules_as_preset(event=None) -> None:
     try:
@@ -1031,6 +1469,8 @@ def _delete_selected_preset(event=None) -> None:
         status_pane.alert_type = "success"
         status_pane.object = f"Preset deleted: {name}"
         current_export_bytes = None
+
+        _invalidate_drilldown_cache(data_changed=True, rules_changed=True)
     except Exception as exc:  # noqa: BLE001
         status_pane.alert_type = "danger"
         status_pane.object = f"Error deleting preset: {exc}"
@@ -1256,7 +1696,7 @@ def run_health_check(event=None) -> None:
 
         _refresh_filtered_results()
 
-        current_export_bytes = _build_export_bytes()
+        current_export_bytes = None
 
         _update_site_view()
 
@@ -1316,6 +1756,7 @@ profile_delete_button.on_click(_delete_profile)
 
 _refresh_presets()
 _refresh_profiles()
+_refresh_complaint_sites()
 
 
 def _on_rat_change(event=None) -> None:
@@ -1333,21 +1774,181 @@ def _on_drilldown_change(event=None) -> None:
 rat_select.param.watch(_on_rat_change, "value")
 site_select.param.watch(_on_drilldown_change, "value")
 kpi_select.param.watch(_on_drilldown_change, "value")
+kpi_compare_select.param.watch(_on_drilldown_change, "value")
+kpi_compare_norm.param.watch(_on_drilldown_change, "value")
+
+
+def _on_rules_table_change(event=None) -> None:
+    global current_export_bytes
+    if _applying_profile or _loading_datasets:
+        return
+    current_export_bytes = None
+    _invalidate_drilldown_cache(rules_changed=True)
+
+
+rules_table.param.watch(_on_rules_table_change, "value")
+
+try:
+    top_anomalies_table.on_click(
+        lambda e: _handle_double_click("top", top_anomalies_table, e)
+    )
+except Exception:  # noqa: BLE001
+    pass
+
+try:
+    multirat_summary_table.on_click(
+        lambda e: _handle_double_click("multirat", multirat_summary_table, e)
+    )
+except Exception:  # noqa: BLE001
+    pass
 
 min_criticality.param.watch(_refresh_filtered_results, "value")
 min_anomaly_score.param.watch(_refresh_filtered_results, "value")
 city_filter.param.watch(_refresh_filtered_results, "value")
+only_complaint_sites.param.watch(_refresh_filtered_results, "value")
 top_rat_filter.param.watch(_refresh_filtered_results, "value")
 top_status_filter.param.watch(_refresh_filtered_results, "value")
 
+complaint_sites_file.param.watch(_refresh_complaint_sites, "value")
+
 export_button.callback = _export_callback
 
 
+def _build_drilldown_export_bytes() -> bytes:
+    rat = rat_select.value
+    code = site_select.value
+    if rat is None or code is None:
+        return b""
+    daily = current_daily_by_rat.get(rat)
+    if daily is None or daily.empty:
+        return b""
+    d = _filtered_daily(daily)
+    if d is None or d.empty:
+        return b""
+
+    s = d[d["site_code"] == int(code)].copy().sort_values("date_only")
+    if s.empty:
+        return b""
+
+    selected_kpis = [str(x) for x in (kpi_compare_select.value or []) if str(x)]
+    if not selected_kpis:
+        selected_kpis = [str(kpi_select.value)] if kpi_select.value else []
+    else:
+        if kpi_select.value and str(kpi_select.value) not in selected_kpis:
+            selected_kpis = [str(kpi_select.value)] + selected_kpis
+
+    selected_kpis = [k for k in selected_kpis if k in s.columns]
+    base_cols = ["date_only"]
+    daily_cols = base_cols + selected_kpis
+    daily_out = s[daily_cols].copy() if selected_kpis else s[["date_only"]].copy()
+
+    rules_df = (
+        rules_table.value
+        if isinstance(rules_table.value, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    windows = _compute_site_windows(d)
+    if windows is None:
+        summary_out = pd.DataFrame()
+    else:
+        baseline_start, baseline_end, recent_start, recent_end = windows
+        rows = []
+        for k in selected_kpis:
+            rule = _infer_rule_row(rules_df, str(rat), str(k))
+            direction = str(rule.get("direction", "higher_is_better"))
+            sla_raw = rule.get("sla", None)
+            try:
+                sla_val = float(sla_raw) if pd.notna(sla_raw) else None
+            except Exception:  # noqa: BLE001
+                sla_val = None
+
+            sk = s[["date_only", k]].copy()
+            sk[k] = pd.to_numeric(sk[k], errors="coerce")
+            sk = sk.dropna(subset=[k])
+
+            baseline_mask = (sk["date_only"] >= baseline_start) & (
+                sk["date_only"] <= baseline_end
+            )
+            recent_mask = (sk["date_only"] >= recent_start) & (
+                sk["date_only"] <= recent_end
+            )
+
+            baseline_med = (
+                float(sk.loc[baseline_mask, k].median())
+                if baseline_mask.any()
+                else None
+            )
+            recent_med = (
+                float(sk.loc[recent_mask, k].median()) if recent_mask.any() else None
+            )
+
+            bad_flags = []
+            recent_vals = sk.loc[recent_mask, ["date_only", k]].sort_values("date_only")
+            for _, r in recent_vals.iterrows():
+                v = r.get(k)
+                bad_flags.append(
+                    bool(
+                        is_bad(
+                            float(v) if pd.notna(v) else None,
+                            baseline_med,
+                            direction,
+                            float(rel_threshold_pct.value),
+                            sla_val,
+                        )
+                    )
+                )
+
+            rows.append(
+                {
+                    "RAT": str(rat),
+                    "site_code": int(code),
+                    "KPI": str(k),
+                    "direction": direction,
+                    "sla": sla_val,
+                    "baseline_median": baseline_med,
+                    "recent_median": recent_med,
+                    "bad_days_recent": int(sum(bad_flags)),
+                    "max_streak_recent": int(max_consecutive_days(bad_flags)),
+                }
+            )
+        summary_out = pd.DataFrame(rows)
+
+    status_df = (
+        current_status_df
+        if isinstance(current_status_df, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    if not status_df.empty:
+        status_out = status_df[
+            (status_df["site_code"] == int(code)) & (status_df["RAT"] == str(rat))
+        ].copy()
+    else:
+        status_out = pd.DataFrame()
+
+    return write_dfs_to_excel(
+        [summary_out, daily_out, status_out],
+        ["Summary", "Daily", "KPI_Status"],
+        index=False,
+    )
+
+
+def _drilldown_export_callback() -> io.BytesIO:
+    try:
+        b = _build_drilldown_export_bytes()
+    except Exception:  # noqa: BLE001
+        b = b""
+    return io.BytesIO(b or b"")
+
+
+drilldown_export_button.callback = _drilldown_export_callback
+
+
 # Page layout components (used by the multipage portal)
 sidebar = pn.Column(
     file_2g,
     file_3g,
     file_lte,
+    complaint_sites_file,
     "---",
     analysis_range,
     baseline_days,
@@ -1359,6 +1960,7 @@ sidebar = pn.Column(
     min_criticality,
     min_anomaly_score,
     city_filter,
+    only_complaint_sites,
     top_rat_filter,
     top_status_filter,
     "---",
@@ -1394,7 +1996,8 @@ main = pn.Column(
     top_anomalies_table,
     pn.layout.Divider(),
     pn.pane.Markdown("## Drill-down"),
-    pn.Row(site_select, rat_select, kpi_select),
+    pn.Row(site_select, rat_select),
+    pn.Row(kpi_select, kpi_compare_select, kpi_compare_norm, drilldown_export_button),
     pn.Row(
         pn.Column(site_kpi_table, sizing_mode="stretch_width"),
         pn.Column(trend_plot_pane, sizing_mode="stretch_both"),