WebSocket System

// Event subscription system using SocketServer
class EventSubscriptionService {
  final SocketServer server;
  final Map<String, Set<SocketClient>> _eventSubscribers = {};

  EventSubscriptionService(this.server) {
    setupEventHandlers();
  }

  void setupEventHandlers() {
    // Handle event subscription
    server.on('subscribe', (SocketClient client, Map<String, dynamic> data) async {
      final event = data['event'] as String?;
      if (event == null) return;

      _eventSubscribers.putIfAbsent(event, () => {}).add(client);

      client.sendJson({
        'event': 'subscribed',
        'subscription_event': event,
        'timestamp': DateTime.now().toIso8601String()
      });

      print('Client ${client.id} subscribed to event: $event');
    });

    // Handle event unsubscription
    server.on('unsubscribe', (SocketClient client, Map<String, dynamic> data) async {
      final event = data['event'] as String?;
      if (event == null) return;

      final subscribers = _eventSubscribers[event];
      if (subscribers != null) {
        subscribers.remove(client);
        if (subscribers.isEmpty) {
          _eventSubscribers.remove(event);
        }
      }

      client.sendJson({
        'event': 'unsubscribed',
        'subscription_event': event,
        'timestamp': DateTime.now().toIso8601String()
      });

      print('Client ${client.id} unsubscribed from event: $event');
    });

    // Handle event broadcasting
    server.on('broadcast_event', (SocketClient client, Map<String, dynamic> data) async {
      final event = data['event'] as String?;
      final eventData = data['data'];

      if (event == null) return;

      await broadcastToEvent(event, {
        'event': event,
        'data': eventData,
        'from_user': client.get('user_id'),
        'timestamp': DateTime.now().toIso8601String()
      }, exclude: client);
    });

    // Handle client disconnection
    server.onDisconnect((SocketClient client) async {
      // Remove client from all subscriptions
      for (final subscribers in _eventSubscribers.values) {
        subscribers.remove(client);
      }

      // Clean up empty subscription sets
      _eventSubscribers.removeWhere((event, subscribers) => subscribers.isEmpty);
    });
  }

  // Broadcast to all subscribers of an event
  Future<void> broadcastToEvent(String event, Map<String, dynamic> message, {
    SocketClient? exclude
  }) async {
    final subscribers = _eventSubscribers[event];
    if (subscribers == null) return;

    final disconnectedClients = <SocketClient>[];

    for (final subscriber in subscribers) {
      if (subscriber != exclude && subscriber.isConnected) {
        try {
          subscriber.sendJson(message);
        } catch (e) {
          print('Failed to send to subscriber: $e');
          disconnectedClients.add(subscriber);
        }
      }
    }

    // Remove disconnected clients
    for (final client in disconnectedClients) {
      subscribers.remove(client);
    }

    if (subscribers.isEmpty) {
      _eventSubscribers.remove(event);
    }
  }

  // Get subscription statistics
  Map<String, dynamic> getSubscriptionStats() {
    return {
      'total_events': _eventSubscribers.length,
      'events': _eventSubscribers.map((event, subscribers) => MapEntry(event, {
        'subscriber_count': subscribers.length,
        'subscribers': subscribers.map((c) => c.get('user_id')).toList()
      }))
    };
  }

  // Check if client is subscribed to event
  bool isSubscribed(SocketClient client, String event) {
    final subscribers = _eventSubscribers[event];
    return subscribers?.contains(client) ?? false;
  }

  // Get all events client is subscribed to
  List<String> getClientSubscriptions(SocketClient client) {
    final subscriptions = <String>[];

    for (final entry in _eventSubscribers.entries) {
      if (entry.value.contains(client)) {
        subscriptions.add(entry.key);
      }
    }

    return subscriptions;
  }
}

// Usage example
void setupEventSubscription(SocketServer server) {
  final eventService = EventSubscriptionService(server);

  // Add some predefined events
  server.on('user_online', (SocketClient client, Map<String, dynamic> data) async {
    await eventService.broadcastToEvent('user_status', {
      'user_id': client.get('user_id'),
      'status': 'online',
      'timestamp': DateTime.now().toIso8601String()
    });
  });

  server.on('user_offline', (SocketClient client, Map<String, dynamic> data) async {
    await eventService.broadcastToEvent('user_status', {
      'user_id': client.get('user_id'),
      'status': 'offline',
      'timestamp': DateTime.now().toIso8601String()
    });
  });

  // Handle stats requests
  server.on('get_subscription_stats', (SocketClient client, Map<String, dynamic> data) async {
    final stats = eventService.getSubscriptionStats();
    client.sendJson({
      'event': 'subscription_stats',
      'data': stats
    });
  });
}

// Client management using SocketClient and SocketManager
class ClientManager {
  final SocketManager manager;
  final Map<String, SocketClient> _clients = {};
  final Map<String, Map<String, dynamic>> _clientMetadata = {};

  ClientManager(this.manager);

  // Add client
  void addClient(SocketClient client) {
    final userId = client.get('user_id') ?? client.id;
    _clients[userId] = client;

    // Store metadata
    _clientMetadata[userId] = {
      'connected_at': DateTime.now().toIso8601String(),
      'ip': client.get('ip'),
      'user_agent': client.get('user_agent'),
      'rooms': <String>[],
      'last_activity': DateTime.now().toIso8601String()
    };

    print('Client added: $userId');
  }

  // Remove client
  void removeClient(String userId) {
    final client = _clients.remove(userId);
    if (client != null) {
      // Leave all rooms
      final metadata = _clientMetadata[userId];
      if (metadata != null) {
        final rooms = List<String>.from(metadata['rooms'] ?? []);
        for (final room in rooms) {
          client.leaveRoom(room);
        }
      }

      _clientMetadata.remove(userId);
      print('Client removed: $userId');
    }
  }

  // Get client by user ID
  SocketClient? getClient(String userId) {
    return _clients[userId];
  }

  // Get all clients
  List<SocketClient> getAllClients() {
    return _clients.values.toList();
  }

  // Update client metadata
  void updateClientMetadata(String userId, String key, dynamic value) {
    if (_clientMetadata.containsKey(userId)) {
      _clientMetadata[userId]![key] = value;
      _clientMetadata[userId]!['last_activity'] = DateTime.now().toIso8601String();
    }
  }

  // Get client metadata
  Map<String, dynamic>? getClientMetadata(String userId) {
    return _clientMetadata[userId];
  }

  // Broadcast to all clients
  Future<void> broadcastToAll(Map<String, dynamic> message) async {
    await manager.broadcast(message);
  }

  // Send message to specific client
  Future<void> sendToClient(String userId, Map<String, dynamic> message) async {
    final client = _clients[userId];
    if (client != null && client.isConnected) {
      client.sendJson(message);
    }
  }

  // Get client statistics
  Map<String, dynamic> getStats() {
    final now = DateTime.now();
    final activeClients = _clients.values.where((c) => c.isConnected).length;

    return {
      'total_clients': _clients.length,
      'active_clients': activeClients,
      'inactive_clients': _clients.length - activeClients,
      'clients': _clientMetadata.entries.map((entry) => {
        'user_id': entry.key,
        'connected_at': entry.value['connected_at'],
        'last_activity': entry.value['last_activity'],
        'rooms': entry.value['rooms'],
        'is_active': _clients[entry.key]?.isConnected ?? false
      }).toList()
    };
  }

  // Clean up inactive clients
  void cleanupInactiveClients() {
    final inactiveClients = <String>[];

    for (final entry in _clients.entries) {
      if (!entry.value.isConnected) {
        inactiveClients.add(entry.key);
      }
    }

    for (final userId in inactiveClients) {
      removeClient(userId);
    }
  }
}

// SocketClient extension methods
extension SocketClientExtensions on SocketClient {
  // Check if client is in a room
  bool isInRoom(String roomName) {
    // This would be implemented in the actual SocketClient class
    return get('rooms')?.contains(roomName) ?? false;
  }

  // Get client rooms
  List<String> getRooms() {
    return List<String>.from(get('rooms') ?? []);
  }

  // Join room with metadata update
  Future<void> joinRoom(String roomName) async {
    // Implementation would call the actual joinRoom method
    final rooms = getRooms();
    if (!rooms.contains(roomName)) {
      rooms.add(roomName);
      set('rooms', rooms);
    }
  }

  // Leave room with metadata update
  Future<void> leaveRoom(String roomName) async {
    // Implementation would call the actual leaveRoom method
    final rooms = getRooms();
    rooms.remove(roomName);
    set('rooms', rooms);
  }

  // Send JSON message
  void sendJson(Map<String, dynamic> data) {
    try {
      final message = jsonEncode(data);
      send(message);
    } catch (e) {
      print('Failed to send JSON message: $e');
    }
  }
}

// Usage example
void setupClientManagement(SocketServer server, SocketManager manager) {
  final clientManager = ClientManager(manager);

  // Handle client connections
  server.onConnect((SocketClient client) async {
    clientManager.addClient(client);

    // Send welcome message
    client.sendJson({
      'event': 'welcome',
      'user_id': client.get('user_id'),
      'timestamp': DateTime.now().toIso8601String()
    });
  });

  // Handle client disconnections
  server.onDisconnect((SocketClient client) async {
    final userId = client.get('user_id') ?? client.id;
    clientManager.removeClient(userId);
  });

  // Handle client info requests
  server.on('get_client_info', (SocketClient client, Map<String, dynamic> data) async {
    final userId = data['user_id'] as String?;
    if (userId != null) {
      final metadata = clientManager.getClientMetadata(userId);
      if (metadata != null) {
        client.sendJson({
          'event': 'client_info',
          'user_id': userId,
          'data': metadata
        });
      }
    }
  });

  // Handle stats requests
  server.on('get_client_stats', (SocketClient client, Map<String, dynamic> data) async {
    final stats = clientManager.getStats();
    client.sendJson({
      'event': 'client_stats',
      'data': stats
    });
  });
}

class ErrorHandler {
  static void handle(WebSocket socket, dynamic error, StackTrace? stackTrace) {
    print('WebSocket error: $error');
    if (stackTrace != null) {
      print('Stack trace: $stackTrace');
    }

    // Send error to client
    try {
      socket.send(jsonEncode({
        'type': 'error',
        'message': 'An error occurred',
        'timestamp': DateTime.now().toIso8601String()
      }));
    } catch (e) {
      print('Failed to send error to client: $e');
    }
  }

  static void handleConnectionError(WebSocket socket, dynamic error) {
    print('Connection error: $error');

    try {
      socket.send(jsonEncode({
        'type': 'connection_error',
        'message': 'Connection failed',
        'error': error.toString()
      }));
    } catch (e) {
      // Socket might be closed, ignore
    }
  }

  static void handleMessageError(WebSocket socket, String message, dynamic error) {
    print('Message processing error: $error');

    try {
      socket.send(jsonEncode({
        'type': 'message_error',
        'message': 'Failed to process message',
        'original_message': message,
        'error': error.toString()
      }));
    } catch (e) {
      print('Failed to send message error: $e');
    }
  }
}