#!/usr/bin/env python3
"""
Launch Day Procedures System
Comprehensive countdown sequence, weather monitoring, range safety, 
crew preparation, ground crew coordination, and emergency protocols.

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

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

class LaunchStatus(Enum):
    PREPARING = "PREPARING"
    COUNTDOWN_ACTIVE = "COUNTDOWN_ACTIVE"
    HOLD = "HOLD"
    ABORT = "ABORT"
    LAUNCHED = "LAUNCHED"

class WeatherCondition(Enum):
    GOOD = "GOOD"
    CAUTION = "CAUTION"
    NO_GO = "NO_GO"

@dataclass
class CountdownEvent:
    time_t_minus: int  # seconds before T-0
    description: str
    system_check: str
    completed: bool = False
    timestamp: Optional[str] = None

@dataclass
class WeatherData:
    wind_speed: float  # m/s
    wind_direction: float  # degrees
    temperature: float  # Celsius
    humidity: float  # percentage
    visibility: float  # km
    cloud_ceiling: float  # meters
    pressure: float  # hPa
    lightning_distance: float  # km
    timestamp: str

@dataclass
class RangeSafetyStatus:
    clear_zone: bool
    exclusion_zone_clear: bool
    tracking_systems_active: bool
    communication_links_active: bool
    destruction_systems_ready: bool
    flight_termination_ready: bool

class LaunchDayProcedures:
    def __init__(self):
        self.status = LaunchStatus.PREPARING
        self.countdown_events = self._initialize_countdown_sequence()
        self.weather_history = []
        self.range_safety_history = []
        self.crew_status = {}
        self.ground_crew_tasks = {}
        self.emergency_activations = []
        
        # Thresholds
        self.weather_thresholds = {
            'wind_speed_max': 15.0,  # m/s
            'wind_speed_min': 0.0,
            'temperature_min': -20.0,  # Celsius
            'temperature_max': 40.0,
            'humidity_max': 95.0,  # %
            'visibility_min': 5.0,  # km
            'cloud_ceiling_min': 1500.0,  # meters
            'lightning_distance_min': 10.0  # km
        }
        
        self.range_safety_requirements = [
            'clear_zone',
            'exclusion_zone_clear', 
            'tracking_systems_active',
            'communication_links_active',
            'destruction_systems_ready',
            'flight_termination_ready'
        ]

    def _initialize_countdown_sequence(self) -> Dict[int, CountdownEvent]:
        """Initialize complete countdown sequence with system checks."""
        sequence = {
            # T-48 hours
            172800: CountdownEvent(172800, "T-48h: Launch Vehicle Activation", "launch_vehicle_power"),
            170400: CountdownEvent(170400, "T-47h: Propellant Loading Begins", "propellant_systems"),
            169200: CountdownEvent(169200, "T-47h: Communication Systems Check", "communication_links"),
            167400: CountdownEvent(167400, "T-46h: Guidance System Alignment", "guidance_alignment"),
            165600: CountdownEvent(165600, "T-46h: Range Safety Systems Check", "range_safety"),
            
            # T-24 hours
            86400: CountdownEvent(86400, "T-24h: Crew Arrival", "crew_check_in"),
            82800: CountdownEvent(82800, "T-23h: Weather Briefing", "weather_assessment"),
            79200: CountdownEvent(79200, "T-22h: Final Systems Check", "all_systems"),
            72000: CountdownEvent(72000, "T-20h: Propellant Loading Complete", "propellant_status"),
            
            # T-6 hours
            21600: CountdownEvent(21600, "T-6h: Ground Equipment Removal", "ground_clear"),
            18000: CountdownEvent(18000, "T-5h: Weather Reassessment", "weather_check"),
            14400: CountdownEvent(14400, "T-4h: Final Vehicle Inspection", "vehicle_check"),
            10800: CountdownEvent(10800, "T-3h: Crew Astronaut Suit-Up", "crew_equipment"),
            7200: CountdownEvent(7200, "T-2h: Crew Transport to Pad", "crew_transport"),
            3600: CountdownEvent(3600, "T-1h: Crew Boarding", "crew_boarding"),
            
            # Final hour
            1800: CountdownEvent(1800, "T-30min: Hatch Closure", "hatch_seal"),
            900: CountdownEvent(900, "T-15min: Final Weather Go", "weather_final"),
            600: CountdownEvent(600, "T-10min: Automated Launch Sequence", "auto_sequence"),
            300: CountdownEvent(300, "T-5min: Final Range Safety Check", "range_final"),
            120: CountdownEvent(120, "T-2min: Engine Chilldown", "engine_prep"),
            60: CountdownEvent(60, "T-1min: Final Systems Go", "systems_go"),
            10: CountdownEvent(10, "T-10s: Main Engine Ignition", "engine_start"),
            0: CountdownEvent(0, "T-0: LIFTOFF", "launch_commit")
        }
        
        return sequence

    def assess_weather(self, weather: WeatherData) -> WeatherCondition:
        """Assess current weather conditions against launch criteria."""
        self.weather_history.append(asdict(weather))
        
        # Check each parameter against thresholds
        violations = []
        warnings = []
        
        if weather.wind_speed > self.weather_thresholds['wind_speed_max']:
            violations.append(f"Wind speed {weather.wind_speed:.1f} m/s exceeds max {self.weather_thresholds['wind_speed_max']:.1f} m/s")
        elif weather.wind_speed < self.weather_thresholds['wind_speed_min']:
            violations.append(f"Wind speed {weather.wind_speed:.1f} m/s below min {self.weather_thresholds['wind_speed_min']:.1f} m/s")
        
        if weather.temperature < self.weather_thresholds['temperature_min']:
            violations.append(f"Temperature {weather.temperature:.1f}°C below min {self.weather_thresholds['temperature_min']:.1f}°C")
        elif weather.temperature > self.weather_thresholds['temperature_max']:
            violations.append(f"Temperature {weather.temperature:.1f}°C above max {self.weather_thresholds['temperature_max']:.1f}°C")
        
        if weather.humidity > self.weather_thresholds['humidity_max']:
            warnings.append(f"Humidity {weather.humidity:.1f}% above max {self.weather_thresholds['humidity_max']:.1f}%")
        
        if weather.visibility < self.weather_thresholds['visibility_min']:
            violations.append(f"Visibility {weather.visibility:.1f} km below min {self.weather_thresholds['visibility_min']:.1f} km")
        
        if weather.cloud_ceiling < self.weather_thresholds['cloud_ceiling_min']:
            violations.append(f"Cloud ceiling {weather.cloud_ceiling:.0f} m below min {self.weather_thresholds['cloud_ceiling_min']:.0f} m")
        
        if weather.lightning_distance < self.weather_thresholds['lightning_distance_min']:
            violations.append(f"Lightning within {weather.lightning_distance:.1f} km (min: {self.weather_thresholds['lightning_distance_min']:.1f} km)")
        
        # Return condition based on violations
        if violations:
            return WeatherCondition.NO_GO, violations, warnings
        elif warnings:
            return WeatherCondition.CAUTION, [], warnings
        else:
            return WeatherCondition.GOOD, [], []

    def check_range_safety(self) -> Dict[str, bool]:
        """Perform comprehensive range safety checks."""
        safety_status = {}
        
        for requirement in self.range_safety_requirements:
            # Simulate checking each requirement
            if 'clear' in requirement:
                # Zone clearance checks
                safety_status[requirement] = True  # Assuming clear for simulation
            elif 'active' in requirement:
                # System active checks
                safety_status[requirement] = True  # Assuming active for simulation
            elif 'ready' in requirement:
                # System ready checks
                safety_status[requirement] = True  # Assuming ready for simulation
        
        self.range_safety_history.append({
            'timestamp': datetime.datetime.now().isoformat(),
            'status': safety_status,
            'all_clear': all(safety_status.values())
        })
        
        return safety_status

    def update_crew_status(self, crew_id: str, status: str, vitals: Optional[Dict] = None):
        """Update crew member status and vitals."""
        self.crew_status[crew_id] = {
            'status': status,
            'timestamp': datetime.datetime.now().isoformat(),
            'vitals': vitals or {}
        }

    def assign_ground_crew_task(self, team: str, task: str, priority: str = "medium"):
        """Assign task to ground crew team."""
        task_id = hashlib.md5(f"{team}{task}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        self.ground_crew_tasks[task_id] = {
            'team': team,
            'task': task,
            'priority': priority,
            'assigned_time': datetime.datetime.now().isoformat(),
            'status': 'assigned',
            'completed_time': None
        }
        
        return task_id

    def complete_ground_crew_task(self, task_id: str):
        """Mark ground crew task as complete."""
        if task_id in self.ground_crew_tasks:
            self.ground_crew_tasks[task_id]['status'] = 'completed'
            self.ground_crew_tasks[task_id]['completed_time'] = datetime.datetime.now().isoformat()

    def activate_emergency_protocol(self, emergency_type: str, severity: str, details: str):
        """Activate emergency protocol."""
        activation_id = hashlib.md5(f"{emergency_type}{severity}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        self.emergency_activations.append({
            'id': activation_id,
            'type': emergency_type,
            'severity': severity,
            'details': details,
            'timestamp': datetime.datetime.now().isoformat(),
            'status': 'active'
        })
        
        return activation_id

    def execute_countdown_step(self, time_to_launch: int) -> Dict[str, Any]:
        """Execute countdown step for given time to launch."""
        if time_to_launch not in self.countdown_events:
            return {"error": "No countdown event for this time"}
        
        event = self.countdown_events[time_to_launch]
        
        # Mark as completed
        event.completed = True
        event.timestamp = datetime.datetime.now().isoformat()
        
        # Simulate system check
        system_check_result = self._perform_system_check(event.system_check)
        
        return {
            "event": asdict(event),
            "system_check": system_check_result,
            "countdown_status": "PROCEED" if system_check_result["passed"] else "HOLD"
        }

    def _perform_system_check(self, check_type: str) -> Dict[str, Any]:
        """Simulate performing a system check."""
        # Simulate various system checks with realistic pass/fail probabilities
        check_results = {
            'launch_vehicle_power': {"passed": True, "details": "All systems nominal"},
            'propellant_systems': {"passed": True, "details": "Pressures within limits"},
            'communication_links': {"passed": True, "details": "All links active"},
            'guidance_alignment': {"passed": True, "details": "Alignment complete"},
            'range_safety': {"passed": True, "details": "Range safety green"},
            'crew_check_in': {"passed": True, "details": "All crew accounted"},
            'weather_assessment': {"passed": True, "details": "Weather within limits"},
            'all_systems': {"passed": True, "details": "Systems go for launch"},
            'propellant_status': {"passed": True, "details": "Loading complete"},
            'ground_clear': {"passed": True, "details": "Ground equipment cleared"},
            'weather_check': {"passed": True, "details": "Weather go"},
            'vehicle_check': {"passed": True, "details": "Vehicle ready"},
            'crew_equipment': {"passed": True, "details": "Crew suited up"},
            'crew_transport': {"passed": True, "details": "Crew transported"},
            'crew_boarding': {"passed": True, "details": "Crew boarded"},
            'hatch_seal': {"passed": True, "details": "Hatch sealed"},
            'weather_final': {"passed": True, "details": "Weather final go"},
            'auto_sequence': {"passed": True, "details": "Auto sequence started"},
            'range_final': {"passed": True, "details": "Range safety final go"},
            'engine_prep': {"passed": True, "details": "Engine ready"},
            'systems_go': {"passed": True, "details": "All systems go"},
            'engine_start': {"passed": True, "details": "Engine ignition"},
            'launch_commit': {"passed": True, "details": "LIFTOFF!"}
        }
        
        return check_results.get(check_type, {"passed": False, "details": "Unknown check type"})

    def generate_launch_report(self) -> Dict[str, Any]:
        """Generate comprehensive launch day report."""
        completed_events = [e for e in self.countdown_events.values() if e.completed]
        pending_events = [e for e in self.countdown_events.values() if not e.completed]
        
        latest_weather = self.weather_history[-1] if self.weather_history else None
        latest_range_safety = self.range_safety_history[-1] if self.range_safety_history else None
        
        return {
            "launch_status": self.status.value,
            "countdown_progress": {
                "completed": len(completed_events),
                "total": len(self.countdown_events),
                "percentage": (len(completed_events) / len(self.countdown_events)) * 100
            },
            "weather_status": latest_weather,
            "range_safety": latest_range_safety,
            "crew_status": self.crew_status,
            "ground_crew": {
                "total_tasks": len(self.ground_crew_tasks),
                "completed_tasks": len([t for t in self.ground_crew_tasks.values() if t['status'] == 'completed'])
            },
            "emergencies": len(self.emergency_activations),
            "timestamp": datetime.datetime.now().isoformat()
        }

def main():
    """Main execution function for launch day procedures."""
    print("🚀 Initializing Starlight Launch Day Procedures System")
    
    # Initialize launch procedures
    launch_proc = LaunchDayProcedures()
    
    # Simulate launch day sequence
    print("\n📋 Launch Day Sequence Simulation")
    print("=" * 50)
    
    # Start countdown
    launch_proc.status = LaunchStatus.COUNTDOWN_ACTIVE
    print(f"✅ Countdown Started: {launch_proc.status.value}")
    
    # Sample weather data
    sample_weather = WeatherData(
        wind_speed=8.5,
        wind_direction=270.0,
        temperature=22.0,
        humidity=65.0,
        visibility=10.0,
        cloud_ceiling=2000.0,
        pressure=1013.25,
        lightning_distance=50.0,
        timestamp=datetime.datetime.now().isoformat()
    )
    
    # Assess weather
    weather_result = launch_proc.assess_weather(sample_weather)
    print(f"\n🌤️ Weather Assessment: {weather_result[0].value}")
    
    # Check range safety
    range_status = launch_proc.check_range_safety()
    print(f"🛡️ Range Safety: {'GO' if all(range_status.values()) else 'NO-GO'}")
    
    # Execute key countdown steps
    key_times = [3600, 1800, 600, 60, 10, 0]
    for time_step in key_times:
        result = launch_proc.execute_countdown_step(time_step)
        if "event" in result:
            event = result["event"]
            print(f"⏰ T-{time_step}s: {event['description']} - {result['countdown_status']}")
    
    # Generate final report
    report = launch_proc.generate_launch_report()
    print(f"\n📊 Launch Report Generated")
    print(f"   Status: {report['launch_status']}")
    print(f"   Countdown Progress: {report['countdown_progress']['percentage']:.1f}%")
    print(f"   Ground Crew Tasks: {report['ground_crew']['completed_tasks']}/{report['ground_crew']['total_tasks']} completed")
    
    # Save report
    with open("launch_day_report.json", "w") as f:
        json.dump(report, f, indent=2)
    
    print(f"\n💾 Report saved to launch_day_report.json")
    print("🎯 Launch Day Procedures System Complete!")

if __name__ == "__main__":
    main()