#!/usr/bin/env python3
"""
Crew Preparation System for Launch Operations
Comprehensive crew readiness, health monitoring, and preparation procedures.

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 CrewStatus(Enum):
    STANDBY = "STANDBY"
    PREPARING = "PREPARING"
    SUITED_UP = "SUITED_UP"
    TRANSPORT = "TRANSPORT"
    BOARDING = "BOARDING"
    ONBOARD = "ONBOARD"
    READY = "READY"

class HealthStatus(Enum):
    OPTIMAL = "OPTIMAL"
    ACCEPTABLE = "ACCEPTABLE"
    CAUTION = "CAUTION"
    CONCERN = "CONCERN"
class EquipmentStatus(Enum):
    CHECKED = "CHECKED"
    READY = "READY"
    IN_USE = "IN_USE"
    ISSUES = "ISSUES"
    FAILED = "FAILED"

@dataclass
class CrewMember:
    member_id: str
    name: str
    role: str
    status: CrewStatus
    health_status: HealthStatus
    last_medical_check: str
    vitals: Dict[str, float]
    equipment_assigned: Dict[str, EquipmentStatus]
    location: str
    checked_in_time: Optional[str] = None
    suited_up_time: Optional[str] = None
    boarded_time: Optional[str] = None

@dataclass
class MedicalCheck:
    check_id: str
    member_id: str
    check_type: str
    heart_rate: int
    blood_pressure_systolic: int
    blood_pressure_diastolic: int
    oxygen_saturation: float
    temperature: float
    respiratory_rate: int
    status: HealthStatus
    notes: str
    timestamp: str

@dataclass
class EquipmentCheck:
    check_id: str
    equipment_type: str
    serial_number: str
    assigned_to: str
    check_type: str
    status: EquipmentStatus
    issues_found: List[str]
    next_check_due: str
    timestamp: str

@dataclass
class PreparationTask:
    task_id: str
    crew_member: str
    task_name: str
    task_type: str
    deadline: str
    completed: bool = False
    completed_time: Optional[str] = None
    verified_by: Optional[str] = None

class CrewPreparationSystem:
    def __init__(self):
        self.crew_members = self._initialize_crew()
        self.medical_checks = []
        self.equipment_checks = []
        self.preparation_tasks = []
        self.preparation_timeline = self._initialize_preparation_timeline()
        self.systems_ready = False

    def _initialize_crew(self) -> Dict[str, CrewMember]:
        """Initialize crew members with default statuses."""
        crew = {
            "commander": CrewMember(
                member_id="commander",
                name="Sarah Chen",
                role="Mission Commander",
                status=CrewStatus.STANDBY,
                health_status=HealthStatus.OPTIMAL,
                last_medical_check=datetime.datetime.now().isoformat(),
                vitals={},
                equipment_assigned={},
                location="Crew Quarters"
            ),
            "pilot": CrewMember(
                member_id="pilot",
                name="Marcus Rodriguez",
                role="Pilot",
                status=CrewStatus.STANDBY,
                health_status=HealthStatus.OPTIMAL,
                last_medical_check=datetime.datetime.now().isoformat(),
                vitals={},
                equipment_assigned={},
                location="Crew Quarters"
            ),
            "specialist_1": CrewMember(
                member_id="specialist_1",
                name="Dr. Emily Watson",
                role="Mission Specialist 1",
                status=CrewStatus.STANDBY,
                health_status=HealthStatus.OPTIMAL,
                last_medical_check=datetime.datetime.now().isoformat(),
                vitals={},
                equipment_assigned={},
                location="Crew Quarters"
            ),
            "specialist_2": CrewMember(
                member_id="specialist_2",
                name="James Kim",
                role="Mission Specialist 2",
                status=CrewStatus.STANDBY,
                health_status=HealthStatus.OPTIMAL,
                last_medical_check=datetime.datetime.now().isoformat(),
                vitals={},
                equipment_assigned={},
                location="Crew Quarters"
            )
        }
        
        return crew

    def _initialize_preparation_timeline(self) -> Dict[str, Dict[str, Any]]:
        """Initialize crew preparation timeline and checkpoints."""
        timeline = {
            "T-12h": {
                "description": "Crew Wake-up and Briefing",
                "required_status": CrewStatus.PREPARING,
                "location": "Briefing Room",
                "tasks": ["medical_briefing", "weather_briefing", "mission_briefing"]
            },
            "T-8h": {
                "description": "Medical Check-in and Equipment Fitting",
                "required_status": CrewStatus.PREPARING,
                "location": "Medical Facility",
                "tasks": ["vital_signs", "equipment_fitting", "suit_check"]
            },
            "T-4h": {
                "description": "Final Medical Clearance",
                "required_status": CrewStatus.PREPARING,
                "location": "Medical Facility",
                "tasks": ["final_medical_check", "equipment_final_check"]
            },
            "T-2h": {
                "description": "Suit-Up and Systems Check",
                "required_status": CrewStatus.SUITED_UP,
                "location": "Suit-Up Room",
                "tasks": ["suit_up", "suit_systems_check", "communications_check"]
            },
            "T-1h": {
                "description": "Crew Transport to Launch Pad",
                "required_status": CrewStatus.TRANSPORT,
                "location": "Transport Vehicle",
                "tasks": ["transport_to_pad", "en_route_communications"]
            },
            "T-30m": {
                "description": "Boarding and Hatch Operations",
                "required_status": CrewStatus.BOARDING,
                "location": "Launch Pad",
                "tasks": ["crew_boarding", "hatch_closing", "onboard_systems_check"]
            },
            "T-10m": {
                "description": "Final Crew Systems Go",
                "required_status": CrewStatus.READY,
                "location": "Spacecraft",
                "tasks": ["final_systems_go", "liftoff_confirmation"]
            }
        }
        
        return timeline

    def check_in_crew_member(self, member_id: str, location: str) -> Dict[str, Any]:
        """Check in a crew member for duty."""
        if member_id not in self.crew_members:
            return {"error": f"Crew member {member_id} not found"}
        
        member = self.crew_members[member_id]
        member.status = CrewStatus.PREPARING
        member.location = location
        member.checked_in_time = datetime.datetime.now().isoformat()
        
        return {
            "check_in_successful": True,
            "member_id": member_id,
            "location": location,
            "check_in_time": member.checked_in_time
        }

    def perform_medical_check(self, member_id: str, vitals: Dict[str, float]) -> Dict[str, Any]:
        """Perform and record medical check for crew member."""
        if member_id not in self.crew_members:
            return {"error": f"Crew member {member_id} not found"}
        
        # Assess health status based on vitals
        health_status = self._assess_health_status(vitals)
        
        medical_check = MedicalCheck(
            check_id=hashlib.md5(f"{member_id}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8],
            member_id=member_id,
            check_type="routine",
            heart_rate=int(vitals.get("heart_rate", 70)),
            blood_pressure_systolic=int(vitals.get("bp_systolic", 120)),
            blood_pressure_diastolic=int(vitals.get("bp_diastolic", 80)),
            oxygen_saturation=vitals.get("oxygen_sat", 98.0),
            temperature=vitals.get("temperature", 36.5),
            respiratory_rate=int(vitals.get("respiratory_rate", 16)),
            status=health_status,
            notes="Routine pre-launch medical examination",
            timestamp=datetime.datetime.now().isoformat()
        )
        
        self.medical_checks.append(medical_check)
        
        # Update crew member status
        member = self.crew_members[member_id]
        member.health_status = health_status
        member.vitals = vitals
        member.last_medical_check = medical_check.timestamp
        
        return {
            "medical_check_completed": True,
            "check_id": medical_check.check_id,
            "member_id": member_id,
            "health_status": health_status.value,
            "vitals": vitals
        }

    def _assess_health_status(self, vitals: Dict[str, float]) -> HealthStatus:
        """Assess crew member health status based on vitals."""
        issues = []
        
        # Check vital signs against normal ranges
        heart_rate = vitals.get("heart_rate", 70)
        if heart_rate < 60 or heart_rate > 100:
            issues.append("abnormal_heart_rate")
        
        bp_systolic = vitals.get("bp_systolic", 120)
        bp_diastolic = vitals.get("bp_diastolic", 80)
        if bp_systolic > 140 or bp_diastolic > 90:
            issues.append("elevated_blood_pressure")
        
        oxygen_sat = vitals.get("oxygen_sat", 98.0)
        if oxygen_sat < 95:
            issues.append("low_oxygen_saturation")
        
        temperature = vitals.get("temperature", 36.5)
        if temperature > 37.5 or temperature < 36.0:
            issues.append("abnormal_temperature")
        
        # Determine health status
        if len(issues) == 0:
            return HealthStatus.OPTIMAL
        elif len(issues) == 1:
            return HealthStatus.ACCEPTABLE
        elif len(issues) == 2:
            return HealthStatus.CAUTION
        else:
            return HealthStatus.CONCERN

    def assign_equipment(self, member_id: str, equipment_type: str, serial_number: str) -> Dict[str, Any]:
        """Assign equipment to crew member and perform check."""
        if member_id not in self.crew_members:
            return {"error": f"Crew member {member_id} not found"}
        
        member = self.crew_members[member_id]
        
        # Perform equipment check
        equipment_status = EquipmentStatus.READY  # Assume ready for simulation
        
        equipment_check = EquipmentCheck(
            check_id=hashlib.md5(f"{equipment_type}{serial_number}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8],
            equipment_type=equipment_type,
            serial_number=serial_number,
            assigned_to=member_id,
            check_type="pre_flight",
            status=equipment_status,
            issues_found=[],  # No issues for simulation
            next_check_due=(datetime.datetime.now() + datetime.timedelta(days=30)).isoformat(),
            timestamp=datetime.datetime.now().isoformat()
        )
        
        self.equipment_checks.append(equipment_check)
        member.equipment_assigned[equipment_type] = equipment_status
        
        return {
            "equipment_assigned": True,
            "check_id": equipment_check.check_id,
            "member_id": member_id,
            "equipment_type": equipment_type,
            "serial_number": serial_number,
            "status": equipment_status.value
        }

    def update_crew_status(self, member_id: str, new_status: CrewStatus, location: str = None) -> Dict[str, Any]:
        """Update crew member status and location."""
        if member_id not in self.crew_members:
            return {"error": f"Crew member {member_id} not found"}
        
        member = self.crew_members[member_id]
        old_status = member.status
        member.status = new_status
        
        if location:
            member.location = location
        
        # Record status change timestamps
        if new_status == CrewStatus.SUITED_UP and old_status != CrewStatus.SUITED_UP:
            member.suited_up_time = datetime.datetime.now().isoformat()
        elif new_status == CrewStatus.ONBOARD and old_status != CrewStatus.ONBOARD:
            member.boarded_time = datetime.datetime.now().isoformat()
        
        return {
            "status_updated": True,
            "member_id": member_id,
            "old_status": old_status.value,
            "new_status": new_status.value,
            "location": member.location,
            "timestamp": datetime.datetime.now().isoformat()
        }

    def create_preparation_task(self, crew_member: str, task_name: str, task_type: str, deadline: str) -> str:
        """Create a preparation task for crew member."""
        task_id = hashlib.md5(f"{crew_member}{task_name}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        task = PreparationTask(
            task_id=task_id,
            crew_member=crew_member,
            task_name=task_name,
            task_type=task_type,
            deadline=deadline
        )
        
        self.preparation_tasks.append(task)
        
        return task_id

    def complete_preparation_task(self, task_id: str, verified_by: str) -> Dict[str, Any]:
        """Mark a preparation task as complete."""
        for task in self.preparation_tasks:
            if task.task_id == task_id:
                task.completed = True
                task.completed_time = datetime.datetime.now().isoformat()
                task.verified_by = verified_by
                
                return {
                    "task_completed": True,
                    "task_id": task_id,
                    "completed_time": task.completed_time,
                    "verified_by": verified_by
                }
        
        return {"error": f"Task {task_id} not found"}

    def check_crew_readiness(self) -> Dict[str, Any]:
        """Check overall crew readiness for launch."""
        crew_readiness = {}
        all_ready = True
        
        for member_id, member in self.crew_members.items():
            # Individual readiness criteria
            health_ok = member.health_status in [HealthStatus.OPTIMAL, HealthStatus.ACCEPTABLE]
            status_ok = member.status == CrewStatus.READY
            equipment_ok = all(status == EquipmentStatus.READY for status in member.equipment_assigned.values())
            
            member_ready = health_ok and status_ok and equipment_ok
            crew_readiness[member_id] = {
                "ready": member_ready,
                "health_ok": health_ok,
                "status_ok": status_ok,
                "equipment_ok": equipment_ok,
                "current_status": member.status.value,
                "health_status": member.health_status.value
            }
            
            if not member_ready:
                all_ready = False
        
        # Check preparation tasks
        total_tasks = len(self.preparation_tasks)
        completed_tasks = len([t for t in self.preparation_tasks if t.completed])
        tasks_ok = total_tasks == completed_tasks
        
        overall_ready = all_ready and tasks_ok
        
        return {
            "overall_ready": overall_ready,
            "crew_readiness": crew_readiness,
            "preparation_tasks": {
                "total": total_tasks,
                "completed": completed_tasks,
                "completion_rate": (completed_tasks / total_tasks * 100) if total_tasks > 0 else 100
            },
            "assessment_time": datetime.datetime.now().isoformat()
        }

    def get_crew_summary(self) -> Dict[str, Any]:
        """Get comprehensive crew preparation summary."""
        summary = {
            "total_crew": len(self.crew_members),
            "crew_by_status": {},
            "crew_by_health": {},
            "medical_checks": len(self.medical_checks),
            "equipment_checks": len(self.equipment_checks),
            "preparation_tasks": {
                "total": len(self.preparation_tasks),
                "completed": len([t for t in self.preparation_tasks if t.completed])
            },
            "locations": {}
        }
        
        # Count by status
        for status in CrewStatus:
            summary["crew_by_status"][status.value] = len([
                m for m in self.crew_members.values() if m.status == status
            ])
        
        # Count by health status
        for health in HealthStatus:
            summary["crew_by_health"][health.value] = len([
                m for m in self.crew_members.values() if m.health_status == health
            ])
        
        # Count by location
        for member in self.crew_members.values():
            location = member.location
            summary["locations"][location] = summary["locations"].get(location, 0) + 1
        
        return summary

def main():
    """Main execution function for crew preparation system."""
    print("👨‍🚀 Initializing Starlight Crew Preparation System")
    
    # Initialize crew preparation
    crew_prep = CrewPreparationSystem()
    
    # Check in crew members
    for member_id in crew_prep.crew_members.keys():
        result = crew_prep.check_in_crew_member(member_id, "Medical Facility")
        print(f"✅ {member_id}: Checked in at {result['location']}")
    
    # Perform medical checks
    sample_vitals = {
        "heart_rate": 72,
        "bp_systolic": 118,
        "bp_diastolic": 78,
        "oxygen_sat": 98.5,
        "temperature": 36.6,
        "respiratory_rate": 14
    }
    
    for member_id in crew_prep.crew_members.keys():
        result = crew_prep.perform_medical_check(member_id, sample_vitals)
        print(f"🏥 {member_id}: Medical check - {result['health_status']}")
    
    # Assign equipment
    equipment_assignments = [
        ("commander", "spacesuit", "SS-001"),
        ("pilot", "spacesuit", "SS-002"),
        ("specialist_1", "spacesuit", "SS-003"),
        ("specialist_2", "spacesuit", "SS-004"),
        ("commander", "helmet", "HLM-001"),
        ("pilot", "helmet", "HLM-002")
    ]
    
    for member_id, equipment_type, serial in equipment_assignments:
        result = crew_prep.assign_equipment(member_id, equipment_type, serial)
        print(f"🛰️ {member_id}: {equipment_type} {serial} assigned")
    
    # Update crew statuses through preparation timeline
    status_updates = [
        ("commander", CrewStatus.SUITED_UP, "Suit-Up Room"),
        ("pilot", CrewStatus.SUITED_UP, "Suit-Up Room"),
        ("commander", CrewStatus.TRANSPORT, "Transport Vehicle"),
        ("pilot", CrewStatus.TRANSPORT, "Transport Vehicle"),
        ("commander", CrewStatus.ONBOARD, "Spacecraft"),
        ("pilot", CrewStatus.ONBOARD, "Spacecraft"),
        ("commander", CrewStatus.READY, "Spacecraft"),
        ("pilot", CrewStatus.READY, "Spacecraft")
    ]
    
    for member_id, status, location in status_updates:
        result = crew_prep.update_crew_status(member_id, status, location)
        print(f"📍 {member_id}: Status -> {result['new_status']} at {location}")
    
    # Create and complete preparation tasks
    task_assignments = [
        ("commander", "Systems Check", "verification", "T-30m"),
        ("pilot", "Communications Test", "verification", "T-20m"),
        ("specialist_1", "Payload Check", "verification", "T-25m"),
        ("specialist_2", "Life Support Check", "verification", "T-15m")
    ]
    
    for member_id, task_name, task_type, deadline in task_assignments:
        task_id = crew_prep.create_preparation_task(member_id, task_name, task_type, deadline)
        crew_prep.complete_preparation_task(task_id, "Flight Director")
        print(f"✓ {member_id}: {task_name} completed")
    
    # Check crew readiness
    readiness = crew_prep.check_crew_readiness()
    print(f"\n🎯 Overall Crew Readiness: {'✅ READY' if readiness['overall_ready'] else '❌ NOT READY'}")
    print(f"📊 Tasks Completion: {readiness['preparation_tasks']['completion_rate']:.1f}%")
    
    # Get summary
    summary = crew_prep.get_crew_summary()
    print(f"👥 Crew Status Breakdown:")
    for status, count in summary["crew_by_status"].items():
        if count > 0:
            print(f"   {status}: {count}")
    
    print(f"🏥 Health Status Breakdown:")
    for health, count in summary["crew_by_health"].items():
        if count > 0:
            print(f"   {health}: {count}")
    
    # Save crew preparation data
    crew_data = {
        "readiness": readiness,
        "summary": summary,
        "timestamp": datetime.datetime.now().isoformat()
    }
    
    with open("crew_preparation_data.json", "w") as f:
        json.dump(crew_data, f, indent=2)
    
    print("\n💾 Crew preparation data saved to crew_preparation_data.json")
    print("🎯 Crew Preparation System Complete!")

if __name__ == "__main__":
    main()