import math
import json
from datetime import datetime
from typing import Dict, List, Optional

class TrajectoryMonitor:
    def __init__(self):
        self.expected_trajectory = []
        self.tolerance_threshold = 0.05
        self.critical_deviation = 0.15
        
    def verify_position(self, current_pos: Dict, expected_pos: Dict) -> Dict:
        deviation = self.calculate_deviation(current_pos, expected_pos)
        
        status = {
            "timestamp": datetime.now().isoformat(),
            "deviation": deviation,
            "status": "NOMINAL",
            "action_required": None
        }
        
        if deviation > self.critical_deviation:
            status["status"] = "CRITICAL"
            status["action_required"] = "IMMEDIATE_ABORT"
        elif deviation > self.tolerance_threshold:
            status["status"] = "WARNING"
            status["action_required"] = "CORRECTION_MANEUVER"
            
        return status
    
    def calculate_deviation(self, current: Dict, expected: Dict) -> float:
        dx = current["x"] - expected["x"]
        dy = current["y"] - expected["y"]
        dz = current["z"] - expected["z"]
        
        actual_distance = math.sqrt(dx**2 + dy**2 + dz**2)
        expected_distance = math.sqrt(expected["x"]**2 + expected["y"]**2 + expected["z"]**2)
        
        return abs(actual_distance - expected_distance) / expected_distance


class SystemMonitor:
    def __init__(self):
        self.systems = {
            "propulsion": {"status": "ACTIVE", "health": 100},
            "power": {"status": "ACTIVE", "health": 100},
            "communications": {"status": "ACTIVE", "health": 100},
            "thermal": {"status": "ACTIVE", "health": 100},
            "guidance": {"status": "ACTIVE", "health": 100}
        }
        self.alert_thresholds = {
            "health_warning": 80,
            "health_critical": 60,
            "temperature_max": 85,
            "pressure_min": 90
        }
    
    def check_system_health(self) -> Dict:
        report = {
            "timestamp": datetime.now().isoformat(),
            "overall_status": "NOMINAL",
            "alerts": [],
            "system_status": {}
        }
        
        critical_count = 0
        warning_count = 0
        
        for system, data in self.systems.items():
            health = data["health"]
            status = "NOMINAL"
            
            if health < self.alert_thresholds["health_critical"]:
                status = "CRITICAL"
                critical_count += 1
                report["alerts"].append({
                    "system": system,
                    "severity": "CRITICAL",
                    "message": f"{system} health critically low: {health}%"
                })
            elif health < self.alert_thresholds["health_warning"]:
                status = "WARNING"
                warning_count += 1
                report["alerts"].append({
                    "system": system,
                    "severity": "WARNING", 
                    "message": f"{system} health degraded: {health}%"
                })
            
            report["system_status"][system] = {
                "status": status,
                "health": health,
                "operational": health > 50
            }
        
        if critical_count > 0:
            report["overall_status"] = "CRITICAL"
        elif warning_count > 0:
            report["overall_status"] = "WARNING"
            
        return report


class AbortController:
    def __init__(self):
        self.abort_conditions = {
            "trajectory_deviation": 0.20,
            "system_failure_count": 2,
            "communication_loss": 300,
            "power_critical": 30
        }
        self.abort_procedures = {
            "IMMEDIATE": "emergency_separation",
            "GRADUAL": "controlled_deorbit", 
            "HOLD": "maintain_safe_orbit"
        }
    
    def evaluate_abort_conditions(self, trajectory_data: Dict, 
                                 system_data: Dict, comm_data: Dict) -> Dict:
        evaluation = {
            "abort_required": False,
            "abort_type": None,
            "reason": None,
            "urgency": "NONE"
        }
        
        if trajectory_data.get("deviation", 0) > self.abort_conditions["trajectory_deviation"]:
            evaluation["abort_required"] = True
            evaluation["abort_type"] = "IMMEDIATE"
            evaluation["reason"] = "Critical trajectory deviation"
            evaluation["urgency"] = "CRITICAL"
            return evaluation
        
        critical_systems = sum(1 for sys in system_data.values() 
                             if sys.get("status") == "CRITICAL")
        if critical_systems >= self.abort_conditions["system_failure_count"]:
            evaluation["abort_required"] = True
            evaluation["abort_type"] = "IMMEDIATE"
            evaluation["reason"] = f"Multiple system failures: {critical_systems}"
            evaluation["urgency"] = "CRITICAL"
            return evaluation
        
        comm_loss_time = comm_data.get("last_contact_seconds", 0)
        if comm_loss_time > self.abort_conditions["communication_loss"]:
            evaluation["abort_required"] = True
            evaluation["abort_type"] = "GRADUAL"
            evaluation["reason"] = "Extended communication loss"
            evaluation["urgency"] = "HIGH"
        
        return evaluation
    
    def execute_abort_procedure(self, abort_type: str) -> Dict:
        procedure = self.abort_procedures.get(abort_type, "HOLD")
        
        execution_plan = {
            "procedure": procedure,
            "steps": [],
            "estimated_time": 0,
            "success_probability": 0
        }
        
        if procedure == "emergency_separation":
            execution_plan["steps"] = [
                "1. Confirm abort authorization",
                "2. Initiate separation sequence",
                "3. Deploy emergency systems",
                "4. Establish safe trajectory",
                "5. Activate recovery beacons"
            ]
            execution_plan["estimated_time"] = 120
            execution_plan["success_probability"] = 0.85
            
        elif procedure == "controlled_deorbit":
            execution_plan["steps"] = [
                "1. Calculate deorbit trajectory",
                "2. Configure attitude for reentry",
                "3. Initiate retrograde burn",
                "4. Monitor descent profile",
                "5. Prepare landing systems"
            ]
            execution_plan["estimated_time"] = 600
            execution_plan["success_probability"] = 0.92
        
        return execution_plan


class ContingencyPlanner:
    def __init__(self):
        self.failure_scenarios = {
            "engine_failure": {
                "probability": 0.05,
                "impact": "HIGH",
                "response": "secondary_engine_activation"
            },
            "power_loss": {
                "probability": 0.08,
                "impact": "CRITICAL", 
                "response": "backup_power_switch"
            },
            "communication_failure": {
                "probability": 0.12,
                "impact": "MEDIUM",
                "response": "alternative_frequency_switch"
            },
            "thermal_runaway": {
                "probability": 0.03,
                "impact": "CRITICAL",
                "response": "emergency_cooling_activation"
            },
            "structural_integrity_loss": {
                "probability": 0.01,
                "impact": "CATASTROPHIC",
                "response": "immediate_abandon"
            }
        }
    
    def generate_contingency_plan(self, scenario: str) -> Dict:
        failure_info = self.failure_scenarios.get(scenario, {})
        
        plan = {
            "scenario": scenario,
            "probability": failure_info.get("probability", 0),
            "impact_level": failure_info.get("impact", "UNKNOWN"),
            "response_strategy": failure_info.get("response", "NO_RESPONSE"),
            "execution_steps": [],
            "resource_requirements": {},
            "time_critical": failure_info.get("impact") in ["CRITICAL", "CATASTROPHIC"]
        }
        
        if scenario == "engine_failure":
            plan["execution_steps"] = [
                "1. Detect engine failure indicators",
                "2. Isolate failed engine",
                "3. Activate secondary engine",
                "4. Recalculate trajectory",
                "5. Verify thrust output",
                "6. Update mission profile"
            ]
            plan["resource_requirements"] = {
                "fuel_reserve": "25%",
                "power": "HIGH",
                "time_window": "60 seconds"
            }
            
        elif scenario == "power_loss":
            plan["execution_steps"] = [
                "1. Identify power source failure",
                "2. Switch to backup power systems",
                "3. Shed non-critical loads",
                "4. Reconfigure power distribution",
                "5. Verify system stability",
                "6. Initiate power conservation mode"
            ]
            plan["resource_requirements"] = {
                "backup_power": "100%",
                "critical_systems_only": True,
                "time_window": "30 seconds"
            }
        
        return plan
    
    def assess_risk_matrix(self) -> Dict:
        risk_matrix = {}
        
        for scenario, details in self.failure_scenarios.items():
            probability = details["probability"]
            impact = details["impact"]
            
            prob_score = min(int(probability * 20), 5)
            impact_scores = {"LOW": 1, "MEDIUM": 3, "HIGH": 5, "CRITICAL": 7, "CATASTROPHIC": 10}
            impact_score = impact_scores.get(impact, 5)
            
            risk_score = (prob_score + impact_score) / 2
            
            risk_matrix[scenario] = {
                "probability_score": prob_score,
                "impact_score": impact_score,
                "overall_risk": risk_score,
                "risk_level": "HIGH" if risk_score > 7 else "MEDIUM" if risk_score > 4 else "LOW",
                "mitigation_required": risk_score > 5
            }
        
        return risk_matrix


class PostLaunchMonitoringDashboard:
    def __init__(self):
        self.trajectory_monitor = TrajectoryMonitor()
        self.system_monitor = SystemMonitor()
        self.abort_controller = AbortController()
        self.contingency_planner = ContingencyPlanner()
        self.monitoring_log = []
    
    def run_comprehensive_check(self) -> Dict:
        timestamp = datetime.now().isoformat()
        
        current_position = {"x": 1000.5, "y": 2000.3, "z": 1500.7}
        expected_position = {"x": 1000.0, "y": 2000.0, "z": 1500.0}
        
        trajectory_status = self.trajectory_monitor.verify_position(current_position, expected_position)
        system_status = self.system_monitor.check_system_health()
        abort_evaluation = self.abort_controller.evaluate_abort_conditions(
            trajectory_status, system_status["system_status"], {"last_contact_seconds": 0}
        )
        risk_assessment = self.contingency_planner.assess_risk_matrix()
        
        report = {
            "timestamp": timestamp,
            "mission_status": "NOMINAL",
            "trajectory": trajectory_status,
            "systems": system_status,
            "abort_evaluation": abort_evaluation,
            "risk_matrix": risk_assessment,
            "recommendations": []
        }
        
        if trajectory_status["status"] != "NOMINAL":
            report["recommendations"].append(f"Trajectory: {trajectory_status['action_required']}")
        
        if system_status["overall_status"] != "NOMINAL":
            report["recommendations"].append(f"Systems: Check {len(system_status['alerts'])} alerts")
        
        if abort_evaluation["abort_required"]:
            report["mission_status"] = "ABORT_CONDITION"
            report["recommendations"].append(f"ABORT: {abort_evaluation['reason']}")
        
        self.monitoring_log.append(report)
        
        return report
    
    def export_monitoring_report(self) -> str:
        latest_report = self.monitoring_log[-1] if self.monitoring_log else {}
        
        return json.dumps({
            "report_summary": latest_report,
            "total_checks": len(self.monitoring_log),
            "last_check": latest_report.get("timestamp"),
            "system_status": latest_report.get("systems", {}).get("overall_status", "UNKNOWN")
        }, indent=2)


def test_monitoring_system():
    dashboard = PostLaunchMonitoringDashboard()
    
    report = dashboard.run_comprehensive_check()
    
    assert report["timestamp"] is not None
    assert "trajectory" in report
    assert "systems" in report
    assert "abort_evaluation" in report
    assert "risk_matrix" in report
    
    export_data = dashboard.export_monitoring_report()
    assert len(export_data) > 0
    
    print("Monitoring system test passed")
    return True


def generate_html_dashboard(report: Dict) -> str:
    """Generate interactive HTML dashboard for monitoring."""
    return f"""
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Post-Launch Monitoring Dashboard</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body {{ font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }}
        .dashboard {{ max-width: 1200px; margin: 0 auto; }}
        .header {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; }}
        .status-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; margin-bottom: 20px; }}
        .status-card {{ background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
        .status-nominal {{ border-left: 4px solid #4CAF50; }}
        .status-warning {{ border-left: 4px solid #FF9800; }}
        .status-critical {{ border-left: 4px solid #F44336; }}
        .recommendations {{ background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; }}
        .chart-container {{ background: white; padding: 20px; border-radius: 8px; height: 400px; }}
        .timestamp {{ font-size: 0.9em; color: #666; }}
        .alert {{ padding: 10px; margin: 5px 0; border-radius: 4px; }}
        .alert-critical {{ background: #ffebee; border-left: 4px solid #F44336; }}
        .alert-warning {{ background: #fff3e0; border-left: 4px solid #FF9800; }}
    </style>
</head>
<body>
    <div class="dashboard">
        <div class="header">
            <h1>🚀 Post-Launch Monitoring Dashboard</h1>
            <p>Status Report Generated: {report.get('timestamp', 'Unknown')}</p>
            <p>Overall Mission Status: <strong style="font-size: 1.2em;">{report.get('mission_status', 'UNKNOWN')}</strong></p>
        </div>
        
        <div class="status-grid">
            <div class="status-card status-{report.get('trajectory', {}).get('status', 'unknown').lower()}">
                <h3>📍 Trajectory Verification</h3>
                <p>Status: {report.get('trajectory', {}).get('status', 'UNKNOWN')}</p>
                <p>Deviation: {report.get('trajectory', {}).get('deviation', 0):.4f}</p>
                <p>Action Required: {report.get('trajectory', {}).get('action_required', 'None')}</p>
                <div class="timestamp">{report.get('trajectory', {}).get('timestamp', '')}</div>
            </div>
            
            <div class="status-card status-{report.get('systems', {}).get('overall_status', 'unknown').lower()}">
                <h3>⚙️ System Health Monitoring</h3>
                <p>Status: {report.get('systems', {}).get('overall_status', 'UNKNOWN')}</p>
                <p>Active Alerts: {len(report.get('systems', {}).get('alerts', []))}</p>
                <div class="timestamp">{report.get('systems', {}).get('timestamp', '')}</div>
            </div>
            
            <div class="status-card status-{'critical' if report.get('abort_evaluation', {}).get('abort_required') else 'nominal'}">
                <h3>🛑 Abort Procedures</h3>
                <p>Abort Required: {'YES' if report.get('abort_evaluation', {}).get('abort_required') else 'NO'}</p>
                <p>Abort Type: {report.get('abort_evaluation', {}).get('abort_type', 'NONE')}</p>
                <p>Reason: {report.get('abort_evaluation', {}).get('reason', 'None')}</p>
            </div>
            
            <div class="status-card">
                <h3>📊 Risk Assessment</h3>
                <p>Scenarios Monitored: {len(report.get('risk_matrix', {}))}</p>
                <p>High Risk: {len([r for r in report.get('risk_matrix', {}).values() if r.get('risk_level') == 'HIGH'])}</p>
                <p>Medium Risk: {len([r for r in report.get('risk_matrix', {}).values() if r.get('risk_level') == 'MEDIUM'])}</p>
            </div>
        </div>
        
        <div class="recommendations">
            <h3>🎯 Recommendations</h3>
            {"".join(f"<li>{rec}</li>" for rec in report.get('recommendations', ['Continue monitoring']))}
        </div>
        
        {f'<div class="recommendations"><h3>🚨 Active Alerts</h3>' + 
         "".join(f'<div class="alert alert-{alert["severity"].lower()}"><strong>{alert["system"]}</strong>: {alert["message"]}</div>' 
                for alert in report.get('systems', {}).get('alerts', [])) + 
         '</div>' if report.get('systems', {}).get('alerts') else ''}
        
        <div class="chart-container">
            <canvas id="systemHealthChart"></canvas>
        </div>
    </div>
    
    <script>
        const ctx = document.getElementById('systemHealthChart').getContext('2d');
        const healthData = {json.dumps([data.get("health", 100) for data in report.get('systems', {}).get('system_status', {}).values()])};
        const systemNames = {json.dumps(list(report.get('systems', {}).get('system_status', {}).keys()))};
        
        const healthChart = new Chart(ctx, {{
            type: 'bar',
            data: {{
                labels: systemNames,
                datasets: [{{
                    label: 'System Health (%)',
                    data: healthData,
                    backgroundColor: healthData.map(h => h > 80 ? '#4CAF50' : h > 60 ? '#FF9800' : '#F44336'),
                    borderColor: 'rgba(102, 126, 234, 1)',
                    borderWidth: 2
                }}]
            }},
            options: {{
                responsive: true,
                plugins: {{
                    title: {{
                        display: true,
                        text: 'System Health Overview'
                    }}
                }},
                scales: {{
                    y: {{
                        beginAtZero: true,
                        max: 100
                    }}
                }}
            }}
        }});
    </script>
</body>
</html>
    """

if __name__ == "__main__":
    # Run monitoring system test
    test_result = test_monitoring_system()
    
    # Generate comprehensive report
    dashboard = PostLaunchMonitoringDashboard()
    report = dashboard.run_comprehensive_check()
    
    # Create HTML dashboard
    html_content = generate_html_dashboard(report)
    
    # Save HTML dashboard to file
    with open("post_launch_dashboard.html", "w") as f:
        f.write(html_content)
    
    # Save JSON report
    with open("monitoring_report.json", "w") as f:
        f.write(dashboard.export_monitoring_report())
    
    print("✅ Post-launch monitoring checklist implementation completed!")
    print(f"📊 HTML Dashboard: post_launch_dashboard.html")
    print(f"📋 JSON Report: monitoring_report.json")
    print(f"🚀 Overall Status: {report['mission_status']}")
    print(f"📡 Systems Monitored: {len(report['systems']['system_status'])}")
    print(f"⚠️ Active Alerts: {len(report['systems']['alerts'])}")