Upload streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,2764 @@
-import altair as alt
 import numpy as np
 import pandas as pd
 import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from sklearn.metrics import (
+    roc_auc_score,
+    average_precision_score,
+    brier_score_loss,
+    confusion_matrix,
+    roc_curve,
+    precision_recall_curve,
+)
+from datetime import datetime
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# ========================================================
+# Page Configuration
+# ========================================================
+st.set_page_config(
+    page_title="Advanced AI Health Intelligence Platform",
+    page_icon="🧬",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ========================================================
+# Advanced Styling with Glassmorphism & Animations
+# ========================================================
+st.markdown(
+    """
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+
+    * {
+        font-family: 'Inter', sans-serif;
+    }
+
+    .main {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 50%, #f093fb 100%);
+        animation: gradientShift 15s ease infinite;
+    }
+
+    @keyframes gradientShift {
+        0% { background-position: 0% 50%; }
+        50% { background-position: 100% 50%; }
+        100% { background-position: 0% 50%; }
+    }
+
+    .stApp {
+        background: transparent;
+    }
+
+    /* Glassmorphism Cards */
+    .glass-card {
+        background: rgba(255, 255, 255, 0.08);
+        backdrop-filter: blur(20px);
+        border-radius: 20px;
+        border: 1px solid rgba(255, 255, 255, 0.18);
+        padding: 25px;
+        box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+        transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);
+    }
+
+    .glass-card:hover {
+        transform: translateY(-8px);
+        box-shadow: 0 15px 45px 0 rgba(31, 38, 135, 0.5);
+        border: 1px solid rgba(255, 255, 255, 0.3);
+    }
+
+    /* Hero Section */
+    .hero-section {
+        background: linear-gradient(135deg, rgba(102, 126, 234, 0.15) 0%, rgba(118, 75, 162, 0.15) 100%);
+        backdrop-filter: blur(25px);
+        border-radius: 30px;
+        padding: 50px;
+        margin: 30px 0;
+        border: 2px solid rgba(255, 255, 255, 0.2);
+        box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+        animation: float 6s ease-in-out infinite;
+    }
+
+    @keyframes float {
+        0%, 100% { transform: translateY(0px); }
+        50% { transform: translateY(-20px); }
+    }
+
+    .hero-title {
+        font-size: 4.5rem;
+        font-weight: 800;
+        background: linear-gradient(135deg, #ffffff 0%, #e0e7ff 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        margin: 0;
+        text-shadow: 0 4px 20px rgba(255, 255, 255, 0.3);
+        animation: pulse 3s ease-in-out infinite;
+    }
+
+    @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.8; }
+    }
+
+    .hero-subtitle {
+        font-size: 1.4rem;
+        color: rgba(255, 255, 255, 0.9);
+        margin-top: 15px;
+        font-weight: 400;
+    }
+
+    /* Advanced Metrics Cards */
+    .metric-card {
+        background: linear-gradient(135deg, rgba(255, 255, 255, 0.12) 0%, rgba(255, 255, 255, 0.05) 100%);
+        backdrop-filter: blur(15px);
+        border-radius: 18px;
+        padding: 30px;
+        border: 1px solid rgba(255, 255, 255, 0.2);
+        position: relative;
+        overflow: hidden;
+        transition: all 0.3s ease;
+    }
+
+    .metric-card::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: -100%;
+        width: 100%;
+        height: 100%;
+        background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.2), transparent);
+        transition: left 0.5s;
+    }
+
+    .metric-card:hover::before {
+        left: 100%;
+    }
+
+    .metric-card:hover {
+        transform: scale(1.05);
+        border: 1px solid rgba(255, 255, 255, 0.4);
+    }
+
+    .metric-icon {
+        font-size: 3rem;
+        margin-bottom: 15px;
+        display: inline-block;
+        animation: bounce 2s infinite;
+    }
+
+    @keyframes bounce {
+        0%, 100% { transform: translateY(0); }
+        50% { transform: translateY(-10px); }
+    }
+
+    .metric-value {
+        font-size: 3rem;
+        font-weight: 800;
+        color: #ffffff;
+        margin: 10px 0;
+        text-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+    }
+
+    .metric-label {
+        font-size: 1rem;
+        color: rgba(255, 255, 255, 0.8);
+        font-weight: 500;
+        text-transform: uppercase;
+        letter-spacing: 1.5px;
+    }
+
+    .metric-change {
+        font-size: 0.9rem;
+        color: rgba(255, 255, 255, 0.7);
+        margin-top: 8px;
+    }
+
+    /* AI Insight Cards */
+    .insight-card {
+        background: linear-gradient(135deg, rgba(16, 185, 129, 0.15) 0%, rgba(59, 130, 246, 0.15) 100%);
+        backdrop-filter: blur(20px);
+        border-radius: 16px;
+        padding: 25px;
+        margin: 15px 0;
+        border-left: 5px solid #10b981;
+        box-shadow: 0 8px 30px rgba(0, 0, 0, 0.2);
+        animation: slideInLeft 0.6s ease-out;
+    }
+
+    @keyframes slideInLeft {
+        from {
+            opacity: 0;
+            transform: translateX(-50px);
+        }
+        to {
+            opacity: 1;
+            transform: translateX(0);
+        }
+    }
+
+    .insight-warning {
+        border-left-color: #f59e0b;
+        background: linear-gradient(135deg, rgba(245, 158, 11, 0.15) 0%, rgba(239, 68, 68, 0.15) 100%);
+    }
+
+    .insight-danger {
+        border-left-color: #ef4444;
+        background: linear-gradient(135deg, rgba(239, 68, 68, 0.15) 0%, rgba(220, 38, 38, 0.15) 100%);
+    }
+
+    .insight-title {
+        font-size: 1.3rem;
+        font-weight: 700;
+        color: #ffffff;
+        margin-bottom: 10px;
+    }
+
+    .insight-text {
+        font-size: 1rem;
+        color: rgba(255, 255, 255, 0.9);
+        line-height: 1.6;
+    }
+
+    /* Section Headers */
+    .section-header {
+        background: linear-gradient(135deg, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.05) 100%);
+        backdrop-filter: blur(15px);
+        border-radius: 15px;
+        padding: 20px 30px;
+        margin: 30px 0 20px 0;
+        border: 1px solid rgba(255, 255, 255, 0.2);
+        display: flex;
+        align-items: center;
+        gap: 15px;
+    }
+
+    .section-icon {
+        font-size: 2rem;
+        animation: rotate 3s linear infinite;
+    }
+
+    @keyframes rotate {
+        from { transform: rotate(0deg); }
+        to { transform: rotate(360deg); }
+    }
+
+    .section-title {
+        font-size: 1.8rem;
+        font-weight: 700;
+        color: #ffffff;
+        margin: 0;
+    }
+
+    .section-subtitle {
+        font-size: 1rem;
+        color: rgba(255, 255, 255, 0.7);
+        margin: 5px 0 0 0;
+    }
+
+    /* Interactive Buttons */
+    .stButton > button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        border-radius: 12px;
+        padding: 15px 35px;
+        font-weight: 600;
+        font-size: 1rem;
+        transition: all 0.3s ease;
+        box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+    }
+
+    .stButton > button:hover {
+        transform: translateY(-3px);
+        box-shadow: 0 8px 25px rgba(102, 126, 234, 0.6);
+    }
+
+    /* Custom Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 12px;
+        background: rgba(255, 255, 255, 0.05);
+        backdrop-filter: blur(10px);
+        border-radius: 18px;
+        padding: 12px;
+    }
+
+    .stTabs [data-baseweb="tab"] {
+        background: transparent;
+        border-radius: 12px;
+        color: rgba(255, 255, 255, 0.8);
+        font-weight: 600;
+        font-size: 1.02rem;
+        padding: 14px 32px;
+        transition: all 0.3s ease;
+    }
+
+    .stTabs [aria-selected="true"] {
+        background: linear-gradient(
+            135deg,
+            rgba(102, 126, 234, 0.3) 0%,
+            rgba(118, 75, 162, 0.3) 100%
+        );
+        color: #ffffff;
+        border: 1px solid rgba(255, 255, 255, 0.35);
+    }
+
+    /* Data Tables */
+    .stDataFrame {
+        background: rgba(255, 255, 255, 0.05);
+        backdrop-filter: blur(10px);
+        border-radius: 12px;
+        border: 1px solid rgba(255, 255, 255, 0.1);
+    }
+
+    /* Plotly Charts Enhancement */
+    .js-plotly-plot {
+        border-radius: 15px;
+        overflow: hidden;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+    }
+
+    /* Sidebar Styling */
+    [data-testid="stSidebar"] {
+        background: linear-gradient(180deg, rgba(102, 126, 234, 0.15) 0%, rgba(118, 75, 162, 0.15) 100%);
+        backdrop-filter: blur(20px);
+        border-right: 1px solid rgba(255, 255, 255, 0.2);
+    }
+
+    [data-testid="stSidebar"] .element-container {
+        color: white;
+    }
+
+    /* Loading Animation */
+    @keyframes shimmer {
+        0% { background-position: -1000px 0; }
+        100% { background-position: 1000px 0; }
+    }
+
+    .loading {
+        background: linear-gradient(90deg, rgba(255,255,255,0.1) 25%, rgba(255,255,255,0.2) 50%, rgba(255,255,255,0.1) 75%);
+        background-size: 1000px 100%;
+        animation: shimmer 2s infinite;
+    }
+
+    /* Status Badges */
+    .status-badge {
+        display: inline-block;
+        padding: 6px 15px;
+        border-radius: 20px;
+        font-weight: 600;
+        font-size: 0.85rem;
+        letter-spacing: 0.5px;
+    }
+
+    .status-success {
+        background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+        color: white;
+    }
+
+    .status-warning {
+        background: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);
+        color: white;
+    }
+
+    .status-danger {
+        background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+        color: white;
+    }
+
+    /* Tooltip Enhancement */
+    .tooltip-custom {
+        background: rgba(0, 0, 0, 0.9);
+        backdrop-filter: blur(10px);
+        border: 1px solid rgba(255, 255, 255, 0.2);
+        border-radius: 8px;
+        padding: 10px;
+        color: white;
+    }
+
+    /* Hide Streamlit Branding */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+# ========================================================
+# Enhanced Data Generation with More Features
+# ========================================================
+@st.cache_data
+def generate_advanced_data(n_users: int = 5000, seed: int = 42):
+    rng = np.random.default_rng(seed)
+
+    # Basic demographics
+    user_id = np.arange(1, n_users + 1)
+    age = rng.integers(15, 75, size=n_users)
+    age_group = pd.cut(
+        age,
+        bins=[14, 22, 30, 40, 50, 60, 75],
+        labels=["Gen Z", "Millennials", "Young Adults", "Middle Age", "Senior", "Elderly"],
+    )
+    gender = rng.choice(["Male", "Female", "Other"], size=n_users, p=[0.48, 0.48, 0.04])
+    location = rng.choice(["Urban", "Suburban", "Rural"], size=n_users, p=[0.55, 0.35, 0.10])
+    occupation = rng.choice(
+        ["Student", "Professional", "Healthcare", "Tech", "Retired", "Other"],
+        size=n_users,
+        p=[0.20, 0.30, 0.15, 0.20, 0.10, 0.05],
+    )
+
+    # Digital behavior
+    screen_hours = np.clip(rng.normal(7.2, 2.5, size=n_users), 1.0, 18.0)
+    sleep_hours = np.clip(
+        7.8 - 0.35 * (screen_hours - 7) + rng.normal(0, 0.9, size=n_users),
+        3.0,
+        12.0,
+    )
+
+    # Mental health indicators
+    stress = np.clip(
+        5.5 + 0.65 * (screen_hours - 7) + rng.normal(0, 1.3, size=n_users),
+        1,
+        10,
+    )
+    anxiety = np.clip(
+        5.0 + 0.55 * stress + rng.normal(0, 1.1, size=n_users),
+        1,
+        10,
+    )
+    depression = np.clip(
+        4.5 + 0.45 * stress + 0.3 * anxiety + rng.normal(0, 1.2, size=n_users),
+        1,
+        10,
+    )
+    focus = np.clip(
+        8.0 - 0.45 * (screen_hours - 7) - 0.35 * stress + rng.normal(0, 0.9, size=n_users),
+        1,
+        10,
+    )
+    wellbeing = np.clip(
+        8.2 - 0.45 * stress + 0.45 * (sleep_hours - 7.5) + rng.normal(0, 0.8, size=n_users),
+        1,
+        10,
+    )
+    mood = np.clip(
+        7.5 - 0.35 * stress + 0.25 * wellbeing + rng.normal(0, 1.0, size=n_users),
+        1,
+        10,
+    )
+    energy = np.clip(
+        7.8 - 0.3 * stress + 0.4 * (sleep_hours - 7.5) + rng.normal(0, 0.9, size=n_users),
+        1,
+        10,
+    )
+
+    # App usage patterns
+    phone_unlocks = np.clip(
+        rng.normal(110 + 15 * (screen_hours - 7), 35, size=n_users),
+        10,
+        400,
+    ).astype(int)
+    notifications = np.clip(
+        rng.normal(95 + 12 * (screen_hours - 7), 32, size=n_users),
+        5,
+        350,
+    ).astype(int)
+    social_minutes = np.clip(
+        rng.normal(165 + 18 * (screen_hours - 7), 55, size=n_users),
+        5,
+        480,
+    ).astype(int)
+    gaming_minutes = np.clip(
+        rng.normal(70 + 10 * (screen_hours - 7), 40, size=n_users),
+        0,
+        360,
+    ).astype(int)
+    work_minutes = np.clip(
+        rng.normal(220, 80, size=n_users),
+        0,
+        600,
+    ).astype(int)
+
+    # Exercise and lifestyle
+    exercise_minutes = np.clip(
+        rng.normal(40 - 2.5 * (screen_hours - 7), 28, size=n_users),
+        0,
+        200,
+    ).astype(int)
+    outdoor_time = np.clip(
+        rng.normal(55 - 3.5 * (screen_hours - 7), 35, size=n_users),
+        0,
+        280,
+    ).astype(int)
+
+    # Health metrics
+    bmi = np.clip(rng.normal(24.5 + 0.3 * (screen_hours - 7), 4.5, size=n_users), 16, 45)
+    heart_rate = np.clip(
+        rng.normal(72 + 2 * stress, 10, size=n_users),
+        50,
+        120,
+    ).astype(int)
+    steps_daily = np.clip(
+        rng.normal(7500 - 300 * (screen_hours - 7), 2500, size=n_users),
+        1000,
+        20000,
+    ).astype(int)
+
+    # Social factors
+    social_support = np.clip(
+        rng.normal(7.0 - 0.2 * stress, 1.5, size=n_users),
+        1,
+        10,
+    )
+    loneliness = np.clip(
+        rng.normal(4.5 + 0.4 * stress - 0.5 * social_support, 1.8, size=n_users),
+        1,
+        10,
+    )
+
+    # Risk calculation with enhanced features
+    logit = (
+        0.62 * (screen_hours - 7)
+        + 0.58 * (stress - 5.5)
+        + 0.52 * (anxiety - 5)
+        + 0.48 * (depression - 4.5)
+        - 0.46 * (sleep_hours - 7.5)
+        - 0.42 * (wellbeing - 8)
+        - 0.38 * (mood - 7.5)
+        - 0.35 * (energy - 7.8)
+        + 0.22 * ((phone_unlocks - 110) / 60)
+        + 0.18 * ((social_minutes - 165) / 70)
+        - 0.15 * ((exercise_minutes - 40) / 35)
+        - 0.12 * ((outdoor_time - 55) / 55)
+        + 0.2 * (loneliness - 4.5)
+        - 0.18 * (social_support - 7)
+        + rng.normal(0, 0.8, size=n_users)
+    )
+
+    risk_score = 1.0 / (1.0 + np.exp(-logit))
+    risk_score = np.clip(risk_score, 0.01, 0.99)
+    high_risk = (rng.random(n_users) < risk_score).astype(int)
+
+    risk_segment = pd.cut(
+        risk_score,
+        bins=[0.0, 0.30, 0.60, 1.0],
+        labels=["Low Risk", "Moderate Risk", "High Risk"],
+    )
+
+    # Engagement metrics
+    last_active = pd.Timestamp.now() - pd.to_timedelta(
+        rng.integers(0, 45, size=n_users), unit="D"
+    )
+    engagement_score = np.clip(
+        rng.normal(7.8 - 0.25 * (screen_hours - 7), 1.6, size=n_users),
+        1,
+        10,
+    )
+
+    # Treatment history
+    seeking_help = rng.choice([0, 1], size=n_users, p=[0.7, 0.3])
+    medication = rng.choice([0, 1], size=n_users, p=[0.8, 0.2])
+
+    df = pd.DataFrame(
+        {
+            "user_id": user_id,
+            "age": age,
+            "age_group": age_group,
+            "gender": gender,
+            "location": location,
+            "occupation": occupation,
+            "screen_hours": screen_hours.round(2),
+            "sleep_hours": sleep_hours.round(2),
+            "stress": stress.round(1),
+            "anxiety": anxiety.round(1),
+            "depression": depression.round(1),
+            "focus": focus.round(1),
+            "wellbeing": wellbeing.round(1),
+            "mood": mood.round(1),
+            "energy": energy.round(1),
+            "phone_unlocks": phone_unlocks,
+            "notifications": notifications,
+            "social_minutes": social_minutes,
+            "gaming_minutes": gaming_minutes,
+            "work_minutes": work_minutes,
+            "exercise_minutes": exercise_minutes,
+            "outdoor_time": outdoor_time,
+            "bmi": bmi.round(1),
+            "heart_rate": heart_rate,
+            "steps_daily": steps_daily,
+            "social_support": social_support.round(1),
+            "loneliness": loneliness.round(1),
+            "seeking_help": seeking_help,
+            "medication": medication,
+            "risk_score": risk_score,
+            "high_risk": high_risk,
+            "risk_segment": risk_segment,
+            "last_active": last_active,
+            "engagement_score": engagement_score.round(1),
+        }
+    )
+
+    # Time series data (90 days)
+    dates = pd.date_range(end=pd.Timestamp.now(), periods=90, freq="D")
+    time_series = pd.DataFrame(
+        {
+            "date": dates,
+            "avg_screen": 7.0
+            + np.sin(np.arange(90) / 7) * 1.8
+            + rng.normal(0, 0.4, 90),
+            "avg_stress": 5.8
+            + np.sin(np.arange(90) / 10) * 1.4
+            + rng.normal(0, 0.4, 90),
+            "avg_wellbeing": 7.8
+            - np.sin(np.arange(90) / 10) * 1.2
+            + rng.normal(0, 0.4, 90),
+            "high_risk_count": (
+                800
+                + np.sin(np.arange(90) / 7) * 120
+                + rng.normal(0, 40, 90)
+            ).astype(int),
+            "avg_sleep": 7.5
+            - np.sin(np.arange(90) / 12) * 0.8
+            + rng.normal(0, 0.3, 90),
+            "engagement": 7.5
+            + np.sin(np.arange(90) / 8) * 1.0
+            + rng.normal(0, 0.3, 90),
+        }
+    )
+
+    # Hourly patterns
+    hours = list(range(24))
+    hourly = pd.DataFrame(
+        {
+            "hour": hours,
+            "screen_time": [
+                25 if h < 6 else 55 + 20 * np.sin((h - 6) / 3.5) for h in hours
+            ],
+            "notifications": [
+                12 if h < 6 else 35 + 18 * np.sin((h - 6) / 3.8) for h in hours
+            ],
+            "stress": [
+                3.5 if h < 6 else 5.5 + 2.5 * np.sin((h - 10) / 3.2) for h in hours
+            ],
+            "energy": [
+                4 if h < 6 else 7.5 - 1.5 * np.sin((h - 14) / 4) for h in hours
+            ],
+        }
+    )
+
+    return df, time_series, hourly
+
+
+# ========================================================
+# Helper Functions
+# ========================================================
+def calculate_metrics(df_metrics: pd.DataFrame, threshold: float = 0.5):
+    y_true = df_metrics["high_risk"].values
+    y_score = df_metrics["risk_score"].values
+    y_pred = (y_score >= threshold).astype(int)
+
+    auc = roc_auc_score(y_true, y_score)
+    ap = average_precision_score(y_true, y_score)
+    brier = brier_score_loss(y_true, y_score)
+    cm = confusion_matrix(y_true, y_pred)
+
+    if cm.shape == (2, 2):
+        tn, fp, fn, tp = cm.ravel()
+    else:
+        tn = fp = fn = tp = 0
+
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if (precision + recall) > 0
+        else 0.0
+    )
+    specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0
+
+    return {
+        "auc": auc,
+        "ap": ap,
+        "brier": brier,
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "specificity": specificity,
+        "tp": int(tp),
+        "fp": int(fp),
+        "tn": int(tn),
+        "fn": int(fn),
+    }
+
+
+def generate_ai_insights(df_view: pd.DataFrame, metrics: dict):
+    insights = []
+
+    if len(df_view) == 0:
+        return insights
+
+    # Critical risk concentration
+    high_risk_pct = (df_view["risk_segment"] == "High Risk").mean() * 100
+    if high_risk_pct > 35:
+        insights.append(
+            {
+                "type": "danger",
+                "title": "🚨 CRITICAL: High Risk Alert",
+                "text": f"{high_risk_pct:.1f}% of monitored population in high-risk category. Systematic intervention programs are recommended.",
+                "priority": "critical",
+            }
+        )
+    elif high_risk_pct > 25:
+        insights.append(
+            {
+                "type": "warning",
+                "title": "⚠️ WARNING: Elevated Risk Levels",
+                "text": f"{high_risk_pct:.1f}% high-risk users detected. Targeted support strategies are advised.",
+                "priority": "high",
+            }
+        )
+
+    # Screen time impact analysis
+    high_risk_screen = df_view[df_view["risk_segment"] == "High Risk"][
+        "screen_hours"
+    ].mean()
+    low_risk_screen = df_view[df_view["risk_segment"] == "Low Risk"][
+        "screen_hours"
+    ].mean()
+    if high_risk_screen - low_risk_screen > 2.5:
+        insights.append(
+            {
+                "type": "info",
+                "title": "📱 Digital Exposure Correlation",
+                "text": f"High-risk cohort shows {high_risk_screen - low_risk_screen:.1f}h higher daily screen time compared to low-risk users.",
+                "priority": "medium",
+            }
+        )
+
+    # Sleep deprivation alert
+    avg_sleep = df_view["sleep_hours"].mean()
+    if avg_sleep < 6.5:
+        critical_sleep = (df_view["sleep_hours"] < 6).sum()
+        insights.append(
+            {
+                "type": "warning",
+                "title": "😴 Sleep Deficit Detected",
+                "text": f"Population average sleep: {avg_sleep:.1f}h. {critical_sleep:,} users are below 6 hours.",
+                "priority": "high",
+            }
+        )
+
+    # Mental health trends
+    avg_stress = df_view["stress"].mean()
+    avg_anxiety = df_view["anxiety"].mean()
+    if avg_stress > 6.5 or avg_anxiety > 6.5:
+        insights.append(
+            {
+                "type": "warning",
+                "title": "🧠 Mental Health Stress Indicators",
+                "text": f"Elevated psychological metrics: Stress {avg_stress:.1f}/10, Anxiety {avg_anxiety:.1f}/10.",
+                "priority": "high",
+            }
+        )
+
+    # Model performance
+    if metrics["auc"] > 0.88:
+        insights.append(
+            {
+                "type": "success",
+                "title": "✅ Model Performance: Strong Signal",
+                "text": f"Predictive performance on this dataset is strong (AUC: {metrics['auc']:.3f}). Risk stratification is internally consistent with the available features.",
+                "priority": "low",
+            }
+        )
+    elif metrics["auc"] < 0.75:
+        insights.append(
+            {
+                "type": "warning",
+                "title": "⚠️ Model Performance Warning",
+                "text": f"AUC {metrics['auc']:.3f} is below the preferred range for reliable screening. Consider recalibration or feature refinement.",
+                "priority": "medium",
+            }
+        )
+
+    # Social isolation patterns
+    avg_loneliness = df_view["loneliness"].mean()
+    if avg_loneliness > 6.0:
+        insights.append(
+            {
+                "type": "warning",
+                "title": "👥 Social Isolation Signal",
+                "text": f"Average loneliness score: {avg_loneliness:.1f}/10. Social support and engagement may be helpful.",
+                "priority": "medium",
+            }
+        )
+
+    # Physical activity deficit
+    avg_exercise = df_view["exercise_minutes"].mean()
+    if avg_exercise < 25:
+        sedentary_count = (df_view["exercise_minutes"] < 15).sum()
+        insights.append(
+            {
+                "type": "info",
+                "title": "🏃 Physical Activity Deficit",
+                "text": f"Average exercise: {avg_exercise:.0f} min/day. {sedentary_count:,} users show very low activity.",
+                "priority": "medium",
+            }
+        )
+
+    return sorted(
+        insights,
+        key=lambda x: {"critical": 0, "high": 1, "medium": 2, "low": 3}[x["priority"]],
+    )
+
+
+# ========================================================
+# Load Data
+# ========================================================
+df, time_series_df, hourly_df = generate_advanced_data()
+
+# ========================================================
+# Sidebar Configuration
+# ========================================================
+with st.sidebar:
+    st.markdown(
+        """
+    <div style='text-align: center; padding: 20px;'>
+        <h1 style='font-size: 2.5rem; margin: 0; color: white;'>🧬</h1>
+        <h3 style='margin: 10px 0; color: white;'>AI Health Intelligence</h3>
+        <p style='color: rgba(255,255,255,0.7); font-size: 0.9rem;'>Advanced analytics for digital wellbeing</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown("---")
+
+    st.markdown("### 🎯 Risk Configuration")
+    threshold = st.slider(
+        "Risk Classification Threshold",
+        min_value=0.1,
+        max_value=0.9,
+        value=0.5,
+        step=0.05,
+        help="Adjust sensitivity for high-risk classification",
+    )
+
+    st.markdown("---")
+    st.markdown("### 🔍 Advanced Filters")
+
+    selected_segments = st.multiselect(
+        "Risk Segments",
+        options=["Low Risk", "Moderate Risk", "High Risk"],
+        default=["Low Risk", "Moderate Risk", "High Risk"],
+    )
+
+    selected_age_groups = st.multiselect(
+        "Age Demographics",
+        options=df["age_group"].unique().tolist(),
+        default=df["age_group"].unique().tolist(),
+    )
+
+    selected_gender = st.multiselect(
+        "Gender",
+        options=["Male", "Female", "Other"],
+        default=["Male", "Female", "Other"],
+    )
+
+    selected_occupation = st.multiselect(
+        "Occupation Type",
+        options=df["occupation"].unique().tolist(),
+        default=df["occupation"].unique().tolist(),
+    )
+
+    screen_time_range = st.slider(
+        "Screen Time (hours/day)",
+        min_value=0.0,
+        max_value=18.0,
+        value=(0.0, 18.0),
+        step=0.5,
+    )
+
+    stress_range = st.slider(
+        "Stress Level Range",
+        min_value=1.0,
+        max_value=10.0,
+        value=(1.0, 10.0),
+        step=0.5,
+    )
+
+    st.markdown("---")
+    st.markdown("### 📊 Display Preferences")
+
+    show_animations = st.checkbox("Enable Animations", value=True)
+    show_insights = st.checkbox("AI-Powered Insights", value=True)
+    show_advanced_metrics = st.checkbox("Advanced Analytics", value=True)
+    real_time_mode = st.checkbox("Real-Time Mode (UI only)", value=False)
+
+    st.markdown("---")
+    st.markdown("### 📥 Data Export")
+
+    export_format = st.selectbox("Export Format", ["CSV", "JSON"])
+
+    if st.button("📊 Export Dataset", use_container_width=True):
+        if export_format == "CSV":
+            data = df.to_csv(index=False).encode("utf-8")
+            st.download_button(
+                "⬇️ Download CSV",
+                data=data,
+                file_name=f"health_data_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv",
+                use_container_width=True,
+            )
+        elif export_format == "JSON":
+            data = df.to_json(orient="records", indent=2).encode("utf-8")
+            st.download_button(
+                "⬇️ Download JSON",
+                data=data,
+                file_name=f"health_data_{datetime.now().strftime('%Y%m%d')}.json",
+                mime="application/json",
+                use_container_width=True,
+            )
+
+
+
+# Apply filters
+mask = (
+    df["risk_segment"].isin(selected_segments)
+    & df["age_group"].isin(selected_age_groups)
+    & df["gender"].isin(selected_gender)
+    & df["occupation"].isin(selected_occupation)
+    & (df["screen_hours"] >= screen_time_range[0])
+    & (df["screen_hours"] <= screen_time_range[1])
+    & (df["stress"] >= stress_range[0])
+    & (df["stress"] <= stress_range[1])
+)
+
+df_filtered = df[mask].copy()
+no_filter_data = len(df_filtered) == 0
+plot_df = df_filtered.copy() if not no_filter_data else df.copy()
+
+plot_df["flagged"] = (plot_df["risk_score"] >= threshold).astype(int)
+
+if plot_df["high_risk"].nunique() < 2:
+    df_metrics = df.copy()
+    metrics_scope = "full dataset (filtered data insufficient)"
+else:
+    df_metrics = plot_df.copy()
+    metrics_scope = "filtered subset" if not no_filter_data else "full dataset"
+
+metrics = calculate_metrics(df_metrics, threshold)
+insights = generate_ai_insights(plot_df, metrics) if show_insights else []
+
+if no_filter_data:
+    st.warning("⚠️ No data matches current filters. Displaying full dataset.")
+
+kpi_df = plot_df
+
+# ========================================================
+# Hero Section
+# ========================================================
+st.markdown(
+    """
+<div class='hero-section'>
+    <div style='text-align: center;'>
+        <h1 class='hero-title'>🧬 AI Health Intelligence Platform</h1>
+        <p class='hero-subtitle'>
+            Advanced predictive analytics for digital wellbeing and mental health risk assessment
+        </p>
+        <p style='color: rgba(255,255,255,0.6); font-size: 0.95rem; margin-top: 15px;'>
+            Interactive monitoring • Machine learning predictions • Scenario-based interventions
+        </p>
+    </div>
+</div>
+""",
+    unsafe_allow_html=True,
+)
+
+# ========================================================
+# Key Metrics Dashboard
+# ========================================================
+col1, col2, col3, col4, col5 = st.columns(5)
+
+with col1:
+    total_users = len(plot_df)
+    st.markdown(
+        f"""
+    <div class='metric-card'>
+        <div class='metric-icon'>👥</div>
+        <div class='metric-value'>{total_users:,}</div>
+        <div class='metric-label'>Active Users</div>
+        <div class='metric-change'>Monitoring scope</div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+with col2:
+    high_risk_count = (plot_df["risk_segment"] == "High Risk").sum()
+    high_risk_pct = (high_risk_count / len(plot_df) * 100) if len(plot_df) > 0 else 0
+    st.markdown(
+        f"""
+    <div class='metric-card'>
+        <div class='metric-icon'>🚨</div>
+        <div class='metric-value'>{high_risk_count:,}</div>
+        <div class='metric-label'>High Risk</div>
+        <div class='metric-change'>{high_risk_pct:.1f}% of population</div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+with col3:
+    st.markdown(
+        f"""
+    <div class='metric-card'>
+        <div class='metric-icon'>🎯</div>
+        <div class='metric-value'>{metrics['auc']:.3f}</div>
+        <div class='metric-label'>Model AUC</div>
+        <div class='metric-change'>Predictive performance</div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+with col4:
+    avg_screen = kpi_df["screen_hours"].mean()
+    screen_delta = avg_screen - 7.0
+    st.markdown(
+        f"""
+    <div class='metric-card'>
+        <div class='metric-icon'>📱</div>
+        <div class='metric-value'>{avg_screen:.1f}h</div>
+        <div class='metric-label'>Avg Screen Time</div>
+        <div class='metric-change'>{"↑" if screen_delta > 0 else "↓"} {abs(screen_delta):.1f}h vs baseline</div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+with col5:
+    avg_wellbeing = kpi_df["wellbeing"].mean()
+    st.markdown(
+        f"""
+    <div class='metric-card'>
+        <div class='metric-icon'>💚</div>
+        <div class='metric-value'>{avg_wellbeing:.1f}</div>
+        <div class='metric-label'>Wellbeing Score</div>
+        <div class='metric-change'>Out of 10.0</div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+st.markdown("<br>", unsafe_allow_html=True)
+
+# Secondary KPIs
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    st.metric("Precision", f"{metrics['precision']:.1%}", f"F1: {metrics['f1']:.3f}")
+
+with col2:
+    st.metric(
+        "Recall",
+        f"{metrics['recall']:.1%}",
+        f"Specificity: {metrics['specificity']:.3f}",
+    )
+
+with col3:
+    flagged_pct = plot_df["flagged"].mean()
+    st.metric("Flagged Users", f"{flagged_pct:.1%}", f"At threshold {threshold:.2f}")
+
+with col4:
+    avg_stress = kpi_df["stress"].mean()
+    st.metric(
+        "Avg Stress",
+        f"{avg_stress:.1f}/10",
+        f"Anxiety: {kpi_df['anxiety'].mean():.1f}/10",
+    )
+
+# ========================================================
+# AI Insights Section
+# ========================================================
+if show_insights and insights:
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>🤖</div>
+        <div>
+            <div class='section-title'>AI-Powered Insights</div>
+            <div class='section-subtitle'>Machine learning analysis and recommendations</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    for insight in insights[:6]:
+        alert_class = ""
+        if insight["type"] == "warning":
+            alert_class = "insight-warning"
+        elif insight["type"] == "danger":
+            alert_class = "insight-danger"
+
+        st.markdown(
+            f"""
+        <div class='insight-card {alert_class}'>
+            <div class='insight-title'>{insight['title']}</div>
+            <div class='insight-text'>{insight['text']}</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+# ========================================================
+# Main Tabs
+# ========================================================
+st.markdown("<br>", unsafe_allow_html=True)
+
+tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(
+    [
+        "Executive Dashboard",
+        "Risk Analytics",
+        "Behavioral Insights",
+        "Model Performance",
+        "Scenario Simulator",
+        "Clinical Reports",
+    ]
+)
+
+# ========================================================
+# TAB 1: Executive Dashboard
+# ========================================================
+with tab1:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>📊</div>
+        <div>
+            <div class='section-title'>Population Health Overview</div>
+            <div class='section-subtitle'>Comprehensive metrics and trend analysis</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    col1, col2 = st.columns([1.5, 1])
+
+    with col1:
+        st.markdown("#### Risk Score Distribution & Segmentation")
+        fig = px.histogram(
+            plot_df,
+            x="risk_score",
+            color="risk_segment",
+            nbins=60,
+            color_discrete_map={
+                "Low Risk": "#10b981",
+                "Moderate Risk": "#f59e0b",
+                "High Risk": "#ef4444",
+            },
+            labels={"risk_score": "Risk Score", "count": "User Count"},
+        )
+        fig.add_vline(
+            x=threshold,
+            line_dash="dash",
+            line_color="#ffffff",
+            line_width=3,
+            annotation_text=f"Threshold: {threshold:.2f}",
+            annotation_position="top right",
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff", size=12),
+            margin=dict(l=40, r=20, t=20, b=40),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Risk Segment Distribution")
+        segment_counts = plot_df["risk_segment"].value_counts()
+        fig = go.Figure(
+            data=[
+                go.Pie(
+                    labels=segment_counts.index,
+                    values=segment_counts.values,
+                    hole=0.6,
+                    marker=dict(
+                        colors=["#10b981", "#f59e0b", "#ef4444"],
+                        line=dict(color="rgba(0,0,0,0.5)", width=3),
+                    ),
+                    textfont=dict(size=15, color="#fff"),
+                    textposition="outside",
+                )
+            ]
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff", size=12),
+            margin=dict(l=20, r=20, t=20, b=20),
+            showlegend=True,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    # 90-Day Trends
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 90-Day Population Health Trends")
+
+    fig = make_subplots(
+        rows=2,
+        cols=3,
+        subplot_titles=(
+            "Screen Time Trajectory",
+            "Stress Evolution",
+            "Wellbeing Index",
+            "High-Risk Population",
+            "Sleep Patterns",
+            "Engagement Metrics",
+        ),
+        vertical_spacing=0.12,
+        horizontal_spacing=0.08,
+    )
+
+    # Screen time
+    fig.add_trace(
+        go.Scatter(
+            x=time_series_df["date"],
+            y=time_series_df["avg_screen"],
+            mode="lines",
+            name="Screen Time",
+            line=dict(color="#3b82f6", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(59,130,246,0.3)",
+        ),
+        row=1,
+        col=1,
+    )
+
+    # Stress
+    fig.add_trace(
+        go.Scatter(
+            x=time_series_df["date"],
+            y=time_series_df["avg_stress"],
+            mode="lines",
+            name="Stress",
+            line=dict(color="#ef4444", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(239,68,68,0.3)",
+        ),
+        row=1,
+        col=2,
+    )
+
+    # Wellbeing
+    fig.add_trace(
+        go.Scatter(
+            x=time_series_df["date"],
+            y=time_series_df["avg_wellbeing"],
+            mode="lines",
+            name="Wellbeing",
+            line=dict(color="#10b981", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(16,185,129,0.3)",
+        ),
+        row=1,
+        col=3,
+    )
+
+    # High-risk count
+    fig.add_trace(
+        go.Bar(
+            x=time_series_df["date"],
+            y=time_series_df["high_risk_count"],
+            name="High-Risk Users",
+            marker=dict(color="#f59e0b"),
+        ),
+        row=2,
+        col=1,
+    )
+
+    # Sleep
+    fig.add_trace(
+        go.Scatter(
+            x=time_series_df["date"],
+            y=time_series_df["avg_sleep"],
+            mode="lines+markers",
+            name="Sleep",
+            line=dict(color="#8b5cf6", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(139,92,246,0.3)",
+        ),
+        row=2,
+        col=2,
+    )
+
+    # Engagement
+    fig.add_trace(
+        go.Scatter(
+            x=time_series_df["date"],
+            y=time_series_df["engagement"],
+            mode="lines",
+            name="Engagement",
+            line=dict(color="#ec4899", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(236,72,153,0.3)",
+        ),
+        row=2,
+        col=3,
+    )
+
+    fig.update_layout(
+        height=700,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#ffffff", size=11),
+        margin=dict(l=40, r=20, t=50, b=40),
+        showlegend=False,
+    )
+
+    fig.update_xaxes(showgrid=True, gridcolor="rgba(255,255,255,0.1)")
+    fig.update_yaxes(showgrid=True, gridcolor="rgba(255,255,255,0.1)")
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Demographics Analysis
+    st.markdown("<br>", unsafe_allow_html=True)
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.markdown("#### Age Distribution (Avg Risk)")
+        age_risk = plot_df.groupby("age_group")["risk_score"].mean().reset_index()
+        fig = px.bar(
+            age_risk,
+            x="age_group",
+            y="risk_score",
+            color="risk_score",
+            color_continuous_scale=["#10b981", "#f59e0b", "#ef4444"],
+        )
+        fig.update_layout(
+            height=350,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            showlegend=False,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Gender Distribution")
+        gender_counts = plot_df["gender"].value_counts()
+        fig = px.bar(
+            x=gender_counts.index,
+            y=gender_counts.values,
+            color=gender_counts.index,
+            color_discrete_map={
+                "Male": "#3b82f6",
+                "Female": "#ec4899",
+                "Other": "#8b5cf6",
+            },
+        )
+        fig.update_layout(
+            height=350,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            showlegend=False,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col3:
+        st.markdown("#### Location Distribution")
+        location_counts = plot_df["location"].value_counts()
+        fig = px.pie(
+            values=location_counts.values,
+            names=location_counts.index,
+            color_discrete_sequence=["#3b82f6", "#8b5cf6", "#10b981"],
+            hole=0.4,
+        )
+        fig.update_layout(
+            height=350,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col4:
+        st.markdown("#### Occupation (Avg Risk)")
+        occ_risk = (
+            plot_df.groupby("occupation")["risk_score"]
+            .mean()
+            .sort_values(ascending=False)
+        )
+        fig = px.bar(
+            x=occ_risk.values,
+            y=occ_risk.index,
+            orientation="h",
+            color=occ_risk.values,
+            color_continuous_scale=["#10b981", "#f59e0b", "#ef4444"],
+        )
+        fig.update_layout(
+            height=350,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            showlegend=False,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+# ========================================================
+# TAB 2: Risk Analytics
+# ========================================================
+with tab2:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>🎯</div>
+        <div>
+            <div class='section-title'>Advanced Risk Assessment</div>
+            <div class='section-subtitle'>Deep dive into risk factors and correlations</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    col1, col2 = st.columns([1.3, 1])
+
+    with col1:
+        st.markdown("#### Multi-Factor Correlation Matrix")
+        corr_cols = [
+            "screen_hours",
+            "sleep_hours",
+            "stress",
+            "anxiety",
+            "depression",
+            "wellbeing",
+            "mood",
+            "energy",
+            "social_support",
+            "loneliness",
+            "risk_score",
+        ]
+        corr_matrix = plot_df[corr_cols].corr()
+
+        fig = go.Figure(
+            data=go.Heatmap(
+                z=corr_matrix.values,
+                x=corr_matrix.columns,
+                y=corr_matrix.columns,
+                colorscale=[[0, "#ef4444"], [0.5, "#f3f4f6"], [1, "#10b981"]],
+                text=corr_matrix.values.round(2),
+                texttemplate="%{text}",
+                textfont={"size": 10},
+                colorbar=dict(title="Correlation"),
+            )
+        )
+        fig.update_layout(
+            height=550,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff", size=10),
+            margin=dict(l=120, r=40, t=20, b=120),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Risk Distribution by Segment")
+        fig = go.Figure()
+        for segment in ["Low Risk", "Moderate Risk", "High Risk"]:
+            data = plot_df[plot_df["risk_segment"] == segment]["risk_score"]
+            color = {
+                "Low Risk": "#10b981",
+                "Moderate Risk": "#f59e0b",
+                "High Risk": "#ef4444",
+            }[segment]
+            fig.add_trace(
+                go.Box(y=data, name=segment, marker_color=color, boxmean="sd")
+            )
+        fig.update_layout(
+            height=550,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            yaxis_title="Risk Score",
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    # ROC and Confusion Matrix
+    st.markdown("<br>", unsafe_allow_html=True)
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("#### Confusion Matrix Analysis")
+        cm = confusion_matrix(
+            df_metrics["high_risk"].values,
+            (df_metrics["risk_score"].values >= threshold).astype(int),
+        )
+        if cm.shape == (2, 2):
+            tn, fp, fn, tp = cm.ravel()
+        else:
+            tn = fp = fn = tp = 0
+
+        cm_display = [[tn, fp], [fn, tp]]
+        fig = go.Figure(
+            data=go.Heatmap(
+                z=cm_display,
+                x=["Predicted Negative", "Predicted Positive"],
+                y=["Actual Negative", "Actual Positive"],
+                text=cm_display,
+                texttemplate="%{text}",
+                textfont={"size": 24},
+                colorscale=[[0, "#1e293b"], [1, "#3b82f6"]],
+                showscale=False,
+            )
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff", size=13),
+            margin=dict(l=100, r=20, t=20, b=80),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### ROC Curve Analysis")
+        fpr, tpr, _ = roc_curve(
+            df_metrics["high_risk"].values, df_metrics["risk_score"].values
+        )
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(
+                x=fpr,
+                y=tpr,
+                mode="lines",
+                name=f"ROC (AUC = {metrics['auc']:.3f})",
+                line=dict(color="#3b82f6", width=4),
+                fill="tozeroy",
+                fillcolor="rgba(59,130,246,0.3)",
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=[0, 1],
+                y=[0, 1],
+                mode="lines",
+                name="Random Classifier",
+                line=dict(color="#64748b", width=2, dash="dash"),
+            )
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            xaxis_title="False Positive Rate",
+            yaxis_title="True Positive Rate",
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    # Feature Importance
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### Risk Factor Importance (Conceptual)")
+
+    features = [
+        "Screen Time",
+        "Stress",
+        "Sleep Quality",
+        "Anxiety",
+        "Depression",
+        "Wellbeing",
+        "Social Support",
+        "Loneliness",
+        "Phone Unlocks",
+        "Social Media",
+        "Exercise",
+        "Outdoor Time",
+    ]
+    importance = [0.62, 0.58, 0.46, 0.52, 0.48, 0.42, 0.18, 0.2, 0.22, 0.18, 0.15, 0.12]
+
+    fig = px.bar(
+        x=importance,
+        y=features,
+        orientation="h",
+        color=importance,
+        color_continuous_scale=["#64748b", "#3b82f6", "#8b5cf6", "#ec4899"],
+    )
+    fig.update_layout(
+        height=500,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#ffffff"),
+        xaxis_title="Relative Importance (Model Coefficients)",
+        showlegend=False,
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Risk scatter plots
+    st.markdown("<br>", unsafe_allow_html=True)
+    col1, col2 = st.columns(2)
+
+    sample = (
+        plot_df.sample(n=min(2000, len(plot_df)), random_state=42)
+        if len(plot_df) > 0
+        else plot_df
+    )
+
+    with col1:
+        st.markdown("#### Screen Time vs Sleep")
+        if len(sample) > 0:
+            fig = px.scatter(
+                sample,
+                x="screen_hours",
+                y="sleep_hours",
+                color="risk_score",
+                size="stress",
+                color_continuous_scale=["#10b981", "#f59e0b", "#ef4444"],
+                hover_data=["stress", "wellbeing", "age"],
+            )
+            fig.update_layout(
+                height=450,
+                plot_bgcolor="rgba(0,0,0,0)",
+                paper_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#ffffff"),
+            )
+            st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Stress vs Wellbeing")
+        if len(sample) > 0:
+            fig = px.scatter(
+                sample,
+                x="stress",
+                y="wellbeing",
+                color="risk_segment",
+                size="risk_score",
+                color_discrete_map={
+                    "Low Risk": "#10b981",
+                    "Moderate Risk": "#f59e0b",
+                    "High Risk": "#ef4444",
+                },
+                hover_data=["screen_hours", "sleep_hours", "depression"],
+            )
+            fig.update_layout(
+                height=450,
+                plot_bgcolor="rgba(0,0,0,0)",
+                paper_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#ffffff"),
+            )
+            st.plotly_chart(fig, use_container_width=True)
+
+# ========================================================
+# TAB 3: Behavioral Insights
+# ========================================================
+with tab3:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>📱</div>
+        <div>
+            <div class='section-title'>Digital Behavior Analysis</div>
+            <div class='section-subtitle'>Usage patterns and lifestyle correlations</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # 24-hour patterns
+    st.markdown("#### Circadian Activity Patterns")
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    fig.add_trace(
+        go.Scatter(
+            x=hourly_df["hour"],
+            y=hourly_df["screen_time"],
+            name="Screen Time",
+            mode="lines+markers",
+            line=dict(color="#3b82f6", width=3),
+            fill="tozeroy",
+            fillcolor="rgba(59,130,246,0.3)",
+        ),
+        secondary_y=False,
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=hourly_df["hour"],
+            y=hourly_df["notifications"],
+            name="Notifications",
+            mode="lines+markers",
+            line=dict(color="#f59e0b", width=2),
+        ),
+        secondary_y=False,
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=hourly_df["hour"],
+            y=hourly_df["stress"],
+            name="Stress Level",
+            mode="lines+markers",
+            line=dict(color="#ef4444", width=2, dash="dash"),
+        ),
+        secondary_y=True,
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=hourly_df["hour"],
+            y=hourly_df["energy"],
+            name="Energy Level",
+            mode="lines",
+            line=dict(color="#10b981", width=2, dash="dot"),
+        ),
+        secondary_y=True,
+    )
+
+    fig.update_layout(
+        height=500,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#ffffff"),
+        hovermode="x unified",
+    )
+
+    fig.update_xaxes(
+        title_text="Hour of Day", showgrid=True, gridcolor="rgba(255,255,255,0.1)"
+    )
+    fig.update_yaxes(
+        title_text="Activity Level",
+        secondary_y=False,
+        showgrid=True,
+        gridcolor="rgba(255,255,255,0.1)",
+    )
+    fig.update_yaxes(title_text="Psychological Metrics", secondary_y=True)
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    st.markdown("<br>", unsafe_allow_html=True)
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown("#### App Usage Distribution")
+        usage_data = pd.DataFrame(
+            {
+                "Category": ["Social Media", "Work/Study", "Gaming", "Entertainment", "Other"],
+                "Minutes": [
+                    plot_df["social_minutes"].mean(),
+                    plot_df["work_minutes"].mean(),
+                    plot_df["gaming_minutes"].mean(),
+                    80,
+                    45,
+                ],
+            }
+        )
+        fig = px.pie(
+            usage_data,
+            values="Minutes",
+            names="Category",
+            color_discrete_sequence=[
+                "#3b82f6",
+                "#10b981",
+                "#8b5cf6",
+                "#ec4899",
+                "#64748b",
+            ],
+            hole=0.5,
+        )
+        fig.update_layout(
+            height=400,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Digital Interaction Metrics")
+        interaction_data = (
+            plot_df.groupby("risk_segment")
+            .agg({"phone_unlocks": "mean", "notifications": "mean"})
+            .reset_index()
+        )
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Bar(
+                x=interaction_data["risk_segment"],
+                y=interaction_data["phone_unlocks"],
+                name="Phone Unlocks",
+                marker_color="#3b82f6",
+            )
+        )
+        fig.add_trace(
+            go.Bar(
+                x=interaction_data["risk_segment"],
+                y=interaction_data["notifications"],
+                name="Notifications",
+                marker_color="#f59e0b",
+            )
+        )
+        fig.update_layout(
+            height=400,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            barmode="group",
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col3:
+        st.markdown("#### Physical Activity Balance")
+        balance_data = pd.DataFrame(
+            {
+                "Activity": ["Exercise", "Outdoor", "Screen Time"],
+                "Minutes": [
+                    plot_df["exercise_minutes"].mean(),
+                    plot_df["outdoor_time"].mean(),
+                    plot_df["screen_hours"].mean() * 60,
+                ],
+            }
+        )
+        fig = px.bar(
+            balance_data,
+            x="Activity",
+            y="Minutes",
+            color="Activity",
+            color_discrete_sequence=["#10b981", "#8b5cf6", "#ef4444"],
+        )
+        fig.update_layout(
+            height=400,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            showlegend=False,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    # Health metrics
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### Population Health Indicators")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        high_screen = len(plot_df[plot_df["screen_hours"] > 10])
+        st.metric(
+            "Excessive Screen Use",
+            f"{high_screen:,}",
+            f"{(high_screen/len(plot_df)*100):.1f}% of users",
+        )
+
+    with col2:
+        sleep_deficit = len(plot_df[plot_df["sleep_hours"] < 6])
+        st.metric(
+            "Sleep Deficit",
+            f"{sleep_deficit:,}",
+            f"{(sleep_deficit/len(plot_df)*100):.1f}% critical",
+        )
+
+    with col3:
+        high_stress = len(plot_df[plot_df["stress"] > 7])
+        st.metric(
+            "High Stress",
+            f"{high_stress:,}",
+            f"{(high_stress/len(plot_df)*100):.1f}% elevated",
+        )
+
+    with col4:
+        sedentary = len(plot_df[plot_df["exercise_minutes"] < 20])
+        st.metric(
+            "Sedentary Lifestyle",
+            f"{sedentary:,}",
+            f"{(sedentary/len(plot_df)*100):.1f}% inactive",
+        )
+
+# ========================================================
+# TAB 4: Model Performance
+# ========================================================
+with tab4:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>🔬</div>
+        <div>
+            <div class='section-title'>ML Model Performance</div>
+            <div class='section-subtitle'>Evaluation and diagnostics on the current cohort</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Performance metrics
+    col1, col2, col3, col4, col5 = st.columns(5)
+
+    metrics_data = [
+        ("AUC-ROC", metrics["auc"], "🎯"),
+        ("Precision", metrics["precision"], "🔍"),
+        ("Recall", metrics["recall"], "📊"),
+        ("F1 Score", metrics["f1"], "⚡"),
+        ("Brier Score", metrics["brier"], "📈"),
+    ]
+
+    for i, (label, value, icon) in enumerate(metrics_data):
+        with [col1, col2, col3, col4, col5][i]:
+            st.markdown(
+                f"""
+            <div class='metric-card'>
+                <div class='metric-icon'>{icon}</div>
+                <div class='metric-value'>{value:.3f}</div>
+                <div class='metric-label'>{label}</div>
+            </div>
+            """,
+                unsafe_allow_html=True,
+            )
+
+    st.caption(f"Analysis scope: {metrics_scope}")
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Threshold analysis
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("#### Threshold Optimization Curve")
+        thresholds = np.linspace(0.1, 0.9, 60)
+        precision_scores = []
+        recall_scores = []
+        f1_scores = []
+
+        for t in thresholds:
+            temp_metrics = calculate_metrics(df_metrics, t)
+            precision_scores.append(temp_metrics["precision"])
+            recall_scores.append(temp_metrics["recall"])
+            f1_scores.append(temp_metrics["f1"])
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(
+                x=thresholds,
+                y=precision_scores,
+                mode="lines",
+                name="Precision",
+                line=dict(color="#10b981", width=3),
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=thresholds,
+                y=recall_scores,
+                mode="lines",
+                name="Recall",
+                line=dict(color="#3b82f6", width=3),
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=thresholds,
+                y=f1_scores,
+                mode="lines",
+                name="F1 Score",
+                line=dict(color="#8b5cf6", width=3),
+            )
+        )
+        fig.add_vline(
+            x=threshold,
+            line_dash="dash",
+            line_color="#f59e0b",
+            line_width=3,
+            annotation_text=f"Current: {threshold:.2f}",
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            xaxis_title="Decision Threshold",
+            yaxis_title="Score",
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    with col2:
+        st.markdown("#### Precision-Recall Curve")
+        precision_vals, recall_vals, _ = precision_recall_curve(
+            df_metrics["high_risk"].values, df_metrics["risk_score"].values
+        )
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(
+                x=recall_vals,
+                y=precision_vals,
+                mode="lines",
+                name=f"PR Curve (AP = {metrics['ap']:.3f})",
+                line=dict(color="#8b5cf6", width=4),
+                fill="tozeroy",
+                fillcolor="rgba(139,92,246,0.3)",
+            )
+        )
+        fig.update_layout(
+            height=450,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            xaxis_title="Recall",
+            yaxis_title="Precision",
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+    # Calibration
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### Model Calibration Analysis")
+
+    df_cal = df_metrics.copy()
+    df_cal["score_bin"] = pd.qcut(
+        df_cal["risk_score"], q=10, duplicates="drop"
+    )
+    cal_stats = (
+        df_cal.groupby("score_bin")
+        .agg({"risk_score": "mean", "high_risk": "mean", "user_id": "count"})
+        .reset_index()
+    )
+
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=cal_stats["risk_score"],
+            y=cal_stats["high_risk"],
+            mode="markers+lines",
+            name="Observed Rate",
+            marker=dict(size=cal_stats["user_id"] / 25, color="#3b82f6"),
+            line=dict(color="#3b82f6", width=3),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=[0, 1],
+            y=[0, 1],
+            mode="lines",
+            name="Perfect Calibration",
+            line=dict(color="#10b981", width=2, dash="dash"),
+        )
+    )
+    fig.update_layout(
+        height=500,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#ffffff"),
+        xaxis_title="Predicted Risk Score",
+        yaxis_title="Observed Event Rate",
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+# ========================================================
+# TAB 5: Scenario Simulator
+# ========================================================
+with tab5:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>🧪</div>
+        <div>
+            <div class='section-title'>Interactive Risk Simulator</div>
+            <div class='section-subtitle'>Test behavioral interventions and quantify risk impact</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    if real_time_mode:
+        st.markdown(
+            """
+        <div style='background: rgba(34,197,94,0.1); padding: 14px 18px; border-radius: 10px;
+                    border-left: 4px solid #22c55e; margin-bottom: 14px;'>
+            <span style='color:#bbf7d0; font-size:0.9rem;'>
+                Real-time mode enabled — use this simulator as a live what-if console for new profiles.
+            </span>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    st.markdown(
+        """
+    <div style='background: rgba(59,130,246,0.12); padding: 20px; border-radius: 12px;
+                border-left: 4px solid #3b82f6; margin: 16px 0;'>
+        <strong>How this works:</strong><br>
+        1) Configure a single user profile using the sliders below.<br>
+        2) The risk engine predicts mental health risk in real-time based on the inputs.<br>
+        3) Intervention scenarios show how small changes shift the risk curve.
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Helper: risk computation for scenarios
+    def compute_risk_from_features(params: dict) -> float:
+        logit_val = (
+            0.62 * (params["screen"] - 7)
+            + 0.58 * (params["stress"] - 5.5)
+            + 0.52 * (params["anxiety"] - 5)
+            + 0.48 * (params["depression"] - 4.5)
+            - 0.46 * (params["sleep"] - 7.5)
+            - 0.42 * (params["wellbeing"] - 8)
+            - 0.38 * (params["mood"] - 7.5)
+            - 0.35 * (params["energy"] - 7.8)
+            + 0.22 * ((params["unlocks"] - 110) / 60.0)
+            + 0.18 * ((params["social"] - 165) / 70.0)
+            - 0.15 * ((params["exercise"] - 40) / 35.0)
+            - 0.12 * ((params["outdoor"] - 55) / 55.0)
+            + 0.2 * (params["loneliness"] - 4.5)
+            - 0.18 * (params["social_support"] - 7)
+        )
+        return float(np.clip(1.0 / (1.0 + np.exp(-logit_val)), 0.01, 0.99))
+
+    # Sliders: base scenario
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown("##### 📱 Digital Behavior")
+        sim_screen = st.slider(
+            "Screen Time (hours/day)", 1.0, 18.0, 7.0, 0.5, key="sim_screen"
+        )
+        sim_unlocks = st.slider(
+            "Phone Unlocks/day", 10, 400, 110, 5, key="sim_unlocks"
+        )
+        sim_notifications = st.slider(
+            "Notifications/day", 5, 350, 95, 5, key="sim_notif"
+        )
+        sim_social = st.slider(
+            "Social Media (min/day)", 5, 480, 165, 10, key="sim_social"
+        )
+        sim_gaming = st.slider(
+            "Gaming (min/day)", 0, 360, 70, 10, key="sim_gaming"
+        )
+
+    with col2:
+        st.markdown("##### 😴 Health & Wellbeing")
+        sim_sleep = st.slider(
+            "Sleep (hours/day)", 3.0, 12.0, 7.5, 0.5, key="sim_sleep"
+        )
+        sim_stress = st.slider(
+            "Stress Level (1-10)", 1.0, 10.0, 5.5, 0.5, key="sim_stress"
+        )
+        sim_anxiety = st.slider(
+            "Anxiety Level (1-10)", 1.0, 10.0, 5.0, 0.5, key="sim_anxiety"
+        )
+        sim_depression = st.slider(
+            "Depression (1-10)", 1.0, 10.0, 4.5, 0.5, key="sim_depression"
+        )
+        sim_wellbeing = st.slider(
+            "Wellbeing (1-10)", 1.0, 10.0, 8.0, 0.5, key="sim_wellbeing"
+        )
+        sim_mood = st.slider(
+            "Mood (1-10)", 1.0, 10.0, 7.5, 0.5, key="sim_mood"
+        )
+        sim_energy = st.slider(
+            "Energy (1-10)", 1.0, 10.0, 7.8, 0.5, key="sim_energy"
+        )
+
+    with col3:
+        st.markdown("##### 🏃 Physical & Social")
+        sim_exercise = st.slider(
+            "Exercise (min/day)", 0, 200, 40, 5, key="sim_exercise"
+        )
+        sim_outdoor = st.slider(
+            "Outdoor Time (min/day)", 0, 280, 55, 10, key="sim_outdoor"
+        )
+        sim_social_support = st.slider(
+            "Social Support (1-10)", 1.0, 10.0, 7.0, 0.5, key="sim_social_support"
+        )
+        sim_loneliness = st.slider(
+            "Loneliness (1-10)", 1.0, 10.0, 4.5, 0.5, key="sim_loneliness"
+        )
+
+        st.markdown("<br>", unsafe_allow_html=True)
+        if st.button("🔄 Reset to Population Baseline", use_container_width=True):
+            st.rerun()
+
+    # Bundle base features
+    base_features = {
+        "screen": sim_screen,
+        "sleep": sim_sleep,
+        "stress": sim_stress,
+        "anxiety": sim_anxiety,
+        "depression": sim_depression,
+        "wellbeing": sim_wellbeing,
+        "mood": sim_mood,
+        "energy": sim_energy,
+        "unlocks": sim_unlocks,
+        "social": sim_social,
+        "exercise": sim_exercise,
+        "outdoor": sim_outdoor,
+        "loneliness": sim_loneliness,
+        "social_support": sim_social_support,
+    }
+
+    # Base scenario risk
+    scenario_risk = compute_risk_from_features(base_features)
+    scenario_segment = (
+        "Low Risk"
+        if scenario_risk < 0.30
+        else "Moderate Risk"
+        if scenario_risk < 0.60
+        else "High Risk"
+    )
+    scenario_flagged = "Yes" if scenario_risk >= threshold else "No"
+    percentile = (
+        (df["risk_score"] < scenario_risk).mean() * 100 if len(df) > 0 else 0.0
+    )
+
+    # Results cards
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 🎯 Simulation Results")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        color_risk = (
+            "#ef4444"
+            if scenario_risk > 0.6
+            else "#f59e0b"
+            if scenario_risk > 0.3
+            else "#10b981"
+        )
+        st.markdown(
+            f"""
+        <div class='metric-card'>
+            <div class='metric-label'>PREDICTED RISK SCORE</div>
+            <div class='metric-value' style='color: {color_risk};'>
+                {scenario_risk:.3f}
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col2:
+        segment_color = {
+            "Low Risk": "#10b981",
+            "Moderate Risk": "#f59e0b",
+            "High Risk": "#ef4444",
+        }[scenario_segment]
+        st.markdown(
+            f"""
+        <div class='metric-card'>
+            <div class='metric-label'>RISK CATEGORY</div>
+            <div class='metric-value' style='color: {segment_color}; font-size: 2rem;'>
+                {scenario_segment}
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col3:
+        flag_color = "#ef4444" if scenario_flagged == "Yes" else "#10b981"
+        st.markdown(
+            f"""
+        <div class='metric-card'>
+            <div class='metric-label'>INTERVENTION FLAG</div>
+            <div class='metric-value' style='color: {flag_color}; font-size: 2.5rem;'>
+                {scenario_flagged}
+            </div>
+            <div class='metric-change'>At threshold {threshold:.2f}</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col4:
+        st.markdown(
+            f"""
+        <div class='metric-card'>
+            <div class='metric-label'>POPULATION PERCENTILE</div>
+            <div class='metric-value'>{percentile:.0f}th</div>
+            <div class='metric-change'>Risk ranking vs full population</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    # Scenario vs population + radar
+    st.markdown("<br>", unsafe_allow_html=True)
+    col_left, col_right = st.columns(2)
+
+    with col_left:
+        st.markdown("#### 📊 Scenario vs Population Averages")
+
+        comparison_data = pd.DataFrame(
+            {
+                "Metric": [
+                    "Screen Time",
+                    "Sleep",
+                    "Stress",
+                    "Anxiety",
+                    "Wellbeing",
+                    "Exercise (×10min)",
+                    "Social Support",
+                ],
+                "Your Scenario": [
+                    sim_screen,
+                    sim_sleep,
+                    sim_stress,
+                    sim_anxiety,
+                    sim_wellbeing,
+                    sim_exercise / 10.0,
+                    sim_social_support,
+                ],
+                "Population Avg": [
+                    df["screen_hours"].mean(),
+                    df["sleep_hours"].mean(),
+                    df["stress"].mean(),
+                    df["anxiety"].mean(),
+                    df["wellbeing"].mean(),
+                    df["exercise_minutes"].mean() / 10.0,
+                    df["social_support"].mean(),
+                ]
+                if len(df) > 0
+                else [0, 0, 0, 0, 0, 0, 0],
+            }
+        )
+
+        fig_comp = go.Figure()
+        fig_comp.add_trace(
+            go.Bar(
+                x=comparison_data["Metric"],
+                y=comparison_data["Your Scenario"],
+                name="Your Scenario",
+                marker_color="#3b82f6",
+            )
+        )
+        fig_comp.add_trace(
+            go.Bar(
+                x=comparison_data["Metric"],
+                y=comparison_data["Population Avg"],
+                name="Population Average",
+                marker_color="#64748b",
+            )
+        )
+        fig_comp.update_layout(
+            height=430,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            barmode="group",
+        )
+        st.plotly_chart(fig_comp, use_container_width=True)
+
+    with col_right:
+        st.markdown("#### 🧬 Profile Radar View")
+
+        radar_categories = [
+            "Screen Load",
+            "Sleep",
+            "Stress",
+            "Anxiety",
+            "Wellbeing",
+            "Exercise",
+            "Social Support",
+        ]
+
+        radar_values = [
+            min(sim_screen / 1.8, 10.0),
+            min(sim_sleep * 1.2, 10.0),
+            sim_stress,
+            sim_anxiety,
+            sim_wellbeing,
+            min(sim_exercise / 12.0, 10.0),
+            sim_social_support,
+        ]
+
+        radar_categories += radar_categories[:1]
+        radar_values += radar_values[:1]
+
+        fig_radar = go.Figure()
+        fig_radar.add_trace(
+            go.Scatterpolar(
+                r=radar_values,
+                theta=radar_categories,
+                fill="toself",
+                name="Scenario profile",
+                line=dict(color="#3b82f6", width=3),
+                fillcolor="rgba(59,130,246,0.35)",
+            )
+        )
+        fig_radar.update_layout(
+            height=430,
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#ffffff"),
+            polar=dict(
+                radialaxis=dict(
+                    visible=True,
+                    range=[0, 10],
+                    gridcolor="rgba(148,163,184,0.4)",
+                ),
+                angularaxis=dict(gridcolor="rgba(148,163,184,0.4)"),
+            ),
+            showlegend=False,
+        )
+        st.plotly_chart(fig_radar, use_container_width=True)
+
+    # Quick intervention scenarios
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 🧭 Quick Intervention What-If Scenarios")
+
+    # Digital reset: reduce screen & social, increase exercise a bit
+    digital_reset = base_features.copy()
+    digital_reset["screen"] = max(1.0, digital_reset["screen"] - 2.0)
+    digital_reset["social"] = max(5.0, digital_reset["social"] - 60.0)
+    digital_reset["unlocks"] = max(10.0, digital_reset["unlocks"] - 40.0)
+    digital_reset["exercise"] = min(200.0, digital_reset["exercise"] + 20.0)
+    risk_digital = compute_risk_from_features(digital_reset)
+
+    # Sleep protocol: +1.5h sleep, -1 stress, -0.5 anxiety
+    sleep_reset = base_features.copy()
+    sleep_reset["sleep"] = min(12.0, sleep_reset["sleep"] + 1.5)
+    sleep_reset["stress"] = max(1.0, sleep_reset["stress"] - 1.0)
+    sleep_reset["anxiety"] = max(1.0, sleep_reset["anxiety"] - 0.5)
+    risk_sleep = compute_risk_from_features(sleep_reset)
+
+    # Holistic plan: combine modest improvements
+    holistic = base_features.copy()
+    holistic["screen"] = max(1.0, holistic["screen"] - 1.5)
+    holistic["sleep"] = min(12.0, holistic["sleep"] + 1.0)
+    holistic["exercise"] = min(200.0, holistic["exercise"] + 25.0)
+    holistic["outdoor"] = min(280.0, holistic["outdoor"] + 30.0)
+    holistic["loneliness"] = max(1.0, holistic["loneliness"] - 1.0)
+    holistic["social_support"] = min(10.0, holistic["social_support"] + 1.0)
+    risk_holistic = compute_risk_from_features(holistic)
+
+    col1, col2, col3 = st.columns(3)
+
+    def render_intervention_card(title: str, risk_new: float):
+        delta = risk_new - scenario_risk
+        color = (
+            "#10b981"
+            if delta < 0
+            else "#f59e0b"
+            if abs(delta) < 0.01
+            else "#ef4444"
+        )
+        sign = "+" if delta >= 0 else "−"
+        st.markdown(
+            f"""
+        <div class='metric-card'>
+            <div class='metric-label'>{title}</div>
+            <div class='metric-value' style='font-size: 2.1rem; color: {color};'>
+                {risk_new:.3f}
+            </div>
+            <div class='metric-change'>
+                Δ risk: {sign}{abs(delta):.3f}
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col1:
+        render_intervention_card(
+            "Digital Reset (−2h screen, −60min social)", risk_digital
+        )
+    with col2:
+        render_intervention_card("Sleep Protocol (+1.5h sleep, ↓ stress)", risk_sleep)
+    with col3:
+        render_intervention_card(
+            "Holistic Plan (screen, sleep, exercise, social)", risk_holistic
+        )
+
+    # Sensitivity curve: risk vs screen time
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 📈 Sensitivity: Risk vs Screen Time (other factors fixed)")
+
+    screen_min = max(1.0, sim_screen - 3.0)
+    screen_max = min(18.0, sim_screen + 3.0)
+    screen_grid = np.linspace(screen_min, screen_max, 40)
+    risk_grid = []
+
+    for s_val in screen_grid:
+        tmp = base_features.copy()
+        tmp["screen"] = float(s_val)
+        risk_grid.append(compute_risk_from_features(tmp))
+
+    fig_sens = go.Figure()
+    fig_sens.add_trace(
+        go.Scatter(
+            x=screen_grid,
+            y=risk_grid,
+            mode="lines",
+            name="Risk vs Screen Time",
+            line=dict(color="#3b82f6", width=4),
+            fill="tozeroy",
+            fillcolor="rgba(59,130,246,0.25)",
+        )
+    )
+    fig_sens.add_vline(
+        x=sim_screen,
+        line_dash="dash",
+        line_color="#f59e0b",
+        line_width=3,
+        annotation_text=f"Current: {sim_screen:.1f}h",
+        annotation_position="top right",
+    )
+    fig_sens.update_layout(
+        height=430,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#ffffff"),
+        xaxis_title="Screen Time (hours/day)",
+        yaxis_title="Predicted Risk",
+    )
+    fig_sens.update_xaxes(showgrid=True, gridcolor="rgba(255,255,255,0.14)")
+    fig_sens.update_yaxes(showgrid=True, gridcolor="rgba(255,255,255,0.14)")
+    st.plotly_chart(fig_sens, use_container_width=True)
+
+    # Recommendations
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 💡 AI-Generated Recommendations")
+
+    recommendations = []
+
+    if sim_screen > 10:
+        recommendations.append(
+            (
+                "danger",
+                "🔴 Screen time is well above healthy limits. Introduce strict boundaries, offline blocks, and app usage limits.",
+            )
+        )
+    elif sim_screen > 8:
+        recommendations.append(
+            (
+                "warning",
+                "🟡 High digital exposure detected. Add app time caps and at least one daily offline block of 60–90 minutes.",
+            )
+        )
+
+    if sim_sleep < 6:
+        recommendations.append(
+            (
+                "danger",
+                "🔴 Severe sleep deficit. Establish a consistent sleep schedule, limit screens before bedtime, and consider medical follow-up if problems persist.",
+            )
+        )
+    elif sim_sleep < 7:
+        recommendations.append(
+            (
+                "warning",
+                "🟡 Sleep is below the recommended range. Aim for 30–60 additional minutes for the next two weeks and track consistency.",
+            )
+        )
+
+    if sim_stress > 7 or sim_anxiety > 7:
+        recommendations.append(
+            (
+                "danger",
+                "🔴 Elevated psychological stress and anxiety. Structured support (for example, counseling or therapy) may be beneficial.",
+            )
+        )
+
+    if sim_exercise < 20:
+        recommendations.append(
+            (
+                "warning",
+                "🟡 Physical activity is low. Target at least 30 minutes of light-to-moderate movement on most days.",
+            )
+        )
+
+    if sim_loneliness > 6:
+        recommendations.append(
+            (
+                "warning",
+                "🟡 Social isolation signals detected. Strengthening connections through community activities or regular check-ins may help.",
+            )
+        )
+
+    if (
+        sim_wellbeing > 7.5
+        and sim_stress < 5.5
+        and sim_exercise > 30
+        and sim_sleep >= 7
+    ):
+        recommendations.append(
+            (
+                "success",
+                "🟢 Overall balance looks healthy. Continue tracking digital habits and maintaining the current protective lifestyle factors.",
+            )
+        )
+
+    if not recommendations:
+        recommendations.append(
+            (
+                "success",
+                "🟢 Metrics are balanced. Maintain current routines and review again after any major lifestyle changes.",
+            )
+        )
+
+    for rec_type, rec_text in recommendations:
+        bg_color = {
+            "danger": "rgba(239,68,68,0.15)",
+            "warning": "rgba(245,158,11,0.15)",
+            "success": "rgba(16,185,129,0.15)",
+        }[rec_type]
+        border_color = {
+            "danger": "#ef4444",
+            "warning": "#f59e0b",
+            "success": "#10b981",
+        }[rec_type]
+        st.markdown(
+            f"""
+        <div style='background: {bg_color}; padding: 15px; border-radius: 10px;
+                    border-left: 4px solid {border_color}; margin: 8px 0;'>
+            <p style='color: white; margin: 0; font-size: 1rem;'>{rec_text}</p>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+# ========================================================
+# TAB 6: Clinical Reports
+# ========================================================
+with tab6:
+    st.markdown(
+        """
+    <div class='section-header'>
+        <div class='section-icon'>🏥</div>
+        <div>
+            <div class='section-title'>Clinical Intelligence Reports</div>
+            <div class='section-subtitle'>High-risk users and summary indicators</div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Top risk users
+    st.markdown("#### 🚨 Critical Risk Users - Priority List")
+
+    if len(plot_df) > 0:
+        top_risk = plot_df.nlargest(
+            30,
+            "risk_score",
+        )[
+            [
+                "user_id",
+                "age",
+                "gender",
+                "occupation",
+                "risk_score",
+                "risk_segment",
+                "screen_hours",
+                "sleep_hours",
+                "stress",
+                "anxiety",
+                "depression",
+                "wellbeing",
+                "social_support",
+                "loneliness",
+                "last_active",
+            ]
+        ].copy()
+
+        top_risk["risk_score"] = top_risk["risk_score"].round(3)
+        top_risk["screen_hours"] = top_risk["screen_hours"].round(1)
+        top_risk["sleep_hours"] = top_risk["sleep_hours"].round(1)
+        top_risk["days_inactive"] = (
+            pd.Timestamp.now() - top_risk["last_active"]
+        ).dt.days
+
+        st.dataframe(
+            top_risk.drop(columns=["last_active"]),
+            use_container_width=True,
+            height=500,
+        )
+
+        # Export high-risk report
+        if st.button(
+            "📄 Export High-Risk Report (CSV)", use_container_width=False
+        ):
+            csv_data = top_risk.to_csv(index=False).encode("utf-8")
+            st.download_button(
+                "⬇️ Download Report",
+                data=csv_data,
+                file_name=f"high_risk_users_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+                mime="text/csv",
+            )
+    else:
+        st.info("No users in current filtered view.")
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Summary statistics
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown("#### Risk Distribution Summary")
+        if len(plot_df) > 0:
+            risk_summary = (
+                plot_df["risk_segment"]
+                .value_counts()
+                .rename_axis("risk_segment")
+                .to_frame("count")
+            )
+            risk_summary["percentage"] = (
+                risk_summary["count"] / len(plot_df) * 100
+            ).round(1)
+            st.dataframe(risk_summary, use_container_width=True)
+        else:
+            st.write("No data available for summary.")
+
+    with col2:
+        st.markdown("#### Mental Health Averages")
+        if len(plot_df) > 0:
+            mental_health_avg = (
+                plot_df[
+                    [
+                        "stress",
+                        "anxiety",
+                        "depression",
+                        "wellbeing",
+                        "mood",
+                        "energy",
+                    ]
+                ]
+                .mean()
+                .round(2)
+                .to_frame(name="Average Score")
+            )
+            st.dataframe(mental_health_avg, use_container_width=True)
+        else:
+            st.write("No data available for summary.")
+
+    with col3:
+        st.markdown("#### Behavioral Metrics")
+        if len(plot_df) > 0:
+            behavior_avg = (
+                plot_df[
+                    [
+                        "screen_hours",
+                        "phone_unlocks",
+                        "notifications",
+                        "social_minutes",
+                        "gaming_minutes",
+                        "exercise_minutes",
+                        "outdoor_time",
+                        "steps_daily",
+                    ]
+                ]
+                .mean()
+                .round(2)
+                .to_frame(name="Average Value")
+            )
+            st.dataframe(behavior_avg, use_container_width=True)
+        else:
+            st.write("No data available for summary.")