// Browser (localStorage)
localStorage.setItem('debug', 'socket.io-client:*');

// Then reload the page

# Node.js (environment variable)
DEBUG=socket.io-client:* node app.js

# Python (logging)
import logging

logging.basicConfig(level=logging.DEBUG)
logging.getLogger('socketio').setLevel(logging.DEBUG)
logging.getLogger('engineio').setLevel(logging.DEBUG)

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'root': {
        'handlers': ['console'],
        'level': 'INFO',
    },
    'loggers': {
        'skyspy.socketio': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': False,
        },
        'socketio': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': False,
        },
        'engineio': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

# Test HTTP endpoint
curl -v https://skyspy.example.com/socket.io/

# Test with authentication
curl -v -H "Authorization: Bearer YOUR_TOKEN" \
  https://skyspy.example.com/socket.io/

# Check if WebSocket upgrade succeeds
wscat -c wss://skyspy.example.com/socket.io/?EIO=4&transport=websocket

const socket = io('https://skyspy.example.com', {
  auth: { token: 'YOUR_TOKEN' }
});

// Log all incoming events
const originalOn = socket.on.bind(socket);
socket.on = function(event, callback) {
  return originalOn(event, function(...args) {
    console.log(`[Event] ${event}:`, args);
    return callback(...args);
  });
};

// Log all outgoing events
const originalEmit = socket.emit.bind(socket);
socket.emit = function(event, ...args) {
  console.log(`[Emit] ${event}:`, args);
  return originalEmit(event, ...args);
};

import socketio
import logging

logger = logging.getLogger(__name__)

class DebugClient(socketio.Client):
    def emit(self, event, data=None, *args, **kwargs):
        logger.debug(f'[Emit] {event}: {data}')
        return super().emit(event, data, *args, **kwargs)
    
    def on(self, event, handler=None):
        def wrapper(data):
            logger.debug(f'[Event] {event}: {data}')
            if handler:
                return handler(data)
        return super().on(event, wrapper)

sio = DebugClient()
logging.basicConfig(level=logging.DEBUG)

import { throttle } from 'lodash';

// Throttle map updates to 30 FPS
const throttledRender = throttle((aircraft) => {
  renderMap(aircraft);
}, 1000 / 30);

socket.on('aircraft:update', (aircraft) => {
  // Update state immediately
  updateAircraftState(aircraft);
  
  // Throttle rendering
  throttledRender(getAircraft());
});

// Or use requestAnimationFrame
let updatePending = false;

socket.on('aircraft:update', (aircraft) => {
  updateAircraftState(aircraft);
  
  if (!updatePending) {
    updatePending = true;
    requestAnimationFrame(() => {
      renderMap(getAircraft());
      updatePending = false;
    });
  }
});

class SkySpyClient {
  constructor(url, getToken) {
    this.url = url;
    this.getToken = getToken; // Function to get/refresh token
    this.socket = null;
    this.connect();
  }

  connect() {
    const token = this.getToken();
    
    this.socket = io(this.url, {
      auth: { token },
      transports: ['websocket']
    });

    this.socket.on('connect_error', (error) => {
      if (error.message.includes('auth') || error.message.includes('token')) {
        console.log('Auth error, refreshing token...');
        this.refreshAndReconnect();
      }
    });

    this.socket.on('disconnect', (reason) => {
      if (reason === 'io server disconnect') {
        // Server disconnected (possibly auth failure)
        console.log('Server disconnect, refreshing token...');
        this.refreshAndReconnect();
      }
    });
  }

  async refreshAndReconnect() {
    try {
      // Refresh token (e.g., call refresh endpoint)
      const newToken = await this.refreshToken();
      
      // Disconnect old socket
      if (this.socket) {
        this.socket.disconnect();
      }
      
      // Reconnect with new token
      this.connect();
    } catch (error) {
      console.error('Token refresh failed:', error);
      // Redirect to login or show error
    }
  }

  async refreshToken() {
    const response = await fetch('/api/auth/refresh/', {
      method: 'POST',
      credentials: 'include' // Send refresh cookie
    });
    
    if (!response.ok) {
      throw new Error('Failed to refresh token');
    }
    
    const data = await response.json();
    return data.access_token;
  }
}