Update app.py

app.py

@@ -3,7 +3,10 @@ import pandas as pd
 import joblib
 import os
 import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 from huggingface_hub import hf_hub_download
+from datetime import datetime
+import json
 
 # --- CONFIGURATION ---
 HF_USERNAME = os.getenv("HF_USERNAME", "iStillWaters")
@@ -13,26 +16,56 @@ MODEL_REPO_ID = f"{HF_USERNAME}/{MODEL_REPO_NAME}"
 MODEL_FILENAME = "best_engine_model.pkl"
 SCALER_FILENAME = "scaler.joblib"
 
+# Sensor thresholds for warnings
+SENSOR_THRESHOLDS = {
+    'rpm_warning': 2000,
+    'rpm_critical': 2300,
+    'coolant_temp_warning': 100,
+    'coolant_temp_critical': 120,
+    'oil_pressure_low': 2.0,
+    'oil_pressure_critical': 1.5,
+    'fuel_pressure_low': 5.0,
+}
+
 # --- LOAD ARTIFACTS ---
 @st.cache_resource
 def load_artifacts():
+    """Load model and scaler from HuggingFace Hub with error handling"""
     try:
         model_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=MODEL_FILENAME)
         scaler_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=SCALER_FILENAME)
-        return joblib.load(model_path), joblib.load(scaler_path)
+        model = joblib.load(model_path)
+        scaler = joblib.load(scaler_path)
+        return model, scaler, None
     except Exception as e:
-        st.error(f"Failed to load model: {e}")
-        return None, None
+        return None, None, str(e)
 
-model, scaler = load_artifacts()
+# --- SESSION STATE INITIALIZATION ---
+def init_session_state():
+    """Initialize session state variables"""
+    if 'history' not in st.session_state:
+        st.session_state.history = []
+    if 'alert_threshold' not in st.session_state:
+        st.session_state.alert_threshold = 0.7
+    if 'dark_mode' not in st.session_state:
+        st.session_state.dark_mode = True
+    if 'show_recommendations' not in st.session_state:
+        st.session_state.show_recommendations = True
 
-# --- HELPER: CREATE GAUGE CHART ---
-def create_gauge(value, title, min_val, max_val, color="blue"):
+# --- HELPER FUNCTIONS ---
+def create_gauge(value, title, min_val, max_val, thresholds=None, color="blue"):
+    """Create an enhanced gauge chart with color-coded zones"""
+    if thresholds is None:
+        # Default thresholds: green (0-60%), yellow (60-80%), red (80-100%)
+        thresholds = [min_val, min_val + (max_val-min_val)*0.6, 
+                     min_val + (max_val-min_val)*0.8, max_val]
+    
     fig = go.Figure(go.Indicator(
-        mode = "gauge+number",
+        mode = "gauge+number+delta",
         value = value,
-        domain = {'x': [0, 1], 'y': [0, 1]},
         title = {'text': title, 'font': {'size': 18}},
+        delta = {'reference': (max_val + min_val) / 2, 'relative': False},
+        domain = {'x': [0, 1], 'y': [0, 1]},
         gauge = {
             'axis': {'range': [min_val, max_val]},
             'bar': {'color': color},
@@ -40,133 +73,531 @@ def create_gauge(value, title, min_val, max_val, color="blue"):
             'borderwidth': 2,
             'bordercolor': "gray",
             'steps': [
-                {'range': [min_val, max_val*0.5], 'color': "#e6e6e6"},
-                {'range': [max_val*0.5, max_val], 'color': "#c0c0c0"}],
+                {'range': [thresholds[0], thresholds[1]], 'color': "#90EE90"},
+                {'range': [thresholds[1], thresholds[2]], 'color': "#FFD700"},
+                {'range': [thresholds[2], thresholds[3]], 'color': "#FFB6C1"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': thresholds[2]
+            }
         }
     ))
-    # Fixed height ensures alignment with images
     fig.update_layout(height=250, margin=dict(l=20, r=20, t=50, b=20))
     return fig
 
-# --- UI LAYOUT ---
-st.set_page_config(layout="wide", page_title="Engine Dashboard", page_icon="🏎️")
+def validate_inputs(rpm, fuel_p, lub_oil_p, coolant_temp, coolant_p, lub_oil_t):
+    """Validate sensor readings and return warnings"""
+    warnings = []
+    critical = []
+    
+    # RPM checks
+    if rpm > SENSOR_THRESHOLDS['rpm_critical']:
+        critical.append("🔴 CRITICAL: RPM exceeding safe limits!")
+    elif rpm > SENSOR_THRESHOLDS['rpm_warning']:
+        warnings.append("⚠️ RPM approaching redline")
+    
+    # Coolant temperature checks
+    if coolant_temp > SENSOR_THRESHOLDS['coolant_temp_critical']:
+        critical.append("🔴 CRITICAL: Engine overheating!")
+    elif coolant_temp > SENSOR_THRESHOLDS['coolant_temp_warning']:
+        warnings.append("⚠️ Coolant temperature elevated")
+    
+    # Oil pressure checks
+    if lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_critical']:
+        critical.append("🔴 CRITICAL: Oil pressure dangerously low!")
+    elif lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_low']:
+        warnings.append("⚠️ Oil pressure below normal")
+    
+    # Fuel pressure checks
+    if fuel_p < SENSOR_THRESHOLDS['fuel_pressure_low']:
+        warnings.append("⚠️ Fuel pressure low")
+    
+    return warnings, critical
+
+def prepare_input_data(rpm, lub_oil_p, fuel_p, coolant_p, lub_oil_t, coolant_temp):
+    """Prepare input data for model prediction"""
+    return pd.DataFrame({
+        'Engine rpm': [rpm],
+        'Lub oil pressure': [lub_oil_p],
+        'Fuel pressure': [fuel_p],
+        'Coolant pressure': [coolant_p],
+        'lub oil temp': [lub_oil_t],
+        'Coolant temp': [coolant_temp]
+    })
+
+def run_prediction(model, scaler, input_df):
+    """Run model prediction with error handling"""
+    try:
+        scaled = scaler.transform(input_df)
+        pred = model.predict(scaled)[0]
+        prob = model.predict_proba(scaled)[0][1] if hasattr(model, 'predict_proba') else 0.0
+        return pred, prob, None
+    except Exception as e:
+        return None, None, str(e)
+
+def get_status_info(prob):
+    """Get status badge and color based on probability"""
+    if prob > 0.75:
+        return "🔴 CRITICAL", "#ff4b4b", "CRITICAL FAILURE RISK"
+    elif prob > 0.5:
+        return "🟡 WARNING", "#ffa500", "ELEVATED FAILURE RISK"
+    elif prob > 0.25:
+        return "🟠 CAUTION", "#ff8c00", "MODERATE RISK"
+    else:
+        return "🟢 HEALTHY", "#00cc00", "SYSTEMS NOMINAL"
+
+def get_recommendations(input_df, prob, warnings, critical):
+    """Generate actionable recommendations based on sensor readings and prediction"""
+    recommendations = []
+    
+    # Critical alerts first
+    if critical:
+        recommendations.extend(critical)
+        recommendations.append("🚨 IMMEDIATE ACTION REQUIRED - SHUT DOWN ENGINE")
+    
+    # Sensor-specific recommendations
+    rpm = input_df['Engine rpm'].values[0]
+    coolant_temp = input_df['Coolant temp'].values[0]
+    lub_oil_p = input_df['Lub oil pressure'].values[0]
+    fuel_p = input_df['Fuel pressure'].values[0]
+    
+    if coolant_temp > SENSOR_THRESHOLDS['coolant_temp_warning']:
+        recommendations.append("🔧 Check coolant level and radiator for blockages")
+        recommendations.append("🔧 Inspect water pump operation")
+    
+    if lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_low']:
+        recommendations.append("🔧 Check engine oil level immediately")
+        recommendations.append("🔧 Inspect oil pump and filter for blockages")
+    
+    if fuel_p < SENSOR_THRESHOLDS['fuel_pressure_low']:
+        recommendations.append("🔧 Check fuel filter for clogs")
+        recommendations.append("🔧 Inspect fuel pump performance")
+    
+    if rpm > SENSOR_THRESHOLDS['rpm_warning'] and prob > 0.5:
+        recommendations.append("🔧 Reduce engine load immediately")
+        recommendations.append("🔧 Schedule comprehensive engine inspection")
+    
+    # Model-based recommendations
+    if prob > 0.7:
+        recommendations.append("📅 Schedule immediate maintenance inspection")
+        recommendations.append("📊 Consider engine diagnostics scan")
+    elif prob > 0.4:
+        recommendations.append("📅 Schedule preventive maintenance within 48 hours")
+    
+    if not recommendations and not warnings:
+        recommendations.append("✅ All systems operating within normal parameters")
+        recommendations.append("📅 Continue regular maintenance schedule")
+    
+    return recommendations
 
-# --- CUSTOM CSS ---
-st.markdown("""
-    <style>
-    .main {background-color: #0e1117;}
-    h1 {text-align: center; color: white;}
+def calculate_feature_importance(input_df):
+    """Calculate normalized feature importance scores"""
+    rpm_score = input_df['Engine rpm'].values[0] / 2500
+    coolant_score = input_df['Coolant temp'].values[0] / 200
+    oil_score = max(0, 1 - (input_df['Lub oil pressure'].values[0] / 10))
+    fuel_score = input_df['Fuel pressure'].values[0] / 25
     
-    /* Center the Diagnostics Header */
-    .diag-header {
-        text-align: center;
-        font-weight: bold;
-        margin-bottom: 20px;
+    return {
+        'Engine RPM': rpm_score,
+        'Coolant Temperature': coolant_score,
+        'Oil Pressure (Risk)': oil_score,
+        'Fuel Pressure': fuel_score
     }
 
-    /* Increase Button Size */
-    div.stButton > button {
-        font-size: 24px !important;
-        font-weight: bold !important;
-        padding: 10px 20px !important;
-        width: 100%;
-        background-color: #ff4b4b;
-        color: white;
+def create_history_chart():
+    """Create historical trend chart"""
+    if len(st.session_state.history) < 2:
+        return None
+    
+    hist_df = pd.DataFrame(st.session_state.history)
+    
+    fig = make_subplots(
+        rows=2, cols=1,
+        subplot_titles=('Failure Probability Over Time', 'Engine RPM Over Time'),
+        vertical_spacing=0.15
+    )
+    
+    # Probability trend
+    fig.add_trace(
+        go.Scatter(
+            x=hist_df['timestamp'], 
+            y=hist_df['probability']*100,
+            mode='lines+markers',
+            name='Failure Risk (%)',
+            line=dict(color='red', width=2),
+            marker=dict(size=8)
+        ),
+        row=1, col=1
+    )
+    
+    # Add threshold line
+    fig.add_hline(
+        y=st.session_state.alert_threshold*100, 
+        line_dash="dash", 
+        line_color="orange",
+        annotation_text="Alert Threshold",
+        row=1, col=1
+    )
+    
+    # RPM trend
+    fig.add_trace(
+        go.Scatter(
+            x=hist_df['timestamp'], 
+            y=hist_df['rpm'],
+            mode='lines+markers',
+            name='RPM',
+            line=dict(color='cyan', width=2),
+            marker=dict(size=8)
+        ),
+        row=2, col=1
+    )
+    
+    fig.update_xaxes(title_text="Time", row=2, col=1)
+    fig.update_yaxes(title_text="Probability (%)", row=1, col=1)
+    fig.update_yaxes(title_text="RPM", row=2, col=1)
+    
+    fig.update_layout(height=500, showlegend=True)
+    return fig
+
+def export_report(input_df, prob, pred, warnings, critical, recommendations):
+    """Generate downloadable report"""
+    report = {
+        'Timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'Status': 'FAILURE RISK' if pred == 1 else 'OPERATIONAL',
+        'Failure Probability': f"{prob*100:.2f}%",
+        'Engine RPM': input_df['Engine rpm'].values[0],
+        'Fuel Pressure (Bar)': input_df['Fuel pressure'].values[0],
+        'Oil Pressure': input_df['Lub oil pressure'].values[0],
+        'Oil Temperature': input_df['lub oil temp'].values[0],
+        'Coolant Pressure': input_df['Coolant pressure'].values[0],
+        'Coolant Temperature': input_df['Coolant temp'].values[0],
+        'Warnings': '; '.join(warnings) if warnings else 'None',
+        'Critical Alerts': '; '.join(critical) if critical else 'None',
+        'Recommendations': '; '.join(recommendations[:3]) if recommendations else 'None'
     }
-    </style>
-    """, unsafe_allow_html=True)
-
-st.title("🏎️ Digital Twin: Engine Health Monitor")
-
-# --- DASHBOARD INPUTS (Left & Right Panels) ---
-col_left, col_center, col_right = st.columns([1.2, 2, 1.2])
-
-with col_left:
-    st.subheader("Fuel & Air")
-    rpm = st.slider("Engine RPM", 0, 2500, 750)
-    fuel_p = st.slider("Fuel Pressure (Bar)", 0.0, 25.0, 6.2)
-    st.plotly_chart(create_gauge(rpm, "RPM", 0, 2500, "cyan"), use_container_width=True)
-
-with col_right:
-    st.subheader("Cooling & Oil")
-    lub_oil_p = st.slider("Oil Pressure", 0.0, 10.0, 3.16)
-    coolant_temp = st.slider("Coolant Temp (°C)", 0.0, 200.0, 80.0)
-    st.plotly_chart(create_gauge(coolant_temp, "Coolant Temp", 0, 200, "orange"), use_container_width=True)
-
-# Additional Inputs
-with st.expander("More Sensors (Fine Tuning)"):
-    col_ex1, col_ex2 = st.columns(2)
-    with col_ex1:
-        coolant_p = st.number_input("Coolant Pressure", 0.0, 10.0, 2.16)
-    with col_ex2:
-        lub_oil_t = st.number_input("Oil Temp", 0.0, 100.0, 80.0)
-
-# --- PREDICTION CENTERPIECE ---
-with col_center:
-    # Center Aligned Header using HTML
-    st.markdown("<h2 class='diag-header'>🩺 Real-Time Diagnostics</h2>", unsafe_allow_html=True)
-    
-    if st.button("Analyze Engine Status"):
-        if model and scaler:
-            # Prepare Data
-            input_df = pd.DataFrame({
-                'Engine rpm': [rpm],
-                'Lub oil pressure': [lub_oil_p],
-                'Fuel pressure': [fuel_p],
-                'Coolant pressure': [coolant_p],
-                'lub oil temp': [lub_oil_t],
-                'Coolant temp': [coolant_temp]
-            })
+    return pd.DataFrame([report])
+
+# --- MAIN APP ---
+def main():
+    # Page config
+    st.set_page_config(
+        layout="wide", 
+        page_title="Engine Health Monitor", 
+        page_icon="🏎️",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Initialize session state
+    init_session_state()
+    
+    # Load model
+    model, scaler, error = load_artifacts()
+    
+    # Check if model loaded successfully
+    if model is None or scaler is None:
+        st.error(f"⚠️ Failed to load model: {error}")
+        st.info("Please check your HuggingFace configuration and ensure the model repository is accessible.")
+        st.stop()
+    
+    # --- SIDEBAR ---
+    with st.sidebar:
+        st.image("https://img.icons8.com/color/96/000000/engine.png", width=80)
+        st.title("⚙️ Settings")
+        
+        # Model info
+        st.subheader("Model Information")
+        st.info(f"**Repository:** {MODEL_REPO_ID}")
+        st.info(f"**Model File:** {MODEL_FILENAME}")
+        
+        # Settings
+        st.subheader("Configuration")
+        st.session_state.alert_threshold = st.slider(
+            "Alert Threshold", 
+            0.0, 1.0, 
+            st.session_state.alert_threshold,
+            help="Probability threshold for failure alerts"
+        )
+        
+        st.session_state.show_recommendations = st.checkbox(
+            "Show Recommendations", 
+            st.session_state.show_recommendations
+        )
+        
+        auto_refresh = st.checkbox("🔄 Auto-refresh (10s)", value=False)
+        
+        # History management
+        st.subheader("History")
+        if st.session_state.history:
+            st.metric("Total Analyses", len(st.session_state.history))
+            if st.button("Clear History"):
+                st.session_state.history = []
+                st.rerun()
+        else:
+            st.info("No analysis history yet")
+        
+        # Info
+        st.divider()
+        st.caption("🏎️ Digital Twin Engine Monitor v2.0")
+        st.caption("Powered by Streamlit & ML")
+    
+    # --- CUSTOM CSS ---
+    st.markdown("""
+        <style>
+        .main {background-color: #0e1117;}
+        h1 {text-align: center; color: white;}
+        
+        .diag-header {
+            text-align: center;
+            font-weight: bold;
+            margin-bottom: 20px;
+        }
+        
+        div.stButton > button {
+            font-size: 20px !important;
+            font-weight: bold !important;
+            padding: 10px 20px !important;
+            width: 100%;
+            background-color: #ff4b4b;
+            color: white;
+            border-radius: 10px;
+        }
+        
+        .metric-card {
+            background-color: #1e1e1e;
+            padding: 15px;
+            border-radius: 10px;
+            border-left: 4px solid #ff4b4b;
+        }
+        
+        .status-badge {
+            padding: 10px 20px;
+            border-radius: 20px;
+            font-weight: bold;
+            text-align: center;
+            font-size: 24px;
+        }
+        </style>
+        """, unsafe_allow_html=True)
+    
+    # --- HEADER ---
+    st.title("🏎️ Digital Twin: Engine Health Monitor")
+    st.markdown("### Real-time Predictive Maintenance System")
+    
+    # --- DASHBOARD INPUTS ---
+    col_left, col_center, col_right = st.columns([1.2, 2, 1.2])
+    
+    with col_left:
+        st.subheader("⛽ Fuel & Air Systems")
+        rpm = st.slider("Engine RPM", 0, 2500, 750, step=50)
+        fuel_p = st.slider("Fuel Pressure (Bar)", 0.0, 25.0, 6.2, step=0.1)
+        st.plotly_chart(
+            create_gauge(rpm, "RPM", 0, 2500, color="cyan"), 
+            use_container_width=True
+        )
+    
+    with col_right:
+        st.subheader("🛢️ Cooling & Lubrication")
+        lub_oil_p = st.slider("Oil Pressure (Bar)", 0.0, 10.0, 3.16, step=0.1)
+        coolant_temp = st.slider("Coolant Temp (°C)", 0.0, 200.0, 80.0, step=1.0)
+        st.plotly_chart(
+            create_gauge(coolant_temp, "Coolant Temp (°C)", 0, 200, color="orange"), 
+            use_container_width=True
+        )
+    
+    # Additional sensors
+    with st.expander("🔧 Advanced Sensor Configuration"):
+        col_ex1, col_ex2 = st.columns(2)
+        with col_ex1:
+            coolant_p = st.number_input(
+                "Coolant Pressure (Bar)", 
+                0.0, 10.0, 2.16, step=0.1,
+                help="Cooling system pressure"
+            )
+        with col_ex2:
+            lub_oil_t = st.number_input(
+                "Oil Temperature (°C)", 
+                0.0, 150.0, 80.0, step=1.0,
+                help="Lubrication oil temperature"
+            )
+    
+    # --- PREDICTION CENTER ---
+    with col_center:
+        st.markdown("<h2 class='diag-header'>🩺 Real-Time Diagnostics</h2>", unsafe_allow_html=True)
+        
+        # Validation warnings (before prediction)
+        warnings, critical = validate_inputs(rpm, fuel_p, lub_oil_p, coolant_temp, coolant_p, lub_oil_t)
+        
+        if critical:
+            for alert in critical:
+                st.error(alert)
+        
+        if warnings:
+            with st.expander("⚠️ Sensor Warnings", expanded=True):
+                for warning in warnings:
+                    st.warning(warning)
+        
+        # Analysis button
+        if st.button("🔍 Analyze Engine Status"):
+            # Prepare input
+            input_df = prepare_input_data(rpm, lub_oil_p, fuel_p, coolant_p, lub_oil_t, coolant_temp)
             
-            # Scale & Predict
-            scaled = scaler.transform(input_df)
-            pred = model.predict(scaled)[0]
-            try:
-                prob = model.predict_proba(scaled)[0][1]
-            except:
-                prob = 0.0
-
-            # --- DYNAMIC DASHBOARD DISPLAY ---
+            # Run prediction
+            pred, prob, pred_error = run_prediction(model, scaler, input_df)
             
-            # Create Gauge Figure (Used for both cases)
-            gauge_color = "red" if prob > 0.5 else "green"
-            fig_prob = go.Figure(go.Indicator(
-                mode = "gauge+number",
-                value = prob * 100,
-                title = {'text': "Failure Probability (%)", 'font': {'size': 20}},
-                gauge = {
-                    'axis': {'range': [0, 100]}, 
-                    'bar': {'color': gauge_color},
-                    'threshold': {
-                        'line': {'color': "red", 'width': 4},
-                        'thickness': 0.75,
-                        'value': 90
-                    }
-                }
-            ))
-            fig_prob.update_layout(height=300, margin=dict(l=20, r=20, t=50, b=20))
-
-            # --- SIDE-BY-SIDE LAYOUT ---
-            # Create two columns within the center column
-            res_col1, res_col2 = st.columns([1, 1], gap="medium")
-
-            if pred == 1:
-                st.error("🚨 CRITICAL FAILURE DETECTED")
-                img_url = "https://freesvg.org/img/check-engine.png"
+            if pred_error:
+                st.error(f"Prediction error: {pred_error}")
             else:
-                st.success("✅ SYSTEMS NOMINAL")
-                img_url = "https://img.freepik.com/premium-vector/check-engine-light-icon-vector-illustration_529846-559.jpg"
-
-            with res_col1:
+                # Store in history
+                st.session_state.history.append({
+                    'timestamp': datetime.now(),
+                    'rpm': rpm,
+                    'probability': prob,
+                    'status': 'FAIL' if pred == 1 else 'OK',
+                    'coolant_temp': coolant_temp,
+                    'oil_pressure': lub_oil_p
+                })
+                
+                # Get status
+                status_badge, status_color, status_text = get_status_info(prob)
+                
+                # Create probability gauge
+                gauge_color = "red" if prob > 0.5 else "green"
+                fig_prob = go.Figure(go.Indicator(
+                    mode = "gauge+number",
+                    value = prob * 100,
+                    title = {'text': "Failure Probability (%)", 'font': {'size': 20}},
+                    number = {'suffix': "%", 'font': {'size': 40}},
+                    gauge = {
+                        'axis': {'range': [0, 100]}, 
+                        'bar': {'color': gauge_color},
+                        'steps': [
+                            {'range': [0, 25], 'color': "#90EE90"},
+                            {'range': [25, 50], 'color': "#FFD700"},
+                            {'range': [50, 75], 'color': "#FFA500"},
+                            {'range': [75, 100], 'color': "#FF6B6B"}
+                        ],
+                        'threshold': {
+                            'line': {'color': "red", 'width': 4},
+                            'thickness': 0.75,
+                            'value': st.session_state.alert_threshold * 100
+                        }
+                    }
+                ))
+                fig_prob.update_layout(height=300, margin=dict(l=20, r=20, t=50, b=20))
+                
+                # Display results
                 st.markdown(
-                    f'<div style="display: flex; justify-content: center; align-items: center; height: 300px;">'
-                    f'<img src="{img_url}" style="max-height: 250px; max-width: 100%; border-radius: 10px;">'
-                    f'</div>', 
+                    f"<div class='status-badge' style='background-color: {status_color}20; "
+                    f"color: {status_color}; border: 2px solid {status_color};'>"
+                    f"{status_badge}</div>", 
                     unsafe_allow_html=True
                 )
+                st.markdown("<br>", unsafe_allow_html=True)
+                
+                # Side-by-side layout
+                res_col1, res_col2 = st.columns([1, 1], gap="medium")
+                
+                # Image based on status
+                if pred == 1 or prob > st.session_state.alert_threshold:
+                    img_url = "https://freesvg.org/img/check-engine.png"
+                else:
+                    img_url = "https://img.freepik.com/premium-vector/check-engine-light-icon-vector-illustration_529846-559.jpg"
+                
+                with res_col1:
+                    st.markdown(
+                        f'<div style="display: flex; justify-content: center; align-items: center; height: 300px;">'
+                        f'<img src="{img_url}" style="max-height: 250px; max-width: 100%; border-radius: 10px;">'
+                        f'</div>', 
+                        unsafe_allow_html=True
+                    )
+                
+                with res_col2:
+                    st.plotly_chart(fig_prob, use_container_width=True)
+                
+                # Feature importance
+                if prob > 0.3:
+                    st.markdown("---")
+                    st.subheader("⚡ Key Risk Factors")
+                    feature_scores = calculate_feature_importance(input_df)
+                    sorted_factors = sorted(feature_scores.items(), key=lambda x: x[1], reverse=True)
+                    
+                    cols = st.columns(4)
+                    for idx, (factor, severity) in enumerate(sorted_factors):
+                        with cols[idx]:
+                            st.metric(
+                                factor, 
+                                f"{severity*100:.1f}%",
+                                delta=None,
+                                help=f"Normalized risk score for {factor}"
+                            )
+                
+                # Recommendations
+                if st.session_state.show_recommendations:
+                    st.markdown("---")
+                    recommendations = get_recommendations(input_df, prob, warnings, critical)
+                    
+                    if recommendations:
+                        st.subheader("🛠️ Recommended Actions")
+                        for i, rec in enumerate(recommendations, 1):
+                            st.write(f"{i}. {rec}")
+                
+                # Export report
+                st.markdown("---")
+                report_df = export_report(input_df, prob, pred, warnings, critical, recommendations)
+                csv = report_df.to_csv(index=False)
+                
+                col_export1, col_export2 = st.columns(2)
+                with col_export1:
+                    st.download_button(
+                        "📥 Download Report (CSV)", 
+                        csv, 
+                        f"engine_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        "text/csv",
+                        use_container_width=True
+                    )
+                
+                with col_export2:
+                    json_report = report_df.to_json(orient='records', indent=2)
+                    st.download_button(
+                        "📥 Download Report (JSON)", 
+                        json_report, 
+                        f"engine_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                        "application/json",
+                        use_container_width=True
+                    )
+        else:
+            st.info("👆 Adjust the sensor sliders above and click **Analyze Engine Status** to run diagnostics")
+    
+    # --- HISTORICAL TRENDS ---
+    if st.session_state.history:
+        st.markdown("---")
+        st.subheader("📊 Historical Analysis")
+        
+        trend_chart = create_history_chart()
+        if trend_chart:
+            st.plotly_chart(trend_chart, use_container_width=True)
             
-            with res_col2:
-                st.plotly_chart(fig_prob, use_container_width=True)
+            # Summary statistics
+            hist_df = pd.DataFrame(st.session_state.history)
+            col_stat1, col_stat2, col_stat3, col_stat4 = st.columns(4)
+            
+            with col_stat1:
+                st.metric("Average Risk", f"{hist_df['probability'].mean()*100:.1f}%")
+            with col_stat2:
+                st.metric("Max Risk", f"{hist_df['probability'].max()*100:.1f}%")
+            with col_stat3:
+                failures = (hist_df['status'] == 'FAIL').sum()
+                st.metric("Failure Alerts", failures)
+            with col_stat4:
+                st.metric("Total Analyses", len(hist_df))
+    
+    # Auto-refresh logic
+    if auto_refresh:
+        import time
+        time.sleep(10)
+        st.rerun()
 
-    else:
-        st.info("Adjust sliders and click Analyze")
+if __name__ == "__main__":
+    main()