Update core/visualizations.py

core/visualizations.py

@@ -1,258 +1,468 @@
 """
-Enhanced investor-grade visualizations - FIXED VERSION
+Enhanced visualization engine for ARF Demo
 """
-
 import plotly.graph_objects as go
 import plotly.express as px
-import pandas as pd
 import numpy as np
-from plotly.subplots import make_subplots
-from datetime import datetime
-from typing import Dict, Optional, List
+import pandas as pd
+from typing import Dict, List, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
 
-from core.data_models import IncidentScenario
 
 class EnhancedVisualizationEngine:
-    """Interactive, investor-grade visualizations"""
+    """Enhanced visualization engine with multiple chart types"""
     
     def __init__(self):
-        self.color_palette = px.colors.qualitative.Set3
-        self.theme = {
-            "background": "rgba(0,0,0,0)",
-            "grid": "rgba(200,200,200,0.1)",
-            "critical": "#FF6B6B",
-            "warning": "#FFE66D",
-            "success": "#4ECDC4",
-            "info": "#45B7D1"
+        self.color_palette = {
+            "primary": "#3b82f6",
+            "success": "#10b981",
+            "warning": "#f59e0b",
+            "danger": "#ef4444",
+            "info": "#8b5cf6",
+            "dark": "#1e293b",
+            "light": "#f8fafc"
         }
     
-    def create_interactive_timeline(self, scenario: IncidentScenario) -> go.Figure:
-        """Create truly interactive timeline with annotations"""
+    def create_executive_dashboard(self, data: Optional[Dict] = None) -> go.Figure:
+        """Create executive dashboard with ROI visualization"""
+        if data is None:
+            data = {"roi_multiplier": 5.2}
+        
+        roi_multiplier = data.get("roi_multiplier", 5.2)
+        
+        # Create a multi-panel executive dashboard
         fig = go.Figure()
         
-        # Create timeline events
-        events = [
-            {"time": "T-5m", "event": "📉 Cache hit rate drops below 20%", "type": "problem"},
-            {"time": "T-4m", "event": "⚠️ Database load exceeds 90%", "type": "alert"},
-            {"time": "T-3m", "event": "🤖 ARF detects pattern", "type": "detection"},
-            {"time": "T-2m", "event": "🧠 Analysis complete", "type": "analysis"},
-            {"time": "T-1m", "event": "⚡ Healing executed", "type": "action"},
-            {"time": "T-0m", "event": "✅ System recovered", "type": "recovery"}
-        ]
+        # Main ROI gauge
+        fig.add_trace(go.Indicator(
+            mode="number+gauge",
+            value=roi_multiplier,
+            title={"text": "<b>ROI Multiplier</b><br>Investment Return"},
+            domain={'x': [0.25, 0.75], 'y': [0.6, 1]},
+            gauge={
+                'axis': {'range': [0, 10], 'tickwidth': 1},
+                'bar': {'color': self.color_palette["success"]},
+                'steps': [
+                    {'range': [0, 2], 'color': '#e5e7eb'},
+                    {'range': [2, 4], 'color': '#d1d5db'},
+                    {'range': [4, 6], 'color': '#10b981'},
+                    {'range': [6, 10], 'color': '#059669'}
+                ],
+                'threshold': {
+                    'line': {'color': "black", 'width': 4},
+                    'thickness': 0.75,
+                    'value': roi_multiplier
+                }
+            }
+        ))
         
-        # Color mapping
-        color_map = {
-            "problem": self.theme["critical"],
-            "alert": self.theme["warning"],
-            "detection": self.theme["info"],
-            "analysis": "#9B59B6",
-            "action": self.theme["success"],
-            "recovery": "#2ECC71"
-        }
+        # Add secondary metrics as subplots
+        fig.add_trace(go.Indicator(
+            mode="number",
+            value=85,
+            title={"text": "MTTR Reduction"},
+            number={'suffix': "%", 'font': {'size': 24}},
+            domain={'x': [0.1, 0.4], 'y': [0.2, 0.5]}
+        ))
+        
+        fig.add_trace(go.Indicator(
+            mode="number",
+            value=94,
+            title={"text": "Detection Accuracy"},
+            number={'suffix': "%", 'font': {'size': 24}},
+            domain={'x': [0.6, 0.9], 'y': [0.2, 0.5]}
+        ))
         
-        # Add events
-        for event in events:
+        fig.update_layout(
+            height=700,
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            font={'family': "Arial, sans-serif"},
+            margin=dict(t=50, b=50, l=50, r=50)
+        )
+        
+        return fig
+    
+    def create_telemetry_plot(self, scenario_name: str, anomaly_detected: bool = True) -> go.Figure:
+        """Create telemetry plot for a scenario"""
+        # Generate realistic telemetry data
+        time_points = np.arange(0, 100, 1)
+        
+        # Different patterns for different scenarios
+        if "Cache" in scenario_name:
+            base_data = 100 + 50 * np.sin(time_points * 0.2)
+            noise = np.random.normal(0, 8, 100)
+            metric_name = "Cache Hit Rate (%)"
+            normal_range = (70, 95)
+        elif "Database" in scenario_name:
+            base_data = 70 + 30 * np.sin(time_points * 0.15)
+            noise = np.random.normal(0, 6, 100)
+            metric_name = "Connection Pool Usage"
+            normal_range = (20, 60)
+        elif "Memory" in scenario_name:
+            base_data = 50 + 40 * np.sin(time_points * 0.1)
+            noise = np.random.normal(0, 10, 100)
+            metric_name = "Memory Usage (%)"
+            normal_range = (40, 80)
+        else:
+            base_data = 80 + 20 * np.sin(time_points * 0.25)
+            noise = np.random.normal(0, 5, 100)
+            metric_name = "System Load"
+            normal_range = (50, 90)
+        
+        data = base_data + noise
+        
+        fig = go.Figure()
+        
+        if anomaly_detected:
+            # Normal operation
             fig.add_trace(go.Scatter(
-                x=[event["time"]],
-                y=[1],
-                mode='markers+text',
-                marker=dict(
-                    size=20,
-                    color=color_map[event["type"]],
-                    symbol='circle',
-                    line=dict(width=2, color='white')
-                ),
-                text=[event["event"]],
-                textposition="top center",
-                hoverinfo='text',
-                name=event["type"].capitalize(),
-                hovertemplate="<b>%{text}</b><br>Click for details<extra></extra>"
+                x=time_points[:70],
+                y=data[:70],
+                mode='lines',
+                name='Normal Operation',
+                line=dict(color=self.color_palette["primary"], width=3),
+                fill='tozeroy',
+                fillcolor='rgba(59, 130, 246, 0.1)'
+            ))
+            
+            # Anomaly period
+            fig.add_trace(go.Scatter(
+                x=time_points[70:],
+                y=data[70:],
+                mode='lines',
+                name='Anomaly Detected',
+                line=dict(color=self.color_palette["danger"], width=3, dash='dash'),
+                fill='tozeroy',
+                fillcolor='rgba(239, 68, 68, 0.1)'
+            ))
+            
+            # Add detection point
+            fig.add_vline(
+                x=70,
+                line_dash="dash",
+                line_color=self.color_palette["success"],
+                annotation_text="ARF Detection",
+                annotation_position="top"
+            )
+        else:
+            # All normal
+            fig.add_trace(go.Scatter(
+                x=time_points,
+                y=data,
+                mode='lines',
+                name=metric_name,
+                line=dict(color=self.color_palette["primary"], width=3),
+                fill='tozeroy',
+                fillcolor='rgba(59, 130, 246, 0.1)'
             ))
         
-        # Add connecting line
-        fig.add_trace(go.Scatter(
-            x=[e["time"] for e in events],
-            y=[1] * len(events),
-            mode='lines',
-            line=dict(color='gray', width=2, dash='dash'),
-            hoverinfo='none',
-            showlegend=False
-        ))
+        # Add normal range
+        fig.add_hrect(
+            y0=normal_range[0],
+            y1=normal_range[1],
+            fillcolor="rgba(16, 185, 129, 0.1)",
+            opacity=0.2,
+            line_width=0,
+            annotation_text="Normal Range",
+            annotation_position="top left"
+        )
         
         fig.update_layout(
-            title="<b>Interactive Incident Timeline</b><br><sup>Click events for details</sup>",
-            height=450,
-            paper_bgcolor=self.theme["background"],
-            plot_bgcolor=self.theme["background"],
-            hovermode='closest',
-            clickmode='event+select',
-            yaxis=dict(
-                showticklabels=False,
-                range=[0.5, 1.5],
-                gridcolor=self.theme["grid"]
-            ),
-            xaxis=dict(
-                gridcolor=self.theme["grid"]
-            ),
-            showlegend=True,
+            title=f"📈 {metric_name} - Live Telemetry",
+            xaxis_title="Time (minutes)",
+            yaxis_title=metric_name,
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20),
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
             legend=dict(
-                yanchor="top",
-                y=0.99,
-                xanchor="left",
-                x=0.01
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
             )
         )
         
         return fig
     
-    def create_executive_dashboard(self, user_roi: Optional[Dict] = None) -> go.Figure:
-        """Create comprehensive executive dashboard - FIXED VERSION"""
-        # FIX: Handle None or empty user_roi
-        if user_roi is None:
-            user_roi = {}
-        
-        # Get ROI value safely
-        roi_value = user_roi.get('roi_multiplier', 5.2)
-        
-        # If roi_value is a string with "×", convert it
-        if isinstance(roi_value, str):
-            if "×" in roi_value:
-                try:
-                    roi_value = float(roi_value.replace("×", ""))
-                except:
-                    roi_value = 5.2
-            else:
-                try:
-                    roi_value = float(roi_value)
-                except:
-                    roi_value = 5.2
-        
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=(
-                '<b>Cost Transformation</b>',
-                '<b>Team Capacity Shift</b>',
-                '<b>MTTR Comparison</b>',
-                '<b>ROI Analysis</b>'
-            ),
-            vertical_spacing=0.2,
-            horizontal_spacing=0.15
+    def create_impact_gauge(self, scenario_name: str) -> go.Figure:
+        """Create business impact gauge"""
+        impact_map = {
+            "Cache Miss Storm": {"revenue": 8500, "severity": "critical"},
+            "Database Connection Pool Exhaustion": {"revenue": 4200, "severity": "high"},
+            "Kubernetes Memory Leak": {"revenue": 5500, "severity": "high"},
+            "API Rate Limit Storm": {"revenue": 3800, "severity": "medium"},
+            "Network Partition": {"revenue": 12000, "severity": "critical"},
+            "Storage I/O Saturation": {"revenue": 6800, "severity": "high"}
+        }
+        
+        impact = impact_map.get(scenario_name, {"revenue": 5000, "severity": "medium"})
+        
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=impact["revenue"],
+            title={'text': "💰 Hourly Revenue Risk", 'font': {'size': 16}},
+            number={'prefix': "$", 'font': {'size': 28}},
+            gauge={
+                'axis': {'range': [0, 15000], 'tickwidth': 1},
+                'bar': {'color': self._get_severity_color(impact["severity"])},
+                'steps': [
+                    {'range': [0, 3000], 'color': '#10b981'},
+                    {'range': [3000, 7000], 'color': '#f59e0b'},
+                    {'range': [7000, 15000], 'color': '#ef4444'}
+                ],
+                'threshold': {
+                    'line': {'color': "black", 'width': 4},
+                    'thickness': 0.75,
+                    'value': impact["revenue"]
+                }
+            }
+        ))
+        
+        fig.update_layout(
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20),
+            paper_bgcolor='rgba(0,0,0,0)'
         )
         
-        # 1. Cost Transformation
-        cost_labels = ['Without ARF', 'With ARF Enterprise', 'Net Savings']
-        cost_values = [2.96, 1.0, 1.96]  # In millions
-        
-        fig.add_trace(
-            go.Bar(
-                x=cost_labels,
-                y=cost_values,
-                marker_color=[self.theme["critical"], self.theme["success"], '#45B7D1'],
-                text=[f'${v}M' for v in cost_values],
-                textposition='auto',
-                name='Annual Cost',
-                hovertemplate="<b>%{x}</b><br>Cost: $%{y}M<extra></extra>"
-            ),
-            row=1, col=1
+        return fig
+    
+    def create_agent_performance_chart(self) -> go.Figure:
+        """Create agent performance comparison chart"""
+        agents = ["Detection", "Recall", "Decision"]
+        accuracy = [98.7, 92.0, 94.0]
+        speed = [45, 30, 60]  # seconds
+        confidence = [99.8, 92.0, 94.0]
+        
+        fig = go.Figure(data=[
+            go.Bar(name='Accuracy (%)', x=agents, y=accuracy, 
+                   marker_color=self.color_palette["primary"]),
+            go.Bar(name='Speed (seconds)', x=agents, y=speed,
+                   marker_color=self.color_palette["success"]),
+            go.Bar(name='Confidence (%)', x=agents, y=confidence,
+                   marker_color=self.color_palette["info"])
+        ])
+        
+        fig.update_layout(
+            title="🤖 Agent Performance Metrics",
+            barmode='group',
+            height=400,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
         )
         
-        # 2. Team Capacity Shift
-        activities = ['Firefighting', 'Innovation', 'Strategic Work']
-        before = [60, 20, 20]
-        after = [10, 60, 30]
-        
-        fig.add_trace(
-            go.Bar(
-                x=activities,
-                y=before,
-                name='Before ARF',
-                marker_color=self.theme["critical"],
-                opacity=0.7,
-                hovertemplate="Before: %{y}%%<extra></extra>"
+        return fig
+    
+    def create_timeline_comparison(self) -> go.Figure:
+        """Create timeline comparison chart"""
+        phases = ["Detection", "Analysis", "Decision", "Execution", "Recovery"]
+        manual_times = [300, 1800, 1200, 1800, 3600]  # seconds
+        arf_times = [45, 30, 60, 720, 0]
+        
+        # Convert to minutes for readability
+        manual_times_min = [t/60 for t in manual_times]
+        arf_times_min = [t/60 for t in arf_times]
+        
+        fig = go.Figure()
+        
+        fig.add_trace(go.Bar(
+            name='Manual Process',
+            x=phases,
+            y=manual_times_min,
+            marker_color=self.color_palette["danger"],
+            text=[f"{t:.0f}m" for t in manual_times_min],
+            textposition='auto'
+        ))
+        
+        fig.add_trace(go.Bar(
+            name='ARF Autonomous',
+            x=phases,
+            y=arf_times_min,
+            marker_color=self.color_palette["success"],
+            text=[f"{t:.0f}m" for t in arf_times_min],
+            textposition='auto'
+        ))
+        
+        total_manual = sum(manual_times_min)
+        total_arf = sum(arf_times_min)
+        
+        fig.update_layout(
+            title=f"⏰ Incident Timeline Comparison<br>"
+                  f"<span style='font-size: 14px; color: #6b7280'>"
+                  f"Total: {total_manual:.0f}m manual vs {total_arf:.0f}m ARF "
+                  f"({((total_manual - total_arf) / total_manual * 100):.0f}% faster)</span>",
+            barmode='group',
+            height=400,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
             ),
-            row=1, col=2
+            yaxis_title="Time (minutes)"
         )
         
-        fig.add_trace(
-            go.Bar(
-                x=activities,
-                y=after,
-                name='After ARF Enterprise',
-                marker_color=self.theme["success"],
-                opacity=0.7,
-                hovertemplate="After: %{y}%%<extra></extra>"
-            ),
-            row=1, col=2
+        return fig
+    
+    def create_roi_simulation_chart(self, roi_data: Dict) -> go.Figure:
+        """Create ROI simulation chart"""
+        scenarios = ["Worst Case", "Base Case", "Best Case"]
+        roi_values = [
+            roi_data.get("worst_case", 4.0),
+            roi_data.get("base_case", 5.2),
+            roi_data.get("best_case", 6.5)
+        ]
+        
+        fig = go.Figure(go.Bar(
+            x=scenarios,
+            y=roi_values,
+            marker_color=[
+                self.color_palette["warning"],
+                self.color_palette["success"],
+                self.color_palette["primary"]
+            ],
+            text=[f"{v:.1f}×" for v in roi_values],
+            textposition='auto'
+        ))
+        
+        fig.update_layout(
+            title="📊 ROI Simulation Scenarios",
+            yaxis_title="ROI Multiplier",
+            height=400,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            yaxis=dict(range=[0, max(roi_values) * 1.2])
         )
         
-        # 3. MTTR Comparison
-        mttr_methods = ['Manual', 'Traditional', 'ARF OSS', 'ARF Enterprise']
-        mttr_times = [120, 45, 25, 8]
-        
-        fig.add_trace(
-            go.Bar(
-                x=mttr_methods,
-                y=mttr_times,
-                marker_color=[self.theme["critical"], '#FFE66D', '#45B7D1', self.theme["success"]],
-                text=[f'{t} min' for t in mttr_times],
-                textposition='auto',
-                name='MTTR',
-                hovertemplate="<b>%{x}</b><br>Resolution: %{y} min<extra></extra>"
-            ),
-            row=2, col=1
+        # Add industry average line
+        fig.add_hline(
+            y=5.2,
+            line_dash="dash",
+            line_color="gray",
+            annotation_text="Industry Average",
+            annotation_position="top right"
         )
         
-        # 4. ROI Gauge
-        fig.add_trace(
-            go.Indicator(
-                mode="gauge+number+delta",
-                value=roi_value,
-                title={'text': "<b>ROI Multiplier</b>", 'font': {'size': 16}},
-                delta={'reference': 1.0, 'increasing': {'color': self.theme["success"]}},
-                gauge={
-                    'axis': {'range': [0, 10], 'tickwidth': 1},
-                    'bar': {'color': self.theme["success"]},
-                    'steps': [
-                        {'range': [0, 2], 'color': 'lightgray'},
-                        {'range': [2, 4], 'color': 'gray'},
-                        {'range': [4, 6], 'color': 'lightgreen'},
-                        {'range': [6, 10], 'color': self.theme["success"]}
-                    ],
-                    'threshold': {
-                        'line': {'color': "red", 'width': 4},
-                        'thickness': 0.75,
-                        'value': roi_value
-                    }
-                }
-            ),
-            row=2, col=2
+        return fig
+    
+    def create_learning_graph(self, graph_type: str = "patterns") -> go.Figure:
+        """Create learning engine visualization"""
+        if graph_type == "patterns":
+            return self._create_pattern_graph()
+        elif graph_type == "dependencies":
+            return self._create_dependency_graph()
+        else:
+            return self._create_action_graph()
+    
+    def _create_pattern_graph(self) -> go.Figure:
+        """Create pattern recognition graph"""
+        nodes = ["Cache Miss", "DB Pool", "Memory Leak", "API Limit", "Network"]
+        connections = [
+            ("Cache Miss", "DB Pool", 0.85),
+            ("DB Pool", "Memory Leak", 0.72),
+            ("Memory Leak", "API Limit", 0.65),
+            ("API Limit", "Network", 0.58),
+            ("Cache Miss", "Network", 0.45)
+        ]
+        
+        fig = go.Figure()
+        
+        # Add nodes
+        for node in nodes:
+            fig.add_trace(go.Scatter(
+                x=[np.random.random()],
+                y=[np.random.random()],
+                mode='markers+text',
+                name=node,
+                marker=dict(size=30, color=self.color_palette["primary"]),
+                text=[node],
+                textposition="top center"
+            ))
+        
+        # Add edges
+        for src, dst, weight in connections:
+            fig.add_trace(go.Scatter(
+                x=[np.random.random(), np.random.random()],
+                y=[np.random.random(), np.random.random()],
+                mode='lines',
+                line=dict(width=weight * 5, color='gray'),
+                showlegend=False
+            ))
+        
+        fig.update_layout(
+            title="🧠 RAG Memory - Incident Pattern Graph",
+            height=500,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            showlegend=False,
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
         )
         
-        # Update layout
+        return fig
+    
+    def _create_dependency_graph(self) -> go.Figure:
+        """Create system dependency graph"""
+        fig = go.Figure(go.Sunburst(
+            labels=["System", "Cache", "Database", "API", "User Service", "Payment"],
+            parents=["", "System", "System", "System", "API", "API"],
+            values=[100, 30, 40, 30, 15, 15],
+            marker=dict(colors=px.colors.sequential.Blues)
+        ))
+        
         fig.update_layout(
-            height=700,
-            showlegend=True,
-            paper_bgcolor=self.theme["background"],
-            plot_bgcolor=self.theme["background"],
-            title_text="<b>Executive Business Dashboard</b>",
-            barmode='group',
-            legend=dict(
-                yanchor="top",
-                y=0.99,
-                xanchor="left",
-                x=0.01,
-                bgcolor='rgba(255,255,255,0.9)'
-            )
+            title="🔗 System Dependency Map",
+            height=500,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)'
         )
         
-        # Update axes
-        fig.update_xaxes(title_text="Cost Model", row=1, col=1, gridcolor=self.theme["grid"])
-        fig.update_yaxes(title_text="Annual Cost ($M)", row=1, col=1, gridcolor=self.theme["grid"])
+        return fig
+    
+    def _create_action_graph(self) -> go.Figure:
+        """Create action-outcome graph"""
+        actions = ["Scale Cache", "Restart DB", "Limit API", "Monitor Memory"]
+        success_rates = [87, 92, 78, 85]
         
-        fig.update_xaxes(title_text="Activity", row=1, col=2, gridcolor=self.theme["grid"])
-        fig.update_yaxes(title_text="Time Allocation (%)", row=1, col=2, gridcolor=self.theme["grid"])
+        fig = go.Figure(go.Bar(
+            x=actions,
+            y=success_rates,
+            marker_color=self.color_palette["success"],
+            text=[f"{rate}%" for rate in success_rates],
+            textposition='auto'
+        ))
         
-        fig.update_xaxes(title_text="Resolution Method", row=2, col=1, gridcolor=self.theme["grid"])
-        fig.update_yaxes(title_text="Minutes to Resolve", row=2, col=1, gridcolor=self.theme["grid"])
+        fig.update_layout(
+            title="🎯 Action Success Rates",
+            yaxis_title="Success Rate (%)",
+            height=400,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            yaxis=dict(range=[0, 100])
+        )
         
-        return fig
+        return fig
+    
+    def _get_severity_color(self, severity: str) -> str:
+        """Get color for severity level"""
+        color_map = {
+            "critical": self.color_palette["danger"],
+            "high": self.color_palette["warning"],
+            "medium": self.color_palette["info"],
+            "low": self.color_palette["success"]
+        }
+        return color_map.get(severity.lower(), self.color_palette["info"])