Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,33 +1,32 @@
 
 # -*- coding: utf-8 -*-
 """
-Health Matrix — AI Shortage Detection & Auto‑Fill (Styled, API‑Ready, Improved UI)
-----------------------------------------------------------------------------------
-- Business Case section at top (from attachment)
-- Upgraded Timeline (progress fill + better badges)
-- Beautiful HTML tables for Summary & Reasoning
-- Custom API/UKG/Mock data sources (priority: Custom API)
+Health Matrix — AI Shortage Detection & Auto‑Fill (Business KPIs, API/UKG-ready)
+-------------------------------------------------------------------------------
+- Business KPIs at top (value over text) + concise Business Case.
+- Sidebar = Data Source / Labor Rules / Cost Model / Channels / Advanced.
+- Robust datetime parsing (fixes 'Invalid isoformat string').
+- Data preflight validation & clear warnings (no tracebacks).
+- One-click end‑to‑end run (Forecast → Offers → Auto‑Fill).
 """
 
 from __future__ import annotations
 
-import os, math, random, datetime as dt
+import os, math, random, json, datetime as dt
 from io import StringIO
-from typing import Dict, Any, List, Iterable, Optional, Tuple
+from typing import Dict, Any, List, Optional, Tuple
 
 import pandas as pd
 import requests
 import streamlit as st
 import streamlit.components.v1 as components
 
-# =========[ Env ]=========
 APP_TITLE = "Health Matrix — AI Shortage & Auto‑Fill"
 random.seed(42)
 
-def env(n,d=""): return os.environ.get(n,d)
+# ---------- Environment (can be overridden from UI) ----------
+def env(k, d=""): return os.environ.get(k, d)
 UKG_APP_KEY, UKG_AUTH_TOKEN = env("UKG_APP_KEY"), env("UKG_AUTH_TOKEN")
-OPENAI_API_KEY = env("OPENAI_API_KEY")
-
 CUSTOM_API_BASE      = env("CUSTOM_API_BASE")
 CUSTOM_API_TOKEN     = env("CUSTOM_API_TOKEN")
 CUSTOM_API_SHIFTS    = env("CUSTOM_API_SHIFTS", "/open_shifts")
@@ -37,305 +36,334 @@ CUSTOM_API_METHOD_SHIFTS    = env("CUSTOM_API_METHOD_SHIFTS", "GET").upper()
 CUSTOM_API_METHOD_EMPLOYEES = env("CUSTOM_API_METHOD_EMPLOYEES", "GET").upper()
 CUSTOM_API_METHOD_HISTORY   = env("CUSTOM_API_METHOD_HISTORY", "GET").upper()
 
-DATA_SOURCE = "custom" if CUSTOM_API_BASE else ("ukg" if (UKG_APP_KEY and UKG_AUTH_TOKEN) else "mock")
-
-SHIFT_FIELD_MAP = {"id":"id","department":"department","start":"start","end":"end","required_skill":"required_skill","required_cert":"required_cert"}
-EMP_FIELD_MAP   = {"personNumber":"personNumber","fullName":"fullName","phoneNumber":"phoneNumber","organizationPath":"organizationPath","certifications":"Certifications","ot_7d":"OT_Hours_7d","availability":"Availability"}
-
-# =========[ CSS / Theme ]=========
-BASE_CSS = r"""
-html, body { margin:0; padding:0; height:100%; font-family:'Segoe UI','Tajawal','Noto Sans Arabic',sans-serif;
-  background:linear-gradient(145deg,#002d5b 0%,#001a33 100%); color:#eaf4ff; overflow-x:hidden; }
-a { color:#7fd1ff; text-decoration:none } a:hover{ text-decoration:underline }
-.stButton>button{ background:linear-gradient(90deg,#004c97,#36BA01); color:#fff; border:none; border-radius:14px;
-  padding:.9rem 1.2rem; font-size:1rem; font-weight:700; box-shadow:0 10px 28px rgba(0,0,0,.18); transition:transform .2s }
-.stButton>button:hover{ transform:translateY(-1px) }
-.hm-card{ background:rgba(255,255,255,.04); padding:1rem; border-radius:16px; border:1px solid rgba(255,255,255,.08); backdrop-filter: blur(6px); }
-.hm-title{ font-size:1.1rem; font-weight:800; color:#eaf4ff; margin:0 0 .6rem; display:flex; gap:.5rem; align-items:center }
-.hm-chip{ display:inline-flex; align-items:center; gap:.35rem; padding:.25rem .6rem; border-radius:999px; border:1px solid rgba(255,255,255,.14); font-size:.8rem }
-.hm-chip.ok{ background:#eaf8ef; color:#0a5a2b; border-color:#cbeed6 } .hm-chip.info{ background:#eef6ff; color:#124a86; border-color:#d7e9ff }
-"""
-
-EXTRA_CSS = r"""
-/* Soft background dots */
-.hm-bg{ position:fixed; inset:0; overflow:hidden; z-index:0 }
-.hm-dot{ position:absolute; width:280px; height:280px; border-radius:50%; opacity:.12; filter:blur(18px) }
-.hm-dot.a{ top:10%; left:20%; background:radial-gradient(circle,#004c97,#36ba01); animation:floatAround 12s ease-in-out infinite }
-.hm-dot.b{ top:60%; left:70%; background:radial-gradient(circle,#36ba01,#004c97); animation:floatAround 14s ease-in-out infinite }
-.hm-dot.c{ top:80%; left:30%; background:radial-gradient(circle,#004c97,#36ba01); animation:floatAround 16s ease-in-out infinite }
-@keyframes floatAround{0%{transform:translate(0,0) scale(1)}25%{transform:translate(50px,-30px) scale(1.2)}50%{transform:translate(-40px,60px) scale(1.1)}75%{transform:translate(30px,-50px) scale(1.25)}100%{transform:translate(0,0) scale(1)}}
-
-/* Upgraded timeline */
-.hm-flow{ position:relative; margin:1rem 0 .5rem; padding:1rem; border-radius:16px; background:rgba(0,0,0,.18); border:1px solid rgba(255,255,255,.06) }
-.hm-track{ position:relative; height:6px; background:#2a3e55; border-radius:999px; overflow:hidden; margin:0 .4rem 1.1rem }
-.hm-fill{ position:absolute; inset:0; width:0%; height:100%; background:linear-gradient(90deg,#36ba01,#60d65e); transition:width .6s ease }
-.hm-steps{ display:grid; grid-template-columns:repeat(auto-fit,minmax(120px,1fr)); gap:.8rem }
-.hm-step{ background:#0f2337; border:1px solid #1b3a58; border-radius:14px; padding:.55rem .7rem; color:#d7eaff }
-.hm-step.active{ outline:2px solid #36ba01 }
-.hm-step .title{ font-weight:800; font-size:.92rem; display:flex; gap:.4rem; align-items:center }
-.hm-step .desc{ font-size:.8rem; opacity:.9; margin-top:.2rem }
-
-/* HTML Tables: Summary + Reasoning */
-.hm-table{ width:100%; border-collapse:separate; border-spacing:0; overflow:hidden; border-radius:12px; border:1px solid rgba(255,255,255,.10); }
-.hm-table thead th{ background:#093356; color:#eaf4ff; text-align:left; padding:.65rem .7rem; font-weight:700; border-bottom:1px solid rgba(255,255,255,.12) }
-.hm-table tbody td{ padding:.6rem .7rem; border-bottom:1px solid rgba(255,255,255,.06); color:#e9f4ff; }
-.hm-table tbody tr:nth-child(even){ background:rgba(255,255,255,.03) }
-.badge{ display:inline-flex; align-items:center; gap:.3rem; padding:.2rem .5rem; border-radius:999px; font-size:.78rem; border:1px solid }
+# ---------- Styling ----------
+BASE_CSS = r"""html, body { margin:0; padding:0; height:100%; font-family:'Inter','Segoe UI','Tajawal','Noto Sans Arabic',sans-serif; background:#f7fbff; color:#0d2236; }
+.stApp { background: radial-gradient(90% 60% at 10% 10%, #e9f5ff 0, transparent 60%), radial-gradient(80% 60% at 90% 5%, #ecfff0 0, transparent 60%); }
+h1, h2, h3 { letter-spacing: .2px }
+.kpi-grid { display:grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap:14px; margin: 1rem 0; }
+.kpi { background:#fff; border:1px solid #e8eef5; border-radius:14px; padding:14px; box-shadow:0 10px 20px rgba(13,34,54,.04) }
+.kpi .big { font-size:28px; font-weight:900; color:#0f7a1a }
+.kpi .sub { font-size:13px; color:#567; margin-top:4px }
+.kpi .delta { font-size:12px; padding:2px 8px; border-radius:999px; border:1px solid #dce8f5; display:inline-block; margin-top:8px; background:#f6fbff }
+.hm-card { background:#fff; border:1px solid #e8eef5; border-radius:14px; padding:14px; box-shadow:0 10px 20px rgba(13,34,54,.04); margin-top:12px }
+.hm-title{ font-weight:800; color:#0d2236; margin:0 0 .4rem; display:flex; align-items:center; gap:.5rem }
+.badge { display:inline-flex; align-items:center; gap:.3rem; padding:.2rem .5rem; border-radius:999px; font-size:.78rem; border:1px solid }
 .badge.ok{ background:#eaf8ef; color:#0a5a2b; border-color:#cbeed6 } .badge.warn{ background:#fff7e6; color:#985f00; border-color:#ffe1a3 }
-.badge.no{ background:#ffeded; color:#9d2b2b; border-color:#ffc4c4 } .badge.yes{ background:#eaf8ef; color:#0a5a2b; border-color:#cbeed6 }
+.badge.no{ background:#ffeded; color:#9d2b2b; border-color:#ffc4c4 } .badge.info{ background:#eef6ff; color:#124a86; border-color:#d7e9ff }
+.tbl { width:100%; border-collapse:separate; border-spacing:0; overflow:hidden; border-radius:12px; border:1px solid #e8eef5; }
+.tbl thead th{ background:#f3f8fe; color:#17324a; text-align:left; padding:.6rem .65rem; font-weight:800; border-bottom:1px solid #e8eef5 }
+.tbl tbody td{ padding:.55rem .65rem; border-bottom:1px solid #f1f5fa; }
+.tbl tbody tr:nth-child(even){ background:#fcfeff }
+.stepper { position:relative; padding: 10px; border-radius:12px; background:#f6fbff; border:1px solid #e1edf9; margin: 10px 0; }
+.track { height:6px; background:#e1edf9; border-radius:999px; overflow:hidden; margin-bottom:10px }
+.fill { height:100%; width:0%; background:linear-gradient(90deg,#1ab04b,#6bd47d) }
 """
 
-# =========[ Small helpers ]=========
-def _render_bg():
-    st.markdown(f"<style>{BASE_CSS}</style>", unsafe_allow_html=True)
-    st.markdown(f"<style>{EXTRA_CSS}</style>", unsafe_allow_html=True)
-    st.markdown('''
-    <div class="hm-bg">
-      <div class="hm-dot a"></div><div class="hm-dot b"></div><div class="hm-dot c"></div>
+def html_table(df: pd.DataFrame, title: str, icon: str="📊"):
+    if df is None or df.empty:
+        st.info("No data")
+        return
+    ths=''.join([f'<th>{c}</th>' for c in df.columns])
+    def fmt(c,v):
+        if c.lower() in ("eligible","status"):
+            s=str(v).lower()
+            if s in ("yes","✅ filled","filled"): return f'<span class="badge ok">✅ {v}</span>'
+            if "unfilled" in s or s in ("no","not eligible"): return f'<span class="badge no">✖ {v}</span>'
+            if "skip" in s or "notify" in s: return f'<span class="badge warn">⚠ {v}</span>'
+        return str(v)
+    rows=''.join(['<tr>'+''.join([f'<td>{fmt(c,r[c])}</td>' for c in df.columns])+'</tr>' for _,r in df.iterrows()])
+    st.markdown(f'''
+    <div class="hm-card">
+      <div class="hm-title">{icon} {title}</div>
+      <div style="overflow:auto">
+        <table class="tbl"><thead><tr>{ths}</tr></thead><tbody>{rows}</tbody></table>
+      </div>
     </div>''', unsafe_allow_html=True)
 
-def _api_headers()->Dict[str,str]:
-    h={"Content-Type":"application/json"}
-    if CUSTOM_API_TOKEN: h["Authorization"]=f"Bearer {CUSTOM_API_TOKEN}"
+# ---------- Data helpers ----------
+def to_dt_series(v) -> pd.Series:
+    # Robust conversion: supports "YYYY-MM-DD", "YYYY-MM-DD HH:MM:SS", etc.
+    s = pd.to_datetime(v, errors="coerce", infer_datetime_format=True, utc=False)
+    return s
+
+def prepare_history(df: pd.DataFrame) -> pd.DataFrame:
+    if df is None or df.empty: return pd.DataFrame()
+    df = df.copy()
+    # normalize columns
+    cols_lower = {c.lower(): c for c in df.columns}
+    for need in ["date","department","demand","scheduled_staff"]:
+        if need not in cols_lower:
+            raise ValueError(f"Missing required column: {need}")
+    dt_series = to_dt_series(df[cols_lower["date"]])
+    if dt_series.isna().all():
+        raise ValueError("All date values are invalid. Please check date format.")
+    df["date"] = dt_series.dt.date
+    df["week"] = dt_series.dt.isocalendar().week.astype(int)
+    df["dow"]  = dt_series.dt.dayofweek.astype(int) # 0=Mon
+    for c in ["demand","scheduled_staff","absences"]:
+        if c in cols_lower: df[c] = pd.to_numeric(df[cols_lower[c]], errors="coerce").fillna(0).astype(int)
+        elif c not in df.columns and c in ["absences"]:
+            df[c] = 0
+    return df
+
+def staff_required(demand: float, ratio: float) -> int:
+    ratio = max(0.1, float(ratio or 4.0))
+    return int(math.ceil(demand / ratio))
+
+def forecast_next(df: pd.DataFrame, department: str) -> float:
+    sub = df[df["department"]==department].sort_values("date")
+    if sub.empty: return 0.0
+    last_dow = sub.iloc[-1]["dow"]
+    same = sub[sub["dow"]==last_dow].tail(4)
+    return float((same["demand"].mean() if not same.empty else sub["demand"].tail(7).mean()))
+
+REQUIRED_SKILL_BY_DEP = {"ICU":"ICU RN","ER":"ER RN","MedSurg":"MedSurg RN"}
+REQUIRED_CERT_BY_DEP  = {"ICU":"ACLS","ER":"BLS","MedSurg":"BLS"}
+
+def detect_shortages(history_df: pd.DataFrame, departments: List[str], params: Dict[str,Any]) -> pd.DataFrame:
+    def uplift(x: float) -> float:
+        fac = 1.0
+        if params.get("holiday"): fac *= params["uplift"].get("holidays",1.15)
+        if params.get("event"):   fac *= params["uplift"].get("events",1.08)
+        if params.get("weather"): fac *= params["uplift"].get("weather",1.05)
+        return x * fac
+    rows = []
+    for dep in departments:
+        base = forecast_next(history_df, dep)
+        adj  = uplift(base)
+        need = staff_required(adj, params.get("patients_per_nurse", 4.0))
+        scheduled = int(history_df[history_df["department"]==dep]["scheduled_staff"].tail(1).values[0]) if not history_df[history_df["department"]==dep].empty else 0
+        shortage = max(0, need - scheduled)
+        for i in range(shortage):
+            rows.append({
+                "ShiftID": f"GEN-{dep[:2].upper()}-{i+1:03d}",
+                "Department": dep,
+                "Start": params.get("start_time","2025-08-16 07:00"),
+                "End":   params.get("end_time","2025-08-16 19:00"),
+                "RequiredSkill": REQUIRED_SKILL_BY_DEP.get(dep,"MedSurg RN"),
+                "RequiredCert":  REQUIRED_CERT_BY_DEP.get(dep,"BLS"),
+            })
+    return pd.DataFrame(rows)
+
+# ---------- Integration (Custom API / UKG / Mock) ----------
+def _api_headers() -> Dict[str,str]:
+    h = {"Content-Type":"application/json"}
+    if CUSTOM_API_TOKEN: h["Authorization"] = f"Bearer {CUSTOM_API_TOKEN}"
     return h
 
-def _api_call(path:str, method:str="GET", params:Dict[str,Any]|None=None, payload:Dict[str,Any]|None=None)->Any:
-    url=(CUSTOM_API_BASE or "").rstrip("/")+"/"+path.lstrip("/")
-    r=requests.request(method.upper(), url, headers=_api_headers(), params=params, json=payload, timeout=30)
+def _api_call(path: str, method: str="GET", params: Dict[str,Any]|None=None, payload: Dict[str,Any]|None=None):
+    url = (CUSTOM_API_BASE or "").rstrip("/") + "/" + path.lstrip("/")
+    r = requests.request(method.upper(), url, headers=_api_headers(), params=params, json=payload, timeout=30)
     r.raise_for_status()
     try: return r.json()
     except Exception: return r.text
 
-def custom_fetch_open_shifts(start_date:str, end_date:str)->pd.DataFrame:
-    data=_api_call(CUSTOM_API_SHIFTS, CUSTOM_API_METHOD_SHIFTS, params={"start_date":start_date,"end_date":end_date})
-    rows=[]
-    for s in data or []:
+def custom_fetch_open_shifts(start_date: str, end_date: str) -> pd.DataFrame:
+    data = _api_call(CUSTOM_API_SHIFTS, CUSTOM_API_METHOD_SHIFTS, params={"start_date":start_date,"end_date":end_date})
+    rows = []
+    for s in (data or []):
         rows.append({
-            "ShiftID": s.get(SHIFT_FIELD_MAP["id"]) or s.get("ShiftID") or s.get("id"),
-            "Department": s.get(SHIFT_FIELD_MAP["department"]) or s.get("department") or s.get("dept") or s.get("unit"),
-            "Start": s.get(SHIFT_FIELD_MAP["start"]) or s.get("startDateTime") or s.get("start"),
-            "End": s.get(SHIFT_FIELD_MAP["end"]) or s.get("endDateTime") or s.get("end"),
-            "RequiredSkill": s.get(SHIFT_FIELD_MAP["required_skill"]) or s.get("requiredSkill") or s.get("jobRole"),
-            "RequiredCert": s.get(SHIFT_FIELD_MAP["required_cert"]) or s.get("requiredCert") or "BLS",
+            "ShiftID": s.get("id") or s.get("ShiftID") or s.get("shiftId"),
+            "Department": s.get("department") or s.get("dept") or s.get("unit"),
+            "Start": s.get("start") or s.get("startDateTime"),
+            "End":   s.get("end")   or s.get("endDateTime"),
+            "RequiredSkill": s.get("required_skill") or s.get("requiredSkill") or s.get("jobRole"),
+            "RequiredCert":  s.get("required_cert")  or s.get("requiredCert") or "BLS",
         })
     return pd.DataFrame(rows)
 
-def custom_fetch_employees(employee_ids: Optional[List[int]]=None)->pd.DataFrame:
-    params={"ids":",".join(map(str,employee_ids or []))} if CUSTOM_API_METHOD_EMPLOYEES=="GET" else None
-    payload={"ids":employee_ids or []} if CUSTOM_API_METHOD_EMPLOYEES=="POST" else None
-    data=_api_call(CUSTOM_API_EMPLOYEES, CUSTOM_API_METHOD_EMPLOYEES, params=params, payload=payload)
-    rows=[]
-    for e in data or []:
-        org=e.get(EMP_FIELD_MAP["organizationPath"]) or e.get("organizationPath") or ""
+def custom_fetch_employees(ids: Optional[List[int]]=None) -> pd.DataFrame:
+    params = {"ids": ",".join(map(str,ids or []))} if CUSTOM_API_METHOD_EMPLOYEES=="GET" else None
+    payload= {"ids": ids or []} if CUSTOM_API_METHOD_EMPLOYEES=="POST" else None
+    data = _api_call(CUSTOM_API_EMPLOYEES, CUSTOM_API_METHOD_EMPLOYEES, params=params, payload=payload)
+    rows = []
+    for e in (data or []):
+        org = e.get("organizationPath") or ""
         rows.append({
-            "personNumber": e.get(EMP_FIELD_MAP["personNumber"]) or e.get("personNumber"),
-            "fullName": e.get(EMP_FIELD_MAP["fullName"]) or e.get("fullName"),
-            "phoneNumber": e.get(EMP_FIELD_MAP["phoneNumber"]) or e.get("phoneNumber"),
+            "personNumber": e.get("personNumber"),
+            "fullName": e.get("fullName"),
+            "phoneNumber": e.get("phoneNumber"),
             "organizationPath": org,
-            "Certifications": e.get(EMP_FIELD_MAP["certifications"]) or e.get("Certifications") or e.get("certifications") or [],
-            "OT_Hours_7d": e.get(EMP_FIELD_MAP["ot_7d"]) or e.get("OT_Hours_7d") or 0,
-            "Availability": e.get(EMP_FIELD_MAP["availability"]) or e.get("Availability") or [],
+            "Certifications": e.get("Certifications") or e.get("certifications") or [],
+            "OT_Hours_7d": e.get("OT_Hours_7d") or 0,
+            "Availability": e.get("Availability") or [],
             "JobRole": org.split("/")[-1] if isinstance(org,str) and org else ""
         })
     return pd.DataFrame(rows)
 
-def mock_open_shifts()->pd.DataFrame:
+def _ukg_headers() -> Dict[str,str]:
+    return {"Content-Type":"application/json", "appkey": UKG_APP_KEY or "", "Authorization": f"Bearer {UKG_AUTH_TOKEN}" if UKG_AUTH_TOKEN else ""}
+
+def ukg_fetch_open_shifts(start_date: str, end_date: str) -> pd.DataFrame:
+    try:
+        url = "https://partnerdemo-019.cfn.mykronos.com/api/v1/scheduling/schedule/multi_read"
+        payload = {"select":["OPENSHIFTS"],"where":{"locations":{"dateRange":{"startDate":start_date,"endDate":end_date},"includeEmployeeTransfer":False,"locations":{"ids":["2401","2402"]}}}}
+        r = requests.post(url, headers=_ukg_headers(), json=payload, timeout=30); r.raise_for_status(); data = r.json()
+        rows = []
+        for s in data.get("openShifts", []):
+            rows.append({
+                "ShiftID": s.get("id"),
+                "Department": (s.get("label") or "").split("-")[0],
+                "Start": s.get("startDateTime"), "End": s.get("endDateTime"),
+                "RequiredSkill": (s.get("segments", [{}])[0].get("orgJobRef",{}).get("qualifier","")) if s.get("segments") else "",
+                "RequiredCert": "BLS"
+            })
+        return pd.DataFrame(rows)
+    except Exception as e:
+        st.warning(f"UKG open_shifts error: {e}")
+        return pd.DataFrame()
+
+def mock_open_shifts() -> pd.DataFrame:
     return pd.DataFrame([
         {"ShiftID":"S-1001","Department":"ICU","Start":"2025-08-16 07:00","End":"2025-08-16 19:00","RequiredSkill":"ICU RN","RequiredCert":"ACLS"},
         {"ShiftID":"S-1002","Department":"ER","Start":"2025-08-16 19:00","End":"2025-08-17 07:00","RequiredSkill":"ER RN","RequiredCert":"BLS"},
     ])
 
-def mock_employees()->pd.DataFrame:
-    df=pd.DataFrame([
-        {"personNumber":850,"fullName":"Amal Al‑Harbi","phoneNumber":"+966500000001","organizationPath":"Hospital/Nursing/ICU/ICU RN","Certifications":["ACLS","BLS"],"OT_Hours_7d":4,"Availability":["2025-08-16 07:00-19:00"]},
-        {"personNumber":825,"fullName":"Saud Al‑Qahtani","phoneNumber":"+966500000002","organizationPath":"Hospital/Nursing/ER/ER RN","Certifications":["BLS"],"OT_Hours_7d":10,"Availability":["2025-08-16 19:00-07:00"]},
-        {"personNumber":811,"fullName":"Nora Al‑Qahtani","phoneNumber":"+966500000003","organizationPath":"Hospital/Nursing/MedSurg/MedSurg RN","Certifications":["BLS"],"OT_Hours_7d":2,"Availability":["2025-08-16 07:00-19:00"]},
+def mock_employees() -> pd.DataFrame:
+    df = pd.DataFrame([
+        {"personNumber":850,"fullName":"Amal Al-Harbi","phoneNumber":"+966500000001","organizationPath":"Hospital/Nursing/ICU/ICU RN","Certifications":["ACLS","BLS"],"OT_Hours_7d":4,"Availability":["2025-08-16 07:00-19:00"]},
+        {"personNumber":825,"fullName":"Saud Al-Qahtani","phoneNumber":"+966500000002","organizationPath":"Hospital/Nursing/ER/ER RN","Certifications":["BLS"],"OT_Hours_7d":10,"Availability":["2025-08-16 19:00-07:00"]},
+        {"personNumber":811,"fullName":"Nora Al-Qahtani","phoneNumber":"+966500000003","organizationPath":"Hospital/Nursing/MedSurg/MedSurg RN","Certifications":["BLS"],"OT_Hours_7d":2,"Availability":["2025-08-16 07:00-19:00"]},
     ])
-    df["JobRole"]=df["organizationPath"].apply(lambda p: p.split("/")[-1] if isinstance(p,str) else "")
+    df["JobRole"] = df["organizationPath"].apply(lambda p: p.split("/")[-1] if isinstance(p,str) else "")
     return df
 
-# History helpers
-def prepare_history(df:pd.DataFrame)->pd.DataFrame:
-    df=df.copy()
-    df["date"]=pd.to_datetime(df["date"]).dt.date
-    df["dow"]=pd.to_datetime(df["date"]).map(lambda d: dt.date.fromisoformat(str(d)).weekday())
-    for c in ["demand","scheduled_staff","absences"]:
-        if c in df.columns: df[c]=pd.to_numeric(df[c],errors="coerce").fillna(0).astype(int)
-    return df
-
-def forecast_next(df:pd.DataFrame, dep:str)->float:
-    sub=df[df["department"]==dep].sort_values("date")
-    if sub.empty: return 0.0
-    last_dow=sub.iloc[-1]["dow"]
-    same=sub[sub["dow"]==last_dow].tail(4)
-    return float((same["demand"].mean() if not same.empty else sub["demand"].tail(7).mean()))
-
-def staff_required(demand:float, ratio:float)->int:
-    if ratio<=0: ratio=4.0
-    return int(math.ceil(demand/ratio))
-
-REQUIRED_SKILL_BY_DEP={"ICU":"ICU RN","ER":"ER RN","MedSurg":"MedSurg RN"}
-REQUIRED_CERT_BY_DEP={"ICU":"ACLS","ER":"BLS","MedSurg":"BLS"}
-
-def detect_shortages(hist:pd.DataFrame, deps:List[str], params:Dict[str,Any])->pd.DataFrame:
-    def uplift(x:float)->float:
-        fac=1.0
-        if params.get("holiday"): fac*=params["uplift"].get("holidays",1.15)
-        if params.get("event"):   fac*=params["uplift"].get("events",1.08)
-        if params.get("weather"): fac*=params["uplift"].get("weather",1.05)
-        return x*fac
-    rows=[]
-    for dep in deps:
-        base=forecast_next(hist, dep); adj=uplift(base)
-        need=staff_required(adj, params.get("patients_per_nurse",4.0))
-        scheduled=int(hist[hist["department"]==dep]["scheduled_staff"].tail(1).values[0]) if not hist[hist["department"]==dep].empty else 0
-        shortage=max(0, need-scheduled)
-        for i in range(shortage):
-            rows.append({
-                "ShiftID": f"GEN-{dep[:2].upper()}-{i+1:03d}",
-                "Department": dep,
-                "Start": params.get("start_time","2025-08-16 07:00"),
-                "End": params.get("end_time","2025-08-16 19:00"),
-                "RequiredSkill": REQUIRED_SKILL_BY_DEP.get(dep,"MedSurg RN"),
-                "RequiredCert": REQUIRED_CERT_BY_DEP.get(dep,"BLS"),
-            })
-    return pd.DataFrame(rows)
-
-# Eligibility & ranking
-def is_eligible(emp:pd.Series, shift:pd.Series, ot_threshold:int, labor_max:int)->Tuple[bool,List[str]]:
-    reasons=[]
-    role_ok=emp.get("JobRole","").lower()==shift["RequiredSkill"].lower(); reasons.append("Role✔" if role_ok else "Role✖")
-    cert_ok=shift["RequiredCert"].lower() in [c.lower() for c in emp.get("Certifications",[])]; reasons.append("Cert✔" if cert_ok else "Cert✖")
-    av_list=emp.get("Availability",[]) or []; start,end=str(shift["Start"]), str(shift["End"])
-    avail_ok=(not av_list) or any(start in a or end in a for a in av_list); reasons.append("Avail✔" if avail_ok else "Avail✖")
-    ot_ok=int(emp.get("OT_Hours_7d",0))<=int(ot_threshold); reasons.append("OT✔" if ot_ok else "OT✖")
-    labor_ok=(int(emp.get("OT_Hours_7d",0))+12)<=int(labor_max); reasons.append("Labor✔" if labor_ok else "Labor✖")
-    return all([role_ok,cert_ok,avail_ok,ot_ok, labor_ok]), reasons
-
-def rank_candidates(df_emp:pd.DataFrame, shift:pd.Series, ot_threshold:int, labor_max:int)->pd.DataFrame:
-    rows=[]
-    for _,emp in df_emp.iterrows():
-        ok, reasons = is_eligible(emp, shift, ot_threshold, labor_max)
-        score=sum(x in reasons for x in ["Role✔","Cert✔","Avail✔","OT✔","Labor✔"])
+# ---------- Eligibility & Offers ----------
+def is_eligible(emp: pd.Series, shift: pd.Series, ot_threshold: int, labor_max_hours: int) -> Tuple[bool, List[str]]:
+    reasons = []
+    role_ok = emp.get("JobRole","").strip().lower() == (shift.get("RequiredSkill","") or "").strip().lower(); reasons.append("Role✔" if role_ok else "Role✖")
+    cert_ok = (shift.get("RequiredCert","") or "").lower() in [str(c).lower() for c in (emp.get("Certifications",[]) or [])]; reasons.append("Cert✔" if cert_ok else "Cert✖")
+    avail_list = emp.get("Availability", []) or []
+    start, end = str(shift.get("Start","")), str(shift.get("End",""))
+    avail_ok = (not avail_list) or any(start in a or end in a for a in avail_list); reasons.append("Avail✔" if avail_ok else "Avail✖")
+    ot_ok = int(emp.get("OT_Hours_7d",0)) <= int(ot_threshold); reasons.append("OT✔" if ot_ok else "OT✖")
+    labor_ok = (int(emp.get("OT_Hours_7d",0)) + 12) <= int(labor_max_hours); reasons.append("Labor✔" if labor_ok else "Labor✖")
+    return all([role_ok, cert_ok, avail_ok, ot_ok, labor_ok]), reasons
+
+def rank_candidates(df_emp: pd.DataFrame, shift: pd.Series, ot_threshold: int, labor_max_hours: int) -> pd.DataFrame:
+    rows = []
+    for _, emp in df_emp.iterrows():
+        ok, reasons = is_eligible(emp, shift, ot_threshold, labor_max_hours)
+        score = sum(x in reasons for x in ["Role✔","Cert✔","Avail✔","OT✔","Labor✔"])
         rows.append({
             "ShiftID": shift["ShiftID"], "Employee": emp.get("fullName",""), "Phone": emp.get("phoneNumber",""),
             "personNumber": emp.get("personNumber",""), "JobRole": emp.get("JobRole",""),
             "Certifications": ",".join(emp.get("Certifications",[])), "Reasons": " | ".join(reasons),
             "Eligible": "Yes" if ok else "No", "Score": int(score)
         })
-    return pd.DataFrame(rows).sort_values(["Eligible","Score"], ascending=[True,False])
-
-# =========[ UI bits ]=========
-def business_case_block():
-    html = '''
-    <div class="hm-card" dir="ltr" style="margin-top:1rem">
-      <div class="hm-title">📌 Business Case</div>
-      <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:12px">
-        <div>
-          <div class="hm-chip info">Use Case</div>
-          <p style="margin:.5rem 0 0;line-height:1.5">
-            Manager can’t predict the shortage of staff in specific departments and occasions, and can’t fill in open shifts automatically.
-          </p>
-        </div>
-        <div>
-          <div class="hm-chip info">AI Solution</div>
-          <ul style="margin:.5rem 0 0;line-height:1.5">
-            <li>Detect shortage, then identify eligible employees by skills, certifications, availability, OT thresholds, and labor rules.</li>
-            <li>Auto‑suggest or send shift offers via SMS, app, or email.</li>
-            <li>Auto‑fill open shifts based on acceptance/rejection.</li>
-            <li>Notify relevant employees of the assignments.</li>
-          </ul>
-        </div>
-        <div>
-          <div class="hm-chip info">Prerequisites</div>
-          <p style="margin:.5rem 0 0;line-height:1.5">
-            Historical scheduling data, absentee trends, labor demand forecasts, and external factors (holidays, events, weather) are available in WFM.
-          </p>
-        </div>
-      </div>
+    return pd.DataFrame(rows).sort_values(["Eligible","Score"], ascending=[True, False])
+
+def estimate_time_to_fill(total_offers: int, accept_rate: float) -> float:
+    if accept_rate <= 0: return float("inf")
+    return round(1.0 / accept_rate, 2)
+
+# ---------- UI Blocks ----------
+def business_kpis(open_df: pd.DataFrame, ranked_map: Dict[str,pd.DataFrame], cost_ot: float, cost_agency: float) -> None:
+    shifts = int(len(open_df)) if open_df is not None else 0
+    eligible_per_shift = {sid: int((df["Eligible"]=="Yes").sum()) for sid, df in (ranked_map or {}).items()}
+    shifts_with_coverage = sum(1 for sid,c in eligible_per_shift.items() if c>0)
+    coverage = round((shifts_with_coverage / shifts * 100.0), 1) if shifts else 0.0
+    accept_rate = 0.35 if shifts_with_coverage else 0.05
+    ttf = estimate_time_to_fill(3, accept_rate)
+    saved = int(max(0.0, (cost_agency - cost_ot) * 12.0 * shifts_with_coverage))
+    ineligible = sum(int((df["Eligible"]=="No").sum()) for df in (ranked_map or {}).values())
+    st.markdown('<div class="kpi-grid">', unsafe_allow_html=True)
+    st.markdown(f'''
+      <div class="kpi"><div class="big">{shifts}</div><div class="sub">Shifts at Risk / Open</div><div class="delta badge info">based on forecast & source</div></div>
+      <div class="kpi"><div class="big">{coverage}%</div><div class="sub">Eligible Coverage</div><div class="delta badge ok">{shifts_with_coverage} of {shifts} shifts have eligible</div></div>
+      <div class="kpi"><div class="big">{ttf} h</div><div class="sub">Est. Time-to-Fill</div><div class="delta badge info">with parallel offers</div></div>
+      <div class="kpi"><div class="big">{saved:,} SAR</div><div class="sub">Cost Impact (savings)</div><div class="delta badge ok">vs agency for filled shifts</div></div>
+      <div class="kpi"><div class="big">{ineligible}</div><div class="sub">Compliance Risks Avoided</div><div class="delta badge warn">filtered by OT/Cert/Labor</div></div>
+    ''', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def business_case_brief():
+    st.markdown('''
+    <div class="hm-card">
+      <div class="hm-title">📌 Business Case (concise)</div>
+      <ul style="margin:.2rem 0 0; color:#3a556f;">
+        <li>Predict and detect staffing shortages per department/occasion.</li>
+        <li>Auto-identify eligible employees (skills, certs, availability, OT, labor rules).</li>
+        <li>Auto-suggest/sent offers via SMS/App/Email, then auto-fill on acceptance.</li>
+        <li>Notify assigned employees; track cost vs agency and compliance benefits.</li>
+      </ul>
+    </div>
+    ''', unsafe_allow_html=True)
+
+def stepper(progress: float, labels: List[str]):
+    pct = max(0, min(100, int(progress*100)))
+    steps_html = ''.join([f'<span class="badge {"ok" if i<pct/100*len(labels) else "info"}">{labels[i]}</span> ' for i in range(len(labels))])
+    st.markdown(f'''
+    <div class="stepper">
+      <div class="track"><div class="fill" style="width:{pct}%"></div></div>
+      {steps_html}
     </div>
-    '''
-    st.markdown(html, unsafe_allow_html=True)
-
-def flow_timeline(steps: List[Dict[str,str]], progress: float):
-    width = max(0,min(100,int(progress*100)))
-    grid = ''.join([f'''\
-      <div class="hm-step {'active' if i==int(progress*(len(steps))) else ''}">\
-        <div class="title">{s.get('icon','⏺')} {s.get('title','')}</div>\
-        <div class="desc">{s.get('desc','')}</div>\
-      </div>''' for i,s in enumerate(steps)])
-    html = f'''\
-    <div class="hm-flow">\
-      <div class="hm-track"><div class="hm-fill" style="width:{width}%"></div></div>\
-      <div class="hm-steps">{grid}</div>\
-    </div>\
-    '''
-    components.html(html, height=220, scrolling=False)
+    ''', unsafe_allow_html=True)
 
-def html_table(df: pd.DataFrame, title: str, icon: str="📊"):
-    if df is None or df.empty:
-        st.info("No data")
-        return
-    df = df.copy()
-    ths=''.join([f'<th>{c}</th>' for c in df.columns])
-    def fmt_cell(cname,val):
-        if cname.lower() in ("eligible","status"):
-            if str(val).lower() in ("yes","✅ filled","filled"):
-                return f'<span class="badge yes">✅ {val}</span>'
-            if "unfilled" in str(val).lower() or str(val).lower() in ("no","not eligible"):
-                return f'<span class="badge no">✖ {val}</span>'
-            if "skipp" in str(val).lower() or "notify" in str(val).lower():
-                return f'<span class="badge warn">⚠ {val}</span>'
-        return str(val)
-    rows=''
-    for _,r in df.iterrows():
-        tds=''.join([f'<td>{fmt_cell(c,r[c])}</td>' for c in df.columns])
-        rows+=f'<tr>{tds}</tr>'
-    html=f'''\
-    <div class="hm-card" style="margin-top:.8rem">\
-      <div class="hm-title">{icon} {title}</div>\
-      <div style="overflow:auto">\
-        <table class="hm-table">\
-          <thead><tr>{ths}</tr></thead>\
-          <tbody>{rows}</tbody>\
-        </table>\
-      </div>\
-    </div>'''
-    st.markdown(html, unsafe_allow_html=True)
-
-# =========[ Main ]=========
+# ---------- Main ----------
 def main():
     st.set_page_config(page_title=APP_TITLE, layout="wide")
-    _render_bg()
-
-    st.markdown('<div style="text-align:center; margin-top:2.2rem;"><h1 style="color:#36ba01;margin:0">AI Shortage Detection & Auto‑Fill</h1><p style="opacity:.9;margin:.3rem 0 0">by Health Matrix</p></div>', unsafe_allow_html=True)
+    st.markdown(f"<style>{BASE_CSS}</style>", unsafe_allow_html=True)
 
-    # Business Case at top
-    business_case_block()
+    st.markdown('<div style="text-align:center; margin-top:1.2rem;"><h1 style="color:#1ab04b;margin:0">AI Shortage Detection & Auto‑Fill</h1><p style="opacity:.8;margin:.3rem 0 0">by Health Matrix</p></div>', unsafe_allow_html=True)
+    business_case_brief()
 
-    # Sidebar controls
+    # Sidebar with value-oriented controls
     with st.sidebar:
-        st.markdown("### ⚙️ Settings")
-        st.write("Data Source:", "Custom API" if CUSTOM_API_BASE else ("UKG" if (UKG_APP_KEY and UKG_AUTH_TOKEN) else "Mock"))
-        c1,c2,c3 = st.columns(3)
-        with c1: holiday=st.checkbox("Holidays", True)
-        with c2: event=st.checkbox("Events", False)
-        with c3: weather=st.checkbox("Weather", False)
-        uplifts={"holidays": st.number_input("Holiday uplift",1.0,2.5,1.15,0.01),
-                 "events":   st.number_input("Event uplift",1.0,2.5,1.08,0.01),
-                 "weather":  st.number_input("Weather uplift",1.0,2.5,1.05,0.01)}
-        ratio = st.number_input("Patients per Nurse",1.0,10.0,4.0,0.5)
-        ot_threshold = st.number_input("OT Max 7d (h)",0,40,12,1)
-        labor_max = st.number_input("Labor weekly max +12h",20,80,60,1)
+        st.markdown("### 🔌 Data Source")
+        default_idx = 0 if CUSTOM_API_BASE else (1 if UKG_APP_KEY and UKG_AUTH_TOKEN else 2)
+        source = st.radio("", ["Custom API","UKG","Sample/CSV"], index=default_idx)
+        if source == "Custom API":
+            base = st.text_input("Base URL", value=CUSTOM_API_BASE)
+            token= st.text_input("Auth Token (Bearer)", value=CUSTOM_API_TOKEN, type="password")
+        else:
+            base = CUSTOM_API_BASE; token = CUSTOM_API_TOKEN
+        st.markdown("---")
+        st.markdown("### 🧭 Labor Rules")
+        ot_threshold = st.number_input("OT Max (7d) hours", 0, 40, 12, 1)
+        labor_max = st.number_input("Weekly Max incl. +12h", 20, 80, 60, 1)
+        st.markdown("---")
+        st.markdown("### 💰 Cost Model")
+        cost_ot = st.number_input("Internal OT hourly (SAR)", 0.0, 500.0, 85.0, 1.0)
+        cost_agency = st.number_input("Agency hourly (SAR)", 0.0, 800.0, 150.0, 1.0)
         st.markdown("---")
+        st.markdown("### 📣 Channels")
+        ch_sms = st.checkbox("SMS", True); ch_app = st.checkbox("App", True); ch_email = st.checkbox("Email", False)
+        st.markdown("---")
+        with st.expander("Advanced (external factors)"):
+            holiday = st.checkbox("Holidays", True); event = st.checkbox("Events", False); weather = st.checkbox("Weather", False)
+            uplifts = {"holidays": st.number_input("Holiday uplift",1.0,2.5,1.15,0.01), "events": st.number_input("Event uplift",1.0,2.5,1.08,0.01), "weather": st.number_input("Weather uplift",1.0,2.5,1.05,0.01)}
         start_time = st.text_input("Shift Start", "2025-08-16 07:00")
         end_time   = st.text_input("Shift End",   "2025-08-16 19:00")
+        run_all = st.button("▶️ Run end‑to‑end")
 
-    # History (mock CSV inside app for quick check)
+    # History block (Sample or CSV)
     st.markdown('<div class="hm-card">', unsafe_allow_html=True)
     st.markdown('<div class="hm-title">🧾 Scheduling History</div>', unsafe_allow_html=True)
-    sample = st.toggle("Use sample history", True)
-    if sample:
+    if source == "Sample/CSV":
+        sample = st.toggle("Use sample history", True)
+        if sample:
+            sample_csv = """date,department,demand,scheduled_staff,absences
+2025-07-20,ICU,28,7,1
+2025-07-27,ICU,30,7,1
+2025-08-03,ICU,32,7,0
+2025-08-10,ICU,34,7,1
+2025-07-20,ER,90,18,3
+2025-07-27,ER,92,18,2
+2025-08-03,ER,95,18,2
+2025-08-10,ER,110,18,4
+2025-07-20,MedSurg,120,28,4
+2025-07-27,MedSurg,118,28,3
+2025-08-03,MedSurg,125,28,3
+2025-08-10,MedSurg,131,28,5
+"""
+            hist_df = pd.read_csv(StringIO(sample_csv))
+        else:
+            up = st.file_uploader("Upload CSV (date, department, demand, scheduled_staff[, absences])", type=["csv"])
+            if up is None: st.stop()
+            hist_df = pd.read_csv(up)
+    else:
+        # For API/UKG, we won't fetch history remotely; we assume demand baseline is captured elsewhere; sample stays for forecast baseline.
         sample_csv = """date,department,demand,scheduled_staff,absences
 2025-07-20,ICU,28,7,1
 2025-07-27,ICU,30,7,1
@@ -351,95 +379,93 @@ def main():
 2025-08-10,MedSurg,131,28,5
 """
         hist_df = pd.read_csv(StringIO(sample_csv))
-    else:
-        up = st.file_uploader("Upload CSV (date, department, demand, scheduled_staff, absences)", type=["csv"])
-        if up is None: st.stop()
-        hist_df = pd.read_csv(up)
-    hist_df = prepare_history(hist_df)
-    st.dataframe(hist_df, use_container_width=True)
+    try:
+        hist_df = prepare_history(hist_df)
+        st.dataframe(hist_df, use_container_width=True)
+    except Exception as e:
+        st.error(f"History preprocessing error: {e}")
+        st.stop()
     st.markdown('</div>', unsafe_allow_html=True)
 
-    # Detect
-    deps = sorted(hist_df["department"].unique().tolist())
-    target_deps = st.multiselect("Target departments", options=deps, default=deps)
-    if st.button("🔎 Detect Shortages"):
-        params={"holiday":holiday,"event":event,"weather":weather,"uplift":uplifts,"patients_per_nurse":ratio,"start_time":start_time,"end_time":end_time}
-        if CUSTOM_API_BASE:
-            open_api = custom_fetch_open_shifts("2025-08-15","2025-08-18")
-        elif UKG_APP_KEY and UKG_AUTH_TOKEN:
-            open_api = pd.DataFrame()
-        else:
-            open_api = mock_open_shifts()
-        gen_df = detect_shortages(hist_df, target_deps, params)
-        open_df = pd.concat([open_api, gen_df], ignore_index=True).drop_duplicates(subset=["ShiftID"], keep="first")
-        st.session_state["open_shifts"] = open_df
-        flow_timeline([
-            {"icon":"📊","title":"Forecast","desc":"Estimate demand & staffing"},
-            {"icon":"🚨","title":"Shortage","desc":"Generate open shifts"},
-            {"icon":"🗂️","title":"Merge","desc":"Combine with API/UKG open shifts"},
-        ], progress=0.66)
-        html_table(open_df, "Open Shifts")
-
-    # Employees, offers
-    colA, colB = st.columns([2,3])
-    with colA:
-        emp_ids_txt = st.text_input("Employee IDs (comma separated)", "850,825,811")
-        load = st.button("📥 Load Employees")
-    with colB:
-        st.info("Will evaluate Role/Cert/Availability/OT/Labor rules → rank → send offers (SMS/App/Email).")
-
-    if load:
-        if CUSTOM_API_BASE:
-            emp_df = custom_fetch_employees([int(x) for x in emp_ids_txt.split(",") if x.strip().isdigit()])
-        else:
-            emp_df = mock_employees()
-        st.session_state["employees"] = emp_df
-        st.dataframe(emp_df, use_container_width=True)
-
-    if st.button("📤 Auto‑Suggest Offers"):
-        open_df = st.session_state.get("open_shifts", pd.DataFrame())
-        emp_df  = st.session_state.get("employees", mock_employees())
+    # Run pipeline
+    if run_all:
+        params = {"holiday":holiday, "event":event, "weather":weather, "uplift":uplifts, "patients_per_nurse":4.0, "start_time":start_time, "end_time":end_time}
+
+        # Fetch open shifts according to the chosen source
+        open_df = pd.DataFrame()
+        if source == "Custom API" and base:
+            try:
+                global CUSTOM_API_BASE, CUSTOM_API_TOKEN
+                CUSTOM_API_BASE, CUSTOM_API_TOKEN = base, token
+                open_df = custom_fetch_open_shifts("2025-08-15","2025-08-18")
+            except Exception as e:
+                st.warning(f"Custom API shifts error: {e}")
+        elif source == "UKG":
+            open_df = ukg_fetch_open_shifts("2025-08-15","2025-08-18")
         if open_df.empty:
-            st.error("No open shifts yet.")
-        else:
-            offers=[]
-            for _,s in open_df.iterrows():
-                ranked = rank_candidates(emp_df, s, ot_threshold=ot_threshold, labor_max=labor_max)
-                top = ranked.head(3) if not ranked.empty else pd.DataFrame()
-                for _, r in top.iterrows():
-                    ch = random.choice(["SMS","App","Email"])
-                    offers.append({"ShiftID": r["ShiftID"], "Employee": r["Employee"], "Channel": ch, "Result": f"{ch}→{r.get('Phone') or r['Employee']} (simulated)"})
-            offers_df = pd.DataFrame(offers)
-            st.session_state["offers"]=offers_df
-            flow_timeline([
-                {"icon":"🧮","title":"Evaluate","desc":"Rank candidates"},
-                {"icon":"🤝","title":"Suggest","desc":"Send top offers"},
-            ], progress=0.82)
-            html_table(offers_df, "Offers Sent", "📨")
-
-    if st.button("⚙️ Run Auto‑Fill (simulate responses)"):
-        offers_df = st.session_state.get("offers", pd.DataFrame())
-        open_df   = st.session_state.get("open_shifts", pd.DataFrame())
-        if offers_df.empty or open_df.empty:
-            st.error("No offers/open shifts to process.")
+            st.info("No open shifts from source → generating from forecast.")
+        gen_df = detect_shortages(hist_df, sorted(hist_df['department'].unique().tolist()), params)
+        open_df = pd.concat([open_df, gen_df], ignore_index=True).drop_duplicates(subset=["ShiftID"], keep="first")
+        if open_df.empty:
+            st.warning("No open shifts available. Adjust parameters or provide source.")
+            st.stop()
+
+        # Employees
+        if source == "Custom API" and base:
+            try:
+                employees = custom_fetch_employees([])
+            except Exception as e:
+                st.warning(f"Custom API employees error: {e}")
+                employees = mock_employees()
         else:
-            grouped = offers_df.groupby("ShiftID")
-            assigned, notices = [], []
-            for sid, grp in grouped:
-                emp = grp.sample(1)["Employee"].iloc[0]
-                assigned.append({"ShiftID":sid,"Employee":emp,"Status":"✅ Filled"})
-                notices.append({"To":emp,"Message":f"You are assigned to shift {sid}","Channel":"App"})
-            st.session_state["assigned"]=pd.DataFrame(assigned)
-            st.session_state["notices"]=pd.DataFrame(notices)
-            flow_timeline([
-                {"icon":"📬","title":"Offers","desc":"Waiting for responses"},
-                {"icon":"✅","title":"Auto‑Fill","desc":"Assign accepted employees"},
-                {"icon":"🔔","title":"Notify","desc":"Send notifications"},
-            ], progress=1.0)
-            html_table(st.session_state["assigned"], "Shift Fulfillment Summary", "📈")
-            html_table(st.session_state["notices"],  "Notifications", "🔔")
-
-    st.markdown("---")
+            employees = mock_employees()
+        st.session_state["open_shifts"], st.session_state["employees"] = open_df, employees
+
+        # Rank per shift
+        ranked_map = {}
+        for _, s in open_df.iterrows():
+            ranked_map[s["ShiftID"]] = rank_candidates(employees, s, ot_threshold, labor_max)
+
+        # KPIs
+        st.markdown('<style>'+BASE_CSS+'</style>', unsafe_allow_html=True)
+        business_kpis(open_df, ranked_map, cost_ot, cost_agency)
+
+        # Timeline
+        stepper(0.66, ["Forecast","Offers","Auto‑Fill"])
+
+        # Show open shifts
+        html_table(open_df, "Open Shifts", "🗂️")
+
+        # Prepare offers (top‑3 per shift)
+        offers = []
+        for sid, ranked in ranked_map.items():
+            top = ranked[ranked["Eligible"]=="Yes"].head(3) if not ranked.empty else pd.DataFrame()
+            for _, r in top.iterrows():
+                ch = ("SMS" if ch_sms else ("App" if ch_app else "Email"))
+                offers.append({"ShiftID": sid, "Employee": r["Employee"], "Channel": ch, "Result": f"{ch}→{r.get('Phone') or r['Employee']} (simulated)"})
+        offers_df = pd.DataFrame(offers)
+        html_table(offers_df, "Offers Sent", "📨")
+
+        # Auto‑fill simulate: first candidate per shift accepts
+        assigned, notices = [], []
+        for sid, group in offers_df.groupby("ShiftID"):
+            if not group.empty:
+                emp = group.iloc[0]["Employee"]
+                assigned.append({"ShiftID": sid, "Employee": emp, "Status": "✅ Filled"})
+                notices.append({"To": emp, "Message": f"You are assigned to shift {sid}", "Channel": "App"})
+            else:
+                assigned.append({"ShiftID": sid, "Employee": "—", "Status": "⚠️ Unfilled"})
+        assigned_df, notices_df = pd.DataFrame(assigned), pd.DataFrame(notices)
+
+        stepper(1.0, ["Forecast","Offers","Auto‑Fill"])
+        html_table(assigned_df, "Shift Fulfillment Summary", "📈")
+        if not notices_df.empty:
+            html_table(notices_df, "Notifications", "🔔")
+
+        # Download results
+        csv = assigned_df.to_csv(index=False).encode("utf-8")
+        st.download_button("Download Fulfillment CSV", csv, "fulfillment_summary.csv", "text/csv")
+
     st.caption("© 2025 Health Matrix — Digital Health Transformation")
 
 if __name__ == "__main__":