"""
🚀 ARF Ultimate Investor Demo v3.8.0 - ENTERPRISE EDITION
MODULAR VERSION - Properly integrated with all components
"""

import logging
import sys
import traceback
import json
import datetime
import asyncio
import time
import numpy as np
from pathlib import Path
from typing import Dict, List, Any, Optional, Tuple

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('arf_demo.log')
    ]
)
logger = logging.getLogger(__name__)

# Add parent directory to path
sys.path.insert(0, str(Path(__file__).parent))

# ===========================================
# IMPORT MODULAR COMPONENTS
# ===========================================
try:
    # Import scenarios
    from demo.scenarios import INCIDENT_SCENARIOS
    
    # Import orchestrator
    from demo.orchestrator import DemoOrchestrator
    
    # Import ROI calculator
    from core.calculators import ROI_Calculator
    
    # Import visualizations
    from core.visualizations import EnhancedVisualizationEngine
    
    # Import UI components
    from ui.components import (
        create_header, create_status_bar, create_tab1_incident_demo,
        create_tab2_business_roi, create_tab3_enterprise_features,
        create_tab4_audit_trail, create_tab5_learning_engine,
        create_footer
    )
    
    logger.info("✅ Successfully imported all modular components")
    
except ImportError as e:
    logger.error(f"Failed to import components: {e}")
    logger.error(traceback.format_exc())
    raise

# ===========================================
# AUDIT TRAIL MANAGER
# ===========================================
class AuditTrailManager:
    """Simple audit trail manager"""
    
    def __init__(self):
        self.executions = []
        self.incidents = []
    
    def add_execution(self, scenario, mode, success=True, savings=0):
        entry = {
            "time": datetime.datetime.now().strftime("%H:%M"),
            "scenario": scenario,
            "mode": mode,
            "status": "✅ Success" if success else "❌ Failed",
            "savings": f"${savings:,}",
            "details": f"{mode} execution"
        }
        self.executions.insert(0, entry)
        return entry
    
    def add_incident(self, scenario, severity="HIGH"):
        entry = {
            "time": datetime.datetime.now().strftime("%H:%M"),
            "scenario": scenario,
            "severity": severity,
            "component": INCIDENT_SCENARIOS.get(scenario, {}).get("component", "unknown"),
            "status": "Analyzed"
        }
        self.incidents.insert(0, entry)
        return entry
    
    def get_execution_table(self):
        return [
            [e["time"], e["scenario"], e["mode"], e["status"], e["savings"], e["details"]]
            for e in self.executions[:10]
        ]
    
    def get_incident_table(self):
        return [
            [e["time"], e["component"], e["scenario"], e["severity"], e["status"]]
            for e in self.incidents[:15]
        ]

# ===========================================
# CREATE DEMO INTERFACE - MODULAR VERSION
# ===========================================
def create_demo_interface():
    """Create demo interface using modular components"""
    
    import gradio as gr
    
    # Initialize components
    viz_engine = EnhancedVisualizationEngine()
    roi_calculator = ROI_Calculator()
    audit_manager = AuditTrailManager()
    orchestrator = DemoOrchestrator()
    
    with gr.Blocks(
        title="🚀 ARF Investor Demo v3.8.0",
        theme=gr.themes.Soft(primary_hue="blue")
    ) as demo:
        
        # Header
        create_header("3.3.6", False)  # OSS version, Mock mode
        
        # Status bar
        create_status_bar()
        
        # ============ 5 TABS ============
        with gr.Tabs():
            
            # TAB 1: Live Incident Demo
            with gr.TabItem("🔥 Live Incident Demo", id="tab1"):
                # Get components from UI module
                (scenario_dropdown, scenario_description, metrics_display, impact_display,
                 timeline_output, oss_btn, enterprise_btn, approval_toggle, demo_btn,
                 approval_display, oss_results_display, enterprise_results_display) = create_tab1_incident_demo(
                    INCIDENT_SCENARIOS, "Cache Miss Storm"
                )
            
            # TAB 2: Business Impact & ROI
            with gr.TabItem("💰 Business Impact & ROI", id="tab2"):
                (dashboard_output, roi_scenario_dropdown, monthly_slider, team_slider,
                 calculate_btn, roi_output, roi_chart) = create_tab2_business_roi()
            
            # TAB 3: Enterprise Features
            with gr.TabItem("🏢 Enterprise Features", id="tab3"):
                (license_display, validate_btn, trial_btn, upgrade_btn,
                 mcp_mode, mcp_mode_info, features_table, integrations_table) = create_tab3_enterprise_features()
            
            # TAB 4: Audit Trail & History
            with gr.TabItem("📜 Audit Trail & History", id="tab4"):
                (refresh_btn, clear_btn, export_btn, execution_table,
                 incident_table, export_text) = create_tab4_audit_trail()
            
            # TAB 5: Learning Engine
            with gr.TabItem("🧠 Learning Engine", id="tab5"):
                (learning_graph, graph_type, show_labels, search_query, search_btn,
                 clear_btn_search, search_results, stats_display, patterns_display,
                 performance_display) = create_tab5_learning_engine()
        
        # Footer
        create_footer()
        
        # ============ EVENT HANDLERS ============
        
        # Update scenario dropdown in ROI tab
        def update_roi_scenario_dropdown():
            return gr.Dropdown.update(
                choices=list(INCIDENT_SCENARIOS.keys()),
                value="Cache Miss Storm"
            )
        
        # Run OSS Analysis
        async def run_oss_analysis(scenario_name):
            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
            
            # Use orchestrator
            analysis = await orchestrator.analyze_incident(scenario_name, scenario)
            
            # Add to audit trail
            audit_manager.add_incident(scenario_name, scenario.get("severity", "HIGH"))
            
            # Update incident table
            incident_table_data = audit_manager.get_incident_table()
            
            # Format OSS results
            oss_results = {
                "status": "✅ OSS Analysis Complete",
                "scenario": scenario_name,
                "confidence": 0.85,
                "recommendations": [
                    "Scale resources based on historical patterns",
                    "Implement circuit breaker",
                    "Add monitoring for key metrics"
                ],
                "healing_intent": {
                    "action": "scale_out",
                    "component": scenario.get("component", "unknown"),
                    "requires_enterprise": True,
                    "advisory_only": True
                }
            }
            
            return oss_results, incident_table_data
        
        oss_btn.click(
            fn=run_oss_analysis,
            inputs=[scenario_dropdown],
            outputs=[oss_results_display, incident_table]
        )
        
        # Execute Enterprise Healing
        def execute_enterprise_healing(scenario_name, approval_required):
            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
            
            # Determine mode
            mode = "Approval" if approval_required else "Autonomous"
            
            # Calculate savings
            impact = scenario.get("business_impact", {})
            revenue_loss = impact.get("revenue_loss_per_hour", 5000)
            savings = int(revenue_loss * 0.85)  # 85% savings
            
            # Add to audit trail
            audit_manager.add_execution(scenario_name, mode, savings=savings)
            
            # Create approval display
            if approval_required:
                approval_html = f"""
                <div style='padding: 20px; background: #e8f5e8; border-radius: 10px; border-left: 4px solid #28a745;'>
                    <h4 style='margin: 0 0 10px 0; color: #1a365d;'>✅ Approved & Executed</h4>
                    <p style='margin: 0; color: #2d3748;'>
                        Action for <strong>{scenario_name}</strong> was approved and executed successfully.
                    </p>
                    <p style='margin: 10px 0 0 0; color: #2d3748;'>
                        <strong>Mode:</strong> {mode}<br>
                        <strong>Cost Saved:</strong> ${savings:,}
                    </p>
                </div>
                """
            else:
                approval_html = f"""
                <div style='padding: 20px; background: #e3f2fd; border-radius: 10px; border-left: 4px solid #2196f3;'>
                    <h4 style='margin: 0 0 10px 0; color: #1a365d;'>⚡ Auto-Executed</h4>
                    <p style='margin: 0; color: #2d3748;'>
                        Action for <strong>{scenario_name}</strong> was executed autonomously.
                    </p>
                    <p style='margin: 10px 0 0 0; color: #2d3748;'>
                        <strong>Mode:</strong> {mode}<br>
                        <strong>Cost Saved:</strong> ${savings:,}
                    </p>
                </div>
                """
            
            # Enterprise results
            enterprise_results = {
                "execution_mode": mode,
                "scenario": scenario_name,
                "actions_executed": [
                    "✅ Scaled resources based on ML recommendations",
                    "✅ Implemented circuit breaker pattern",
                    "✅ Deployed enhanced monitoring"
                ],
                "business_impact": {
                    "recovery_time": "60 min → 12 min",
                    "cost_saved": f"${savings:,}",
                    "users_impacted": "45,000 → 0"
                }
            }
            
            # Update execution table
            execution_table_data = audit_manager.get_execution_table()
            
            return approval_html, enterprise_results, execution_table_data
        
        enterprise_btn.click(
            fn=execute_enterprise_healing,
            inputs=[scenario_dropdown, approval_toggle],
            outputs=[approval_display, enterprise_results_display, execution_table]
        )
        
        # Calculate ROI
        def calculate_roi(scenario_name, monthly_incidents, team_size):
            # Use ROI calculator
            roi_result = roi_calculator.calculate_scenario_roi(
                scenario_name, monthly_incidents, team_size
            )
            
            # Create chart
            chart = roi_calculator.create_comparison_chart(scenario_name)
            
            return roi_result, chart
        
        calculate_btn.click(
            fn=calculate_roi,
            inputs=[roi_scenario_dropdown, monthly_slider, team_slider],
            outputs=[roi_output, roi_chart]
        )
        
        # Audit Trail Refresh
        def refresh_audit_trail():
            return audit_manager.get_execution_table(), audit_manager.get_incident_table()
        
        refresh_btn.click(
            fn=refresh_audit_trail,
            outputs=[execution_table, incident_table]
        )
        
        # Clear History
        def clear_audit_trail():
            audit_manager.executions = []
            audit_manager.incidents = []
            return audit_manager.get_execution_table(), audit_manager.get_incident_table()
        
        clear_btn.click(
            fn=clear_audit_trail,
            outputs=[execution_table, incident_table]
        )
        
        # Initialize ROI scenario dropdown
        demo.load(
            fn=update_roi_scenario_dropdown,
            outputs=[roi_scenario_dropdown]
        )
        
        # Initialize dashboard
        demo.load(
            fn=lambda: viz_engine.create_executive_dashboard(),
            outputs=[dashboard_output]
        )
    
    return demo

# ===========================================
# MAIN EXECUTION
# ===========================================
def main():
    """Main entry point"""
    print("🚀 Starting ARF Ultimate Investor Demo v3.8.0...")
    print("=" * 70)
    print("📊 Features:")
    print("  • 6 Incident Scenarios")
    print("  • Modular Architecture")
    print("  • Working Button Handlers")
    print("  • 5 Functional Tabs")
    print("=" * 70)
    
    demo = create_demo_interface()
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )

if __name__ == "__main__":
    main()