#!/usr/bin/env python3
"""
Emergency Protocols System for Launch Operations
Comprehensive emergency response procedures, automated alerts, and coordination protocols.

Skills: general engineering
Type: implementation
Version: 1.0
Author: Starlight Launch Systems
"""

import json
import math
import datetime
import hashlib
from typing import Dict, List, Optional, Any, Union
from dataclasses import dataclass, asdict
from enum import Enum

class EmergencyType(Enum):
    MEDICAL = "MEDICAL"
    WEATHER = "WEATHER"
    TECHNICAL = "TECHNICAL"
    SECURITY = "SECURITY"
    FIRE = "FIRE"
    EXPLOSION = "EXPLOSION"
    CONTAMINATION = "CONTAMINATION"
    COMMUNICATIONS = "COMMUNICATIONS"
    POWER = "POWER"
    LAUNCH_ABORT = "LAUNCH_ABORT"

class SeverityLevel(Enum):
    LOW = "LOW"
    MEDIUM = "MEDIUM"
    HIGH = "HIGH"
    CRITICAL = "CRITICAL"

class EmergencyStatus(Enum):
    DETECTED = "DETECTED"
    ACTIVE = "ACTIVE"
    RESPONDING = "RESPONDING"
    CONTAINED = "CONTAINED"
    RESOLVED = "RESOLVED"
    ESCALATED = "ESCALATED"

@dataclass
class EmergencyProtocol:
    protocol_id: str
    emergency_type: EmergencyType
    title: str
    description: str
    trigger_conditions: List[str]
    response_steps: List[Dict[str, Any]]
    required_teams: List[str]
    estimated_response_time_min: int
    last_updated: str

@dataclass
class EmergencyEvent:
    event_id: str
    emergency_type: EmergencyType
    severity: SeverityLevel
    title: str
    description: str
    location: str
    detected_time: str
    status: EmergencyStatus
    affected_systems: List[str]
    response_teams: List[str]
    estimated_resolution: Optional[str] = None
    resolution_time: Optional[str] = None
    notes: str = ""

@dataclass
class EmergencyAction:
    action_id: str
    event_id: str
    team_responsible: str
    action: str
    priority: SeverityLevel
    deadline: str
    status: str = "PENDING"
    completed_time: Optional[str] = None
    notes: str = ""

@dataclass
class EmergencyResource:
    resource_id: str
    resource_type: str
    name: str
    location: str
    status: str
    capabilities: List[str]
    contact_info: str

class EmergencyProtocolsSystem:
    def __init__(self):
        self.protocols = self._initialize_protocols()
        self.emergency_events = []
        self.emergency_actions = []
        self.emergency_resources = self._initialize_resources()
        self.emergency_mode = False
        self.active_emergency = None

    def _initialize_protocols(self) -> Dict[str, EmergencyProtocol]:
        """Initialize all emergency response protocols."""
        protocols = {
            "medical_emergency": EmergencyProtocol(
                protocol_id="medical_emergency",
                emergency_type=EmergencyType.MEDICAL,
                title="Medical Emergency Response",
                description="Protocol for medical emergencies involving crew or ground personnel",
                trigger_conditions=["medical_alert", "injury_report", "health_crisis"],
                response_steps=[
                    {"step": 1, "action": "Activate medical team", "timeline": "0 min"},
                    {"step": 2, "action": "Assess patient condition", "timeline": "2 min"},
                    {"step": 3, "action": "Provide immediate medical assistance", "timeline": "5 min"},
                    {"step": 4, "action": "Transport to medical facility if needed", "timeline": "15 min"},
                    {"step": 5, "action": "Document incident and follow-up", "timeline": "30 min"}
                ],
                required_teams=["medical_team", "launch_operations", "recovery_team"],
                estimated_response_time_min=20,
                last_updated=datetime.datetime.now().isoformat()
            ),
            "weather_emergency": EmergencyProtocol(
                protocol_id="weather_emergency",
                emergency_type=EmergencyType.WEATHER,
                title="Severe Weather Emergency Response",
                description="Protocol for severe weather conditions affecting launch operations",
                trigger_conditions=["lightning_detection", "high_winds", "severe_storm", "visibility_issues"],
                response_steps=[
                    {"step": 1, "action": "Activate weather monitoring alert level", "timeline": "0 min"},
                    {"step": 2, "action": "Assess weather impact on launch window", "timeline": "5 min"},
                    {"step": 3, "action": "Prepare launch vehicle sheltering procedures", "timeline": "10 min"},
                    {"step": 4, "action": "Implement crew protection measures", "timeline": "15 min"},
                    {"step": 5, "action": "Execute launch abort if necessary", "timeline": "20 min"}
                ],
                required_teams=["weather_team", "launch_operations", "pad_operations", "crew_team"],
                estimated_response_time_min=25,
                last_updated=datetime.datetime.now().isoformat()
            ),
            "technical_failure": EmergencyProtocol(
                protocol_id="technical_failure",
                emergency_type=EmergencyType.TECHNICAL,
                title="Technical System Failure Response",
                description="Protocol for critical technical failures in launch systems",
                trigger_conditions=["system_failure", "critical_malfunction", "power_loss", "communication_failure"],
                response_steps=[
                    {"step": 1, "action": "Identify failed system and isolate", "timeline": "0 min"},
                    {"step": 2, "action": "Activate backup systems if available", "timeline": "2 min"},
                    {"step": 3, "action": "Assess impact on launch timeline", "timeline": "5 min"},
                    {"step": 4, "action": "Implement repair or workaround procedures", "timeline": "15 min"},
                    {"step": 5, "action": "Verify system integrity before proceeding", "timeline": "30 min"}
                ],
                required_teams=["launch_operations", "technical_team", "propulsion_team", "pad_operations"],
                estimated_response_time_min=30,
                last_updated=datetime.datetime.now().isoformat()
            ),
            "fire_emergency": EmergencyProtocol(
                protocol_id="fire_emergency",
                emergency_type=EmergencyType.FIRE,
                title="Fire Emergency Response",
                description="Protocol for fire emergencies at launch facilities",
                trigger_conditions=["fire_detection", "smoke_alarm", "explosion_risk"],
                response_steps=[
                    {"step": 1, "action": "Activate fire alarm system", "timeline": "0 min"},
                    {"step": 2, "action": "Evacuate affected areas immediately", "timeline": "1 min"},
                    {"step": 3, "action": "Deploy fire suppression systems", "timeline": "3 min"},
                    {"step": 4, "action": "Fire team response and containment", "timeline": "5 min"},
                    {"step": 5, "action": "Damage assessment and recovery planning", "timeline": "30 min"}
                ],
                required_teams=["fire_team", "safety_team", "medical_team", "security_team"],
                estimated_response_time_min=15,
                last_updated=datetime.datetime.now().isoformat()
            ),
            "launch_abort": EmergencyProtocol(
                protocol_id="launch_abort",
                emergency_type=EmergencyType.LAUNCH_ABORT,
                title="Launch Abort Emergency Response",
                description="Protocol for emergency launch abort procedures",
                trigger_conditions=["abort_command", "critical_system_failure", "crew_emergency", "range_safety_abort"],
                response_steps=[
                    {"step": 1, "action": "Execute launch abort sequence", "timeline": "0 min"},
                    {"step": 2, "action": "Engage vehicle safety systems", "timeline": "0.5 min"},
                    {"step": 3, "action": "Activate crew extraction procedures", "timeline": "2 min"},
                    {"step": 4, "action": "Implement post-abort safety checks", "timeline": "10 min"},
                    {"step": 5, "action": "Crew medical evaluation and debrief", "timeline": "30 min"}
                ],
                required_teams=["launch_operations", "range_safety", "medical_team", "recovery_team", "crew_team"],
                estimated_response_time_min=35,
                last_updated=datetime.datetime.now().isoformat()
            ),
            "security_breach": EmergencyProtocol(
                protocol_id="security_breach",
                emergency_type=EmergencyType.SECURITY,
                title="Security Breach Response",
                description="Protocol for security incidents and unauthorized access",
                trigger_conditions=["unauthorized_access", "security_breach", "threat_detection"],
                response_steps=[
                    {"step": 1, "action": "Lock down affected areas", "timeline": "0 min"},
                    {"step": 2, "action": "Activate security response team", "timeline": "2 min"},
                    {"step": 3, "action": "Assess threat level and location", "timeline": "5 min"},
                    {"step": 4, "action": "Implement containment procedures", "timeline": "10 min"},
                    {"step": 5, "action": "Coordinate with law enforcement if needed", "timeline": "15 min"}
                ],
                required_teams=["security_team", "launch_operations", "local_authorities"],
                estimated_response_time_min=20,
                last_updated=datetime.datetime.now().isoformat()
            )
        }
        
        return protocols

    def _initialize_resources(self) -> Dict[str, EmergencyResource]:
        """Initialize emergency response resources."""
        resources = {
            "medical_facility": EmergencyResource(
                resource_id="medical_facility",
                resource_type="medical",
                name="Launch Site Medical Center",
                location="Medical Facility",
                status="STANDBY",
                capabilities=["emergency_medical", "trauma_care", "life_support"],
                contact_info="Internal Radio Channel 1"
            ),
            "fire_department": EmergencyResource(
                resource_id="fire_department",
                resource_type="fire",
                name="Launch Site Fire Department",
                location="Fire Station",
                status="STANDBY",
                capabilities=["fire_suppression", "rescue", "hazardous_materials"],
                contact_info="Internal Radio Channel 2"
            ),
            "emergency_shelter": EmergencyResource(
                resource_id="emergency_shelter",
                resource_type="shelter",
                name="Emergency Operations Center",
                location="Underground Bunker",
                status="READY",
                capabilities=["personnel_shelter", "command_center", "communications"],
                contact_info="Internal Radio Channel 3"
            ),
            "evacuation_transport": EmergencyResource(
                resource_id="evacuation_transport",
                resource_type="transport",
                name="Emergency Evacuation Vehicles",
                location="Motor Pool",
                status="READY",
                capabilities=["personnel_evacuation", "medical_transport", "equipment_removal"],
                contact_info="Internal Radio Channel 4"
            ),
            "backup_power": EmergencyResource(
                resource_id="backup_power",
                resource_type="power",
                name="Backup Power Systems",
                location="Power Plant",
                status="ONLINE",
                capabilities=["emergency_power", "system_backup", "power_distribution"],
                contact_info="Internal Radio Channel 5"
            )
        }
        
        return resources

    def declare_emergency(self, emergency_type: EmergencyType, severity: SeverityLevel,
                         title: str, description: str, location: str,
                         affected_systems: List[str]) -> str:
        """Declare a new emergency event."""
        event_id = hashlib.md5(f"{emergency_type}{severity}{title}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        # Get protocol for this emergency type
        protocol = self.protocols.get(emergency_type.value + "_emergency", None)
        required_teams = protocol.required_teams if protocol else []
        
        emergency_event = EmergencyEvent(
            event_id=event_id,
            emergency_type=emergency_type,
            severity=severity,
            title=title,
            description=description,
            location=location,
            detected_time=datetime.datetime.now().isoformat(),
            status=EmergencyStatus.DETECTED,
            affected_systems=affected_systems,
            response_teams=required_teams,
            estimated_resolution=(datetime.datetime.now() + datetime.timedelta(minutes=protocol.estimated_response_time_min)).isoformat() if protocol else None
        )
        
        self.emergency_events.append(emergency_event)
        self.emergency_mode = True
        self.active_emergency = event_id
        
        # Generate emergency actions based on protocol
        if protocol:
            self._generate_emergency_actions(event_id, protocol, severity)
        
        return event_id

    def _generate_emergency_actions(self, event_id: str, protocol: EmergencyProtocol, severity: SeverityLevel):
        """Generate emergency actions based on protocol."""
        for step in protocol.response_steps:
            action_id = hashlib.md5(f"{event_id}{step['step']}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
            
            # Assign team based on step requirements
            team_responsible = protocol.required_teams[0] if protocol.required_teams else "launch_operations"
            
            action = EmergencyAction(
                action_id=action_id,
                event_id=event_id,
                team_responsible=team_responsible,
                action=step["action"],
                priority=severity,
                deadline=(datetime.datetime.now() + datetime.timedelta(minutes=int(step["timeline"].split()[0]))).isoformat(),
                status="PENDING"
            )
            
            self.emergency_actions.append(action)

    def update_emergency_status(self, event_id: str, new_status: EmergencyStatus, notes: str = "") -> Dict[str, Any]:
        """Update emergency event status."""
        for event in self.emergency_events:
            if event.event_id == event_id:
                old_status = event.status
                event.status = new_status
                event.notes = notes
                
                if new_status == EmergencyStatus.RESOLVED:
                    event.resolution_time = datetime.datetime.now().isoformat()
                    if self.active_emergency == event_id:
                        self.active_emergency = None
                        # Check if any other emergencies are active
                        if not any(e.status in [EmergencyStatus.ACTIVE, EmergencyStatus.RESPONDING] for e in self.emergency_events):
                            self.emergency_mode = False
                
                return {
                    "status_updated": True,
                    "event_id": event_id,
                    "old_status": old_status.value,
                    "new_status": new_status.value,
                    "resolution_time": event.resolution_time
                }
        
        return {"error": f"Emergency event {event_id} not found"}

    def complete_emergency_action(self, action_id: str, notes: str = "") -> Dict[str, Any]:
        """Mark an emergency action as complete."""
        for action in self.emergency_actions:
            if action.action_id == action_id:
                action.status = "COMPLETED"
                action.completed_time = datetime.datetime.now().isoformat()
                action.notes = notes
                
                return {
                    "action_completed": True,
                    "action_id": action_id,
                    "completed_time": action.completed_time
                }
        
        return {"error": f"Emergency action {action_id} not found"}

    def deploy_emergency_resource(self, resource_id: str, event_id: str, deployment_location: str) -> Dict[str, Any]:
        """Deploy emergency resource to respond to emergency."""
        if resource_id not in self.emergency_resources:
            return {"error": f"Resource {resource_id} not found"}
        
        resource = self.emergency_resources[resource_id]
        resource.status = "DEPLOYED"
        
        return {
            "resource_deployed": True,
            "resource_id": resource_id,
            "event_id": event_id,
            "deployment_location": deployment_location,
            "deployment_time": datetime.datetime.now().isoformat()
        }

    def escalate_emergency(self, event_id: str, new_severity: SeverityLevel, escalation_reason: str) -> Dict[str, Any]:
        """Escalate emergency to higher severity level."""
        for event in self.emergency_events:
            if event.event_id == event_id:
                old_severity = event.severity
                event.severity = new_severity
                event.status = EmergencyStatus.ESCALATED
                event.notes = f"ESCALATED: {escalation_reason}"
                
                # Generate additional actions for higher severity
                protocol = self.protocols.get(event.emergency_type.value + "_emergency", None)
                if protocol:
                    self._generate_emergency_actions(event_id, protocol, new_severity)
                
                return {
                    "emergency_escalated": True,
                    "event_id": event_id,
                    "old_severity": old_severity.value,
                    "new_severity": new_severity.value,
                    "escalation_reason": escalation_reason
                }
        
        return {"error": f"Emergency event {event_id} not found"}

    def get_emergency_status(self, event_id: str) -> Dict[str, Any]:
        """Get detailed status of specific emergency event."""
        event = None
        for e in self.emergency_events:
            if e.event_id == event_id:
                event = e
                break
        
        if not event:
            return {"error": f"Emergency event {event_id} not found"}
        
        # Get related actions
        related_actions = [a for a in self.emergency_actions if a.event_id == event_id]
        
        # Get deployed resources
        deployed_resources = [r for r in self.emergency_resources.values() if r.status == "DEPLOYED"]
        
        return {
            "event": asdict(event),
            "actions": [asdict(a) for a in related_actions],
            "deployed_resources": [asdict(r) for r in deployed_resources],
            "protocol": self.protocols.get(event.emergency_type.value + "_emergency"),
            "timestamp": datetime.datetime.now().isoformat()
        }

    def get_emergency_summary(self) -> Dict[str, Any]:
        """Get comprehensive emergency operations summary."""
        # Count emergencies by type and status
        emergencies_by_type = {}
        emergencies_by_status = {}
        emergencies_by_severity = {}
        
        for emergency in self.emergency_events:
            # Count by type
            e_type = emergency.emergency_type.value
            emergencies_by_type[e_type] = emergencies_by_type.get(e_type, 0) + 1
            
            # Count by status
            status = emergency.status.value
            emergencies_by_status[status] = emergencies_by_status.get(status, 0) + 1
            
            # Count by severity
            severity = emergency.severity.value
            emergencies_by_severity[severity] = emergencies_by_severity.get(severity, 0) + 1
        
        # Action statistics
        total_actions = len(self.emergency_actions)
        completed_actions = len([a for a in self.emergency_actions if a.status == "COMPLETED"])
        
        # Resource availability
        resources_by_status = {}
        for resource in self.emergency_resources.values():
            status = resource.status
            resources_by_status[status] = resources_by_status.get(status, 0) + 1
        
        summary = {
            "emergency_mode": self.emergency_mode,
            "active_emergency": self.active_emergency,
            "total_emergencies": len(self.emergency_events),
            "emergencies_by_type": emergencies_by_type,
            "emergencies_by_status": emergencies_by_status,
            "emergencies_by_severity": emergencies_by_severity,
            "emergency_actions": {
                "total": total_actions,
                "completed": completed_actions,
                "completion_rate": (completed_actions / total_actions * 100) if total_actions > 0 else 0
            },
            "emergency_resources": resources_by_status,
            "protocols_available": len(self.protocols),
            "timestamp": datetime.datetime.now().isoformat()
        }
        
        return summary

def main():
    """Main execution function for emergency protocols system."""
    print("🚨 Initializing Starlight Emergency Protocols System")
    
    # Initialize emergency protocols
    emergency_sys = EmergencyProtocolsSystem()
    
    print(f"✅ Emergency Protocols Loaded: {len(emergency_sys.protocols)} protocols")
    print(f"✅ Emergency Resources Available: {len(emergency_sys.emergency_resources)} resources")
    
    # Simulate emergency scenarios
    emergency_scenarios = [
        {
            "type": EmergencyType.MEDICAL,
            "severity": SeverityLevel.HIGH,
            "title": "Crew Medical Emergency",
            "description": "Crew member experiencing sudden medical distress during pre-launch checks",
            "location": "Spacecraft Cabin",
            "affected_systems": ["Life Support", "Crew Systems"]
        },
        {
            "type": EmergencyType.WEATHER,
            "severity": SeverityLevel.CRITICAL,
            "title": "Severe Weather Alert",
            "description": "Lightning detected within 5 miles of launch site during fueling operations",
            "location": "Launch Pad Area",
            "affected_systems": ["Launch Operations", "Fueling Systems", "Pad Operations"]
        },
        {
            "type": EmergencyType.TECHNICAL,
            "severity": SeverityLevel.HIGH,
            "title": "Critical System Failure",
            "description": "Main communication system failure detected during countdown",
            "location": "Launch Control Center",
            "affected_systems": ["Communications", "Launch Control", "Telemetry"]
        }
    ]
    
    declared_emergencies = []
    
    for scenario in emergency_scenarios:
        event_id = emergency_sys.declare_emergency(
            scenario["type"], scenario["severity"], scenario["title"],
            scenario["description"], scenario["location"], scenario["affected_systems"]
        )
        declared_emergencies.append(event_id)
        print(f"🚨 EMERGENCY DECLARED: {scenario['title']} (ID: {event_id})")
    
    # Simulate emergency response actions
    for event_id in declared_emergencies[:2]:  # Process first two emergencies
        # Update to responding status
        result = emergency_sys.update_emergency_status(event_id, EmergencyStatus.RESPONDING, "Emergency response teams activated")
        print(f"📢 Event {event_id}: Status -> {result['new_status']}")
        
        # Complete some emergency actions
        event_actions = [a for a in emergency_sys.emergency_actions if a.event_id == event_id][:2]
        for action in event_actions:
            complete_result = emergency_sys.complete_emergency_action(action.action_id, "Action completed successfully")
            if complete_result.get("action_completed"):
                print(f"✓ Action {action.action_id}: {action.action} - COMPLETED")
        
        # Deploy emergency resources
        if event_id == declared_emergencies[0]:  # Medical emergency
            emergency_sys.deploy_emergency_resource("medical_facility", event_id, "Medical Facility")
            emergency_sys.deploy_emergency_resource("evacuation_transport", event_id, "Launch Pad")
        elif event_id == declared_emergencies[1]:  # Weather emergency
            emergency_sys.deploy_emergency_resource("emergency_shelter", event_id, "Launch Control")
            emergency_sys.deploy_emergency_resource("backup_power", event_id, "Launch Control")
    
    # Escalate one emergency
    escalate_result = emergency_sys.escalate_emergency(
        declared_emergencies[1], SeverityLevel.CRITICAL,
        "Weather conditions deteriorating rapidly, multiple lightning strikes detected"
    )
    print(f"⬆️ Emergency Escalated: {escalate_result['old_severity']} -> {escalate_result['new_severity']}")
    
    # Resolve one emergency
    resolve_result = emergency_sys.update_emergency_status(
        declared_emergencies[0], EmergencyStatus.RESOLVED, "Crew member stabilized and transported to medical facility"
    )
    print(f"✅ Emergency Resolved: {resolve_result['new_status']}")
    
    # Get emergency summary
    summary = emergency_sys.get_emergency_summary()
    print(f"\n📊 Emergency Operations Summary:")
    print(f"   Emergency Mode: {'ACTIVE' if summary['emergency_mode'] else 'STANDBY'}")
    print(f"   Total Emergencies: {summary['total_emergencies']}")
    print(f"   Active Emergency: {summary['active_emergency'] or 'None'}")
    print(f"   Actions Completed: {summary['emergency_actions']['completion_rate']:.1f}%")
    
    print(f"\n📈 Emergencies by Type:")
    for e_type, count in summary['emergencies_by_type'].items():
        print(f"   {e_type}: {count}")
    
    print(f"\n⚠️ Emergencies by Severity:")
    for severity, count in summary['emergencies_by_severity'].items():
        print(f"   {severity}: {count}")
    
    # Save emergency data
    emergency_data = {
        "summary": summary,
        "declared_emergencies": declared_emergencies,
        "timestamp": datetime.datetime.now().isoformat()
    }
    
    with open("emergency_protocols_data.json", "w") as f:
        json.dump(emergency_data, f, indent=2)
    
    print("\n💾 Emergency protocols data saved to emergency_protocols_data.json")
    print("🎯 Emergency Protocols System Complete!")

if __name__ == "__main__":
    main()