Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,4 +1,5 @@
 #Stable version for Yazaki India Ltd
+
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -18,6 +19,85 @@ st.set_page_config(
 # Custom CSS (same as before)
 st.markdown("""
 <style>
+    .tab-header {
+        background: linear-gradient(90deg, #059669, #10b981);
+        padding: 0.8rem;
+        border-radius: 8px;
+        color: white;
+        margin-bottom: 1rem;
+    }
+    .alert-card {
+        background: #fff5f5;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 6px solid #e53e3e;
+        margin: 0.5rem 0;
+    }
+    .ecosystem-alert {
+        background: #fef2f2;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 6px solid #dc2626;
+        margin: 0.5rem 0;
+    }
+    .root-cause {
+        background: #fef7e7;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 3px solid #f6ad55;
+    }
+    .mitigation {
+        background: #e6fffa;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 3px solid #4fd1c7;
+    }
+    .best-option {
+        background: #f0fff4;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 4px solid #48bb78;
+        border: 2px solid #48bb78;
+    }
+    .tier-impact {
+        background: #fff7ed;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 4px solid #f97316;
+    }
+    .mitigation-executed {
+        background: #ecfdf5;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 4px solid #10b981;
+        border: 2px solid #10b981;
+    }
+    .mitigation-recommended {
+        background: #eff6ff;
+        padding: 0.8rem;
+        border-radius: 6px;
+        margin: 0.3rem 0;
+        border-left: 4px solid #3b82f6;
+    }
+    .normal-status {
+        background: #f0fff4;
+        padding: 0.6rem;
+        border-radius: 6px;
+        border-left: 4px solid #48bb78;
+        margin: 0.2rem 0;
+    }
+    .external-signal {
+        background: #f3e5f5;
+        padding: 0.6rem;
+        border-radius: 6px;
+        border-left: 4px solid #9c27b0;
+        margin: 0.2rem 0;
+    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -32,7 +112,7 @@ if 'external_signals' not in st.session_state:
 def generate_8week_demand_data():
     today = datetime(2025, 8, 4)
     dates = [today + timedelta(days=x) for x in range(56)]  # 8 weeks = 56 days
-    
+
     materials = [
         'YAZ001-Wiring Harness',
         'YAZ002-Connectors',
@@ -40,21 +120,21 @@ def generate_8week_demand_data():
         'YAZ004-Sensors',
         'YAZ005-Cable Assemblies'
     ]
-    
+
     all_data = []
-    
+
     for material in materials:
         np.random.seed(hash(material) % 1000)
-        
+
         # Generate base demand patterns
         base_demand = np.random.normal(150, 15, 56)
-        
+
         # First 14 days: FIRM DEMAND
         firm_demand = np.clip(base_demand[:14], 100, 200).astype(int)
-        
+
         # Days 15-56: Customer shared demand (tentative)
         customer_shared = np.clip(base_demand[14:] * (1 + 0.05 * np.sin(np.linspace(0, 3.14, 42))), 80, 220).astype(int)
-        
+
         # Days 15-56: AI-corrected demand (with external signals)
         external_factors = np.zeros(42)
         # Weather impact (weeks 3-4)
@@ -64,17 +144,17 @@ def generate_8week_demand_data():
             external_factors[14:] += 10
         # Festive season boost (weeks 6-7)
         external_factors[28:42] += 8
-        
+
         corrected_demand = np.clip(customer_shared + external_factors, 60, 250).astype(int)
-        
+
         # Generate supply plan for 56 days
         supply_capacity = np.random.normal(155, 12, 56)
         supply_plan = np.clip(supply_capacity, 120, 220).astype(int)
-        
+
         # Apply disruptions to supply (weather impact on days 15-18)
         supply_actual = supply_plan.copy()
         supply_actual[15:19] = (supply_actual[15:19] * 0.8).astype(int)
-        
+
         for i, date in enumerate(dates):
             # Determine which demand to use
             if i < 14:
@@ -89,10 +169,10 @@ def generate_8week_demand_data():
                 customer_val = customer_shared[i-14]
                 corrected_val = corrected_demand[i-14]
                 demand_type = "AI-Corrected"
-            
+
             # Calculate shortfall
             shortfall = max(0, demand_used - supply_actual[i])
-            
+
             all_data.append({
                 'Date': date,
                 'Week': f"Week {(i//7)+1}",
@@ -108,10 +188,10 @@ def generate_8week_demand_data():
                 'Demand_Type': demand_type,
                 'Gap': supply_actual[i] - demand_used
             })
-    
+
     return pd.DataFrame(all_data)
 
-# Updated Tier-2 suppliers for Yazaki India
+# UPDATED: Tier-2 suppliers for Yazaki India
 @st.cache_data
 def get_tier2_suppliers():
     return {
@@ -141,23 +221,23 @@ def get_tier2_suppliers():
         }
     }
 
-# Updated ecosystem generation with Yazaki-specific data
+# UPDATED: Ecosystem data with Yazaki-specific naming
 @st.cache_data
 def generate_ecosystem_data():
     today = datetime(2025, 8, 4)
     dates = [today + timedelta(days=x) for x in range(14)]
+
     suppliers = get_tier2_suppliers()
-    
     all_data = []
-    
+
     for supplier_name, supplier_info in suppliers.items():
         for material in supplier_info['materials']:
             np.random.seed(hash(supplier_name + material) % 1000)
-            
+
             base_capacity = supplier_info['capacity']
             normal_supply = np.full(14, base_capacity, dtype=int)
             disrupted_supply = normal_supply.copy()
-            
+
             if supplier_name == 'Electro Components Pvt Ltd':
                 disrupted_supply[3:7] = (disrupted_supply[3:7] * 0.3).astype(int)
                 disruption_cause = "Port delays in Chennai affecting imports"
@@ -173,16 +253,16 @@ def generate_ecosystem_data():
             else:
                 disruption_cause = "No disruption"
                 disruption_days = []
-            
+
             lead_time = supplier_info['lead_time']
             yazaki_supply = np.full(14, base_capacity, dtype=int)
-            
+
             for disruption_day in disruption_days:
                 arrival_day = disruption_day + lead_time
                 if arrival_day < 14:
                     reduction = normal_supply[disruption_day] - disrupted_supply[disruption_day]
                     yazaki_supply[arrival_day] = max(yazaki_supply[arrival_day] - reduction, 0)
-            
+
             for i, date in enumerate(dates):
                 all_data.append({
                     'Date': date,
@@ -199,10 +279,10 @@ def generate_ecosystem_data():
                     'Is_Disrupted': i in disruption_days,
                     'Is_Yazaki_Impacted': yazaki_supply[i] < normal_supply[i]
                 })
-    
+
     return pd.DataFrame(all_data)
 
-# Keep external signals unchanged (these are general market signals)
+# External signals (unchanged)
 @st.cache_data
 def get_external_signals():
     return [
@@ -217,43 +297,41 @@ def get_external_signals():
 # UPDATED: Generate alerts for 8-week data
 def generate_detailed_alerts(df):
     alerts = []
-    
+
     for material in df['Material'].unique():
         material_data = df[df['Material'] == material]
         shortage_days = material_data[material_data['Shortfall'] > 5]
-        
+
         if not shortage_days.empty:
             for _, row in shortage_days.iterrows():
                 root_causes = []
-                
                 if row['Day'] > 14:
                     if row['Corrected_Demand'] and row['Customer_Demand']:
                         diff = row['Corrected_Demand'] - row['Customer_Demand']
                         if diff > 10:
                             root_causes.append(f"AI detected {diff} units additional demand from external signals")
-                    
                     if row['Day'] >= 15 and row['Day'] <= 18:
-                        root_causes.append("Chennai supplier weather disruption reducing supply")
+                        root_causes.append("Chennai plant weather disruption reducing supply")
                 else:
                     root_causes.append("Firm demand exceeding supply capacity")
-                
+
                 if not root_causes:
                     root_causes.append("Base demand exceeding current supply capacity")
-                
+
                 mitigation_options = [
                     {"option": "Activate Pune backup production", "impact": "+30 units/day", "cost": "High", "timeline": "24 hours"},
                     {"option": "Expedite Tier-2 supplier shipments", "impact": "+15 units/day", "cost": "Medium", "timeline": "12 hours"},
                     {"option": "Emergency air freight from backup suppliers", "impact": "+40 units/day", "cost": "Very High", "timeline": "6 hours"},
                     {"option": "Reallocate inventory from other plants", "impact": "+20 units/day", "cost": "Low", "timeline": "18 hours"}
                 ]
-                
+
                 if row['Shortfall'] > 30:
                     best_option = mitigation_options[2]
                 elif row['Shortfall'] > 15:
                     best_option = mitigation_options[0]
                 else:
                     best_option = mitigation_options[1]
-                
+
                 alerts.append({
                     'material': material,
                     'date': row['Date'].strftime('%Y-%m-%d'),
@@ -265,7 +343,7 @@ def generate_detailed_alerts(df):
                     'mitigation_options': mitigation_options,
                     'best_option': best_option
                 })
-    
+
     return alerts
 
 # Keep mitigation strategies unchanged
@@ -296,14 +374,14 @@ def generate_mitigation_strategies(supplier, material, impact_amount, impact_day
             'capacity': f'+{impact_amount * 0.6:.0f} units/day',
         }
     ]
-    
+
     if impact_amount > 100:
         recommended = [0, 1]
     elif impact_amount > 50:
         recommended = [0, 2]
     else:
         recommended = [2]
-    
+
     return base_strategies, recommended
 
 # Load data
@@ -313,7 +391,7 @@ external_signals = get_external_signals()
 suppliers = get_tier2_suppliers()
 
 # Simple title (header removed as requested)
-st.title("Supply Chain Command Center - Yazaki India Ltd")
+st.title("Supply Chain Command Center")
 
 # Tab Navigation (same as before)
 st.sidebar.title("🎯 Dashboard Navigation")
@@ -325,332 +403,540 @@ dashboard_tab = st.sidebar.radio(
 
 # UPDATED TAB 1: 8-WEEK DEMAND & SUPPLY FORECAST
 if dashboard_tab == "📊 Demand & Supply Forecast":
-    
     st.markdown("""
-    <div style='background: linear-gradient(90deg, #1e3c72 0%, #2a5298 100%); padding: 15px; border-radius: 10px; margin-bottom: 20px;'>
-        <h3 style='color: white; margin: 0; text-align: center;'>
-            📊 8-Week Planning Horizon | Firm Demand (Days 1-14) | AI-Corrected Demand (Days 15-56)
-        </h3>
+    <div class="tab-header">
+        <h2>📊 8-Week Demand & Supply Forecast Dashboard</h2>
+        <p>8-Week Planning Horizon | Firm Demand (Days 1-14) | AI-Corrected Demand (Days 15-56)</p>
     </div>
     """, unsafe_allow_html=True)
-    
-    # Material selector
-    materials = df_demand['Material'].unique()
-    selected_material = st.selectbox("🔍 Select Material for Analysis:", materials)
-    
-    # Filter data for selected material
-    material_data = df_demand[df_demand['Material'] == selected_material].copy()
-    
-    # Create forecast visualization
-    fig = go.Figure()
-    
-    # Add firm demand (first 14 days)
-    firm_data = material_data[material_data['Day'] <= 14]
-    fig.add_trace(go.Scatter(
-        x=firm_data['Date'],
-        y=firm_data['Demand_Used'],
-        mode='lines+markers',
-        name='Firm Demand (Days 1-14)',
-        line=dict(color='#2E86AB', width=3),
-        marker=dict(size=8)
-    ))
-    
-    # Add customer shared demand (days 15-56)
-    future_data = material_data[material_data['Day'] > 14]
-    fig.add_trace(go.Scatter(
-        x=future_data['Date'],
-        y=future_data['Customer_Demand'],
-        mode='lines',
-        name='Customer Shared Demand',
-        line=dict(color='#F18F01', width=2, dash='dot'),
-        opacity=0.7
-    ))
-    
-    # Add AI-corrected demand (days 15-56)
-    fig.add_trace(go.Scatter(
-        x=future_data['Date'],
-        y=future_data['Corrected_Demand'],
-        mode='lines+markers',
-        name='AI-Corrected Demand',
-        line=dict(color='#C73E1D', width=3),
-        marker=dict(size=6)
-    ))
-    
-    # Add supply projection
-    fig.add_trace(go.Scatter(
-        x=material_data['Date'],
-        y=material_data['Supply_Projected'],
-        mode='lines',
-        name='Supply Projection',
-        line=dict(color='#4CAF50', width=2),
-        fill='tonexty',
-        fillcolor='rgba(76, 175, 80, 0.1)'
-    ))
-    
-    fig.update_layout(
-        title=f"📈 8-Week Demand vs Supply Forecast: {selected_material}",
-        xaxis_title="Date",
-        yaxis_title="Units",
-        height=500,
-        hovermode='x unified',
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+
+    # Material selection
+    selected_materials_demand = st.sidebar.multiselect(
+        "Focus Materials:",
+        df_demand['Material'].unique(),
+        default=df_demand['Material'].unique()[:3]
     )
-    
-    st.plotly_chart(fig, use_container_width=True)
-    
-    # Weekly aggregation
-    weekly_summary = material_data.groupby('Week').agg({
+
+    # Week filter
+    week_filter = st.sidebar.selectbox(
+        "Focus on Weeks:",
+        ["All 8 Weeks", "Weeks 1-2 (Firm)", "Weeks 3-4", "Weeks 5-6", "Weeks 7-8"],
+        index=0
+    )
+
+    # Filter data
+    filtered_df_demand = df_demand[df_demand['Material'].isin(selected_materials_demand)]
+
+    if week_filter != "All 8 Weeks":
+        if week_filter == "Weeks 1-2 (Firm)":
+            filtered_df_demand = filtered_df_demand[filtered_df_demand['Day'] <= 14]
+        elif week_filter == "Weeks 3-4":
+            filtered_df_demand = filtered_df_demand[(filtered_df_demand['Day'] > 14) & (filtered_df_demand['Day'] <= 28)]
+        elif week_filter == "Weeks 5-6":
+            filtered_df_demand = filtered_df_demand[(filtered_df_demand['Day'] > 28) & (filtered_df_demand['Day'] <= 42)]
+        else:  # Weeks 7-8
+            filtered_df_demand = filtered_df_demand[filtered_df_demand['Day'] > 42]
+
+    # Generate and display alerts
+    st.subheader("🚨 8-Week Supply Chain Alerts")
+
+    alerts = generate_detailed_alerts(filtered_df_demand)
+
+    if alerts:
+        for i, alert in enumerate(alerts[:3]):
+            st.markdown(f"""
+            <div class="alert-card">
+                <h4>⚠️ {alert['material']} - {alert['severity']} Shortage Alert</h4>
+                <p><b>Date:</b> {alert['date']} ({alert['week']}) | <b>Shortage:</b> {alert['shortage']} units | <b>Type:</b> {alert['demand_type']}</p>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.markdown("**🔍 Root Cause Analysis:**")
+            for cause in alert['root_causes']:
+                st.markdown(f"""
+                <div class="root-cause">
+                    🎯 {cause}
+                </div>
+                """, unsafe_allow_html=True)
+
+            st.markdown("**⚡ Mitigation Options:**")
+            for option in alert['mitigation_options']:
+                is_best = option == alert['best_option']
+                option_class = "best-option" if is_best else "mitigation"
+                best_indicator = "🏆 **RECOMMENDED** " if is_best else ""
+
+                st.markdown(f"""
+                <div class="{option_class}">
+                    {best_indicator}<b>{option['option']}</b><br>
+                    📈 Impact: {option['impact']} | 💰 Cost: {option['cost']} | ⏱️ Timeline: {option['timeline']}
+                </div>
+                """, unsafe_allow_html=True)
+
+            col1, col2, col3 = st.columns([2, 1, 1])
+            with col1:
+                if st.button(f"✅ Implement Solution", key=f"demand_implement_{i}"):
+                    st.success(f"Implementing: {alert['best_option']['option']}")
+
+            st.markdown("---")
+    else:
+        st.markdown("""
+        <div class="normal-status">
+            ✅ <b>All Good!</b> No critical supply shortages detected in the 8-week horizon.
+        </div>
+        """, unsafe_allow_html=True)
+
+    # UPDATED: 8-Week Detailed Planning Table
+    st.subheader("📋 8-Week Demand-Supply Planning Table")
+
+    # Prepare display table
+    display_df = filtered_df_demand.copy()
+    display_df['Date_Display'] = display_df['Date'].dt.strftime('%m-%d')
+
+    # Create styled table
+    table_cols = ['Date_Display', 'Week', 'Material', 'Firm_Demand', 'Customer_Demand',
+                  'Corrected_Demand', 'Supply_Projected', 'Shortfall']
+
+    table_data = display_df[table_cols].copy()
+    table_data.columns = ['Date', 'Week', 'Material', 'Firm Demand', 'Customer Demand',
+                         'Corrected Demand', 'Supply Plan', 'Shortfall']
+
+    # Color coding function
+    def highlight_shortfall(val):
+        if pd.isna(val):
+            return ''
+        return 'background-color: #ffcccc' if val > 0 else ''
+
+    def highlight_firm_period(row):
+        if pd.notna(row['Firm Demand']):
+            return ['background-color: #e6f3ff'] * len(row)
+        return [''] * len(row)
+
+    # Apply styling
+    styled_table = table_data.style.applymap(highlight_shortfall, subset=['Shortfall'])
+    styled_table = styled_table.apply(highlight_firm_period, axis=1)
+
+    st.dataframe(styled_table, use_container_width=True, height=500)
+
+    # Weekly summary
+    st.subheader("📊 Weekly Summary")
+
+    weekly_summary = filtered_df_demand.groupby(['Week', 'Material']).agg({
         'Demand_Used': 'sum',
         'Supply_Projected': 'sum',
         'Shortfall': 'sum'
     }).reset_index()
-    
-    # Display weekly summary
+
+    weekly_summary['Balance'] = weekly_summary['Supply_Projected'] - weekly_summary['Demand_Used']
+
+    st.dataframe(weekly_summary, use_container_width=True)
+
+    # Enhanced visualization
+    st.subheader("📈 8-Week Demand vs Supply Outlook")
+
+    for material in selected_materials_demand:
+        material_data = filtered_df_demand[filtered_df_demand['Material'] == material]
+
+        st.markdown(f"**{material}**")
+
+        fig = go.Figure()
+
+        # Add demand used line
+        fig.add_trace(go.Scatter(
+            x=material_data['Date'],
+            y=material_data['Demand_Used'],
+            mode='lines+markers',
+            name='Demand Used',
+            line=dict(color='blue', width=3),
+            marker=dict(size=6)
+        ))
+
+        # Add supply line
+        fig.add_trace(go.Scatter(
+            x=material_data['Date'],
+            y=material_data['Supply_Projected'],
+            mode='lines+markers',
+            name='Supply Projected',
+            line=dict(color='green', width=3),
+            marker=dict(size=6)
+        ))
+
+        # Highlight shortfall areas
+        shortage_data = material_data[material_data['Shortfall'] > 0]
+        if not shortage_data.empty:
+            fig.add_trace(go.Scatter(
+                x=shortage_data['Date'],
+                y=shortage_data['Supply_Projected'],
+                mode='markers',
+                name='Shortage Days',
+                marker=dict(color='red', size=10, symbol='x'),
+            ))
+
+        # Mark firm demand period
+        firm_data = material_data[material_data['Day'] <= 14]
+        if not firm_data.empty:
+            fig.add_vrect(
+                x0=firm_data['Date'].min(),
+                x1=firm_data['Date'].max(),
+                fillcolor="lightblue",
+                opacity=0.2,
+                line_width=0,
+                annotation_text="Firm Demand Period",
+                annotation_position="top left"
+            )
+
+        fig.update_layout(
+            title=f'{material} - 8-Week Supply vs Demand Forecast',
+            xaxis_title='Date',
+            yaxis_title='Units',
+            height=400,
+            showlegend=True,
+            hovermode='x unified'
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+    # External demand sensing (same as before)
+    st.subheader("📡 Real-time External Demand Sensing")
+
     col1, col2 = st.columns(2)
-    
+
     with col1:
-        st.subheader("📊 Weekly Summary")
-        for _, week_data in weekly_summary.iterrows():
-            gap = week_data['Supply_Projected'] - week_data['Demand_Used']
-            status = "✅ Surplus" if gap > 0 else "⚠️ Shortage" if gap < 0 else "⚖️ Balanced"
-            
+        st.write("**Active External Signals:**")
+        for signal in external_signals:
+            confidence_color = "🟢" if signal['Confidence'] > 90 else "🟡" if signal['Confidence'] > 80 else "🟠"
             st.markdown(f"""
-            **{week_data['Week']}**: {status}
-            - Demand: {week_data['Demand_Used']:,} units
-            - Supply: {week_data['Supply_Projected']:,} units
-            - Gap: {gap:+,} units
-            """)
-    
+            <div class="external-signal">
+                <b>{confidence_color} {signal['Source']}</b><br>
+                {signal['Signal']}<br>
+                <small>Impact: {signal['Impact']} | Confidence: {signal['Confidence']}%</small>
+            </div>
+            """, unsafe_allow_html=True)
+
     with col2:
-        st.subheader("🚨 Shortage Alerts")
-        alerts = generate_detailed_alerts(material_data)
-        
-        if alerts:
-            for alert in alerts[:3]:  # Show top 3 alerts
-                severity_color = {"Critical": "#FF4444", "High": "#FF8800", "Medium": "#FFBB00"}[alert['severity']]
-                
-                st.markdown(f"""
-                <div style='border-left: 4px solid {severity_color}; padding: 10px; margin: 10px 0; background: #f8f9fa;'>
-                    <strong>{alert['severity']} Alert</strong><br>
-                    <strong>Date:</strong> {alert['date']} ({alert['week']}) | <strong>Shortage:</strong> {alert['shortage']} units | <strong>Type:</strong> {alert['demand_type']}<br>
-                    <strong>Root Cause:</strong> {alert['root_causes'][0]}<br>
-                    <strong>Best Mitigation:</strong> {alert['best_option']['option']} ({alert['best_option']['timeline']})
-                </div>
-                """, unsafe_allow_html=True)
-        else:
-            st.success("✅ No shortages detected for this material!")
+        st.write("**8-Week Scenario Planning:**")
+
+        scenario = st.selectbox("Select Scenario to Test:",
+                               ["Base Case", "Extended Monsoon", "Sustained EV Boost", "Supply Chain Strike"])
+
+        if st.button("🎮 Run 8-Week Scenario", key="demand_scenario"):
+            if scenario == "Extended Monsoon":
+                st.error("Scenario: 30% supply reduction for 3 weeks. Activating multi-tier contingency plans...")
+            elif scenario == "Sustained EV Boost":
+                st.warning("Scenario: 25% demand increase for 6 weeks. Scaling ecosystem capacity...")
+            elif scenario == "Supply Chain Strike":
+                st.info("Scenario: Multi-supplier disruption. Implementing emergency protocols...")
+
+# Keep TAB 2 and TAB 3 unchanged from previous version, but replace Rane with Yazaki in variables and text
 
-# TAB 2: ECOSYSTEM SUPPLIER IMPACT (updated variable names)
 elif dashboard_tab == "🌐 Ecosystem Supplier Impact":
-    
     st.markdown("""
-    <div style='background: linear-gradient(90deg, #1e3c72 0%, #2a5298 100%); padding: 15px; border-radius: 10px; margin-bottom: 20px;'>
-        <h3 style='color: white; margin: 0; text-align: center;'>
-            🌐 Tier 2 Supplier Disruption Analysis | Cascading Impact Modeling | Automated Mitigation Response
-        </h3>
+    <div class="tab-header">
+        <h2>🌐 Ecosystem Supplier Impact Dashboard</h2>
+        <p>Tier 2 Supplier Disruption Analysis | Cascading Impact Modeling | Automated Mitigation Response</p>
     </div>
     """, unsafe_allow_html=True)
-    
-    # Supplier overview
-    st.subheader("📈 Supplier Performance Overview")
-    
-    supplier_summary = df_ecosystem.groupby('Supplier').agg({
-        'Tier2_Impact': 'sum',
-        'Yazaki_Impact': 'sum',
-        'Is_Disrupted': 'sum'
-    }).reset_index()
-    
-    supplier_summary.columns = ['Supplier', 'Total_Tier2_Impact', 'Total_Yazaki_Impact', 'Disruption_Days']
-    
-    # Display supplier cards
-    cols = st.columns(len(supplier_summary))
-    for i, (_, supplier) in enumerate(supplier_summary.iterrows()):
-        with cols[i]:
-            supplier_info = suppliers[supplier['Supplier']]
-            disruption_status = "🔴 Disrupted" if supplier['Disruption_Days'] > 0 else "🟢 Normal"
-            
+
+    selected_suppliers = st.sidebar.multiselect(
+        "Monitor Suppliers:",
+        list(suppliers.keys()),
+        default=list(suppliers.keys())
+    )
+
+    st.subheader("🚨 Live Ecosystem Supply Chain Alerts")
+
+    ecosystem_alerts = []
+    for supplier in selected_suppliers:
+        supplier_data = df_ecosystem[df_ecosystem['Supplier'] == supplier]
+        disrupted_data = supplier_data[supplier_data['Is_Disrupted'] == True]
+
+        if not disrupted_data.empty:
+            for material in disrupted_data['Material'].unique():
+                material_disruptions = disrupted_data[disrupted_data['Material'] == material]
+
+                total_impact = material_disruptions['Tier2_Impact'].sum()
+                impact_days = len(material_disruptions)
+                first_impact_date = material_disruptions['Date'].min()
+
+                yazaki_impacted = supplier_data[
+                    (supplier_data['Material'] == material) &
+                    (supplier_data['Is_Yazaki_Impacted'] == True)
+                ]
+
+                if not yazaki_impacted.empty:
+                    yazaki_impact_start = yazaki_impacted['Date'].min()
+                    yazaki_impact_days = len(yazaki_impacted)
+                    yazaki_total_impact = yazaki_impacted['Yazaki_Impact'].sum()
+
+                    ecosystem_alerts.append({
+                        'supplier': supplier,
+                        'material': material,
+                        'disruption_cause': material_disruptions.iloc[0]['Disruption_Cause'],
+                        'tier2_impact_start': first_impact_date,
+                        'tier2_impact_days': impact_days,
+                        'tier2_total_impact': total_impact,
+                        'yazaki_impact_start': yazaki_impact_start,
+                        'yazaki_impact_days': yazaki_impact_days,
+                        'yazaki_total_impact': yazaki_total_impact,
+                        'lead_time': material_disruptions.iloc[0]['Lead_Time_Days']
+                    })
+
+    if ecosystem_alerts:
+        for alert in ecosystem_alerts:
             st.markdown(f"""
-            <div style='border: 2px solid #ddd; padding: 15px; border-radius: 10px; text-align: center;'>
-                <h4>{supplier['Supplier']}</h4>
-                <p><strong>Location:</strong> {supplier_info['location']}</p>
-                <p><strong>Status:</strong> {disruption_status}</p>
-                <p><strong>Yazaki Impact:</strong> {supplier['Total_Yazaki_Impact']} units</p>
-                <p><strong>Reliability:</strong> {supplier_info['reliability']}%</p>
+            <div class="ecosystem-alert">
+                <h4>⚠️ Tier 2 Supplier Disruption Alert</h4>
+                <p><b>Supplier:</b> {alert['supplier']} | <b>Material:</b> {alert['material']}</p>
+                <p><b>Root Cause:</b> {alert['disruption_cause']}</p>
             </div>
             """, unsafe_allow_html=True)
-    
-    # Detailed supplier analysis
-    st.subheader("🔍 Detailed Supplier Analysis")
-    
-    selected_supplier = st.selectbox("Select Supplier for Detailed Analysis:", df_ecosystem['Supplier'].unique())
-    supplier_data = df_ecosystem[df_ecosystem['Supplier'] == selected_supplier]
-    
-    # Create supplier timeline
-    fig_supplier = go.Figure()
-    
-    for material in supplier_data['Material'].unique():
-        material_data = supplier_data[supplier_data['Material'] == material]
-        
-        fig_supplier.add_trace(go.Scatter(
-            x=material_data['Date'],
-            y=material_data['Tier2_Normal_Supply'],
-            mode='lines',
-            name=f'{material} - Normal Supply',
-            line=dict(dash='dot'),
-            opacity=0.6
-        ))
-        
-        fig_supplier.add_trace(go.Scatter(
+
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.markdown("**🏭 Tier 2 Supplier Impact:**")
+                st.markdown(f"""
+                <div class="tier-impact">
+                    📅 <b>Impact Period:</b> {alert['tier2_impact_start'].strftime('%Y-%m-%d')} ({alert['tier2_impact_days']} days)<br>
+                    📉 <b>Total Supply Lost:</b> {alert['tier2_total_impact']} units<br>
+                    🎯 <b>Daily Impact:</b> {alert['tier2_total_impact'] // alert['tier2_impact_days']} units/day
+                </div>
+                """, unsafe_allow_html=True)
+
+            with col2:
+                st.markdown("**⚙️ Yazaki India Ltd Impact (with Lead Time):**")
+                st.markdown(f"""
+                <div class="tier-impact">
+                    📅 <b>Impact Period:</b> {alert['yazaki_impact_start'].strftime('%Y-%m-%d')} ({alert['yazaki_impact_days']} days)<br>
+                    📉 <b>Total Supply Lost:</b> {alert['yazaki_total_impact']} units<br>
+                    ⏱️ <b>Lead Time Delay:</b> {alert['lead_time']} days
+                </div>
+                """, unsafe_allow_html=True)
+
+            strategies, recommended_indices = generate_mitigation_strategies(
+                alert['supplier'],
+                alert['material'],
+                alert['yazaki_total_impact'] // alert['yazaki_impact_days'],
+                alert['yazaki_impact_days']
+            )
+
+            st.markdown("**🤖 Agentic AI Mitigation Strategies:**")
+
+            for i, strategy in enumerate(strategies):
+                is_recommended = i in recommended_indices
+                is_executed = f"eco_{alert['supplier']}_{alert['material']}_{i}" in st.session_state.executed_mitigations
+
+                if is_executed:
+                    card_class = "mitigation-executed"
+                    status_prefix = "✅ **EXECUTED** "
+                elif is_recommended:
+                    card_class = "mitigation-recommended"
+                    status_prefix = "🏆 **AI RECOMMENDED** "
+                else:
+                    card_class = "mitigation-recommended"
+                    status_prefix = ""
+
+                st.markdown(f"""
+                <div class="{card_class}">
+                    {status_prefix}<b>{strategy['strategy']}</b><br>
+                    📋 {strategy['description']}<br>
+                    ⏱️ <b>Timeline:</b> {strategy['timeline']} | 💰 <b>Cost:</b> {strategy['cost']}<br>
+                    📈 <b>Effectiveness:</b> {strategy['effectiveness']} | 🚀 <b>Capacity:</b> {strategy['capacity']}
+                </div>
+                """, unsafe_allow_html=True)
+
+                strategy_key = f"eco_{alert['supplier']}_{alert['material']}_{i}"
+
+                col1, col2 = st.columns([2, 1])
+
+                with col1:
+                    if not is_executed:
+                        if st.button(f"🚀 Execute Strategy", key=f"execute_{strategy_key}"):
+                            st.session_state.executed_mitigations.append(strategy_key)
+                            st.success(f"Executing: {strategy['strategy']}")
+                            st.rerun()
+                    else:
+                        st.success("Strategy Active")
+
+                with col2:
+                    if is_recommended:
+                        st.button("🏆 Recommended", key=f"rec_{strategy_key}", disabled=True)
+
+            st.markdown("---")
+    else:
+        st.markdown("""
+        <div class="normal-status">
+            ✅ <b>Ecosystem Healthy!</b> No supplier disruptions detected in the current timeframe.
+        </div>
+        """, unsafe_allow_html=True)
+
+    st.subheader("📊 Ecosystem Supply Chain Flow Visualization")
+
+    fig = go.Figure()
+
+    for supplier in selected_suppliers:
+        supplier_data = df_ecosystem[df_ecosystem['Supplier'] == supplier]
+        sample_material = supplier_data['Material'].iloc[0]
+        material_data = supplier_data[supplier_data['Material'] == sample_material]
+
+        fig.add_trace(go.Scatter(
             x=material_data['Date'],
             y=material_data['Tier2_Disrupted_Supply'],
             mode='lines+markers',
-            name=f'{material} - Actual Supply',
+            name=f'{supplier} (Tier 2)',
+            line=dict(width=2, dash='dash'),
             marker=dict(size=6)
         ))
-    
-    fig_supplier.update_layout(
-        title=f"📊 Supply Timeline: {selected_supplier}",
-        xaxis_title="Date",
-        yaxis_title="Supply Units",
-        height=400
+
+        fig.add_trace(go.Scatter(
+            x=material_data['Date'],
+            y=material_data['Yazaki_Impacted_Supply'],
+            mode='lines+markers',
+            name=f'Yazaki Impact from {supplier}',
+            line=dict(width=3),
+            marker=dict(size=8)
+        ))
+
+    fig.update_layout(
+        title='Tier 2 Supplier Disruptions → Yazaki India Ltd Supply Impact',
+        xaxis_title='Date',
+        yaxis_title='Supply Units',
+        height=500,
+        showlegend=True,
+        hovermode='x unified'
     )
-    
-    st.plotly_chart(fig_supplier, use_container_width=True)
-    
-    # Disruption details
-    disrupted_data = supplier_data[supplier_data['Is_Disrupted'] == True]
-    if not disrupted_data.empty:
-        st.subheader("⚠️ Disruption Details")
-        
-        for material in disrupted_data['Material'].unique():
-            material_disruptions = disrupted_data[disrupted_data['Material'] == material]
-            if not material_disruptions.empty:
-                disruption_info = material_disruptions.iloc[0]
-                
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.markdown(f"""
-                    <div style='border-left: 4px solid #FF4444; padding: 15px; background: #f8f9fa; margin: 10px 0;'>
-                        <strong>Supplier:</strong> {disruption_info['Supplier']}<br>
-                        <strong>Material:</strong> {disruption_info['Material']}<br>
-                        <strong>Root Cause:</strong> {disruption_info['Disruption_Cause']}<br>
-                        <strong>Impact Duration:</strong> {len(material_disruptions)} days<br>
-                        <strong>Total Impact:</strong> {material_disruptions['Tier2_Impact'].sum()} units
-                    </div>
-                    """, unsafe_allow_html=True)
-                
-                with col2:
-                    # Generate mitigation strategies
-                    strategies, recommended = generate_mitigation_strategies(
-                        disruption_info['Supplier'],
-                        disruption_info['Material'],
-                        material_disruptions['Tier2_Impact'].sum(),
-                        len(material_disruptions)
-                    )
-                    
-                    st.markdown("**🛠️ Recommended Mitigation Strategies:**")
-                    for idx in recommended:
-                        strategy = strategies[idx]
-                        st.markdown(f"""
-                        **{strategy['strategy']}**
-                        - {strategy['description']}
-                        - Timeline: {strategy['timeline']}
-                        - Cost: {strategy['cost']}
-                        - Capacity: {strategy['capacity']}
-                        """)
-
-# TAB 3: BUFFER OPTIMIZER (unchanged)
+
+    st.plotly_chart(fig, use_container_width=True)
+
+# TAB 3: BUFFER OPTIMIZER (same as before)
 elif dashboard_tab == "🛡️ Buffer Optimizer":
-    
     st.markdown("""
-    <div style='background: linear-gradient(90deg, #1e3c72 0%, #2a5298 100%); padding: 15px; border-radius: 10px; margin-bottom: 20px;'>
-        <h3 style='color: white; margin: 0; text-align: center;'>
-            🛡️ AI-driven safety-stock recommendations across the full network
-        </h3>
+    <div class="tab-header">
+        <h2>🛡️ Multi-Echelon Buffer Optimizer</h2>
+        <p>AI-driven safety-stock recommendations across the full network</p>
     </div>
     """, unsafe_allow_html=True)
-    
-    # Buffer analysis
-    st.subheader("📊 Current Buffer Analysis")
-    
-    # Calculate buffer recommendations
-    buffer_data = []
-    for material in df_demand['Material'].unique():
-        material_demand = df_demand[df_demand['Material'] == material]
-        
-        avg_demand = material_demand['Demand_Used'].mean()
-        max_demand = material_demand['Demand_Used'].max()
-        demand_volatility = material_demand['Demand_Used'].std()
-        
-        # Calculate recommended buffer
-        safety_factor = 1.5  # Can be adjusted based on service level requirements
-        recommended_buffer = int(demand_volatility * safety_factor)
-        
-        # Current buffer (assumed)
-        current_buffer = int(avg_demand * 0.1)  # Assuming 10% of average demand
-        
-        buffer_data.append({
-            'Material': material,
-            'Avg_Demand': int(avg_demand),
-            'Max_Demand': int(max_demand),
-            'Demand_Volatility': int(demand_volatility),
-            'Current_Buffer': current_buffer,
-            'Recommended_Buffer': recommended_buffer,
-            'Buffer_Gap': recommended_buffer - current_buffer
-        })
-    
-    buffer_df = pd.DataFrame(buffer_data)
-    
-    # Display buffer table
-    st.dataframe(buffer_df, use_container_width=True)
-    
-    # Buffer optimization visualization
-    fig_buffer = go.Figure()
-    
-    fig_buffer.add_trace(go.Bar(
-        name='Current Buffer',
-        x=buffer_df['Material'],
-        y=buffer_df['Current_Buffer'],
-        marker_color='lightblue'
-    ))
-    
-    fig_buffer.add_trace(go.Bar(
-        name='Recommended Buffer',
-        x=buffer_df['Material'],
-        y=buffer_df['Recommended_Buffer'],
-        marker_color='orange'
-    ))
-    
-    fig_buffer.update_layout(
-        title='📊 Buffer Stock Analysis: Current vs Recommended',
-        xaxis_title='Material',
-        yaxis_title='Buffer Units',
-        barmode='group',
-        height=400
-    )
-    
-    st.plotly_chart(fig_buffer, use_container_width=True)
-    
-    # Buffer recommendations
-    st.subheader("💡 Buffer Optimization Recommendations")
-    
+
+    service_level = st.slider("Target Service Level (%)", 90, 99, 95)
+    review_period = st.number_input("Inventory Review Period (days)", min_value=1, max_value=14, value=1)
+
+    z_factor = {90: 1.28, 92: 1.41, 95: 1.64, 97: 1.88, 98: 2.05, 99: 2.33}
+    Z = z_factor.get(service_level, 1.64)
+
+    # Use 8-week demand data for buffer calculation
+    demand_stats = (df_demand
+                    .groupby("Material")
+                    .agg(DailyMean=("Demand_Used", "mean"),
+                         Sigma=("Demand_Used", "std"))
+                    .reset_index())
+
+    lead_times = (df_ecosystem
+                  .groupby("Material")
+                  .agg(LeadTime=("Lead_Time_Days", "max"))
+                  .reset_index())
+
+    current_buffers = (df_demand[df_demand["Day"] == 1]
+                       .loc[:, ["Material", "Supply_Projected"]]
+                       .rename(columns={"Supply_Projected": "OnHand"}))
+
+    buffer_df = (demand_stats.merge(lead_times, on="Material")
+                 .merge(current_buffers, on="Material", how="left"))
+
+    buffer_df["RecommendedBuffer"] = (
+        Z * buffer_df["Sigma"] * np.sqrt(buffer_df["LeadTime"] + review_period)
+    ).round()
+
+    buffer_df["Delta"] = buffer_df["RecommendedBuffer"] - buffer_df["OnHand"]
+    buffer_df["Action"] = np.where(buffer_df["Delta"] > 50,
+                                   "Increase buffer",
+                                   np.where(buffer_df["Delta"] < -50,
+                                            "Reduce buffer", "OK"))
+
+    st.subheader("📋 Buffer Recommendations")
+    display_cols = ["Material", "OnHand", "RecommendedBuffer", "Delta", "Action"]
+    st.dataframe(buffer_df[display_cols], use_container_width=True, height=300)
+
+    st.subheader("💰 Cost Impact Analysis")
+    carrying_cost = st.number_input("Annual Carrying Cost (% of unit cost)", min_value=0, max_value=50, value=20)
+    unit_cost = 100
+
+    buffer_df["CostImpact(₹)"] = (buffer_df["Delta"] * unit_cost * (carrying_cost/100) / 12)
+
+    cost_chart_data = buffer_df.set_index("Material")["CostImpact(₹)"]
+    st.bar_chart(cost_chart_data)
+
+    st.subheader("⚡ Execute AI Recommendations")
     for _, row in buffer_df.iterrows():
-        if row['Buffer_Gap'] > 0:
-            st.warning(f"**{row['Material']}**: Increase buffer by {row['Buffer_Gap']} units to handle demand volatility")
-        elif row['Buffer_Gap'] < 0:
-            st.info(f"**{row['Material']}**: Current buffer is {abs(row['Buffer_Gap'])} units above recommendation - consider optimization")
-        else:
-            st.success(f"**{row['Material']}**: Buffer levels are optimal")
+        if row["Action"] != "OK":
+            if st.button(f"🚀 {row['Action']} for {row['Material']}", key=row["Material"]):
+                st.success(f"AI executed: {row['Action']} - Adjusting {int(row['Delta'])} units for {row['Material']}")
+
+# Performance summary
+st.subheader("📊 Performance Summary")
+
+col1, col2, col3, col4 = st.columns(4)
+
+if dashboard_tab == "📊 Demand & Supply Forecast":
+    filtered_df = filtered_df_demand if 'filtered_df_demand' in locals() else df_demand
+
+    total_shortage_days = len(filtered_df[filtered_df['Shortfall'] > 0])
+    critical_shortage_days = len(filtered_df[filtered_df['Shortfall'] > 30])
+    materials_at_risk = len(filtered_df[filtered_df['Shortfall'] > 5]['Material'].unique())
+    avg_shortfall = filtered_df['Shortfall'].mean()
+
+    with col1:
+        st.metric("Days with Shortages", f"{total_shortage_days}")
+
+    with col2:
+        st.metric("Critical Days", f"{critical_shortage_days}")
+
+    with col3:
+        st.metric("Materials at Risk", f"{materials_at_risk}")
+
+    with col4:
+        st.metric("Avg Daily Shortfall", f"{avg_shortfall:.1f} units")
+
+elif dashboard_tab == "🌐 Ecosystem Supplier Impact":
+    total_suppliers_disrupted = len(df_ecosystem[df_ecosystem['Is_Disrupted'] == True]['Supplier'].unique())
+    total_yazaki_impact_days = len(df_ecosystem[df_ecosystem['Is_Yazaki_Impacted'] == True])
+    total_mitigation_strategies = len([s for s in st.session_state.executed_mitigations if 'eco_' in s])
+    avg_lead_time = df_ecosystem['Lead_Time_Days'].mean()
+
+    with col1:
+        st.metric("Suppliers Disrupted", f"{total_suppliers_disrupted}")
+
+    with col2:
+        st.metric("Yazaki Impact Days", f"{total_yazaki_impact_days}")
+
+    with col3:
+        st.metric("Active Mitigations", f"{total_mitigation_strategies}")
+
+    with col4:
+        st.metric("Avg Lead Time", f"{avg_lead_time:.1f} days")
+
+else:  # Buffer Optimizer
+    if 'buffer_df' in locals():
+        total_materials = len(buffer_df)
+        materials_need_increase = len(buffer_df[buffer_df['Action'] == 'Increase buffer'])
+        materials_need_decrease = len(buffer_df[buffer_df['Action'] == 'Reduce buffer'])
+        total_cost_impact = buffer_df['CostImpact(₹)'].sum()
+
+        with col1:
+            st.metric("Total Materials", f"{total_materials}")
+
+        with col2:
+            st.metric("Need Buffer Increase", f"{materials_need_increase}")
+
+        with col3:
+            st.metric("Need Buffer Reduction", f"{materials_need_decrease}")
+
+        with col4:
+            st.metric("Monthly Cost Impact", f"₹{total_cost_impact:,.0f}")
 
 # Footer
+st.markdown("---")
 st.markdown("""
----
-<div style='text-align: center; padding: 20px; background: linear-gradient(90deg, #1e3c72 0%, #2a5298 100%); border-radius: 10px; margin-top: 30px;'>
-    <h3 style='color: white; margin: 0;'>
-        📊 <strong>Yazaki India Ltd 8-Week Supply Chain Command Center</strong> | Firm + AI-Corrected Demand | Ecosystem Intelligence + Buffer Optimization
-    </h3>
-    <p style='color: white; margin: 10px 0 0 0;'>
-        Powered by Agentic AI | 8-Week Planning Horizon | Comprehensive Supply Chain Resilience
-    </p>
+<div style='text-align: center; color: #666;'>
+    <p>🌐 <b>Yazaki India Ltd 8-Week Supply Chain Command Center</b> | Firm + AI-Corrected Demand | Ecosystem Intelligence + Buffer Optimization<br>
+    Powered by Agentic AI | 8-Week Planning Horizon | Comprehensive Supply Chain Resilience</p>
 </div>
 """, unsafe_allow_html=True)