Update app.py

app.py

@@ -3,9 +3,9 @@ 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
@@ -14,75 +14,89 @@ from sklearn.pipeline import Pipeline
 from sklearn.ensemble import RandomForestRegressor
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import r2_score, mean_absolute_error
+import warnings
+warnings.filterwarnings('ignore')
+
+# 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 better UI
+# Custom CSS for premium look
 st.markdown("""
 <style>
     .main-header {
-        font-size: 2.5rem;
+        font-size: 2.8rem;
         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.1rem;
+        font-size: 1.2rem;
         color: #666;
+        text-align: center;
         margin-bottom: 2rem;
     }
     .insight-box {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        background: #f8f9fa;
+        border-left: 5px solid #1f77b4;
         padding: 1.5rem;
-        border-radius: 10px;
-        color: white;
         margin: 1rem 0;
+        border-radius: 8px;
+        box-shadow: 0 4px 8px rgba(0,0,0,0.05);
     }
-    .metric-card {
+    .recommendation-card {
         background: white;
+        border: 2px solid #e9ecef;
+        border-radius: 12px;
         padding: 1.5rem;
-        border-radius: 8px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        border-left: 4px solid #1f77b4;
+        margin: 1rem 0;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+        transition: transform 0.2s;
     }
-    .recommendation-card {
-        background: #f0f9ff;
-        padding: 1rem;
-        border-radius: 8px;
-        border-left: 4px solid #22c55e;
-        margin: 0.5rem 0;
+    .recommendation-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 8px 20px rgba(0,0,0,0.12);
     }
-    .warning-card {
-        background: #fef3c7;
-        padding: 1rem;
-        border-radius: 8px;
-        border-left: 4px solid #f59e0b;
-        margin: 0.5rem 0;
+    .positive-impact {
+        color: #28a745;
+        font-weight: 700;
+        font-size: 1.5rem;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 3rem;
+        font-size: 1.1rem;
+        font-weight: 600;
     }
 </style>
 """, unsafe_allow_html=True)
 
 # -----------------------------
-# Data Generation (Hidden from UI)
+# Data Generation
 # -----------------------------
 @st.cache_data(show_spinner=False)
-def generate_synthetic_data(days=90, seed=42, rows_per_day=800):
+def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     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 = ["North America", "Europe", "Asia Pacific"]
+    regions = ["Americas", "EMEA", "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 = {"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}
-
+    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}
     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:
@@ -103,16 +117,17 @@ def generate_synthetic_data(days=90, seed=42, rows_per_day=800):
 
         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)
@@ -123,433 +138,636 @@ def generate_synthetic_data(days=90, seed=42, rows_per_day=800):
         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
             })
-    return pd.DataFrame(records)
 
-def build_features(df: pd.DataFrame):
+    df = pd.DataFrame(records)
+    return df
+
+@st.cache_data(show_spinner=False)
+def build_features(_df):
+    df = _df.copy()
     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"]
-    return df, feats_num, feats_cat, "gm_pct"
+    target = "gm_pct"
+    return df, feats_num, feats_cat, target
 
 @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]
-
+def train_model(feats_num, feats_cat, target, _X, _y):
     pre = ColumnTransformer(
         transformers=[
             ("cat", OneHotEncoder(handle_unknown="ignore"), feats_cat),
             ("num", "passthrough", feats_num),
         ]
     )
-    model = RandomForestRegressor(n_estimators=300, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
+    model = RandomForestRegressor(n_estimators=100, max_depth=10, random_state=42, n_jobs=-1)
     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)
+    X_train, X_test, y_train, y_test = train_test_split(_X, _y, test_size=0.25, shuffle=False, random_state=42)
     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_data(show_spinner=False)
+def compute_shap_values(_pipe, _X_sample, feats_num, feats_cat, shap_sample=500):
+    try:
+        np.random.seed(42)
+        # Get sample
+        X_sample = _X_sample.copy() if hasattr(_X_sample, 'copy') else pd.DataFrame(_X_sample)
 
-@st.cache_resource(show_spinner=False)
-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(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]
 
-    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]
+        # Transform data
+        X_t = _pipe.named_steps["pre"].transform(X_sample)
+        if hasattr(X_t, 'toarray'):
+            X_t = X_t.toarray()
 
-    X_t = preproc.transform(X_sample)
-    try:
-        X_t = X_t.toarray()
-    except:
-        pass
+        # Get feature names
+        cat_features = list(_pipe.named_steps["pre"].named_transformers_["cat"].get_feature_names_out(feats_cat))
+        feature_names = cat_features + feats_num
+
+        # Compute SHAP
+        explainer = shap.TreeExplainer(_pipe.named_steps["rf"])
+        shap_values = explainer.shap_values(X_t)
+
+        # Create DataFrame
+        shap_df = pd.DataFrame(shap_values, columns=feature_names)
 
-    explainer = shap.TreeExplainer(rf)
-    shap_values = explainer.shap_values(X_t)
-    shap_df = pd.DataFrame(shap_values, columns=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
+        return shap_df, X_sample.reset_index(drop=True), feature_names
+    except Exception as e:
+        st.error(f"Error computing SHAP: {str(e)}")
+        return None, None, None
 
-def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
+def estimate_segment_elasticity(df, product, region, channel):
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
     if len(seg_df) < 100 or seg_df["net_price"].std() < 1e-6 or seg_df["qty"].std() < 1e-6:
         return -0.5, False
-    x = np.log(np.clip(seg_df["net_price"].values, 1e-6, None)).reshape(-1,1)
-    y = np.log(np.clip(seg_df["qty"].values, 1e-6, None))
-    lin = LinearRegression().fit(x, y)
-    return float(lin.coef_[0]), True
+    try:
+        x = np.log(np.clip(seg_df["net_price"].values, 1e-6, None)).reshape(-1,1)
+        y = np.log(np.clip(seg_df["qty"].values, 1e-6, None))
+        lin = LinearRegression().fit(x, y)
+        return float(lin.coef_[0]), True
+    except:
+        return -0.5, False
 
-def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
+def simulate_pricing_action(segment_df, elasticity, discount_reduction_pct):
     if segment_df.empty:
         return None
-    base = segment_df.iloc[-1]
-    p0, c0, q0, d0 = base["net_price"], base["unit_cost"], base["qty"], base["discount_pct"]
-
-    new_discount = np.clip(d0 + delta_discount, 0.0, 0.45)
-    p1 = max(0.01, base["list_price"] * (1 - new_discount))
-    c1 = max(0.01, c0 + delta_unit_cost)
-    q1 = max(0.0, q0 * (p1 / p0) ** elasticity) if p0 > 0 else q0
-
-    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, "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
-    }
-
-# -----------------------------
-# 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('<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)
+    try:
+        base = segment_df.iloc[-1]
+        p0 = base["net_price"]
+        c0 = base["unit_cost"]
+        q0 = base["qty"]
+        d0 = base["discount_pct"]
+
+        new_discount = np.clip(d0 - (discount_reduction_pct/100), 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
+
+        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
+
+        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
+        }
+    except:
+        return None
 
 # -----------------------------
-# EXECUTIVE SUMMARY
+# Main App
 # -----------------------------
-st.markdown("## 📊 Executive Summary")
 
-daily = df.groupby("date").agg(revenue=("revenue","sum"), cogs=("cogs","sum"), gm_value=("gm_value","sum")).reset_index()
+# 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)
+
 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()
-roll30 = daily["gm_pct"].tail(30).mean()
+
+# Executive Dashboard Section
+st.markdown("### 📊 Executive Performance Dashboard")
 
 col1, col2, col3, col4 = st.columns(4)
 
 with col1:
-    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")
+    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"
+    )
 
 with col2:
-    st.metric("Revenue (Today)", f"${today_row['revenue']/1e6:.2f}M")
+    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"
+    )
 
 with col3:
-    trend = "↗️" if roll7 > roll30 else "↘️"
-    st.metric("7-Day Avg GM%", f"{roll7*100:.1f}%", f"{trend} vs 30-day avg")
+    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"
+    )
 
 with col4:
-    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">
-        <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)
+    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"
+    )
 
-st.markdown("---")
+# Trend visualization
+st.markdown("#### 📈 Performance Trend Analysis")
 
-# -----------------------------
-# DRIVER ANALYSIS
-# -----------------------------
-st.markdown("## 🔍 What's Driving Your Profitability?")
+fig_trends = make_subplots(
+    rows=1, cols=2,
+    subplot_titles=("Gross Margin % Trend", "Revenue & Margin $ Trend"),
+    specs=[[{"secondary_y": False}, {"secondary_y": True}]]
+)
 
-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
+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
 )
-st.plotly_chart(fig_drivers, use_container_width=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
-""")
+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("---")
 
-# -----------------------------
-# SEGMENT PERFORMANCE
-# -----------------------------
-st.markdown("## 📍 Performance by Business Segment")
+# Train model
+with st.spinner("🤖 Training AI model..."):
+    X = df_feat[feats_num + feats_cat].copy()
+    y = df_feat[target].copy()
+    pipe, metrics, X_test = train_model(feats_num, feats_cat, target, X, y)
+    st.success(f"✅ Model trained: R² = {metrics['r2']:.3f}, MAE = {metrics['mae']:.4f}")
 
-st.markdown("Not all business segments perform equally. Here's where you're winning and where there's opportunity:")
+# Compute SHAP once for all tabs
+with st.spinner("🔬 Analyzing profitability drivers..."):
+    shap_df, X_test_sample, feature_names = compute_shap_values(pipe, X_test, feats_num, feats_cat, shap_sample=500)
 
-# 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()
+# Tabs for different sections
+tab1, tab2, tab3 = st.tabs(["🔍 Key Drivers Analysis", "🎯 Strategic Recommendations", "🧪 What-If Simulator"])
 
-col1, col2 = st.columns(2)
+with tab1:
+    st.markdown("### Understanding What Drives Your Profitability")
+    st.markdown("""
+    <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.
+    </div>
+    """, unsafe_allow_html=True)
 
-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)
+    if shap_df is not None and X_test_sample is not None:
+        # 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
+            if feat.startswith("cat__"):
+                parts = feat.replace("cat__", "").replace("product_", "").replace("region_", "").replace("channel_", "")
+                if "product" in feat.lower():
+                    bus_name = f"Product: {parts}"
+                elif "region" in feat.lower():
+                    bus_name = f"Region: {parts}"
+                elif "channel" in feat.lower():
+                    bus_name = f"Channel: {parts}"
+            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")
+
+            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=[f"{v:.4f}" for v in drivers_df["Impact Score"][::-1]],
+                textposition='outside',
+            ))
+
+            fig_drivers.update_layout(
+                title="Ranked by Average Impact on Gross Margin",
+                xaxis_title="Impact Score",
+                yaxis_title="",
+                height=500,
+                showlegend=False
+            )
+            st.plotly_chart(fig_drivers, use_container_width=True)
+
+        with col_b:
+            st.markdown("#### Key Insights")
+
+            top_3 = drivers_df.head(3)
+
+            st.markdown(f"""
+            <div class="insight-box">
+            <b>🥇 Primary Driver:</b> {top_3.iloc[0]['Driver']}<br>
+            <small>Impact Score: {top_3.iloc[0]['Impact Score']:.4f}</small>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.markdown(f"""
+            <div class="insight-box">
+            <b>🥈 Secondary Driver:</b> {top_3.iloc[1]['Driver']}<br>
+            <small>Impact Score: {top_3.iloc[1]['Impact Score']:.4f}</small>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.markdown(f"""
+            <div class="insight-box">
+            <b>🥉 Tertiary Driver:</b> {top_3.iloc[2]['Driver']}<br>
+            <small>Impact Score: {top_3.iloc[2]['Impact Score']:.4f}</small>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.markdown("#### Segment Performance")
+
+            # Safely join SHAP with original data
+            try:
+                cat_cols = ["product", "region", "channel"]
+                joined = pd.concat([X_test_sample[cat_cols].reset_index(drop=True), 
+                                  shap_df.reset_index(drop=True)], axis=1)
+
+                grp = joined.groupby(cat_cols, as_index=False).mean(numeric_only=True)
+                key_shap_cols = [c for c in shap_df.columns if c in grp.columns]
+                grp["net_impact"] = grp[key_shap_cols].sum(axis=1)
+
+                top_negative = grp.nsmallest(5, "net_impact")
+                top_positive = grp.nlargest(5, "net_impact")
+
+                st.markdown("**⚠️ Segments Reducing Margin:**")
+                for _, row in top_negative.head(3).iterrows():
+                    st.markdown(f"• **{row['product']}** • {row['region']} • {row['channel']} *(Impact: {row['net_impact']:.4f})*")
+
+                st.markdown("**✅ Segments Boosting Margin:**")
+                for _, row in top_positive.head(3).iterrows():
+                    st.markdown(f"• **{row['product']}** • {row['region']} • {row['channel']} *(Impact: {row['net_impact']:.4f})*")
+            except Exception as e:
+                st.warning(f"Unable to compute segment analysis: {str(e)}")
+    else:
+        st.error("Unable to compute driver analysis. Please check your data.")
 
-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)
+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)
 
-st.markdown("---")
+    if shap_df is not None and X_test_sample is not None:
+        with st.spinner("🧠 Generating strategic recommendations..."):
+            try:
+                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)
+                    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
+
+                    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
+                    })
+
+                recs_df = pd.DataFrame(recs).sort_values("Expected GM Uplift", ascending=False)
+
+                if len(recs_df) > 0:
+                    st.markdown("#### 🏆 Top 3 Priority Actions")
+
+                    for i, (idx, rec) in enumerate(recs_df.head(3).iterrows()):
+                        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")
+                    st.dataframe(recs_df, use_container_width=True, height=400)
+
+                    total_daily_impact = recs_df["Expected GM Uplift"].sum()
+                    total_annual_impact = recs_df["Annual Impact Estimate"].sum()
+
+                    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>
+                    </div>
+                    """, unsafe_allow_html=True)
+                else:
+                    st.info("No significant optimization opportunities detected in current data.")
+            except Exception as e:
+                st.error(f"Error generating recommendations: {str(e)}")
+    else:
+        st.error("Unable to generate recommendations. Please check your data.")
 
-# -----------------------------
-# WHAT-IF SIMULATOR
-# -----------------------------
-st.markdown("## 🎯 What-If Simulator: Test Your Strategies")
+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)
 
-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.
-""")
+    last_day = df["date"].max()
+    seg_today = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates()
 
-# 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()
+    col_sim1, col_sim2, col_sim3 = st.columns(3)
 
-col1, col2 = st.columns([2, 1])
+    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()))
 
-with col1:
-    selected_segment = st.selectbox("**Select Business Segment:**", seg_options, key="segment_selector")
+    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 = seg_hist.iloc[-1]
 
-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="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.markdown(f"""
-        <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 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>
         </div>
         """, unsafe_allow_html=True)
 
-st.markdown("---")
+        st.markdown("#### 🎯 Test Pricing Strategy")
 
-# -----------------------------
-# AI RECOMMENDATIONS
-# -----------------------------
-st.markdown("## 💡 AI-Powered Recommendations")
+        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)"
+        )
 
-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.")
+        if discount_change != 0:
+            sim = simulate_pricing_action(seg_hist, elasticity, -discount_change)
+
+            if sim:
+                col_res1, col_res2 = st.columns(2)
+
+                with col_res1:
+                    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']
+
+                    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"${sim['revenue_delta']:+.2f}"
+                    )
+
+                    vol_change = sim['new_qty'] - sim['baseline_qty']
+                    st.metric(
+                        "Volume Impact",
+                        f"{sim['new_qty']:.0f} units",
+                        f"{vol_change:+.0f} units"
+                    )
+
+                    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")
+    else:
+        st.warning("⚠️ Insufficient data for selected segment. Please choose a different combination.")
 
 st.markdown("---")
-
-# 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")
+st.markdown("""
+<div style="text-align: center; color: #666; padding: 2rem 0;">
+    <small>
+    🔒 Demo Mode: Using synthetic SAP-style data for illustration purposes
+    </small>
+</div>
+""", unsafe_allow_html=True)