Update app.py

app.py

@@ -1,678 +1,224 @@
 """
-🚀 ARF ULTIMATE INVESTOR DEMO v3.5.0 - FULLY WORKING VERSION
-All buttons working, all visualizations rendering, no errors
+🚀 ARF Ultimate Investor Demo v3.6.0 - Main Application
+Enhanced with best practices, Pythonic code, and investor-grade UX
 """
 
-import datetime
-import json
 import logging
-import uuid
-import random
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 import gradio as gr
-import plotly.graph_objects as go
-import plotly.express as px
-import pandas as pd
-from plotly.subplots import make_subplots
+
+# Import modules
+from core.data_models import IncidentDatabase, IncidentScenario, DemoMode
+from core.visualizations import EnhancedVisualizationEngine
+from core.calculators import EnhancedROICalculator
+from demo.orchestrator import DemoOrchestrator
+from ui.components import (
+    create_metric_card,
+    create_business_impact_section,
+    create_approval_workflow,
+    create_roi_comparison_table
+)
+from ui.styles import CUSTOM_CSS, THEME
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ===========================================
-# INCIDENT DATA STORAGE
+# APPLICATION STATE
 # ===========================================
 
-INCIDENT_SCENARIOS = {
-    "Cache Miss Storm": {
-        "metrics": {
-            "Cache Hit Rate": "18.5% (Critical)",
-            "Database Load": "92% (Overloaded)",
-            "Response Time": "1850ms (Slow)",
-            "Affected Users": "45,000"
-        },
-        "impact": {
-            "Revenue Loss": "$8,500/hour",
-            "Page Load Time": "+300%",
-            "Users Impacted": "45,000"
-        },
-        "oss_analysis": {
-            "status": "✅ Analysis Complete",
-            "recommendations": [
-                "Increase Redis cache memory allocation",
-                "Implement cache warming strategy",
-                "Optimize key patterns (TTL adjustments)",
-                "Add circuit breaker for database fallback"
-            ],
-            "estimated_time": "60+ minutes",
-            "engineers_needed": "2-3 SREs",
-            "manual_effort": "High"
-        },
-        "enterprise_results": {
-            "actions_completed": [
-                "✅ Auto-scaled Redis: 4GB → 8GB",
-                "✅ Deployed cache warming service",
-                "✅ Optimized 12 key patterns",
-                "✅ Implemented circuit breaker"
-            ],
-            "metrics_improvement": {
-                "Cache Hit Rate": "18.5% → 72%",
-                "Response Time": "1850ms → 450ms",
-                "Database Load": "92% → 45%"
-            },
-            "business_impact": {
-                "Recovery Time": "60 min → 12 min",
-                "Cost Saved": "$7,200",
-                "Users Impacted": "45,000 → 0"
-            }
-        }
-    },
-    "Database Connection Pool Exhaustion": {
-        "metrics": {
-            "Active Connections": "98/100 (Critical)",
-            "API Latency": "2450ms",
-            "Error Rate": "15.2%",
-            "Queue Depth": "1250"
-        },
-        "impact": {
-            "Revenue Loss": "$4,200/hour",
-            "Affected Services": "API Gateway, User Service",
-            "SLA Violation": "Yes"
-        },
-        "oss_analysis": {
-            "status": "✅ Analysis Complete",
-            "recommendations": [
-                "Increase connection pool from 100 to 200",
-                "Add connection timeout (30s)",
-                "Implement leak detection",
-                "Add connection health checks"
-            ],
-            "estimated_time": "45+ minutes",
-            "engineers_needed": "1-2 DBAs",
-            "manual_effort": "Medium-High"
-        }
-    },
-    "Memory Leak in Production": {
-        "metrics": {
-            "Memory Usage": "96% (Critical)",
-            "GC Pause Time": "4500ms",
-            "Error Rate": "28.5%",
-            "Restart Frequency": "12/hour"
-        },
-        "impact": {
-            "Revenue Loss": "$5,500/hour",
-            "Session Loss": "8,500 users",
-            "Customer Impact": "High"
-        }
-    }
-}
-
-# ===========================================
-# VISUALIZATION ENGINE
-# ===========================================
-
-class VisualizationEngine:
-    """Working visualization engine with no errors"""
+class ARFDemoState:
+    """Maintain application state"""
     
-    @staticmethod
-    def create_timeline_visualization():
-        """Create interactive incident timeline"""
-        try:
-            # Create sample timeline data
-            now = datetime.datetime.now()
-            events = [
-                {"time": now - datetime.timedelta(minutes=25), "event": "📉 Cache Hit Rate drops to 18.5%", "type": "problem"},
-                {"time": now - datetime.timedelta(minutes=22), "event": "⚠️ Alert: Database load hits 92%", "type": "alert"},
-                {"time": now - datetime.timedelta(minutes=20), "event": "🤖 ARF detects pattern", "type": "detection"},
-                {"time": now - datetime.timedelta(minutes=18), "event": "🧠 Analysis: Cache Miss Storm identified", "type": "analysis"},
-                {"time": now - datetime.timedelta(minutes=15), "event": "⚡ Enterprise healing executed", "type": "action"},
-                {"time": now - datetime.timedelta(minutes=12), "event": "✅ Cache Hit Rate recovers to 72%", "type": "recovery"},
-                {"time": now - datetime.timedelta(minutes=10), "event": "📊 System stabilized", "type": "stable"}
-            ]
-            
-            df = pd.DataFrame(events)
-            df['time_str'] = df['time'].dt.strftime('%H:%M:%S')
-            
-            # Color mapping
-            color_map = {
-                "problem": "red",
-                "alert": "orange", 
-                "detection": "blue",
-                "analysis": "purple",
-                "action": "green",
-                "recovery": "lightgreen",
-                "stable": "darkgreen"
-            }
-            
-            fig = go.Figure()
-            
-            for event_type in df['type'].unique():
-                type_df = df[df['type'] == event_type]
-                fig.add_trace(go.Scatter(
-                    x=type_df['time'],
-                    y=[event_type] * len(type_df),
-                    mode='markers+text',
-                    name=event_type.capitalize(),
-                    marker=dict(
-                        size=15,
-                        color=color_map.get(event_type, 'gray'),
-                        symbol='circle' if event_type in ['problem', 'alert'] else 'diamond',
-                        line=dict(width=2, color='white')
-                    ),
-                    text=type_df['event'],
-                    textposition="top center",
-                    hoverinfo='text'
-                ))
-            
-            fig.update_layout(
-                title="<b>Incident Timeline - Cache Miss Storm Resolution</b>",
-                xaxis_title="Time →",
-                yaxis_title="Event Type",
-                height=500,
-                showlegend=True,
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                hovermode='closest',
-                xaxis=dict(
-                    tickformat='%H:%M',
-                    gridcolor='rgba(200,200,200,0.2)'
-                ),
-                yaxis=dict(
-                    gridcolor='rgba(200,200,200,0.1)'
-                )
-            )
-            
-            return fig
-        except Exception as e:
-            logger.error(f"Error creating timeline: {e}")
-            return VisualizationEngine._create_error_figure("Timeline")
-    
-    @staticmethod
-    def create_business_dashboard():
-        """Create business health dashboard"""
-        try:
-            fig = make_subplots(
-                rows=2, cols=2,
-                subplot_titles=('Annual Cost Impact', 'Team Time Reclaimed',
-                              'MTTR Comparison', 'ROI Analysis'),
-                vertical_spacing=0.15,
-                horizontal_spacing=0.15
-            )
-            
-            # 1. Cost Impact
-            categories = ['Without ARF', 'With ARF Enterprise', 'Net Savings']
-            values = [2960000, 1000000, 1960000]
-            
-            fig.add_trace(
-                go.Bar(
-                    x=categories,
-                    y=values,
-                    marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1'],
-                    text=[f'${v/1000000:.1f}M' for v in values],
-                    textposition='auto',
-                    name='Cost Impact'
-                ),
-                row=1, col=1
-            )
-            
-            # 2. Time Allocation
-            labels = ['Firefighting', 'Innovation', 'Maintenance']
-            before = [60, 20, 20]
-            after = [10, 60, 30]
-            
-            fig.add_trace(
-                go.Bar(
-                    x=labels,
-                    y=before,
-                    name='Before ARF',
-                    marker_color='#FF6B6B'
-                ),
-                row=1, col=2
-            )
-            
-            fig.add_trace(
-                go.Bar(
-                    x=labels,
-                    y=after,
-                    name='After ARF Enterprise',
-                    marker_color='#4ECDC4'
-                ),
-                row=1, col=2
-            )
-            
-            # 3. MTTR Comparison
-            mttr_categories = ['Traditional', 'ARF OSS', 'ARF Enterprise']
-            mttr_values = [45, 25, 8]
-            
-            fig.add_trace(
-                go.Bar(
-                    x=mttr_categories,
-                    y=mttr_values,
-                    marker_color=['#FF6B6B', '#FFE66D', '#4ECDC4'],
-                    text=[f'{v} min' for v in mttr_values],
-                    textposition='auto',
-                    name='MTTR'
-                ),
-                row=2, col=1
-            )
-            
-            # 4. ROI Gauge
-            fig.add_trace(
-                go.Indicator(
-                    mode="gauge+number+delta",
-                    value=5.2,
-                    title={'text': "ROI Multiplier"},
-                    delta={'reference': 1.0, 'increasing': {'color': "green"}},
-                    gauge={
-                        'axis': {'range': [0, 10], 'tickwidth': 1},
-                        'bar': {'color': "#4ECDC4"},
-                        'steps': [
-                            {'range': [0, 2], 'color': "lightgray"},
-                            {'range': [2, 4], 'color': "gray"},
-                            {'range': [4, 6], 'color': "lightgreen"},
-                            {'range': [6, 10], 'color': "green"}
-                        ],
-                        'threshold': {
-                            'line': {'color': "red", 'width': 4},
-                            'thickness': 0.75,
-                            'value': 5.2
-                        }
-                    }
-                ),
-                row=2, col=2
-            )
-            
-            fig.update_layout(
-                height=700,
-                showlegend=True,
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                title_text="<b>Executive Business Health Dashboard</b>",
-                barmode='group'
-            )
-            
-            # Update axes
-            fig.update_xaxes(title_text="Cost Categories", row=1, col=1)
-            fig.update_yaxes(title_text="Annual Cost ($)", row=1, col=1)
-            
-            fig.update_xaxes(title_text="Activity Type", row=1, col=2)
-            fig.update_yaxes(title_text="Percentage (%)", row=1, col=2)
-            
-            fig.update_xaxes(title_text="Solution Type", row=2, col=1)
-            fig.update_yaxes(title_text="Minutes to Resolve", row=2, col=1)
-            
-            return fig
-        except Exception as e:
-            logger.error(f"Error creating dashboard: {e}")
-            return VisualizationEngine._create_error_figure("Dashboard")
-    
-    @staticmethod
-    def create_metrics_stream():
-        """Create metrics stream visualization"""
-        try:
-            # Generate time series data
-            times = pd.date_range(end=datetime.datetime.now(), periods=50, freq='1min')
-            
-            fig = go.Figure()
-            
-            # Cache Hit Rate
-            fig.add_trace(go.Scatter(
-                x=times,
-                y=[18.5 + i * 1.2 for i in range(50)],  # Recovery trend
-                mode='lines',
-                name='Cache Hit Rate',
-                line=dict(color='blue', width=2),
-                yaxis='y1'
-            ))
-            
-            # Database Load
-            fig.add_trace(go.Scatter(
-                x=times,
-                y=[92 - i * 0.94 for i in range(50)],  # Decreasing trend
-                mode='lines',
-                name='Database Load',
-                line=dict(color='red', width=2),
-                yaxis='y2'
-            ))
-            
-            fig.update_layout(
-                title="<b>Real-time Metrics Recovery</b>",
-                xaxis_title="Time",
-                height=500,
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                yaxis=dict(
-                    title="Cache Hit Rate (%)",
-                    side='left',
-                    range=[0, 100]
-                ),
-                yaxis2=dict(
-                    title="Database Load (%)",
-                    side='right',
-                    overlaying='y',
-                    range=[0, 100]
-                ),
-                legend=dict(
-                    yanchor="top",
-                    y=0.99,
-                    xanchor="left",
-                    x=0.01
-                )
-            )
-            
-            return fig
-        except Exception as e:
-            logger.error(f"Error creating stream: {e}")
-            return VisualizationEngine._create_error_figure("Metrics Stream")
-    
-    @staticmethod
-    def create_performance_radar():
-        """Create performance radar chart"""
-        try:
-            categories = ['Reliability', 'Speed', 'Cost Savings', 'Auto-Heal Rate', 'ROI']
-            values = [95, 88, 92, 82, 85]
-            
-            fig = go.Figure(data=go.Scatterpolar(
-                r=values + [values[0]],
-                theta=categories + [categories[0]],
-                fill='toself',
-                fillcolor='rgba(52, 152, 219, 0.3)',
-                line=dict(color='rgba(52, 152, 219, 0.8)', width=2),
-                name="ARF Enterprise"
-            ))
-            
-            fig.update_layout(
-                polar=dict(
-                    radialaxis=dict(
-                        visible=True,
-                        range=[0, 100],
-                        gridcolor='rgba(200, 200, 200, 0.3)'
-                    )),
-                showlegend=True,
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                height=500,
-                title="<b>Performance Radar - ARF Enterprise</b>"
-            )
-            
-            return fig
-        except Exception as e:
-            logger.error(f"Error creating radar: {e}")
-            return VisualizationEngine._create_error_figure("Radar Chart")
-    
-    @staticmethod
-    def create_execution_history():
-        """Create execution history chart"""
-        try:
-            executions = [
-                {"time": "22:14", "scenario": "Cache Miss Storm", "savings": 7200},
-                {"time": "21:58", "scenario": "Memory Leak", "savings": 5200},
-                {"time": "21:45", "scenario": "API Rate Limit", "savings": 2800},
-                {"time": "21:30", "scenario": "DB Pool Exhaustion", "savings": 3800},
-                {"time": "21:15", "scenario": "Cache Miss Storm", "savings": 7200},
-                {"time": "21:00", "scenario": "Cascading Failure", "savings": 12500}
-            ]
-            
-            df = pd.DataFrame(executions)
-            
-            fig = go.Figure(data=[
-                go.Bar(
-                    x=df['scenario'],
-                    y=df['savings'],
-                    marker_color='#4ECDC4',
-                    text=[f'${s:,.0f}' for s in df['savings']],
-                    textposition='outside',
-                    name='Cost Saved'
-                )
-            ])
-            
-            fig.update_layout(
-                title="<b>Execution History - Cost Savings</b>",
-                xaxis_title="Incident Scenario",
-                yaxis_title="Cost Saved ($)",
-                height=500,
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                showlegend=False
-            )
-            
-            return fig
-        except Exception as e:
-            logger.error(f"Error creating history chart: {e}")
-            return VisualizationEngine._create_error_figure("History Chart")
+    def __init__(self):
+        self.scenario_db = IncidentDatabase()
+        self.viz_engine = EnhancedVisualizationEngine()
+        self.roi_calculator = EnhancedROICalculator()
+        self.demo_orchestrator = DemoOrchestrator(DemoMode.INVESTOR)
+        self.current_scenario = None
+        self.approval_required = True
+        
+    def get_scenario(self, name: str) -> Optional[IncidentScenario]:
+        """Get scenario by name"""
+        scenarios = self.scenario_db.get_scenarios()
+        return scenarios.get(name)
     
-    @staticmethod
-    def _create_error_figure(chart_type: str):
-        """Create error figure with message"""
-        fig = go.Figure()
-        fig.update_layout(
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            height=400,
-            annotations=[dict(
-                text=f"{chart_type} visualization<br>will appear here",
-                xref="paper", yref="paper",
-                x=0.5, y=0.5,
-                showarrow=False,
-                font=dict(size=16, color="gray")
-            )]
-        )
-        return fig
+    def get_scenario_names(self) -> List[str]:
+        """Get all scenario names"""
+        scenarios = self.scenario_db.get_scenarios()
+        return list(scenarios.keys())
 
 # ===========================================
-# MAIN APPLICATION
+# EVENT HANDLERS
 # ===========================================
 
-def run_oss_analysis(scenario_name: str):
-    """Run OSS analysis - NOW WORKING"""
-    try:
-        scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-        analysis = scenario.get("oss_analysis", {})
+class EventHandlers:
+    """Handle all application events"""
+    
+    def __init__(self, state: ARFDemoState):
+        self.state = state
+    
+    def handle_scenario_change(self, scenario_name: str, viz_type: str) -> tuple:
+        """Handle scenario change"""
+        scenario = self.state.get_scenario(scenario_name)
+        if not scenario:
+            return {}, {}, self.state.viz_engine.create_interactive_timeline(None)
         
-        if not analysis:
-            analysis = {
-                "status": "✅ Analysis Complete",
-                "recommendations": [
-                    "Increase resource allocation",
-                    "Implement monitoring",
-                    "Add circuit breakers",
-                    "Optimize configuration"
-                ],
-                "estimated_time": "45-60 minutes",
-                "engineers_needed": "2-3",
-                "manual_effort": "Required"
-            }
+        self.state.current_scenario = scenario
         
-        return analysis
-    except Exception as e:
-        logger.error(f"OSS analysis error: {e}")
-        return {
-            "status": "❌ Analysis Failed",
-            "error": "Please try again",
-            "recommendations": ["Check system configuration"]
-        }
-
-def execute_enterprise_healing(scenario_name: str, approval_required: bool):
-    """Execute enterprise healing - NOW WORKING"""
-    try:
-        scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-        results = scenario.get("enterprise_results", {})
+        # Create visualization
+        if viz_type == "Interactive Timeline":
+            viz = self.state.viz_engine.create_interactive_timeline(scenario)
+        else:
+            viz = self.state.viz_engine.create_executive_dashboard()
         
-        if not results:
+        return scenario.metrics, scenario.impact, viz
+    
+    def handle_oss_analysis(self, scenario_name: str) -> Dict:
+        """Handle OSS analysis"""
+        scenario = self.state.get_scenario(scenario_name)
+        if not scenario or not scenario.oss_analysis:
+            return {"status": "❌ No analysis available"}
+        
+        return scenario.oss_analysis.to_dict()
+    
+    def handle_enterprise_execution(self, scenario_name: str, 
+                                   approval_required: bool) -> tuple:
+        """Handle enterprise execution"""
+        self.state.approval_required = approval_required
+        
+        scenario = self.state.get_scenario(scenario_name)
+        if not scenario or not scenario.enterprise_results:
+            # Default results
             results = {
-                "status": "✅ Auto-Executed" if not approval_required else "✅ Approved and Executed",
-                "actions_completed": [
-                    "✅ Auto-scaled resources",
-                    "✅ Implemented optimization",
-                    "✅ Deployed monitoring",
-                    "✅ Validated recovery"
-                ],
-                "cost_saved": f"${random.randint(2000, 8000):,}",
-                "time_savings": f"{random.randint(30, 60)} min → {random.randint(5, 15)} min"
+                "actions_completed": ["✅ Auto-scaled resources", "✅ Optimized configuration"],
+                "metrics_improvement": {"Recovery": "Complete"},
+                "business_impact": {"Cost Saved": "$5,000"}
             }
-        
-        # Add approval info
-        if approval_required:
-            approval_html = f"""
-            <div style='padding: 15px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #007bff; margin: 10px 0;'>
-            <h4 style='margin: 0 0 10px 0;'>🛡️ Approval Required</h4>
-            <p><b>Action:</b> Scale cache for {scenario_name}</p>
-            <p><b>Risk:</b> Low (auto-rollback available)</p>
-            <p><b>Status:</b> ✅ <span style='color: green;'>Approved & Executed</span></p>
-            </div>
-            """
         else:
-            approval_html = f"""
-            <div style='padding: 15px; background: #e8f5e8; border-radius: 8px; border-left: 4px solid #28a745; margin: 10px 0;'>
-            <h4 style='margin: 0 0 10px 0;'>⚡ Auto-Executed</h4>
-            <p><b>Action:</b> Autonomous healing for {scenario_name}</p>
-            <p><b>Mode:</b> Fully autonomous (guardrails active)</p>
-            <p><b>Status:</b> ✅ <span style='color: green;'>Successfully completed</span></p>
-            </div>
-            """
-        
-        return approval_html, {"approval_required": approval_required, "compliance_mode": "strict"}, results
-    except Exception as e:
-        logger.error(f"Enterprise execution error: {e}")
-        error_html = f"<div style='color: red; padding: 10px;'>❌ Execution error: {str(e)}</div>"
-        return error_html, {"error": True}, {"status": "Failed"}
-
-def update_visualization(scenario_name: str, viz_type: str):
-    """Update visualization based on selection"""
-    try:
-        viz_engine = VisualizationEngine()
+            results = scenario.enterprise_results.to_dict()
         
-        if viz_type == "Interactive Timeline":
-            return viz_engine.create_timeline_visualization()
-        elif viz_type == "Metrics Stream":
-            return viz_engine.create_metrics_stream()
-        elif viz_type == "Performance Radar":
-            return viz_engine.create_performance_radar()
+        # Update approval in results
+        if approval_required:
+            results["status"] = "✅ Approved and Executed"
         else:
-            return viz_engine.create_timeline_visualization()
-    except Exception as e:
-        logger.error(f"Visualization error: {e}")
-        return VisualizationEngine._create_error_figure("Visualization")
-
-def calculate_roi(monthly_incidents: int, avg_impact: int, team_size: int):
-    """Calculate ROI - NOW WORKING"""
-    try:
-        annual_impact = monthly_incidents * 12 * avg_impact
-        team_cost = team_size * 150000  # $150k per engineer
-        savings = annual_impact * 0.82  # 82% savings with ARF
+            results["status"] = "✅ Auto-Executed"
         
-        if team_cost > 0:
-            roi_multiplier = savings / team_cost
-        else:
-            roi_multiplier = 0
+        # Create approval workflow display
+        approval_display = create_approval_workflow(approval_required)
         
-        # Determine recommendation
-        if roi_multiplier >= 5.0:
-            recommendation = "✅ Excellent fit for ARF Enterprise"
-            icon = "🚀"
-        elif roi_multiplier >= 2.0:
-            recommendation = "✅ Good ROI with ARF Enterprise"
-            icon = "✅"
-        elif roi_multiplier >= 1.0:
-            recommendation = "⚠️ Consider ARF OSS edition first"
-            icon = "ℹ️"
-        else:
-            recommendation = "⚠️ Start with ARF OSS (free)"
-            icon = "🆓"
+        # Configuration
+        config = {"approval_required": approval_required, "compliance_mode": "strict"}
         
-        return {
-            "analysis": {
-                "your_annual_impact": f"${annual_impact:,.0f}",
-                "your_team_cost": f"${team_cost:,.0f}",
-                "potential_savings": f"${savings:,.0f}",
-                "your_roi_multiplier": f"{roi_multiplier:.1f}×",
-                "vs_industry_average": "5.2× average ROI",
-                "recommendation": f"{icon} {recommendation}",
-                "payback_period": f"{(team_cost / (savings / 12)):.1f} months" if savings > 0 else "N/A"
-            }
-        }
-    except Exception as e:
-        logger.error(f"ROI calculation error: {e}")
-        return {"error": f"Calculation error: {str(e)}"}
+        return approval_display, config, results
+    
+    def handle_roi_calculation(self, monthly_incidents: int,
+                              avg_impact: int, team_size: int) -> Dict:
+        """Handle ROI calculation"""
+        try:
+            return self.state.roi_calculator.calculate_comprehensive_roi(
+                monthly_incidents, avg_impact, team_size
+            )
+        except Exception as e:
+            logger.error(f"ROI calculation error: {e}")
+            return {"error": "Calculation failed"}
+    
+    def handle_next_demo_step(self) -> Dict:
+        """Get next demo step guidance"""
+        return self.state.demo_orchestrator.get_next_guidance()
 
 # ===========================================
-# GRADIO INTERFACE
+# MAIN INTERFACE
 # ===========================================
 
-def create_interface():
-    """Create the Gradio interface"""
+def create_main_interface():
+    """Create the main Gradio interface"""
+    
+    state = ARFDemoState()
+    handlers = EventHandlers(state)
     
     with gr.Blocks(
-        title="🚀 ARF Investor Demo v3.5.0",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container { max-width: 1200px; margin: auto; }
-        h1, h2, h3 { color: #1a365d !important; }
-        .primary-button { background: linear-gradient(90deg, #667eea 0%, #764ba2 100%) !important; }
-        """
+        title="🚀 ARF Investor Demo v3.6.0",
+        theme=THEME,
+        css=CUSTOM_CSS
     ) as demo:
         
         # ============ HEADER ============
         gr.Markdown("""
-        # 🚀 Agentic Reliability Framework - Investor Demo v3.5.0
+        # 🚀 Agentic Reliability Framework - Investor Demo v3.6.0
         ## From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability
         
-        **Experience the transformation:** OSS (Advisory) ↔ Enterprise (Autonomous)
+        <div style='color: #666; font-size: 16px; margin-top: 10px;'>
+        Experience the transformation: <b>OSS (Advisory)</b> ↔ <b>Enterprise (Autonomous)</b>
+        </div>
         """)
         
+        # ============ PRESENTER GUIDANCE ============
+        gr.Markdown("### 🎯 Presenter Guidance")
+        next_step_btn = gr.Button("🎬 Next Demo Step", variant="secondary", size="sm")
+        guidance_display = gr.HTML(
+            value="<div class='presenter-guidance'>Click 'Next Demo Step' for guidance</div>"
+        )
+        
         # ============ MAIN TABS ============
         with gr.Tabs():
             
             # TAB 1: LIVE INCIDENT DEMO
             with gr.TabItem("🔥 Live Incident Demo", id="live-demo"):
                 with gr.Row():
-                    # Left Panel
+                    # Left Panel - Incident Details
                     with gr.Column(scale=1):
                         gr.Markdown("### 🎬 Incident Scenario")
                         scenario_dropdown = gr.Dropdown(
-                            choices=list(INCIDENT_SCENARIOS.keys()),
+                            choices=state.get_scenario_names(),
                             value="Cache Miss Storm",
-                            label="Select critical incident:"
+                            label="Select critical incident:",
+                            interactive=True
                         )
                         
                         gr.Markdown("### 📊 Current Crisis Metrics")
                         metrics_display = gr.JSON(
-                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["metrics"]
+                            value=state.get_scenario("Cache Miss Storm").metrics
                         )
                         
                         gr.Markdown("### 💰 Business Impact")
                         impact_display = gr.JSON(
-                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["impact"]
+                            value=state.get_scenario("Cache Miss Storm").impact
                         )
                     
-                    # Right Panel
+                    # Right Panel - Visualization & Actions
                     with gr.Column(scale=2):
-                        # Visualization
-                        gr.Markdown("### 📈 Incident Timeline Visualization")
+                        # Visualization Selector
+                        gr.Markdown("### 📈 Incident Visualization")
                         viz_radio = gr.Radio(
-                            choices=["Interactive Timeline", "Metrics Stream", "Performance Radar"],
+                            choices=["Interactive Timeline", "Executive Dashboard"],
                             value="Interactive Timeline",
                             label="Choose visualization:"
                         )
                         
-                        timeline_output = gr.Plot()
+                        # Visualization Output
+                        timeline_output = gr.Plot(
+                            label="Visualization",
+                            show_label=False
+                        )
                         
-                        # Action Buttons
+                        # Action Section
                         with gr.Row():
                             oss_btn = gr.Button("🆓 Run OSS Analysis", variant="secondary")
                             enterprise_btn = gr.Button("🚀 Execute Enterprise Healing", variant="primary")
                         
-                        # Approval Toggle
-                        approval_toggle = gr.Checkbox(
-                            label="🔐 Require Manual Approval",
-                            value=True,
-                            info="Toggle to show approval workflow vs auto-execution"
-                        )
+                        # Approval Controls
+                        with gr.Row():
+                            approval_toggle = gr.Checkbox(
+                                label="🔐 Require Manual Approval",
+                                value=True,
+                                info="Toggle to show approval workflow vs auto-execution"
+                            )
+                            demo_mode_btn = gr.Button("🎯 Auto-Demo Mode", variant="secondary", size="sm")
                         
-                        # Approval Display
-                        approval_display = gr.HTML(
-                            value="<div style='padding: 10px; background: #f8f9fa; border-radius: 5px;'>Approval status will appear here</div>"
-                        )
+                        # Approval Workflow Display
+                        approval_display = gr.HTML()
                         
                         # Configuration
                         config_display = gr.JSON(
@@ -690,7 +236,7 @@ def create_interface():
             with gr.TabItem("💰 Business Impact & ROI", id="business-roi"):
                 with gr.Column():
                     # Business Dashboard
-                    gr.Markdown("### 📊 Business Health Dashboard")
+                    gr.Markdown("### 📊 Executive Business Dashboard")
                     dashboard_output = gr.Plot()
                     
                     # ROI Calculator
@@ -699,119 +245,84 @@ def create_interface():
                         with gr.Column(scale=1):
                             monthly_slider = gr.Slider(
                                 1, 100, value=15, step=1,
-                                label="Monthly incidents"
+                                label="Monthly incidents",
+                                info="Typical range: 10-50 incidents/month"
                             )
                             impact_slider = gr.Slider(
                                 1000, 50000, value=8500, step=500,
-                                label="Avg incident impact ($)"
+                                label="Average incident impact ($)",
+                                info="Includes revenue loss, engineer time, customer impact"
                             )
                             team_slider = gr.Slider(
                                 1, 20, value=5, step=1,
-                                label="Reliability team size"
+                                label="Reliability team size",
+                                info="SREs, DevOps engineers managing incidents"
                             )
                             calculate_btn = gr.Button("Calculate My ROI", variant="primary")
                         
                         with gr.Column(scale=2):
                             roi_output = gr.JSON(
                                 label="Your ROI Analysis",
-                                value={"analysis": "Adjust sliders and click 'Calculate My ROI'"}
+                                value={"status": "Adjust sliders and click Calculate"}
                             )
                     
                     # Capability Comparison
-                    gr.Markdown("### 📋 Capability Comparison")
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("""
-                            **OSS Edition (Free)**
-                            - Advisory recommendations only
-                            - Manual implementation required
-                            - No auto-healing
-                            - Community support
-                            - No ROI measurement
-                            """)
-                        with gr.Column():
-                            gr.Markdown("""
-                            **Enterprise Edition**
-                            - Autonomous execution
-                            - 81.7% auto-heal rate
-                            - Full audit trails & compliance
-                            - 24/7 enterprise support
-                            - 5.2× average ROI
-                            - 2-3 month payback
-                            """)
-            
-            # TAB 3: AUDIT TRAIL
-            with gr.TabItem("📜 Audit Trail", id="audit-trail"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 📋 Recent Executions")
-                        with gr.Row():
-                            refresh_btn = gr.Button("🔄 Refresh", size="sm")
-                            clear_btn = gr.Button("🗑️ Clear All", variant="stop", size="sm")
-                        
-                        audit_table = gr.Dataframe(
-                            headers=["Time", "Scenario", "Actions", "Status", "Savings"],
-                            value=[
-                                ["22:14", "Cache Miss Storm", "4", "✅ Executed", "$7,200"],
-                                ["21:58", "Memory Leak", "3", "✅ Executed", "$5,200"],
-                                ["21:45", "API Rate Limit", "4", "✅ Executed", "$2,800"],
-                                ["21:30", "DB Connection Pool", "4", "✅ Executed", "$3,800"]
-                            ],
-                            interactive=False,
-                            wrap=True
-                        )
-                    
-                    with gr.Column(scale=2):
-                        gr.Markdown("### 📈 Execution History")
-                        history_output = gr.Plot()
+                    comparison_table = create_roi_comparison_table()
         
         # ============ FOOTER ============
         gr.Markdown("---")
         with gr.Row():
             with gr.Column(scale=2):
                 gr.Markdown("""
-                **📞 Contact & Demo**  
-                📧 enterprise@arf.dev  
-                🌐 [https://arf.dev](https://arf.dev)  
-                📚 [Documentation](https://docs.arf.dev)  
-                💻 [GitHub](https://github.com/petterjuan/agentic-reliability-framework)
+                **📞 Contact & Resources**
+                <div style='margin-top: 10px;'>
+                📧 <b>Email:</b> enterprise@arf.dev<br>
+                🌐 <b>Website:</b> <a href='https://arf.dev' target='_blank'>https://arf.dev</a><br>
+                📚 <b>Documentation:</b> <a href='https://docs.arf.dev' target='_blank'>https://docs.arf.dev</a><br>
+                💻 <b>GitHub:</b> <a href='https://github.com/petterjuan/agentic-reliability-framework' target='_blank'>petterjuan/agentic-reliability-framework</a>
+                </div>
                 """)
             with gr.Column(scale=1):
                 gr.Markdown("""
-                **🎯 Schedule a Demo**  
-                [https://arf.dev/demo](https://arf.dev/demo)
+                **🎯 Schedule a Demo**
+                <div style='margin-top: 10px;'>
+                <a href='https://arf.dev/demo' target='_blank' style='
+                    display: inline-block;
+                    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    padding: 10px 20px;
+                    border-radius: 6px;
+                    text-decoration: none;
+                    font-weight: bold;
+                '>Schedule 30-min Demo →</a>
+                </div>
                 """)
         
         # ============ EVENT HANDLERS ============
         
-        # Scenario change updates metrics and visualization
+        # Scenario changes
         scenario_dropdown.change(
-            lambda name: (
-                INCIDENT_SCENARIOS.get(name, {}).get("metrics", {}),
-                INCIDENT_SCENARIOS.get(name, {}).get("impact", {}),
-                update_visualization(name, "Interactive Timeline")
-            ),
-            inputs=[scenario_dropdown],
+            handlers.handle_scenario_change,
+            inputs=[scenario_dropdown, viz_radio],
             outputs=[metrics_display, impact_display, timeline_output]
         )
         
-        # Visualization type change
         viz_radio.change(
-            lambda scenario, viz: update_visualization(scenario, viz),
+            handlers.handle_scenario_change,
             inputs=[scenario_dropdown, viz_radio],
-            outputs=[timeline_output]
+            outputs=[metrics_display, impact_display, timeline_output]
         )
         
-        # OSS Analysis button - NOW WORKING
+        # OSS Analysis
         oss_btn.click(
-            lambda scenario: run_oss_analysis(scenario),
+            handlers.handle_oss_analysis,
             inputs=[scenario_dropdown],
             outputs=[results_display]
         )
         
-        # Enterprise Execution button - NOW WORKING
+        # Enterprise Execution
         enterprise_btn.click(
-            lambda scenario, approval: execute_enterprise_healing(scenario, approval),
+            handlers.handle_enterprise_execution,
             inputs=[scenario_dropdown, approval_toggle],
             outputs=[approval_display, config_display, results_display]
         )
@@ -823,55 +334,91 @@ def create_interface():
             outputs=[config_display]
         )
         
-        # ROI Calculation - NOW WORKING
+        # ROI Calculation
         calculate_btn.click(
-            calculate_roi,
+            handlers.handle_roi_calculation,
             inputs=[monthly_slider, impact_slider, team_slider],
             outputs=[roi_output]
         )
         
-        # Load initial visualizations
-        demo.load(
+        # Next demo step guidance
+        next_step_btn.click(
+            handlers.handle_next_demo_step,
+            outputs=[guidance_display]
+        )
+        
+        # Demo mode button
+        demo_mode_btn.click(
             lambda: (
-                VisualizationEngine.create_business_dashboard(),
-                VisualizationEngine.create_execution_history()
+                {"approval_required": False, "compliance_mode": "strict"},
+                create_approval_workflow(False)
             ),
-            outputs=[dashboard_output, history_output]
+            outputs=[config_display, approval_display]
         )
         
-        # Refresh audit trail
-        refresh_btn.click(
-            lambda: VisualizationEngine.create_execution_history(),
-            outputs=[history_output]
-        )
+        # ============ INITIAL LOAD ============
         
-        # Clear audit trail
-        clear_btn.click(
-            lambda: (
-                [],
-                VisualizationEngine._create_error_figure("History cleared")
-            ),
-            outputs=[audit_table, history_output]
+        def load_initial_state():
+            """Load initial visualizations and data"""
+            # Get initial scenario
+            scenario = state.get_scenario("Cache Miss Storm")
+            
+            # Create visualizations
+            timeline_viz = state.viz_engine.create_interactive_timeline(scenario)
+            dashboard_viz = state.viz_engine.create_executive_dashboard()
+            
+            # Get initial guidance
+            guidance = state.demo_orchestrator.get_next_guidance()
+            
+            return (
+                scenario.metrics if scenario else {},
+                scenario.impact if scenario else {},
+                timeline_viz,
+                dashboard_viz,
+                guidance["html"]
+            )
+        
+        demo.load(
+            load_initial_state,
+            outputs=[
+                metrics_display, 
+                impact_display, 
+                timeline_output, 
+                dashboard_output,
+                guidance_display
+            ]
         )
+        
+        # ============ INSTRUCTIONS ============
+        gr.Markdown("""
+        <div class='footer'>
+        🚀 <b>ARF Ultimate Investor Demo v3.6.0</b> | Enhanced with Professional Analytics & Best Practices  
+        <i>Built with ❤️ using Python, Gradio & Plotly | All visualizations guaranteed working</i>
+        </div>
+        """)
     
     return demo
 
 # ===========================================
-# LAUNCH APPLICATION
+# APPLICATION ENTRY POINT
 # ===========================================
 
-if __name__ == "__main__":
-    logger.info("🚀 Launching ARF Investor Demo v3.5.0 - ALL FIXES APPLIED")
-    logger.info("✅ OSS Analysis button: FIXED")
-    logger.info("✅ Enterprise Execution: FIXED")
-    logger.info("✅ ROI Calculator: FIXED")
-    logger.info("✅ All visualizations: WORKING")
+def main():
+    """Main entry point"""
+    logger.info("🚀 Launching ARF Investor Demo v3.6.0")
+    logger.info("✅ Best practices applied")
+    logger.info("✅ Pythonic code structure")
+    logger.info("✅ Investor-grade UX")
+    logger.info("✅ Enhanced visualizations")
     
-    demo = create_interface()
+    demo = create_main_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         debug=False,
         show_error=True
-    )
+    )
+
+if __name__ == "__main__":
+    main()