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
@@ -15,74 +15,99 @@ from sklearn.ensemble import RandomForestRegressor
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import r2_score, mean_absolute_error
 
-st.set_page_config(page_title="Profitability Intelligence", layout="wide", initial_sidebar_state="collapsed")
+# Enhanced page config
+st.set_page_config(
+    page_title="Profitability Intelligence Suite",
+    page_icon="📊",
+    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 {
+    .metric-container {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         padding: 1.5rem;
-        border-radius: 10px;
+        border-radius: 15px;
+        box-shadow: 0 8px 16px rgba(0,0,0,0.1);
         color: white;
-        margin: 1rem 0;
+        text-align: center;
     }
-    .metric-card {
-        background: white;
+    .insight-box {
+        background: #f8f9fa;
+        border-left: 5px solid #1f77b4;
         padding: 1.5rem;
+        margin: 1rem 0;
         border-radius: 8px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        border-left: 4px solid #1f77b4;
+        box-shadow: 0 4px 8px rgba(0,0,0,0.05);
     }
     .recommendation-card {
-        background: #f0f9ff;
-        padding: 1rem;
-        border-radius: 8px;
-        border-left: 4px solid #22c55e;
-        margin: 0.5rem 0;
+        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;
     }
-    .warning-card {
-        background: #fef3c7;
-        padding: 1rem;
-        border-radius: 8px;
-        border-left: 4px solid #f59e0b;
-        margin: 0.5rem 0;
+    .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;
+    }
+    .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 (Same as original)
 # -----------------------------
 @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 +128,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,79 +149,92 @@ 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)
+
+    df = pd.DataFrame(records)
+    return df
 
 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"]
-    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(_df, 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=300, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
+    model = RandomForestRegressor(n_estimators=250, 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)
-
-    return pipe, {"r2": r2_score(y_test, pred), "mae": mean_absolute_error(y_test, pred)}, X_test
+    r2 = r2_score(y_test, pred)
+    mae = mean_absolute_error(y_test, pred)
+    return pipe, {"r2": r2, "mae": mae}, X_test
 
 @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"]
+def compute_shap(_pipe, _X_sample, feats_num, feats_cat, shap_sample=800):
+    np.random.seed(42)
+    preprocessor = _pipe.named_steps["pre"]
     rf = _pipe.named_steps["rf"]
-    feature_names = list(preproc.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
+    feature_names = list(preprocessor.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
+
+    # Convert to DataFrame if needed
+    if hasattr(_X_sample, 'iloc'):
+        X_sample = _X_sample.copy()
+    else:
+        X_sample = pd.DataFrame(_X_sample)
 
     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 = preproc.transform(X_sample)
+    X_t = preprocessor.transform(X_sample)
     try:
         X_t = X_t.toarray()
-    except:
+    except Exception:
         pass
 
     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
 
 def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
@@ -206,350 +245,559 @@ def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
     lin = LinearRegression().fit(x, y)
     return float(lin.coef_[0]), True
 
-def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
+def simulate_pricing_action(segment_df: pd.DataFrame, 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"]
+    p0 = base["net_price"]
+    c0 = base["unit_cost"]
+    q0 = base["qty"]
+    d0 = base["discount_pct"]
 
-    new_discount = np.clip(d0 + delta_discount, 0.0, 0.45)
+    new_discount = np.clip(d0 - (discount_reduction_pct/100), 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
+    c1 = c0
 
-    rev0, cogs0 = p0 * q0, c0 * q0
-    rev1, cogs1 = p1 * q1, c1 * q1
+    if p0 <= 0:
+        q1 = q0
+    else:
+        q1 = max(0.0, q0 * (p1 / p0) ** elasticity)
 
-    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
-    }
+    rev0 = p0 * q0
+    cogs0 = c0 * q0
+    rev1 = p1 * q1
+    cogs1 = c1 * q1
 
-# -----------------------------
-# 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"]
+    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
 
-# -----------------------------
-# 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)
+    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
+    }
 
 # -----------------------------
-# 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
+# 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
 )
-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
-""")
+# 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("---")
 
-# -----------------------------
-# SEGMENT PERFORMANCE
-# -----------------------------
-st.markdown("## 📍 Performance by Business Segment")
+# Train model
+with st.spinner("🤖 Training AI model..."):
+    pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target)
 
-st.markdown("Not all business segments perform equally. Here's where you're winning and where there's opportunity:")
+# Tabs for different sections
+tab1, tab2, tab3 = st.tabs(["🔍 Key Drivers Analysis", "🎯 Strategic Recommendations", "🧪 What-If Simulator"])
 
-# 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()
+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)
 
-col1, col2 = st.columns(2)
+    # 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)
 
-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)
+    with col_b:
+        st.markdown("#### Key Insights")
 
-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)
+        # Generate business insights
+        top_3 = drivers_df.head(3)
 
-st.markdown("---")
+        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)
 
-# -----------------------------
-# WHAT-IF SIMULATOR
-# -----------------------------
-st.markdown("## 🎯 What-If Simulator: Test Your Strategies")
+        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("""
-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.
-""")
+        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 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()
+        # Segment-level insights
+        st.markdown("#### Segment Performance")
 
-col1, col2 = st.columns([2, 1])
+        # 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)
 
-with col1:
-    selected_segment = st.selectbox("**Select Business Segment:**", seg_options, key="segment_selector")
+        # 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)
+
+        top_negative = grp.nsmallest(5, "net_impact")
+        top_positive = grp.nlargest(5, "net_impact")
+
+        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})*")
+
+        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})*")
+
+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)
+
+    # 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
+            })
+
+        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"
+        )
+
+        # Aggregate impact
+        total_daily_impact = recs_df["Expected GM Uplift"].sum()
+        total_annual_impact = recs_df["Annual Impact Estimate"].sum()
 
-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 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>
         """, 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="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> <small>(% change in volume per 1% price change)</small>
         </div>
         """, unsafe_allow_html=True)
 
-st.markdown("---")
+        st.markdown("#### 🎯 Test Pricing Strategy")
 
-# -----------------------------
-# AI RECOMMENDATIONS
-# -----------------------------
-st.markdown("## 💡 AI-Powered Recommendations")
+        # 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("""
-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:
+                # 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")
 
-st.markdown("---")
+    else:
+        st.warning("⚠️ Insufficient data for selected segment. Please choose a different combination.")
 
-# 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("---")
+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)