#!/usr/bin/env python3
"""
Ground Crew Coordination System for Launch Operations
Comprehensive ground crew management, task coordination, and communication 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 TeamStatus(Enum):
    STANDBY = "STANDBY"
    ACTIVE = "ACTIVE"
    BUSY = "BUSY"
    OFFLINE = "OFFLINE"

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

class TaskStatus(Enum):
    ASSIGNED = "ASSIGNED"
    IN_PROGRESS = "IN_PROGRESS"
    COMPLETED = "COMPLETED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"

@dataclass
class GroundTeam:
    team_id: str
    name: str
    specialization: str
    location: str
    status: TeamStatus
    members: List[str]
    current_task: Optional[str] = None
    contact_frequency: str = "Primary"
    capabilities: List[str] = None

@dataclass
class GroundCrewTask:
    task_id: str
    title: str
    description: str
    assigned_team: str
    priority: TaskPriority
    status: TaskStatus
    location: str
    deadline: str
    assigned_time: str
    estimated_duration_min: int
    dependencies: List[str] = None
    required_equipment: List[str] = None
    completion_time: Optional[str] = None
    notes: str = ""

@dataclass
class CommunicationLog:
    log_id: str
    from_team: str
    to_team: str
    message: str
    message_type: str
    priority: TaskPriority
    timestamp: str
    acknowledged: bool = False
    ack_time: Optional[str] = None

@dataclass
class ResourceAllocation:
    allocation_id: str
    resource_type: str
    resource_id: str
    assigned_to: str
    allocation_time: str
    expected_return: str
    actual_return: Optional[str] = None
    status: str = "ALLOCATED"

class GroundCrewCoordination:
    def __init__(self):
        self.teams = self._initialize_teams()
        self.tasks = self._initialize_initial_tasks()
        self.communications = []
        self.resources = []
        self.coordination_active = False
        self.emergency_mode = False

    def _initialize_teams(self) -> Dict[str, GroundTeam]:
        """Initialize all ground crew teams."""
        teams = {
            "launch_operations": GroundTeam(
                team_id="launch_operations",
                name="Launch Operations Team",
                specialization="Launch Control",
                location="Launch Control Center",
                status=TeamStatus.STANDBY,
                members=["Flight Director", "Launch Director", "Systems Engineer"],
                capabilities=["launch_control", "system_monitoring", "decision_making"]
            ),
            "pad_operations": GroundTeam(
                team_id="pad_operations",
                name="Pad Operations Team",
                specialization="Pad Safety & Operations",
                location="Launch Pad",
                status=TeamStatus.STANDBY,
                members=["Pad Manager", "Safety Officer", "Equipment Specialist"],
                capabilities=["pad_safety", "equipment_operation", "emergency_response"]
            ),
            "propulsion_team": GroundTeam(
                team_id="propulsion_team",
                name="Propulsion Team",
                specialization="Propulsion Systems",
                location="Propulsion Facility",
                status=TeamStatus.STANDBY,
                members=["Propulsion Engineer", "Fuel Systems Tech", "Valve Specialist"],
                capabilities=["fueling_operations", "engine_check", "propulsion_safety"]
            ),
            "weather_team": GroundTeam(
                team_id="weather_team",
                name="Weather Team",
                specialization="Meteorology",
                location="Weather Station",
                status=TeamStatus.STANDBY,
                members=["Meteorologist", "Weather Technician"],
                capabilities=["weather_monitoring", "forecasting", "weather_advisory"]
            ),
            "recovery_team": GroundTeam(
                team_id="recovery_team",
                name="Recovery Team",
                specialization="Spacecraft Recovery",
                location="Recovery Operations Center",
                status=TeamStatus.STANDBY,
                members=["Recovery Coordinator", "Dive Team Lead", "Helicopter Pilot"],
                capabilities=["spacecraft_recovery", "personnel_recovery", "search_rescue"]
            ),
            "medical_team": GroundTeam(
                team_id="medical_team",
                name="Medical Team",
                specialization="Medical Emergency Response",
                location="Medical Facility",
                status=TeamStatus.STANDBY,
                members=["Flight Surgeon", "Paramedic", "Medical Technician"],
                capabilities=["emergency_medical", "crew_health", "trauma_care"]
            ),
            "security_team": GroundTeam(
                team_id="security_team",
                name="Security Team",
                specialization="Range Security",
                location="Security Command",
                status=TeamStatus.STANDBY,
                members=["Security Chief", "Patrol Leader"],
                capabilities=["perimeter_security", "access_control", "threat_response"]
            )
        }
        
        return teams

    def _initialize_initial_tasks(self) -> Dict[str, GroundCrewTask]:
        """Initialize initial ground crew tasks."""
        current_time = datetime.datetime.now()
        
        tasks = {
            "pre_launch_inspection": GroundCrewTask(
                task_id="pre_launch_inspection",
                title="Pre-Launch Vehicle Inspection",
                description="Comprehensive inspection of launch vehicle and ground support equipment",
                assigned_team="pad_operations",
                priority=TaskPriority.HIGH,
                status=TaskStatus.ASSIGNED,
                location="Launch Pad",
                deadline=(current_time + datetime.timedelta(hours=4)).isoformat(),
                assigned_time=current_time.isoformat(),
                estimated_duration_min=180,
                required_equipment=["inspection_kit", "safety_harness", "communication_radio"]
            ),
            "propellant_loading_prep": GroundCrewTask(
                task_id="propellant_loading_prep",
                title="Propellant Loading Preparation",
                description="Prepare propellant loading systems and perform safety checks",
                assigned_team="propulsion_team",
                priority=TaskPriority.HIGH,
                status=TaskStatus.ASSIGNED,
                location="Propulsion Facility",
                deadline=(current_time + datetime.timedelta(hours=6)).isoformat(),
                assigned_time=current_time.isoformat(),
                estimated_duration_min=120,
                required_equipment=["fueling_equipment", "safety_gear", "monitoring_systems"]
            ),
            "weather_briefing": GroundCrewTask(
                task_id="weather_briefing",
                title="Weather Briefing",
                description="Provide detailed weather briefing to all teams",
                assigned_team="weather_team",
                priority=TaskPriority.MEDIUM,
                status=TaskStatus.ASSIGNED,
                location="Briefing Room",
                deadline=(current_time + datetime.timedelta(hours=2)).isoformat(),
                assigned_time=current_time.isoformat(),
                estimated_duration_min=60,
                required_equipment=["weather_displays", "communication_system"]
            ),
            "medical_standby": GroundCrewTask(
                task_id="medical_standby",
                title="Medical Standby Setup",
                description="Establish medical stations and prepare emergency response protocols",
                assigned_team="medical_team",
                priority=TaskPriority.HIGH,
                status=TaskStatus.ASSIGNED,
                location="Medical Facility",
                deadline=(current_time + datetime.timedelta(hours=3)).isoformat(),
                assigned_time=current_time.isoformat(),
                estimated_duration_min=90,
                required_equipment=["medical_kits", "ambulance", "communication_systems"]
            ),
            "security_perimeter": GroundCrewTask(
                task_id="security_perimeter",
                title="Security Perimeter Establishment",
                description="Establish and monitor security perimeter for launch area",
                assigned_team="security_team",
                priority=TaskPriority.HIGH,
                status=TaskStatus.ASSIGNED,
                location="Launch Range",
                deadline=(current_time + datetime.timedelta(hours=1)).isoformat(),
                assigned_time=current_time.isoformat(),
                estimated_duration_min=60,
                required_equipment=["patrol_vehicles", "surveillance_systems", "communication_radios"]
            )
        }
        
        return tasks

    def start_coordination(self) -> Dict[str, Any]:
        """Start ground crew coordination for launch operations."""
        self.coordination_active = True
        
        # Activate all teams
        for team in self.teams.values():
            team.status = TeamStatus.ACTIVE
        
        return {
            "coordination_started": True,
            "timestamp": datetime.datetime.now().isoformat(),
            "teams_activated": len(self.teams)
        }

    def assign_task(self, title: str, description: str, team_id: str, 
                   priority: TaskPriority, location: str, deadline: str,
                   estimated_duration_min: int, 
                   required_equipment: List[str] = None) -> str:
        """Assign a new task to a ground crew team."""
        if team_id not in self.teams:
            raise ValueError(f"Team {team_id} not found")
        
        task_id = hashlib.md5(f"{title}{team_id}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        task = GroundCrewTask(
            task_id=task_id,
            title=title,
            description=description,
            assigned_team=team_id,
            priority=priority,
            status=TaskStatus.ASSIGNED,
            location=location,
            deadline=deadline,
            assigned_time=datetime.datetime.now().isoformat(),
            estimated_duration_min=estimated_duration_min,
            required_equipment=required_equipment or []
        )
        
        self.tasks[task_id] = task
        
        # Update team current task
        self.teams[team_id].current_task = task_id
        self.teams[team_id].status = TeamStatus.BUSY
        
        return task_id

    def update_task_status(self, task_id: str, new_status: TaskStatus, notes: str = "") -> Dict[str, Any]:
        """Update task status and manage team availability."""
        if task_id not in self.tasks:
            return {"error": f"Task {task_id} not found"}
        
        task = self.tasks[task_id]
        old_status = task.status
        task.status = new_status
        task.notes = notes
        
        if new_status == TaskStatus.COMPLETED:
            task.completion_time = datetime.datetime.now().isoformat()
            
            # Update team availability
            team = self.teams[task.assigned_team]
            team.current_task = None
            team.status = TeamStatus.ACTIVE
        
        return {
            "task_updated": True,
            "task_id": task_id,
            "old_status": old_status.value,
            "new_status": new_status.value,
            "completion_time": task.completion_time
        }

    def send_communication(self, from_team: str, to_team: str, message: str, 
                          message_type: str, priority: TaskPriority) -> str:
        """Send communication between ground crew teams."""
        log_id = hashlib.md5(f"{from_team}{to_team}{message}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        comm_log = CommunicationLog(
            log_id=log_id,
            from_team=from_team,
            to_team=to_team,
            message=message,
            message_type=message_type,
            priority=priority,
            timestamp=datetime.datetime.now().isoformat()
        )
        
        self.communications.append(comm_log)
        
        return log_id

    def acknowledge_communication(self, log_id: str) -> bool:
        """Acknowledge receipt of communication."""
        for comm in self.communications:
            if comm.log_id == log_id:
                comm.acknowledged = True
                comm.ack_time = datetime.datetime.now().isoformat()
                return True
        return False

    def allocate_resource(self, resource_type: str, resource_id: str, 
                         assigned_to: str, expected_return: str) -> str:
        """Allocate resource to a team or task."""
        allocation_id = hashlib.md5(f"{resource_type}{resource_id}{assigned_to}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8]
        
        allocation = ResourceAllocation(
            allocation_id=allocation_id,
            resource_type=resource_type,
            resource_id=resource_id,
            assigned_to=assigned_to,
            allocation_time=datetime.datetime.now().isoformat(),
            expected_return=expected_return
        )
        
        self.resources.append(allocation)
        
        return allocation_id

    def return_resource(self, allocation_id: str) -> bool:
        """Mark resource as returned."""
        for resource in self.resources:
            if resource.allocation_id == allocation_id:
                resource.actual_return = datetime.datetime.now().isoformat()
                resource.status = "RETURNED"
                return True
        return False

    def activate_emergency_mode(self, emergency_type: str, priority_teams: List[str]) -> Dict[str, Any]:
        """Activate emergency mode with priority team activation."""
        self.emergency_mode = True
        
        # Activate priority teams immediately
        activated_teams = []
        for team_id in priority_teams:
            if team_id in self.teams:
                self.teams[team_id].status = TeamStatus.BUSY
                activated_teams.append(team_id)
        
        # Send emergency communication to all teams
        emergency_msg = f"EMERGENCY MODE ACTIVATED: {emergency_type}"
        for team_id in self.teams.keys():
            self.send_communication("launch_operations", team_id, emergency_msg, 
                                  "emergency", TaskPriority.CRITICAL)
        
        return {
            "emergency_mode": True,
            "emergency_type": emergency_type,
            "activated_teams": activated_teams,
            "timestamp": datetime.datetime.now().isoformat()
        }

    def get_team_status(self) -> Dict[str, Any]:
        """Get status of all ground crew teams."""
        team_status = {}
        
        for team_id, team in self.teams.items():
            team_status[team_id] = {
                "name": team.name,
                "specialization": team.specialization,
                "location": team.location,
                "status": team.status.value,
                "members_count": len(team.members),
                "current_task": team.current_task,
                "capabilities": team.capabilities
            }
        
        return team_status

    def get_task_overview(self) -> Dict[str, Any]:
        """Get comprehensive task overview."""
        tasks_by_status = {}
        tasks_by_priority = {}
        tasks_by_team = {}
        overdue_tasks = []
        
        current_time = datetime.datetime.now()
        
        for task_id, task in self.tasks.items():
            # Count by status
            status = task.status.value
            tasks_by_status[status] = tasks_by_status.get(status, 0) + 1
            
            # Count by priority
            priority = task.priority.value
            tasks_by_priority[priority] = tasks_by_priority.get(priority, 0) + 1
            
            # Count by team
            team = task.assigned_team
            tasks_by_team[team] = tasks_by_team.get(team, 0) + 1
            
            # Check overdue tasks
            deadline_time = datetime.datetime.fromisoformat(task.deadline)
            if current_time > deadline_time and task.status not in [TaskStatus.COMPLETED, TaskStatus.CANCELLED]:
                overdue_tasks.append({
                    "task_id": task_id,
                    "title": task.title,
                    "deadline": task.deadline,
                    "overdue_by": str(current_time - deadline_time)
                })
        
        return {
            "total_tasks": len(self.tasks),
            "tasks_by_status": tasks_by_status,
            "tasks_by_priority": tasks_by_priority,
            "tasks_by_team": tasks_by_team,
            "overdue_tasks": overdue_tasks,
            "completion_rate": (tasks_by_status.get("COMPLETED", 0) / len(self.tasks) * 100) if len(self.tasks) > 0 else 0
        }

    def get_coordination_summary(self) -> Dict[str, Any]:
        """Get comprehensive ground crew coordination summary."""
        team_status = self.get_team_status()
        task_overview = self.get_task_overview()
        
        # Communication statistics
        total_comms = len(self.communications)
        acknowledged_comms = len([c for c in self.communications if c.acknowledged])
        
        # Resource allocation
        active_resources = len([r for r in self.resources if r.status == "ALLOCATED"])
        
        summary = {
            "coordination_active": self.coordination_active,
            "emergency_mode": self.emergency_mode,
            "teams": {
                "total": len(self.teams),
                "active": len([t for t in self.teams.values() if t.status == TeamStatus.ACTIVE]),
                "busy": len([t for t in self.teams.values() if t.status == TeamStatus.BUSY]),
                "standby": len([t for t in self.teams.values() if t.status == TeamStatus.STANDBY])
            },
            "tasks": task_overview,
            "communications": {
                "total": total_comms,
                "acknowledged": acknowledged_comms,
                "acknowledgment_rate": (acknowledged_comms / total_comms * 100) if total_comms > 0 else 0
            },
            "resources": {
                "total_allocations": len(self.resources),
                "active_allocations": active_resources
            },
            "timestamp": datetime.datetime.now().isoformat()
        }
        
        return summary

def main():
    """Main execution function for ground crew coordination system."""
    print("👥 Initializing Starlight Ground Crew Coordination System")
    
    # Initialize coordination
    ground_coord = GroundCrewCoordination()
    
    # Start coordination
    result = ground_coord.start_coordination()
    print(f"✅ Coordination Started: {result['teams_activated']} teams activated")
    
    # Simulate task execution
    task_updates = [
        ("pre_launch_inspection", TaskStatus.IN_PROGRESS, "Starting vehicle inspection"),
        ("propellant_loading_prep", TaskStatus.IN_PROGRESS, "Preparing fueling systems"),
        ("weather_briefing", TaskStatus.COMPLETED, "Weather briefing completed successfully"),
        ("medical_standby", TaskStatus.COMPLETED, "Medical stations ready"),
        ("security_perimeter", TaskStatus.COMPLETED, "Security perimeter established")
    ]
    
    for task_id, status, notes in task_updates:
        result = ground_coord.update_task_status(task_id, status, notes)
        if result.get("task_updated"):
            print(f"📋 Task {task_id}: {result['new_status']}")
    
    # Send communications between teams
    communications = [
        ("launch_operations", "weather_team", "Request updated weather forecast", "request", TaskPriority.HIGH),
        ("weather_team", "launch_operations", "Weather conditions favorable for launch", "response", TaskPriority.HIGH),
        ("pad_operations", "launch_operations", "Vehicle inspection 75% complete", "update", TaskPriority.MEDIUM),
        ("propulsion_team", "launch_operations", "Fueling systems ready for loading", "status", TaskPriority.HIGH)
    ]
    
    for from_team, to_team, message, msg_type, priority in communications:
        log_id = ground_coord.send_communication(from_team, to_team, message, msg_type, priority)
        # Auto-acknowledge for simulation
        ground_coord.acknowledge_communication(log_id)
        print(f"📢 {from_team} → {to_team}: {message}")
    
    # Allocate resources
    resource_allocations = [
        ("vehicle", "inspector_unit", "pad_operations", "T+2h"),
        ("fueling", "pump_station_1", "propulsion_team", "T+4h"),
        ("medical", "ambulance_1", "medical_team", "T+6h"),
        ("security", "patrol_vehicle_1", "security_team", "T+3h")
    ]
    
    for resource_type, resource_id, team, expected_return in resource_allocations:
        alloc_id = ground_coord.allocate_resource(resource_type, resource_id, team, expected_return)
        print(f"🛠️ {resource_type} {resource_id} allocated to {team}")
    
    # Test emergency mode
    emergency_result = ground_coord.activate_emergency_mode(
        "Weather Alert", ["weather_team", "launch_operations", "pad_operations"]
    )
    print(f"🚨 Emergency Mode: {emergency_result['emergency_type']} - {len(emergency_result['activated_teams'])} teams activated")
    
    # Get coordination summary
    summary = ground_coord.get_coordination_summary()
    print(f"\n📊 Coordination Summary:")
    print(f"   Active Teams: {summary['teams']['active']}/{summary['teams']['total']}")
    print(f"   Task Completion: {summary['tasks']['completion_rate']:.1f}%")
    print(f"   Communications: {summary['communications']['acknowledgment_rate']:.1f}% acknowledged")
    print(f"   Active Resources: {summary['resources']['active_allocations']}")
    
    # Save coordination data
    coordination_data = {
        "summary": summary,
        "team_status": ground_coord.get_team_status(),
        "timestamp": datetime.datetime.now().isoformat()
    }
    
    with open("ground_crew_coordination_data.json", "w") as f:
        json.dump(coordination_data, f, indent=2)
    
    print("\n💾 Ground crew coordination data saved to ground_crew_coordination_data.json")
    print("🎯 Ground Crew Coordination System Complete!")

if __name__ == "__main__":
    main()