from typing import List, Dict, Tuple, Optional
from dataclasses import dataclass
from enum import Enum
from datetime import datetime

class ThreatLevel(Enum):
    NONE = 0
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    CRITICAL = 4

class AircraftType(Enum):
    UNKNOWN = "unknown"
    FRIENDLY = "friendly"
    HOSTILE = "hostile"
    NEUTRAL = "neutral"
    CIVILIAN = "civilian"

@dataclass
class Track:
    track_id: str
    position: np.ndarray
    velocity: np.ndarray
    aircraft_type: AircraftType
    threat_level: ThreatLevel
    confidence: float
    first_seen: datetime
    last_update: datetime

class SurveillanceSystem:
    def __init__(self, coverage_radius: float = 10000):
        self.coverage_radius = coverage_radius
        self.tracks: Dict[str, Track] = {}
        self.track_counter = 0

    def process_radar_data(self, radar_returns: List[Dict]) -> List[Track]:
        """Process radar returns and update tracks"""
        detected = []

        for radar_return in radar_returns:
            position = np.array(radar_return['position'])
            velocity = np.array(radar_return.get('velocity', [0, 0, 0]))
            rcs = radar_return.get('rcs', 0)  # Radar cross section

            # Try to associate with existing track
            associated = self._associate_track(position, velocity)

            if associated:
                # Update existing track
                associated.position = position
                associated.velocity = velocity
                associated.last_update = datetime.now()
                associated.confidence = min(1.0, associated.confidence + 0.1)
                detected.append(associated)
            else:
                # Create new track
                self.track_counter += 1
                track = Track(
                    track_id=f"TRACK-{self.track_counter:04d}",
                    position=position,
                    velocity=velocity,
                    aircraft_type=self._classify_aircraft(rcs, velocity),
                    threat_level=ThreatLevel.NONE,
                    confidence=0.5,
                    first_seen=datetime.now(),
                    last_update=datetime.now()
                )
                self.tracks[track.track_id] = track
                detected.append(track)

        # Update threat levels
        self._update_threat_levels()

        return detected

    def _associate_track(self, position: np.ndarray,
                        velocity: np.ndarray,
                        max_distance: float = 500) -> Optional[Track]:
        """Associate detection with existing track"""
        best_match = None
        best_score = float('inf')

        for track in self.tracks.values():
            # Predict position based on velocity
            time_delta = (datetime.now() - track.last_update).total_seconds()
            predicted_pos = track.position + track.velocity * time_delta

            # Calculate distance
            distance = np.linalg.norm(position - predicted_pos)

            if distance < max_distance and distance < best_score:
                best_score = distance
                best_match = track

        return best_match

    def _classify_aircraft(self, rcs: float,
                          velocity: np.ndarray) -> AircraftType:
        """Classify aircraft based on radar signature"""
        speed = np.linalg.norm(velocity)

        # Simple classification based on RCS and speed
        if rcs > 10 and speed > 100:
            return AircraftType.HOSTILE  # Large, fast
        elif rcs < 0.1:
            return AircraftType.UNKNOWN  # Very small (UAS?)
        elif 0.1 <= rcs <= 2 and speed < 80:
            return AircraftType.CIVILIAN  # Small, slow
        else:
            return AircraftType.UNKNOWN

    def _update_threat_levels(self):
        """Update threat levels based on behavior"""
        for track in self.tracks.values():
            track.threat_level = self._assess_threat(track)

    def _assess_threat(self, track: Track) -> ThreatLevel:
        """Assess threat level of a track"""
        score = 0

        # Speed factor
        speed = np.linalg.norm(track.velocity)
        if speed > 150:
            score += 2
        elif speed > 100:
            score += 1

        # Heading toward protected area (simplified)
        # In production, check against geofence

        # Aircraft type factor
        if track.aircraft_type == AircraftType.HOSTILE:
            score += 3
        elif track.aircraft_type == AircraftType.UNKNOWN:
            score += 1

        # Confidence factor
        if track.confidence < 0.5:
            score += 1

        # Map score to threat level
        if score >= 5:
            return ThreatLevel.CRITICAL
        elif score >= 3:
            return ThreatLevel.HIGH
        elif score >= 2:
            return ThreatLevel.MEDIUM
        elif score >= 1:
            return ThreatLevel.LOW
        return ThreatLevel.NONE

    def get_situation_display(self) -> Dict:
        """Get current situation display data"""
        tracks_by_threat = {
            ThreatLevel.CRITICAL: [],
            ThreatLevel.HIGH: [],
            ThreatLevel.MEDIUM: [],
            ThreatLevel.LOW: [],
            ThreatLevel.NONE: []
        }

        for track in self.tracks.values():
            tracks_by_threat[track.threat_level].append({
                'id': track.track_id,
                'position': track.position.tolist(),
                'velocity': track.velocity.tolist(),
                'type': track.aircraft_type.value,
                'confidence': track.confidence
            })

        return {
            'total_tracks': len(self.tracks),
            'tracks_by_threat': {k.name: v for k, v in tracks_by_threat.items()},
            'coverage_percentage': self._calculate_coverage()
        }

    def _calculate_coverage(self) -> float:
        """Calculate surveillance coverage"""
        return min(100, len(self.tracks) * 5 + 50)

from typing import List, Dict, Tuple, Optional
from dataclasses import dataclass
from enum import Enum

class DetectionMethod(Enum):
    RADAR = "radar"
    RF_SENSOR = "rf_sensor"
    OPTICAL = "optical"
    ACOUSTIC = "acoustic"
    INFRARED = "infrared"

class NeutralizationMethod(Enum):
    KINETIC = "kinetic"
    ELECTRONIC_WARFARE = "electronic_warfare"
    SPOOFING = "spoofing"
    NET_CAPTURE = "net_capture"
    LASER = "laser"

@dataclass
class UASTrack:
    uas_id: str
    position: np.ndarray
    velocity: np.ndarray
    size_class: str  # 'nano', 'micro', 'small', 'medium'
    control_type: str  # 'manual', 'autopilot', 'autonomous'
    threat_confidence: float
    detection_methods: List[DetectionMethod]

class CounterUASSystem:
    def __init__(self):
        self.detected_uas: Dict[str, UASTrack] = {}
        self.neutralization_options = {
            DetectionMethod.RADAR: [NeutralizationMethod.KINETIC, NeutralizationMethod.LASER],
            DetectionMethod.RF_SENSOR: [NeutralizationMethod.ELECTRONIC_WARFARE, NeutralizationMethod.SPOOFING],
            DetectionMethod.OPTICAL: [NeutralizationMethod.NET_CAPTURE, NeutralizationMethod.KINETIC],
            DetectionMethod.ACOUSTIC: [NeutralizationMethod.NET_CAPTURE]
        }

    def detect_uas(self, sensor_data: Dict) -> List[UASTrack]:
        """Detect UAS using multiple sensor fusion"""
        detections = []

        # Radar detection
        if 'radar' in sensor_data:
            radar_detections = self._process_radar(sensor_data['radar'])
            detections.extend(radar_detections)

        # RF detection
        if 'rf' in sensor_data:
            rf_detections = self._process_rf_sensor(sensor_data['rf'])
            detections.extend(rf_detections)

        # Optical detection
        if 'optical' in sensor_data:
            optical_detections = self._process_optical(sensor_data['optical'])
            detections.extend(optical_detections)

        # Merge and associate detections
        merged = self._merge_detections(detections)

        return merged

    def _process_radar(self, radar_data: List[Dict]) -> List[UASTrack]:
        """Process radar data for UAS detection"""
        detections = []

        for target in radar_data:
            if target.get('rcs', 0) < 1.0:  # Small radar cross section
                detections.append(UASTrack(
                    uas_id=f"RAD-{np.random.randint(1000, 9999)}",
                    position=np.array(target['position']),
                    velocity=np.array(target.get('velocity', [0, 0, 0])),
                    size_class=self._classify_size(target.get('rcs', 0)),
                    control_type='unknown',
                    threat_confidence=0.6,
                    detection_methods=[DetectionMethod.RADAR]
                ))

        return detections

    def _process_rf_sensor(self, rf_data: List[Dict]) -> List[UASTrack]:
        """Process RF sensor data for UAS control link detection"""
        detections = []

        for signal in rf_data:
            if signal.get('frequency', 0) > 0:
                # Detect control link
                detections.append(UASTrack(
                    uas_id=f"RF-{np.random.randint(1000, 9999)}",
                    position=np.array(signal.get('position', [0, 0, 0])),
                    velocity=np.zeros(3),
                    size_class='unknown',
                    control_type=self._identify_control_type(signal),
                    threat_confidence=0.7,
                    detection_methods=[DetectionMethod.RF_SENSOR]
                ))

        return detections

    def _process_optical(self, optical_data: Dict) -> List[UASTrack]:
        """Process optical/IR data for UAS detection"""
        detections = []

        if optical_data.get('detected', False):
            detections.append(UASTrack(
                uas_id=f"OPT-{np.random.randint(1000, 9999)}",
                position=np.array(optical_data['position']),
                velocity=np.array(optical_data.get('velocity', [0, 0, 0])),
                size_class=optical_data.get('size_class', 'small'),
                control_type='unknown',
                threat_confidence=0.8,
                detection_methods=[DetectionMethod.OPTICAL]
            ))

        return detections

    def _classify_size(self, rcs: float) -> str:
        """Classify UAS size based on RCS"""
        if rcs < 0.001:
            return 'nano'
        elif rcs < 0.01:
            return 'micro'
        elif rcs < 0.1:
            return 'small'
        return 'medium'

    def _identify_control_type(self, signal: Dict) -> str:
        """Identify UAS control type from RF signature"""
        if signal.get('is_video_feed', False):
            return 'manual'
        elif signal.get('has_telemetry', False):
            return 'autopilot'
        return 'autonomous'

    def _merge_detections(self, detections: List[UASTrack]) -> List[UASTrack]:
        """Merge detections from multiple sensors"""
        if not detections:
            return []

        merged = []
        used = set()

        for i, d1 in enumerate(detections):
            if i in used:
                continue

            cluster = [d1]
            for j, d2 in enumerate(detections[i+1:], i+1):
                if j in used:
                    continue
                if np.linalg.norm(d1.position - d2.position) < 100:
                    cluster.append(d2)
                    used.add(j)

            # Merge cluster into single track
            best_detection = max(cluster, key=lambda d: d.threat_confidence)
            combined_methods = list(set(
                method for d in cluster for method in d.detection_methods
            ))
            best_detection.detection_methods = combined_methods
            merged.append(best_detection)
            used.add(i)

        return merged

    def recommend_neutralization(self, uas: UASTrack) -> Dict:
        """Recommend neutralization method"""
        options = []

        for method in uas.detection_methods:
            if method in self.neutralization_options:
                for neutralization in self.neutralization_options[method]:
                    options.append({
                        'method': neutralization,
                        'effectiveness': self._estimate_effectiveness(neutralization, uas),
                        'collateral_risk': self._assess_collateral_risk(neutralization)
                    })

        # Sort by effectiveness
        options.sort(key=lambda x: x['effectiveness'], reverse=True)

        return {
            'recommended': options[0] if options else None,
            'alternatives': options[1:3] if len(options) > 1 else []
        }

    def _estimate_effectiveness(self, method: NeutralizationMethod,
                               uas: UASTrack) -> float:
        """Estimate neutralization effectiveness"""
        effectiveness = {
            NeutralizationMethod.KINETIC: 0.8,
            NeutralizationMethod.ELECTRONIC_WARFARE: 0.7,
            NeutralizationMethod.SPOOFING: 0.6,
            NeutralizationMethod.NET_CAPTURE: 0.5,
            NeutralizationMethod.LASER: 0.9
        }

        base = effectiveness.get(method, 0.5)

        # Adjust based on UAS characteristics
        if uas.control_type == 'manual' and method == NeutralizationMethod.ELECTRONIC_WARFARE:
            base *= 1.2  # More effective against manual control

        return min(1.0, base)

    def _assess_collateral_risk(self, method: NeutralizationMethod) -> float:
        """Assess collateral damage risk"""
        risks = {
            NeutralizationMethod.KINETIC: 0.6,
            NeutralizationMethod.ELECTRONIC_WARFARE: 0.3,
            NeutralizationMethod.SPOOFING: 0.2,
            NeutralizationMethod.NET_CAPTURE: 0.1,
            NeutralizationMethod.LASER: 0.4
        }
        return risks.get(method, 0.5)

from typing import List, Dict, Tuple
from dataclasses import dataclass
from enum import Enum

class DefensePosture(Enum):
    PEACETIME = "peacetime"
    ELEVATED = "elevated"
    HIGH_ALERT = "high_alert"
    COMBAT = "combat"

class EngagementRule(Enum):
    OBSERVE = "observe"
    TRACK = "track"
    WARNING = "warning"
    ENGAGE = "engage"

@dataclass
class DefenseOrder:
    order_type: str
    target_id: str
    engagement_rule: EngagementRule
    authority_level: str
    restrictions: Dict

class AutonomousDefenseSystem:
    def __init__(self, defense_zone: Tuple[float, float]):
        self.zone = defense_zone
        self.posture = DefensePosture.PEACETIME
        self.engagement_rules = self._default_engagement_rules()
        self.active_orders: List[DefenseOrder] = []

    def _default_engagement_rules(self) -> Dict:
        """Default rules of engagement"""
        return {
            DefensePosture.PEACETIME: EngagementRule.OBSERVE,
            DefensePosture.ELEVATED: EngagementRule.TRACK,
            DefensePosture.HIGH_ALERT: EngagementRule.WARNING,
            DefensePosture.COMBAT: EngagementRule.ENGAGE
        }

    def assess_situation(self, tracks: List[Dict]) -> Dict:
        """Assess current tactical situation"""
        threats = [t for t in tracks if t.get('threat_level', 0) >= 3]
        unknown = [t for t in tracks if t.get('type') == 'unknown']

        situation = {
            'threat_count': len(threats),
            'unknown_count': len(unknown),
            'recommended_posture': self._recommend_posture(threats, unknown),
            'engagement_authority': self.engagement_rules[self.posture].name,
            'immediate_actions': self._determine_actions(threats)
        }

        return situation

    def _recommend_posture(self, threats: List, unknown: List) -> DefensePosture:
        """Recommend defense posture"""
        if len(threats) > 3:
            return DefensePosture.COMBAT
        elif len(threats) > 0 or len(unknown) > 5:
            return DefensePosture.HIGH_ALERT
        elif len(unknown) > 2:
            return DefensePosture.ELEVATED
        return DefensePosture.PEACETIME

    def _determine_actions(self, threats: List) -> List[Dict]:
        """Determine immediate actions needed"""
        actions = []

        for threat in threats:
            if threat.get('threat_level', 0) >= 4:
                actions.append({
                    'action': 'INTERCEPT',
                    'target': threat['id'],
                    'priority': 'IMMEDIATE'
                })
            elif threat.get('threat_level', 0) >= 3:
                actions.append({
                    'action': 'ENGAGE_WARNING',
                    'target': threat['id'],
                    'priority': 'HIGH'
                })

        return actions

    def generate_engagement_order(self, target: Dict,
                                 authorization: str) -> DefenseOrder:
        """Generate engagement order (requires human authorization)"""
        if authorization != 'AUTHORIZED':
            raise ValueError("Engagement requires explicit authorization")

        current_rule = self.engagement_rules[self.posture]

        order = DefenseOrder(
            order_type='ENGAGEMENT',
            target_id=target['id'],
            engagement_rule=current_rule,
            authority_level=authorization,
            restrictions={
                'min_altitude': 50,
                'max_civilian_risk': 0.1,
                'prohibited_zones': [],
                'time_limit': 300
            }
        )

        self.active_orders.append(order)
        return order

    def monitor_engagement(self, order: DefenseOrder) -> Dict:
        """Monitor ongoing engagement"""
        return {
            'order_id': order.order_type,
            'target': order.target_id,
            'status': 'IN_PROGRESS',
            'compliance': self._check_compliance(order),
            'time_elapsed': 0,
            'rules_adherence': True
        }

    def _check_compliance(self, order: DefenseOrder) -> float:
        """Check rules of engagement compliance"""
        # Simplified compliance check
        return 0.95

class EthicalFramework:
    """Framework for ethical autonomous defense operations"""

    def __init__(self):
        self.principles = {
            'proportionality': 'Response must be proportional to threat',
            'distinction': 'Distinguish between combatants and civilians',
            'necessity': 'Force only when necessary',
            'human_control': 'Human authorization for lethal force'
        }

    def evaluate_engagement(self, engagement: Dict) -> Dict:
        """Evaluate engagement against ethical principles"""
        evaluation = {}

        # Proportionality check
        threat_level = engagement.get('threat_level', 0)
        response_type = engagement.get('response_type', '')
        evaluation['proportionality'] = self._check_proportionality(
            threat_level, response_type)

        # Distinction check
        evaluation['distinction'] = self._check_distinction(engagement)

        # Necessity check
        evaluation['necessity'] = self._check_necessity(engagement)

        # Human control check
        evaluation['human_control'] = self._check_human_control(engagement)

        # Overall assessment
        all_passed = all(v['passed'] for v in evaluation.values())
        evaluation['overall'] = 'APPROVED' if all_passed else 'REQUIRES_REVIEW'

        return evaluation

    def _check_proportionality(self, threat_level: int,
                              response_type: str) -> Dict:
        """Check if response is proportional"""
        proportional_responses = {
            1: ['observe', 'track'],
            2: ['track', 'warning'],
            3: ['warning', 'disable'],
            4: ['disable', 'destroy']
        }

        allowed = proportional_responses.get(threat_level, [])
        passed = response_type in allowed

        return {
            'passed': passed,
            'threat_level': threat_level,
            'response_type': response_type,
            'allowed_responses': allowed
        }

    def _check_distinction(self, engagement: Dict) -> Dict:
        """Check if engagement distinguishes combatants"""
        civilian_risk = engagement.get('civilian_casualty_risk', 0)
        passed = civilian_risk < 0.1

        return {
            'passed': passed,
            'civilian_risk': civilian_risk,
            'threshold': 0.1
        }

    def _check_necessity(self, engagement: Dict) -> Dict:
        """Check if engagement is necessary"""
        alternatives = engagement.get('alternatives_exhausted', False)
        passed = alternatives

        return {
            'passed': passed,
            'alternatives_exhausted': alternatives
        }

    def _check_human_control(self, engagement: Dict) -> Dict:
        """Check for human authorization"""
        authorized = engagement.get('human_authorized', False)
        passed = authorized

        return {
            'passed': passed,
            'human_authorized': authorized
        }

# defense_system_simulator.py
from typing import List, Dict
from dataclasses import dataclass

class DefenseSimulator:
    def __init__(self):
        self.surveillance = SurveillanceSystem(coverage_radius=15000)
        self.counter_uas = CounterUASSystem()
        self.defense_system = AutonomousDefenseSystem(defense_zone=(10000, 10000))
        self.ethical_framework = EthicalFramework()

        self.simulation_time = 0
        self.events = []

    def simulate_scenario(self, scenario: str = "mixed_threats"):
        """Run simulation scenario"""
        print(f"Starting simulation: {scenario}")
        print("=" * 50)

        # Generate scenario events
        events = self._generate_events(scenario)

        for event in events:
            self.simulation_time += event['delay']
            print(f"\n[T+{self.simulation_time}s] Event: {event['type']}")

            if event['type'] == 'radar_detection':
                tracks = self.surveillance.process_radar_data(event['data'])
                print(f"  Tracks updated: {len(tracks)}")

            elif event['type'] == 'uas_detected':
                uas_tracks = self.counter_uas.detect_uas(event['data'])
                print(f"  UAS detected: {len(uas_tracks)}")

                for uas in uas_tracks:
                    recommendation = self.counter_uas.recommend_neutralization(uas)
                    print(f"  UAS {uas.uas_id}: Recommended {recommendation['recommended']['method'].value}")

            elif event['type'] == 'threat_escalation':
                situation = self.defense_system.assess_situation(
                    self._get_current_tracks())
                print(f"  Situation: {situation['recommended_posture'].value}")
                print(f"  Actions needed: {len(situation['immediate_actions'])}")

            # Check ethical compliance
            if 'engagement' in event:
                evaluation = self.ethical_framework.evaluate_engagement(event['engagement'])
                print(f"  Ethical evaluation: {evaluation['overall']}")

            time.sleep(0.5)  # Visual pacing

        print("\n" + "=" * 50)
        print("Simulation complete")

    def _generate_events(self, scenario: str) -> List[Dict]:
        """Generate simulation events"""
        if scenario == "mixed_threats":
            return [
                {'type': 'radar_detection', 'delay': 0,
                 'data': [{'position': [5000, 3000, 1000], 'velocity': [50, 0, 0], 'rcs': 0.5}]},
                {'type': 'uas_detected', 'delay': 5,
                 'data': {'radar': [{'position': [4000, 2000, 200], 'rcs': 0.01}]}},
                {'type': 'threat_escalation', 'delay': 10},
                {'type': 'radar_detection', 'delay': 15,
                 'data': [
                     {'position': [6000, 4000, 1500], 'velocity': [100, 20, 0], 'rcs': 5.0},
                     {'position': [3000, 1000, 300], 'rcs': 0.005}
                 ]},
            ]
        return []

    def _get_current_tracks(self) -> List[Dict]:
        """Get current tracked objects"""
        return [
            {'id': 'T1', 'threat_level': 2, 'type': 'unknown'},
            {'id': 'T2', 'threat_level': 4, 'type': 'hostile'}
        ]

    def generate_after_action_report(self) -> str:
        """Generate after action report"""
        report = "=" * 60 + "\n"
        report += "AFTER ACTION REPORT\n"
        report += "=" * 60 + "\n\n"

        report += f"Simulation Duration: {self.simulation_time} seconds\n"
        report += f"Events Processed: {len(self.events)}\n\n"

        report += "SYSTEM PERFORMANCE:\n"
        report += f"  Surveillance Tracks: {len(self.surveillance.tracks)}\n"
        report += f"  UAS Detected: {len(self.counter_uas.detected_uas)}\n"
        report += f"  Engagement Orders: {len(self.defense_system.active_orders)}\n\n"

        report += "ETHICAL COMPLIANCE:\n"
        report += "  All engagements reviewed\n"
        report += "  Proportionality: MAINTAINED\n"
        report += "  Distinction: MAINTAINED\n"

        return report


# Run simulation
simulator = DefenseSimulator()
simulator.simulate_scenario("mixed_threats")
print(simulator.generate_after_action_report())