const audioSocket = io('https://skyspy.example.com/audio', {
  path: '/socket.io',
  auth: { token: 'your_token' },
  transports: ['websocket']
});

audioSocket.on('connect', () => {
  console.log('Connected to audio namespace');
});

import socketio

sio = socketio.Client()

@sio.event
def connect():
    print('Connected to audio namespace')

sio.connect(
    'https://skyspy.example.com/audio',
    socketio_path='/socket.io',
    auth={'token': 'your_token'},
    transports=['websocket']
)

audioSocket.on('audio:snapshot', (data) => {
  console.log(`Recent transmissions: ${data.count}`);
  data.transmissions.forEach(tx => {
    displayTransmission(tx);
  });
});

audioSocket.on('audio:transmission', (tx) => {
  console.log(`New transmission on ${tx.frequency} MHz`);
  
  // Play audio if autoplay enabled
  if (autoplayEnabled) {
    playAudio(tx.audio_url);
  }
  
  // Add to transmission list
  addToTransmissionList(tx);
});

audioSocket.on('audio:transcription_completed', (data) => {
  console.log(`Transcription: ${data.text}`);
  
  // Update UI with transcription
  updateTranscription(data.transmission_id, {
    text: data.text,
    confidence: data.confidence
  });
  
  // Highlight keywords
  if (containsKeywords(data.text, ['emergency', 'mayday', 'pan pan'])) {
    highlightTransmission(data.transmission_id, 'emergency');
  }
});

audioSocket.on('audio:transcription_failed', (data) => {
  console.warn(`Transcription failed: ${data.error}`);
  updateTranscription(data.transmission_id, {
    error: data.error
  });
});

@sio.event
def audio_snapshot(data):
    print(f"Recent transmissions: {data.get('count')}")
    for tx in data.get('transmissions', []):
        display_transmission(tx)

@sio.event
def audio_transmission(tx):
    print(f"New transmission on {tx.get('frequency')} MHz")
    
    # Play audio if autoplay enabled
    if autoplay_enabled:
        play_audio(tx.get('audio_url'))
    
    # Add to transmission list
    add_to_transmission_list(tx)

@sio.event
def audio_transcription_completed(data):
    print(f"Transcription: {data.get('text')}")
    
    # Update UI with transcription
    update_transcription(data.get('transmission_id'), {
        'text': data.get('text'),
        'confidence': data.get('confidence')
    })
    
    # Highlight keywords
    text = data.get('text', '').lower()
    if any(kw in text for kw in ['emergency', 'mayday', 'pan pan']):
        highlight_transmission(data.get('transmission_id'), 'emergency')

@sio.event
def audio_transcription_failed(data):
    print(f"Transcription failed: {data.get('error')}")
    update_transcription(data.get('transmission_id'), {
        'error': data.get('error')
    })

const cannonballSocket = io('https://skyspy.example.com/cannonball', {
  path: '/socket.io',
  auth: { token: 'your_token' },
  transports: ['websocket']
});

cannonballSocket.on('connect', () => {
  console.log('Connected to cannonball namespace');
});

import socketio

sio = socketio.Client()

@sio.event
def connect():
    print('Connected to cannonball namespace')

sio.connect(
    'https://skyspy.example.com/cannonball',
    socketio_path='/socket.io',
    auth={'token': 'your_token'},
    transports=['websocket']
)

let sessionId = null;

cannonballSocket.on('session_started', (data) => {
  sessionId = data.session_id;
  console.log(`Session started: ${sessionId}`);
  console.log(`Default radius: ${data.default_radius_nm} nm`);
});

cannonballSocket.on('threats', (data) => {
  console.log(`Threat level: ${data.threat_level}`);
  console.log(`Threats: ${data.aircraft.length}`);
  
  data.aircraft.forEach(threat => {
    console.log(
      `${threat.callsign || threat.hex}: ` +
      `${threat.distance_nm.toFixed(1)} nm @ ${threat.bearing}° ` +
      `(${threat.trend})`
    );
    
    // Show alert for critical threats
    if (threat.threat_level === 'critical') {
      showCriticalThreatAlert(threat);
    }
  });
  
  // Update UI
  updateThreatMap(data.aircraft);
});

cannonballSocket.on('radius_updated', (data) => {
  console.log(`Radius updated: ${data.radius_nm} nm`);
});

// Send position updates from GPS
navigator.geolocation.watchPosition(
  (position) => {
    cannonballSocket.emit('position_update', {
      lat: position.coords.latitude,
      lon: position.coords.longitude,
      heading: position.coords.heading,
      altitude: position.coords.altitude
    });
  },
  (error) => {
    console.error('GPS error:', error);
  },
  {
    enableHighAccuracy: true,
    maximumAge: 1000,
    timeout: 5000
  }
);

// Change detection radius
function setThreatRadius(radiusNm) {
  cannonballSocket.emit('set_radius', { radius_nm: radiusNm });
}

session_id = None

@sio.event
def session_started(data):
    global session_id
    session_id = data.get('session_id')
    print(f"Session started: {session_id}")
    print(f"Default radius: {data.get('default_radius_nm')} nm")

@sio.event
def threats(data):
    print(f"Threat level: {data.get('threat_level')}")
    aircraft = data.get('aircraft', [])
    print(f"Threats: {len(aircraft)}")
    
    for threat in aircraft:
        callsign = threat.get('callsign') or threat.get('hex')
        distance = threat.get('distance_nm', 0)
        bearing = threat.get('bearing', 0)
        trend = threat.get('trend', 'unknown')
        
        print(f"{callsign}: {distance:.1f} nm @ {bearing}° ({trend})")
        
        # Show alert for critical threats
        if threat.get('threat_level') == 'critical':
            show_critical_threat_alert(threat)
    
    # Update UI
    update_threat_map(aircraft)

@sio.event
def radius_updated(data):
    print(f"Radius updated: {data.get('radius_nm')} nm")

# Send position updates
def send_position(lat, lon, heading=None, altitude=None):
    payload = {'lat': lat, 'lon': lon}
    if heading is not None:
        payload['heading'] = heading
    if altitude is not None:
        payload['altitude'] = altitude
    sio.emit('position_update', payload)

# Change detection radius
def set_threat_radius(radius_nm):
    sio.emit('set_radius', {'radius_nm': radius_nm})

const acarsSocket = io('https://skyspy.example.com/acars', {
  path: '/socket.io',
  transports: ['websocket']
});

acarsSocket.on('acars:message', (message) => {
  console.log(
    `ACARS from ${message.callsign}: ` +
    `Label ${message.label} - ${message.text}`
  );
});

import socketio

sio = socketio.Client()

@sio.event
def acars_message(message):
    callsign = message.get('callsign', 'Unknown')
    label = message.get('label', '')
    text = message.get('text', '')
    print(f"ACARS from {callsign}: Label {label} - {text}")

sio.connect(
    'https://skyspy.example.com/acars',
    socketio_path='/socket.io',
    transports=['websocket']
)