Update app.py

app.py

@@ -1,12 +1,11 @@
-
 import streamlit as st
 import numpy as np
 import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import shap
 import matplotlib.pyplot as plt
+
 from datetime import datetime, timedelta
 from sklearn.model_selection import train_test_split
 from sklearn.compose import ColumnTransformer
@@ -16,99 +15,74 @@ from sklearn.ensemble import RandomForestRegressor
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import r2_score, mean_absolute_error
 
-# Enhanced page config
-st.set_page_config(
-    page_title="Profitability Intelligence Suite",
-    page_icon="📊",
-    layout="wide",
-    initial_sidebar_state="collapsed"
-)
+st.set_page_config(page_title="Profitability Intelligence", layout="wide", initial_sidebar_state="collapsed")
 
-# Custom CSS for premium look
+# Custom CSS for better UI
 st.markdown("""
 <style>
     .main-header {
-        font-size: 2.8rem;
+        font-size: 2.5rem;
         font-weight: 700;
         color: #1f77b4;
-        text-align: center;
         margin-bottom: 0.5rem;
-        text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
     }
     .sub-header {
-        font-size: 1.2rem;
+        font-size: 1.1rem;
         color: #666;
-        text-align: center;
         margin-bottom: 2rem;
     }
-    .metric-container {
+    .insight-box {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         padding: 1.5rem;
-        border-radius: 15px;
-        box-shadow: 0 8px 16px rgba(0,0,0,0.1);
+        border-radius: 10px;
         color: white;
-        text-align: center;
-    }
-    .insight-box {
-        background: #f8f9fa;
-        border-left: 5px solid #1f77b4;
-        padding: 1.5rem;
         margin: 1rem 0;
-        border-radius: 8px;
-        box-shadow: 0 4px 8px rgba(0,0,0,0.05);
     }
-    .recommendation-card {
+    .metric-card {
         background: white;
-        border: 2px solid #e9ecef;
-        border-radius: 12px;
         padding: 1.5rem;
-        margin: 1rem 0;
-        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
-        transition: transform 0.2s;
-    }
-    .recommendation-card:hover {
-        transform: translateY(-5px);
-        box-shadow: 0 8px 20px rgba(0,0,0,0.12);
-    }
-    .positive-impact {
-        color: #28a745;
-        font-weight: 700;
-        font-size: 1.5rem;
-    }
-    .negative-impact {
-        color: #dc3545;
-        font-weight: 700;
-        font-size: 1.5rem;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        border-left: 4px solid #1f77b4;
     }
-    .stTabs [data-baseweb="tab-list"] {
-        gap: 2rem;
+    .recommendation-card {
+        background: #f0f9ff;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #22c55e;
+        margin: 0.5rem 0;
     }
-    .stTabs [data-baseweb="tab"] {
-        height: 3rem;
-        font-size: 1.1rem;
-        font-weight: 600;
+    .warning-card {
+        background: #fef3c7;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #f59e0b;
+        margin: 0.5rem 0;
     }
 </style>
 """, unsafe_allow_html=True)
 
 # -----------------------------
-# Data Generation (Same as original)
+# Data Generation (Hidden from UI)
 # -----------------------------
 @st.cache_data(show_spinner=False)
-def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
+def generate_synthetic_data(days=90, seed=42, rows_per_day=800):
     rng = np.random.default_rng(seed)
     start_date = datetime.today().date() - timedelta(days=days)
     dates = pd.date_range(start_date, periods=days, freq="D")
+
     products = ["Premium Widget", "Standard Widget", "Economy Widget", "Deluxe Widget"]
-    regions = ["Americas", "EMEA", "Asia Pacific"]
+    regions = ["North America", "Europe", "Asia Pacific"]
     channels = ["Direct Sales", "Distribution Partners", "E-Commerce"]
 
     base_price = {"Premium Widget": 120, "Standard Widget": 135, "Economy Widget": 110, "Deluxe Widget": 150}
-    base_cost = {"Premium Widget": 70, "Standard Widget": 88, "Economy Widget": 60, "Deluxe Widget": 95}
-    region_price_bump = {"Americas": 1.00, "EMEA": 1.03, "Asia Pacific": 0.97}
-    region_cost_bump = {"Americas": 1.00, "EMEA": 1.02, "Asia Pacific": 1.01}
+    base_cost  = {"Premium Widget": 70,  "Standard Widget": 88,  "Economy Widget": 60,  "Deluxe Widget": 95}
+
+    region_price_bump = {"North America": 1.00, "Europe": 1.03, "Asia Pacific": 0.97}
+    region_cost_bump  = {"North America": 1.00, "Europe": 1.02, "Asia Pacific": 1.01}
+
     channel_discount_mean = {"Direct Sales": 0.06, "Distribution Partners": 0.12, "E-Commerce": 0.04}
-    channel_discount_std = {"Direct Sales": 0.02, "Distribution Partners": 0.03, "E-Commerce": 0.02}
+    channel_discount_std  = {"Direct Sales": 0.02, "Distribution Partners": 0.03, "E-Commerce": 0.02}
 
     seg_epsilon = {}
     for p in products:
@@ -129,17 +103,16 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
 
         n = rows_per_day
         prod = rng.choice(products, size=n, p=[0.35, 0.3, 0.2, 0.15])
-        reg = rng.choice(regions, size=n, p=[0.4, 0.35, 0.25])
-        ch = rng.choice(channels, size=n, p=[0.45, 0.35, 0.20])
+        reg  = rng.choice(regions,  size=n, p=[0.4, 0.35, 0.25])
+        ch   = rng.choice(channels, size=n, p=[0.45, 0.35, 0.20])
 
         base_p = np.array([base_price[x] for x in prod]) * np.array([region_price_bump[x] for x in reg])
-        base_c = np.array([base_cost[x] for x in prod]) * np.array([region_cost_bump[x] for x in reg])
+        base_c = np.array([base_cost[x]  for x in prod]) * np.array([region_cost_bump[x]  for x in reg])
 
         discount = np.clip(
             np.array([channel_discount_mean[x] for x in ch]) +
             rng.normal(0, [channel_discount_std[x] for x in ch]), 0, 0.45
         )
-
         list_price = rng.normal(base_p, 5)
         net_price = np.clip(list_price * (1 - discount), 20, None)
         unit_cost = np.clip(rng.normal(base_c, 4), 10, None)
@@ -150,86 +123,79 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
         qty = np.maximum(1, rng.poisson(8 * dow_mult * macro * qty_mu))
 
         revenue = net_price * qty
-        cogs = unit_cost * qty
-        gm_val = revenue - cogs
-        gm_pct = np.where(revenue > 0, gm_val / revenue, 0.0)
+        cogs    = unit_cost * qty
+        gm_val  = revenue - cogs
+        gm_pct  = np.where(revenue > 0, gm_val / revenue, 0.0)
 
         for i in range(n):
             records.append({
-                "date": d,
-                "product": prod[i],
-                "region": reg[i],
-                "channel": ch[i],
-                "list_price": float(list_price[i]),
-                "discount_pct": float(discount[i]),
-                "net_price": float(net_price[i]),
-                "unit_cost": float(unit_cost[i]),
-                "qty": int(qty[i]),
-                "revenue": float(revenue[i]),
-                "cogs": float(cogs[i]),
-                "gm_value": float(gm_val[i]),
-                "gm_pct": float(gm_pct[i]),
-                "dow": dow
+                "date": d, "product": prod[i], "region": reg[i], "channel": ch[i],
+                "list_price": float(list_price[i]), "discount_pct": float(discount[i]),
+                "net_price": float(net_price[i]), "unit_cost": float(unit_cost[i]),
+                "qty": int(qty[i]), "revenue": float(revenue[i]), "cogs": float(cogs[i]),
+                "gm_value": float(gm_val[i]), "gm_pct": float(gm_pct[i]), "dow": dow
             })
-
-    df = pd.DataFrame(records)
-    return df
+    return pd.DataFrame(records)
 
 def build_features(df: pd.DataFrame):
     feats_num = ["net_price", "unit_cost", "qty", "discount_pct", "list_price", "dow"]
     feats_cat = ["product", "region", "channel"]
+
     df = df.sort_values("date").copy()
     seg = ["product", "region", "channel"]
     df["price_per_unit"] = df["net_price"]
-    df["cost_per_unit"] = df["unit_cost"]
+    df["cost_per_unit"]  = df["unit_cost"]
+
     df["roll7_qty"] = df.groupby(seg)["qty"].transform(lambda s: s.rolling(7, min_periods=1).median())
     df["roll7_price"] = df.groupby(seg)["price_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
-    df["roll7_cost"] = df.groupby(seg)["cost_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
+    df["roll7_cost"]  = df.groupby(seg)["cost_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
+
     feats_num += ["price_per_unit", "cost_per_unit", "roll7_qty", "roll7_price", "roll7_cost"]
-    target = "gm_pct"
-    return df, feats_num, feats_cat, target
+    return df, feats_num, feats_cat, "gm_pct"
 
 @st.cache_resource(show_spinner=False)
 def train_model(df: pd.DataFrame, feats_num, feats_cat, target):
     X = df[feats_num + feats_cat]
     y = df[target]
+
     pre = ColumnTransformer(
         transformers=[
             ("cat", OneHotEncoder(handle_unknown="ignore"), feats_cat),
             ("num", "passthrough", feats_num),
         ]
     )
-    model = RandomForestRegressor(n_estimators=250, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
+    model = RandomForestRegressor(n_estimators=300, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
     pipe = Pipeline([("pre", pre), ("rf", model)])
+
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, shuffle=False)
     pipe.fit(X_train, y_train)
     pred = pipe.predict(X_test)
-    r2 = r2_score(y_test, pred)
-    mae = mean_absolute_error(y_test, pred)
-    return pipe, {"r2": r2, "mae": mae}, X_test
+
+    return pipe, {"r2": r2_score(y_test, pred), "mae": mean_absolute_error(y_test, pred)}, X_test
 
 @st.cache_resource(show_spinner=False)
-def compute_shap(pipe, X_sample, feats_num, feats_cat, shap_sample=800):
-    np.random.seed(42)
-    preprocessor = pipe.named_steps["pre"]
+def compute_shap(pipe, X_sample, feats_num, feats_cat, shap_sample=1000, seed=42):
+    np.random.seed(seed)
+    preproc = pipe.named_steps["pre"]
     rf = pipe.named_steps["rf"]
-    feature_names = list(preprocessor.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
+    feature_names = list(preproc.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
 
     if len(X_sample) > shap_sample:
         sample_idx = np.random.choice(len(X_sample), size=shap_sample, replace=False)
         X_sample = X_sample.iloc[sample_idx]
 
-    X_t = preprocessor.transform(X_sample)
+    X_t = preproc.transform(X_sample)
     try:
         X_t = X_t.toarray()
-    except Exception:
+    except:
         pass
 
     explainer = shap.TreeExplainer(rf)
     shap_values = explainer.shap_values(X_t)
     shap_df = pd.DataFrame(shap_values, columns=feature_names)
-
-    return shap_df, X_sample.reset_index(drop=True), feature_names
+    
+    joined = pd.concat([X_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
+    return shap_df, X_sample.reset_index(drop=True), feature_names, joined
 
 def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
@@ -240,559 +206,350 @@ def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
     lin = LinearRegression().fit(x, y)
     return float(lin.coef_[0]), True
 
-def simulate_pricing_action(segment_df: pd.DataFrame, elasticity, discount_reduction_pct):
+def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
     if segment_df.empty:
         return None
     base = segment_df.iloc[-1]
-    p0 = base["net_price"]
-    c0 = base["unit_cost"]
-    q0 = base["qty"]
-    d0 = base["discount_pct"]
+    p0, c0, q0, d0 = base["net_price"], base["unit_cost"], base["qty"], base["discount_pct"]
 
-    new_discount = np.clip(d0 - (discount_reduction_pct/100), 0.0, 0.45)
+    new_discount = np.clip(d0 + delta_discount, 0.0, 0.45)
     p1 = max(0.01, base["list_price"] * (1 - new_discount))
-    c1 = c0
-
-    if p0 <= 0:
-        q1 = q0
-    else:
-        q1 = max(0.0, q0 * (p1 / p0) ** elasticity)
-
-    rev0 = p0 * q0
-    cogs0 = c0 * q0
-    rev1 = p1 * q1
-    cogs1 = c1 * q1
+    c1 = max(0.01, c0 + delta_unit_cost)
+    q1 = max(0.0, q0 * (p1 / p0) ** elasticity) if p0 > 0 else q0
 
-    gm_delta_value = (rev1 - cogs1) - (rev0 - cogs0)
-    gm0_pct = (rev0 - cogs0)/rev0 if rev0>0 else 0.0
-    gm1_pct = (rev1 - cogs1)/rev1 if rev1>0 else 0.0
+    rev0, cogs0 = p0 * q0, c0 * q0
+    rev1, cogs1 = p1 * q1, c1 * q1
 
     return {
-        "baseline_price": p0, "new_price": p1,
-        "baseline_cost": c0, "new_cost": c1,
-        "baseline_qty": q0, "new_qty": q1,
-        "baseline_discount": d0*100, "new_discount": new_discount*100,
-        "gm_delta_value": gm_delta_value,
-        "gm0_pct": gm0_pct, "gm1_pct": gm1_pct,
-        "revenue_delta": rev1 - rev0
+        "baseline_price": p0, "new_price": p1, "baseline_cost": c0, "new_cost": c1,
+        "baseline_qty": q0, "new_qty": q1, "gm_delta_value": (rev1 - cogs1) - (rev0 - cogs0),
+        "gm0_pct": (rev0 - cogs0)/rev0 if rev0>0 else 0.0,
+        "gm1_pct": (rev1 - cogs1)/rev1 if rev1>0 else 0.0,
+        "new_discount": new_discount
     }
 
 # -----------------------------
-# Main App
+# Initialize Data
 # -----------------------------
+if "data_loaded" not in st.session_state:
+    with st.spinner("🔄 Loading SAP data and building intelligence models..."):
+        df = generate_synthetic_data(days=90, seed=42, rows_per_day=800)
+        df_feat, feats_num, feats_cat, target = build_features(df)
+        pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target)
+        shap_df, X_test_sample, feature_names, joined = compute_shap(pipe, X_test, feats_num, feats_cat)
+        
+        st.session_state["df"] = df
+        st.session_state["df_feat"] = df_feat
+        st.session_state["pipe"] = pipe
+        st.session_state["metrics"] = metrics
+        st.session_state["shap_df"] = shap_df
+        st.session_state["joined"] = joined
+        st.session_state["feats_num"] = feats_num
+        st.session_state["feats_cat"] = feats_cat
+        st.session_state["data_loaded"] = True
+
+df = st.session_state["df"]
+joined = st.session_state["joined"]
+metrics = st.session_state["metrics"]
+shap_df = st.session_state["shap_df"]
 
-# Header
-st.markdown('<h1 class="main-header">🎯 Profitability Intelligence Suite</h1>', unsafe_allow_html=True)
-st.markdown('<p class="sub-header">AI-Powered Margin Analysis & Strategic Recommendations</p>', unsafe_allow_html=True)
-
-# Generate data
-with st.spinner("🔄 Loading business data..."):
-    df = generate_synthetic_data(days=60, seed=42, rows_per_day=600)
-    df_feat, feats_num, feats_cat, target = build_features(df)
-
-# Calculate KPIs
-daily = df.groupby("date").agg(
-    revenue=("revenue","sum"),
-    cogs=("cogs","sum"),
-    gm_value=("gm_value","sum")
-).reset_index()
-daily["gm_pct"] = np.where(daily["revenue"]>0, daily["gm_value"]/daily["revenue"], 0.0)
+# -----------------------------
+# HEADER
+# -----------------------------
+st.markdown('<p class="main-header">💰 Profitability Intelligence Dashboard</p>', unsafe_allow_html=True)
+st.markdown('<p class="sub-header">AI-powered insights to understand and optimize your gross margin drivers</p>', unsafe_allow_html=True)
+
+# -----------------------------
+# EXECUTIVE SUMMARY
+# -----------------------------
+st.markdown("## 📊 Executive Summary")
 
+daily = df.groupby("date").agg(revenue=("revenue","sum"), cogs=("cogs","sum"), gm_value=("gm_value","sum")).reset_index()
+daily["gm_pct"] = np.where(daily["revenue"]>0, daily["gm_value"]/daily["revenue"], 0.0)
 today_row = daily.iloc[-1]
 yesterday_row = daily.iloc[-2] if len(daily) > 1 else today_row
-week_ago_row = daily.iloc[-8] if len(daily) > 7 else today_row
 roll7 = daily["gm_pct"].tail(7).mean()
-
-# Executive Dashboard Section
-st.markdown("### 📊 Executive Performance Dashboard")
+roll30 = daily["gm_pct"].tail(30).mean()
 
 col1, col2, col3, col4 = st.columns(4)
 
 with col1:
-    delta_gm = (today_row["gm_pct"] - yesterday_row["gm_pct"]) * 100
-    st.metric(
-        label="Gross Margin %",
-        value=f"{today_row['gm_pct']*100:.1f}%",
-        delta=f"{delta_gm:+.2f}pp vs yesterday",
-        delta_color="normal"
-    )
+    delta = today_row["gm_pct"] - yesterday_row["gm_pct"]
+    st.metric("Today's Gross Margin %", f"{today_row['gm_pct']*100:.1f}%", 
+              f"{delta*100:+.1f}% vs yesterday")
 
 with col2:
-    delta_rev = ((today_row["revenue"] - yesterday_row["revenue"]) / yesterday_row["revenue"] * 100) if yesterday_row["revenue"] > 0 else 0
-    st.metric(
-        label="Revenue (Today)",
-        value=f"${today_row['revenue']/1e6:.2f}M",
-        delta=f"{delta_rev:+.1f}% DoD",
-        delta_color="normal"
-    )
+    st.metric("Revenue (Today)", f"${today_row['revenue']/1e6:.2f}M")
 
 with col3:
-    st.metric(
-        label="Gross Margin $ (Today)",
-        value=f"${today_row['gm_value']/1e6:.2f}M",
-        delta=f"${(today_row['gm_value'] - yesterday_row['gm_value'])/1e6:+.2f}M",
-        delta_color="normal"
-    )
+    trend = "↗️" if roll7 > roll30 else "↘️"
+    st.metric("7-Day Avg GM%", f"{roll7*100:.1f}%", f"{trend} vs 30-day avg")
 
 with col4:
-    avg_gm_vs_week = (today_row["gm_pct"] - week_ago_row["gm_pct"]) * 100
-    st.metric(
-        label="7-Day Avg GM%",
-        value=f"{roll7*100:.1f}%",
-        delta=f"{avg_gm_vs_week:+.2f}pp WoW",
-        delta_color="normal"
-    )
-
-# Trend visualization
-st.markdown("#### 📈 Performance Trend Analysis")
-
-fig_trends = make_subplots(
-    rows=1, cols=2,
-    subplot_titles=("Gross Margin % Trend", "Revenue & Margin $ Trend"),
-    specs=[[{"secondary_y": False}, {"secondary_y": True}]]
-)
-
-# GM% trend
-fig_trends.add_trace(
-    go.Scatter(
-        x=daily["date"],
-        y=daily["gm_pct"]*100,
-        name="GM%",
-        line=dict(color="#1f77b4", width=3),
-        fill='tozeroy',
-        fillcolor="rgba(31, 119, 180, 0.1)"
-    ),
-    row=1, col=1
-)
-
-# Revenue and GM$ trend
-fig_trends.add_trace(
-    go.Scatter(
-        x=daily["date"],
-        y=daily["revenue"]/1e6,
-        name="Revenue",
-        line=dict(color="#2ca02c", width=2)
-    ),
-    row=1, col=2
-)
-
-fig_trends.add_trace(
-    go.Scatter(
-        x=daily["date"],
-        y=daily["gm_value"]/1e6,
-        name="GM Value",
-        line=dict(color="#ff7f0e", width=2, dash="dash")
-    ),
-    row=1, col=2, secondary_y=True
-)
-
-fig_trends.update_xaxes(title_text="Date", row=1, col=1)
-fig_trends.update_xaxes(title_text="Date", row=1, col=2)
-fig_trends.update_yaxes(title_text="Gross Margin %", row=1, col=1)
-fig_trends.update_yaxes(title_text="Revenue ($M)", row=1, col=2)
-fig_trends.update_yaxes(title_text="GM Value ($M)", row=1, col=2, secondary_y=True)
-
-fig_trends.update_layout(height=400, showlegend=True, hovermode="x unified")
-st.plotly_chart(fig_trends, use_container_width=True)
-
-st.markdown("---")
-
-# Train model
-with st.spinner("🤖 Training AI model..."):
-    pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target)
-
-# Tabs for different sections
-tab1, tab2, tab3 = st.tabs(["🔍 Key Drivers Analysis", "🎯 Strategic Recommendations", "🧪 What-If Simulator"])
-
-with tab1:
-    st.markdown("### Understanding What Drives Your Profitability")
-    st.markdown("""
+    st.metric("Gross Profit (Today)", f"${today_row['gm_value']/1e6:.2f}M")
+
+# Trend chart
+fig_trend = go.Figure()
+fig_trend.add_trace(go.Scatter(x=daily["date"], y=daily["gm_pct"]*100, 
+                               mode='lines', name='Daily GM%', line=dict(color='#1f77b4', width=2)))
+fig_trend.add_trace(go.Scatter(x=daily["date"], y=daily["gm_pct"].rolling(7).mean()*100, 
+                               mode='lines', name='7-Day Average', line=dict(color='#ff7f0e', width=2, dash='dash')))
+fig_trend.update_layout(title="Gross Margin % Trend", xaxis_title="Date", yaxis_title="GM %",
+                       height=300, hovermode='x unified')
+st.plotly_chart(fig_trend, use_container_width=True)
+
+# Key Insight Box
+gm_change = (today_row["gm_pct"] - roll30) * 100
+if abs(gm_change) > 0.5:
+    trend_word = "improved" if gm_change > 0 else "declined"
+    st.markdown(f"""
     <div class="insight-box">
-    <b>🎓 Business Insight:</b> This analysis reveals which business factors have the strongest impact on gross margin.
-    Understanding these drivers helps prioritize strategic initiatives and operational improvements.
+        <h3>💡 Key Insight</h3>
+        <p>Your gross margin has <strong>{trend_word} by {abs(gm_change):.1f} percentage points</strong> compared to the 30-day average. 
+        The analysis below identifies the specific drivers and business segments responsible for this change.</p>
     </div>
     """, unsafe_allow_html=True)
 
-    # Compute SHAP
-    with st.spinner("🔬 Analyzing profitability drivers..."):
-        shap_df, X_test_sample, feature_names = compute_shap(pipe, X_test, feats_num, feats_cat, shap_sample=800)
-
-        # Calculate mean absolute SHAP
-        mean_abs = shap_df.abs().mean().sort_values(ascending=False)
-
-        # Map technical names to business names
-        business_name_map = {
-            "discount_pct": "Discount Level",
-            "unit_cost": "Unit Cost",
-            "net_price": "Net Selling Price",
-            "list_price": "List Price",
-            "qty": "Order Quantity",
-            "price_per_unit": "Price per Unit",
-            "cost_per_unit": "Cost per Unit",
-            "roll7_qty": "7-Day Avg Quantity",
-            "roll7_price": "7-Day Avg Price",
-            "roll7_cost": "7-Day Avg Cost",
-            "dow": "Day of Week"
-        }
-
-        # Get top drivers with business names
-        top_drivers = []
-        for feat, val in mean_abs.head(10).items():
-            bus_name = feat
-            for key, name in business_name_map.items():
-                if key in feat.lower():
-                    bus_name = name
-                    break
-            # Check for product/region/channel encoding
-            if feat.startswith("cat__"):
-                parts = feat.replace("cat__", "").split("_")
-                if "product" in feat.lower():
-                    bus_name = f"Product: {parts[-1] if parts else feat}"
-                elif "region" in feat.lower():
-                    bus_name = f"Region: {parts[-1] if parts else feat}"
-                elif "channel" in feat.lower():
-                    bus_name = f"Channel: {parts[-1] if parts else feat}"
-            top_drivers.append({"Driver": bus_name, "Impact Score": val})
-
-        drivers_df = pd.DataFrame(top_drivers)
-
-    col_a, col_b = st.columns([1, 1])
-
-    with col_a:
-        st.markdown("#### Top 10 Profitability Drivers")
-
-        # Create horizontal bar chart
-        fig_drivers = go.Figure()
-        fig_drivers.add_trace(go.Bar(
-            y=drivers_df["Driver"][::-1],
-            x=drivers_df["Impact Score"][::-1],
-            orientation='h',
-            marker=dict(
-                color=drivers_df["Impact Score"][::-1],
-                colorscale='Blues',
-                line=dict(color='rgb(8,48,107)', width=1.5)
-            ),
-            text=drivers_df["Impact Score"][::-1].round(4),
-            textposition='outside',
-        ))
-
-        fig_drivers.update_layout(
-            title="Ranked by Average Impact on Gross Margin",
-            xaxis_title="Impact Score (higher = stronger influence)",
-            yaxis_title="",
-            height=500,
-            showlegend=False
-        )
-        st.plotly_chart(fig_drivers, use_container_width=True)
+st.markdown("---")
 
-    with col_b:
-        st.markdown("#### Key Insights")
+# -----------------------------
+# DRIVER ANALYSIS
+# -----------------------------
+st.markdown("## 🔍 What's Driving Your Profitability?")
 
-        # Generate business insights
-        top_3 = drivers_df.head(3)
+st.markdown("""
+Our AI model has analyzed thousands of transactions to identify which factors have the biggest impact on your gross margin. 
+Think of this as understanding which levers you can pull to improve profitability.
+""")
+
+# Calculate driver importance
+mean_abs = shap_df.abs().mean().sort_values(ascending=False)
+
+# Simplify feature names for business users
+def simplify_feature_name(name):
+    if "discount" in name.lower():
+        return "Discount Level"
+    elif "cost_per_unit" in name.lower() or "unit_cost" in name.lower():
+        return "Unit Cost"
+    elif "price_per_unit" in name.lower() or "net_price" in name.lower():
+        return "Selling Price"
+    elif "qty" in name.lower():
+        return "Volume"
+    elif "product_" in name.lower():
+        return name.replace("product_", "Product: ")
+    elif "channel_" in name.lower():
+        return name.replace("channel_", "Channel: ")
+    elif "region_" in name.lower():
+        return name.replace("region_", "Region: ")
+    return name
+
+# Top 10 drivers
+top_drivers = mean_abs.head(10)
+driver_names = [simplify_feature_name(f) for f in top_drivers.index]
+
+fig_drivers = go.Figure(go.Bar(
+    y=driver_names[::-1],
+    x=top_drivers.values[::-1],
+    orientation='h',
+    marker=dict(color=top_drivers.values[::-1], colorscale='Blues', showscale=False)
+))
+fig_drivers.update_layout(
+    title="Top 10 Profit Margin Drivers (Impact Strength)",
+    xaxis_title="Impact on Gross Margin",
+    yaxis_title="",
+    height=400,
+    showlegend=False
+)
+st.plotly_chart(fig_drivers, use_container_width=True)
 
-        st.markdown(f"""
-        <div class="insight-box">
-        <b>🥇 Primary Driver:</b> {top_3.iloc[0]['Driver']}<br>
-        <small>This factor has the strongest influence on margin performance</small>
-        </div>
-        """, unsafe_allow_html=True)
+# Business interpretation
+st.markdown("""
+**What does this mean?**
+- **Higher bars** = Bigger impact on your gross margin
+- Focus your attention on the top 3-5 drivers for maximum profitability improvement
+""")
 
-        st.markdown(f"""
-        <div class="insight-box">
-        <b>🥈 Secondary Driver:</b> {top_3.iloc[1]['Driver']}<br>
-        <small>Second most important factor affecting profitability</small>
-        </div>
-        """, unsafe_allow_html=True)
+st.markdown("---")
 
-        st.markdown(f"""
-        <div class="insight-box">
-        <b>🥉 Tertiary Driver:</b> {top_3.iloc[2]['Driver']}<br>
-        <small>Third key factor with significant margin impact</small>
-        </div>
-        """, unsafe_allow_html=True)
+# -----------------------------
+# SEGMENT PERFORMANCE
+# -----------------------------
+st.markdown("## 📍 Performance by Business Segment")
 
-        # Segment-level insights
-        st.markdown("#### Segment Performance")
+st.markdown("Not all business segments perform equally. Here's where you're winning and where there's opportunity:")
 
-        # Join SHAP with original data
-        cat_cols = ["product", "region", "channel"]
-        joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
+# Calculate segment performance
+key_feats = [c for c in joined.columns if any(k in c for k in ["discount", "price_per_unit", "cost_per_unit","unit_cost","net_price"])]
+grp = joined.groupby(["product","region","channel"]).mean(numeric_only=True)
+rank_cols = [c for c in grp.columns if c in key_feats]
+segment_impact = grp[rank_cols].sum(axis=1).sort_values()
 
-        # Find segments with biggest impact
-        grp = joined.groupby(cat_cols).mean(numeric_only=True)
-        key_shap_cols = [c for c in grp.columns if c in shap_df.columns]
-        grp["net_impact"] = grp[key_shap_cols].sum(axis=1)
+col1, col2 = st.columns(2)
 
-        top_negative = grp.nsmallest(5, "net_impact")
-        top_positive = grp.nlargest(5, "net_impact")
+with col1:
+    st.markdown("### 🔴 Segments Dragging Margin Down")
+    worst = segment_impact.head(8)
+    worst_df = pd.DataFrame({
+        'Segment': [f"{p} • {r} • {c}" for p, r, c in worst.index],
+        'Margin Impact': worst.values
+    })
+    worst_df['Impact Score'] = worst_df['Margin Impact'].apply(lambda x: '🔴' * min(5, int(abs(x)*10)))
+    st.dataframe(worst_df[['Segment', 'Impact Score']], hide_index=True, use_container_width=True)
 
-        st.markdown("**⚠️ Segments Reducing Margin:**")
-        for idx, row in top_negative.head(3).iterrows():
-            st.markdown(f"• **{idx[0]}** • {idx[1]} • {idx[2]} *(Impact: {row['net_impact']:.4f})*")
+with col2:
+    st.markdown("### 🟢 Segments Lifting Margin Up")
+    best = segment_impact.tail(8).sort_values(ascending=False)
+    best_df = pd.DataFrame({
+        'Segment': [f"{p} • {r} • {c}" for p, r, c in best.index],
+        'Margin Impact': best.values
+    })
+    best_df['Performance'] = best_df['Margin Impact'].apply(lambda x: '🟢' * min(5, max(1, int(x*10))))
+    st.dataframe(best_df[['Segment', 'Performance']], hide_index=True, use_container_width=True)
 
-        st.markdown("**✅ Segments Boosting Margin:**")
-        for idx, row in top_positive.head(3).iterrows():
-            st.markdown(f"• **{idx[0]}** • {idx[1]} • {idx[2]} *(Impact: {row['net_impact']:.4f})*")
+st.markdown("---")
 
-with tab2:
-    st.markdown("### AI-Generated Strategic Recommendations")
-    st.markdown("""
-    <div class="insight-box">
-    <b>💡 How This Works:</b> The AI identifies segments with margin pressure and suggests specific pricing actions
-    to improve profitability. Recommendations are ranked by expected financial impact.
-    </div>
-    """, unsafe_allow_html=True)
+# -----------------------------
+# WHAT-IF SIMULATOR
+# -----------------------------
+st.markdown("## 🎯 What-If Simulator: Test Your Strategies")
 
-    # Generate recommendations
-    with st.spinner("🧠 Generating strategic recommendations..."):
-        joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
-        joined["key"] = joined["product"] + "|" + joined["region"] + "|" + joined["channel"]
-
-        cand_cols = [c for c in joined.columns if ("discount" in c.lower() or "cost" in c.lower() or "price" in c.lower()) and c in shap_df.columns]
-        seg_scores = joined.groupby("key")[cand_cols].mean().sum(axis=1)
-        worst_keys = seg_scores.sort_values().head(15).index.tolist()
-
-        recs = []
-        for key in worst_keys:
-            p, r, c = key.split("|")
-            hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
-            if hist.empty or len(hist) < 50:
-                continue
-
-            eps, _ = estimate_segment_elasticity(hist, p, r, c)
-
-            # Suggest discount reduction between 1-3 percentage points
-            prop_disc_pts = np.clip(abs(seg_scores[key])*10, 1.0, 3.0)
-            sim = simulate_pricing_action(hist, eps, prop_disc_pts)
-
-            if sim is None or sim["gm_delta_value"] <= 0:
-                continue
-
-            # Calculate annualized impact (rough estimate)
-            daily_transactions = len(hist) / ((hist["date"].max() - hist["date"].min()).days + 1)
-            annual_impact = sim["gm_delta_value"] * daily_transactions * 365
-
-            recs.append({
-                "Segment": f"{p}",
-                "Region": r,
-                "Channel": c,
-                "Current Discount": f"{sim['baseline_discount']:.1f}%",
-                "Recommended Discount": f"{sim['new_discount']:.1f}%",
-                "Expected GM Uplift": sim["gm_delta_value"],
-                "Annual Impact Estimate": annual_impact,
-                "Current GM%": sim["gm0_pct"]*100,
-                "Projected GM%": sim["gm1_pct"]*100,
-                "Price Elasticity": eps
-            })
+st.markdown("""
+Use this simulator to model the financial impact of potential pricing or cost optimization strategies. 
+Select a segment and adjust the levers to see the projected outcome.
+""")
 
-        recs_df = pd.DataFrame(recs).sort_values("Expected GM Uplift", ascending=False)
-
-    if len(recs_df) > 0:
-        # Show top 3 recommendations in cards
-        st.markdown("#### 🏆 Top 3 Priority Actions")
-
-        for i, (idx, rec) in enumerate(recs_df.head(3).iterrows()):
-            with st.container():
-                st.markdown(f"""
-                <div class="recommendation-card">
-                    <h4>#{i+1}: {rec['Segment']} • {rec['Region']} • {rec['Channel']}</h4>
-                    <p style="font-size: 1.1rem; margin: 0.5rem 0;">
-                        <b>Recommended Action:</b> Reduce discount from <b>{rec['Current Discount']}</b> to <b>{rec['Recommended Discount']}</b>
-                    </p>
-                    <p style="font-size: 1rem; color: #666; margin: 0.5rem 0;">
-                        Current GM: <b>{rec['Current GM%']:.1f}%</b> → Projected GM: <b style="color: #28a745;">{rec['Projected GM%']:.1f}%</b>
-                    </p>
-                    <p class="positive-impact">
-                        💰 Expected Daily Impact: ${rec['Expected GM Uplift']:.2f}
-                    </p>
-                    <p style="font-size: 0.95rem; color: #666;">
-                        📊 Estimated Annual Impact: <b>${rec['Annual Impact Estimate']/1e3:.1f}K</b>
-                    </p>
-                </div>
-                """, unsafe_allow_html=True)
-
-        st.markdown("---")
-        st.markdown("#### 📋 Complete Recommendations List")
-
-        # Format for display
-        display_df = recs_df.copy()
-        display_df["Expected GM Uplift"] = display_df["Expected GM Uplift"].apply(lambda x: f"${x:.2f}")
-        display_df["Annual Impact Estimate"] = display_df["Annual Impact Estimate"].apply(lambda x: f"${x/1e3:.1f}K")
-        display_df["Current GM%"] = display_df["Current GM%"].apply(lambda x: f"{x:.1f}%")
-        display_df["Projected GM%"] = display_df["Projected GM%"].apply(lambda x: f"{x:.1f}%")
-        display_df["Price Elasticity"] = display_df["Price Elasticity"].apply(lambda x: f"{x:.2f}")
-
-        st.dataframe(display_df, use_container_width=True, height=400)
-
-        # Download button
-        st.download_button(
-            label="📥 Download Full Recommendations (CSV)",
-            data=recs_df.to_csv(index=False).encode("utf-8"),
-            file_name=f"profitability_recommendations_{datetime.today().strftime('%Y%m%d')}.csv",
-            mime="text/csv"
-        )
+# Segment selector
+last_day = df["date"].max()
+seg_today = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates().sort_values(["product","region","channel"])
+seg_options = seg_today.apply(lambda r: f"{r['product']} • {r['region']} • {r['channel']}", axis=1).tolist()
 
-        # Aggregate impact
-        total_daily_impact = recs_df["Expected GM Uplift"].sum()
-        total_annual_impact = recs_df["Annual Impact Estimate"].sum()
+col1, col2 = st.columns([2, 1])
 
+with col1:
+    selected_segment = st.selectbox("**Select Business Segment:**", seg_options, key="segment_selector")
+
+with col2:
+    st.markdown("**Scenario Type:**")
+    scenario = st.radio("", ["Optimize Discount", "Reduce Costs", "Custom"], horizontal=True, label_visibility="collapsed")
+
+prod_sel, reg_sel, ch_sel = [s.strip() for s in selected_segment.split("•")]
+seg_hist = df[(df["product"]==prod_sel)&(df["region"]==reg_sel)&(df["channel"]==ch_sel)].sort_values("date")
+elasticity, _ = estimate_segment_elasticity(seg_hist, prod_sel, reg_sel, ch_sel)
+
+# Pre-set scenarios
+if scenario == "Optimize Discount":
+    delta_disc = -2.0
+    delta_cost = 0.0
+    st.info("📉 Testing a 2 percentage point discount reduction to improve margin")
+elif scenario == "Reduce Costs":
+    delta_disc = 0.0
+    delta_cost = -3.0
+    st.info("💰 Testing a $3 reduction in unit cost through operational efficiency")
+else:
+    col1, col2 = st.columns(2)
+    with col1:
+        delta_disc = st.slider("Adjust Discount (percentage points)", -10.0, 10.0, -2.0, 0.5, 
+                               help="Negative = tighter discount, Positive = deeper discount")
+    with col2:
+        delta_cost = st.slider("Adjust Unit Cost ($)", -10.0, 10.0, 0.0, 0.5,
+                              help="Negative = cost reduction, Positive = cost increase")
+
+# Run simulation
+sim_res = simulate_action(seg_hist, elasticity, delta_discount=delta_disc/100.0, delta_unit_cost=delta_cost)
+
+if sim_res:
+    st.markdown("### 📈 Projected Impact")
+    
+    # Results in clean columns
+    metric_col1, metric_col2, metric_col3, metric_col4 = st.columns(4)
+    
+    with metric_col1:
+        price_change = ((sim_res['new_price'] - sim_res['baseline_price']) / sim_res['baseline_price']) * 100
+        st.metric("Price per Unit", f"${sim_res['new_price']:.2f}", f"{price_change:+.1f}%")
+    
+    with metric_col2:
+        cost_change = ((sim_res['new_cost'] - sim_res['baseline_cost']) / sim_res['baseline_cost']) * 100
+        st.metric("Cost per Unit", f"${sim_res['new_cost']:.2f}", f"{cost_change:+.1f}%")
+    
+    with metric_col3:
+        qty_change = ((sim_res['new_qty'] - sim_res['baseline_qty']) / sim_res['baseline_qty']) * 100
+        st.metric("Volume", f"{sim_res['new_qty']:.0f} units", f"{qty_change:+.1f}%")
+    
+    with metric_col4:
+        gm_change = (sim_res['gm1_pct'] - sim_res['gm0_pct']) * 100
+        st.metric("Gross Margin %", f"{sim_res['gm1_pct']*100:.1f}%", f"{gm_change:+.1f} pts")
+    
+    # Financial impact
+    if sim_res['gm_delta_value'] > 0:
         st.markdown(f"""
-        <div class="insight-box" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none;">
-            <h3 style="color: white; margin-top: 0;">💎 Total Opportunity</h3>
-            <p style="font-size: 1.3rem; margin: 0.5rem 0;">
-                <b>Daily GM Impact:</b> ${total_daily_impact:.2f}
-            </p>
-            <p style="font-size: 1.6rem; margin: 0.5rem 0;">
-                <b>Estimated Annual Impact:</b> ${total_annual_impact/1e6:.2f}M
-            </p>
-            <small>Based on current transaction volumes and assuming consistent implementation</small>
+        <div class="recommendation-card">
+            <h4>✅ Positive Impact: +${sim_res['gm_delta_value']:.2f} in daily gross profit</h4>
+            <p>This strategy would <strong>improve profitability</strong> for this segment. 
+            Expected price elasticity of {elasticity:.2f} means volume {('decreases' if elasticity < 0 and delta_disc < 0 else 'adjusts')} 
+            as prices change, but margin improvement outweighs volume impact.</p>
         </div>
         """, unsafe_allow_html=True)
     else:
-        st.info("No significant optimization opportunities detected in current data.")
-
-with tab3:
-    st.markdown("### Custom What-If Analysis")
-    st.markdown("""
-    <div class="insight-box">
-    <b>🧪 Interactive Simulation:</b> Test different pricing strategies for specific segments to understand
-    the potential impact on revenue, volume, and profitability.
-    </div>
-    """, unsafe_allow_html=True)
-
-    # Segment selector
-    last_day = df["date"].max()
-    seg_today = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates()
-
-    col_sim1, col_sim2, col_sim3 = st.columns(3)
-
-    with col_sim1:
-        selected_product = st.selectbox("📦 Select Product", sorted(seg_today["product"].unique()))
-    with col_sim2:
-        selected_region = st.selectbox("🌍 Select Region", sorted(seg_today["region"].unique()))
-    with col_sim3:
-        selected_channel = st.selectbox("🛒 Select Channel", sorted(seg_today["channel"].unique()))
-
-    # Get segment history
-    seg_hist = df[
-        (df["product"]==selected_product) &
-        (df["region"]==selected_region) &
-        (df["channel"]==selected_channel)
-    ].sort_values("date")
-
-    if not seg_hist.empty and len(seg_hist) >= 50:
-        elasticity, _ = estimate_segment_elasticity(seg_hist, selected_product, selected_region, selected_channel)
-
-        # Current state
-        current = seg_hist.iloc[-1]
-
         st.markdown(f"""
-        <div class="insight-box">
-        <b>📊 Current State:</b><br>
-        • Current Discount: <b>{current['discount_pct']*100:.1f}%</b><br>
-        • Net Price: <b>${current['net_price']:.2f}</b><br>
-        • Unit Cost: <b>${current['unit_cost']:.2f}</b><br>
-        • Avg Daily Volume: <b>{seg_hist.tail(7)['qty'].mean():.0f} units</b><br>
-        • Current GM%: <b>{current['gm_pct']*100:.1f}%</b><br>
-        • Price Elasticity: <b>{elasticity:.2f}</b> <small>(% change in volume per 1% price change)</small>
+        <div class="warning-card">
+            <h4>⚠️ Negative Impact: ${sim_res['gm_delta_value']:.2f} in daily gross profit</h4>
+            <p>This strategy would <strong>reduce profitability</strong> for this segment. 
+            Consider alternative approaches or test smaller adjustments.</p>
         </div>
         """, unsafe_allow_html=True)
 
-        st.markdown("#### 🎯 Test Pricing Strategy")
-
-        # Pricing strategy slider
-        discount_change = st.slider(
-            "Adjust Discount Level (percentage points)",
-            min_value=-10.0,
-            max_value=5.0,
-            value=0.0,
-            step=0.5,
-            help="Negative values reduce discount (increase price), positive values increase discount"
-        )
+st.markdown("---")
 
-        if discount_change != 0:
-            sim = simulate_pricing_action(seg_hist, elasticity, -discount_change)
-
-            if sim:
-                # Visualization
-                col_res1, col_res2 = st.columns(2)
-
-                with col_res1:
-                    # Create comparison chart
-                    comparison_data = pd.DataFrame({
-                        'Metric': ['Price', 'Volume', 'GM%'],
-                        'Current': [sim['baseline_price'], sim['baseline_qty'], sim['gm0_pct']*100],
-                        'Projected': [sim['new_price'], sim['new_qty'], sim['gm1_pct']*100]
-                    })
-
-                    fig_comp = go.Figure()
-                    fig_comp.add_trace(go.Bar(
-                        name='Current',
-                        x=comparison_data['Metric'],
-                        y=comparison_data['Current'],
-                        marker_color='#94a3b8'
-                    ))
-                    fig_comp.add_trace(go.Bar(
-                        name='Projected',
-                        x=comparison_data['Metric'],
-                        y=comparison_data['Projected'],
-                        marker_color='#3b82f6'
-                    ))
-
-                    fig_comp.update_layout(
-                        title="Current vs. Projected Performance",
-                        barmode='group',
-                        height=350
-                    )
-                    st.plotly_chart(fig_comp, use_container_width=True)
-
-                with col_res2:
-                    st.markdown("#### 📈 Simulation Results")
-
-                    gm_change = sim['gm1_pct'] - sim['gm0_pct']
-                    rev_change_pct = (sim['revenue_delta'] / (sim['baseline_price'] * sim['baseline_qty'])) * 100 if sim['baseline_price'] * sim['baseline_qty'] > 0 else 0
-                    vol_change_pct = ((sim['new_qty'] - sim['baseline_qty']) / sim['baseline_qty']) * 100 if sim['baseline_qty'] > 0 else 0
-
-                    st.metric(
-                        "Gross Margin Impact",
-                        f"{sim['gm1_pct']*100:.1f}%",
-                        f"{gm_change*100:+.1f}pp"
-                    )
-
-                    st.metric(
-                        "Revenue Impact",
-                        f"${sim['new_price'] * sim['new_qty']:.2f}",
-                        f"{rev_change_pct:+.1f}%"
-                    )
-
-                    st.metric(
-                        "Volume Impact",
-                        f"{sim['new_qty']:.0f} units",
-                        f"{vol_change_pct:+.1f}%"
-                    )
-
-                    # Daily P&L impact
-                    st.markdown(f"""
-                    <div class="insight-box" style="margin-top: 1rem;">
-                    <b>💰 Daily P&L Impact:</b><br>
-                    <span style="font-size: 1.5rem; {'color: #28a745' if sim['gm_delta_value'] > 0 else 'color: #dc3545'}">
-                    ${sim['gm_delta_value']:+.2f}
-                    </span>
-                    </div>
-                    """, unsafe_allow_html=True)
-        else:
-            st.info("👆 Adjust the discount slider above to simulate different pricing strategies")
+# -----------------------------
+# AI RECOMMENDATIONS
+# -----------------------------
+st.markdown("## 💡 AI-Powered Recommendations")
 
-    else:
-        st.warning("⚠️ Insufficient data for selected segment. Please choose a different combination.")
+st.markdown("""
+Based on the analysis of all segments, here are the top opportunities to improve profitability. 
+These recommendations are ranked by expected financial impact.
+""")
+
+# Generate recommendations
+worst_keys = segment_impact.head(20).index.tolist()
+recs = []
+for p, r, c in worst_keys:
+    hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
+    if hist.empty:
+        continue
+    eps, _ = estimate_segment_elasticity(hist, p, r, c)
+    prop_disc_pts = -np.clip(abs(segment_impact[(p,r,c)])*10, 0.5, 3.0)
+    sim = simulate_action(hist, eps, delta_discount=prop_disc_pts/100.0, delta_unit_cost=0.0)
+    if sim and sim["gm_delta_value"] > 0:
+        recs.append({
+            "Segment": f"{p} • {r} • {c}",
+            "Recommended Action": f"Reduce discount by {abs(prop_disc_pts):.1f}%",
+            "Expected Daily Uplift": f"${sim['gm_delta_value']:.2f}",
+            "New Margin %": f"{sim['gm1_pct']*100:.1f}%",
+            "Risk Level": "Low" if abs(eps) < 0.5 else "Medium"
+        })
+
+rec_df = pd.DataFrame(recs).sort_values("Expected Daily Uplift", ascending=False).head(10)
+
+if not rec_df.empty:
+    st.dataframe(rec_df, hide_index=True, use_container_width=True)
+    
+    total_potential = rec_df["Expected Daily Uplift"].str.replace("$", "").astype(float).sum()
+    st.success(f"🎯 **Total Daily Profit Opportunity: ${total_potential:.2f}** | Annualized: ${total_potential * 365:,.0f}")
+    
+    # Download button
+    csv = rec_df.to_csv(index=False).encode('utf-8')
+    st.download_button(
+        label="📥 Download Full Recommendations (CSV)",
+        data=csv,
+        file_name=f"profitability_recommendations_{datetime.now().strftime('%Y%m%d')}.csv",
+        mime="text/csv"
+    )
+else:
+    st.info("No high-confidence recommendations available at this time. Current segment performance is well-optimized.")
 
 st.markdown("---")
-st.markdown("""
-<div style="text-align: center; color: #666; padding: 2rem 0;">
-    <small>
-    🔒 Demo Mode: Using synthetic SAP-style data for illustration purposes<br>
-    For production deployment, connect to live SAP S/4HANA CDS views or data warehouse
-    </small>
-</div>
-""", unsafe_allow_html=True)
+
+# Footer
+st.caption("🔒 **Demo Environment** | Data shown is synthetic for demonstration. Connect to your SAP system for live insights.")
+st.caption(f"Model Performance: R² = {metrics['r2']:.3f} | Analyzing {len(df):,} transactions across {len(df['product'].unique())} products")