http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/ws-manager-service/websocket-service/websocket-manager.service.ts

@@ -1,716 +0,0 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject, Observable, Subscription, timer } from 'rxjs';
-import { take } from 'rxjs/operators';
-import { WSOptions } from '../../request-manager-state-service';
-import { UUID_STR } from '../../utils/encryption/random';
-
-/**
- * WebSocketManagerService - Singleton WebSocket connection manager
- *
- * This service ensures only ONE WebSocket connection exists across ALL instances
- * of HTTPManagerStateService. It uses static properties to track connection state
- * globally, preventing duplicate connections when multiple state services are created.
- *
- * Usage:
- * - Inject into HTTPManagerService (or directly into state services)
- * - Call connect() with WSOptions - only the first call establishes connection
- * - Subsequent calls detect existing connection and skip reconnection
- * - All instances share the same connectionStatus$ and messages$ observables
- */
-@Injectable({
-  providedIn: 'root',
-})
-export class WebSocketManagerService {
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // STATIC SINGLETON STATE (Shared across ALL instances)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  private static socket: WebSocket | null = null;
-  private static isConnecting = false;
-  private static connectionInitialized = false;
-
-  // Store last options for reconnection
-  private static lastOptions: WSOptions | null = null;
-  private static lastJwtToken: string = '';
-
-
-  // Retry configuration
-  private static retryCount = 0;
-  private static retryDelay = 5000;
-  private static retrySubscription: Subscription | null = null;
-  private static maxRetries = 10;
-  private static connectionReadyNotified = false;
-  private static retryCountSubject = new BehaviorSubject<number>(0);
-  public retryCount$ = WebSocketManagerService.retryCountSubject.asObservable();
-  private static maxRetriesSubject = new BehaviorSubject<number>(10);
-  public maxRetries$ = WebSocketManagerService.maxRetriesSubject.asObservable();
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // INSTANCE OBSERVABLES (Shared across ALL instances via static BehaviorSubjects)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  private static messages = new BehaviorSubject<any>(null);
-  public messages$: Observable<any> = WebSocketManagerService.messages.asObservable();
-
-  private static connectionStatus = new BehaviorSubject<boolean>(false);
-  public connectionStatus$: Observable<boolean> = WebSocketManagerService.connectionStatus.asObservable();
-
-  private static isSubscribed: boolean = false;
-
-  // Track currently subscribed channels
-  private static subscribedChannels = new BehaviorSubject<Set<string>>(new Set());
-  public subscribedChannels$: Observable<Set<string>> = WebSocketManagerService.subscribedChannels.asObservable();
-
-  // Public method to get current subscribed channels
-  public static getSubscribedChannels(): Set<string> {
-    return WebSocketManagerService.subscribedChannels.getValue();
-  }
-
-  // Public method to add a channel to subscribed channels
-  public static addSubscribedChannel(channelName: string): void {
-    const current = new Set(WebSocketManagerService.subscribedChannels.value);
-    current.add(channelName);
-    WebSocketManagerService.subscribedChannels.next(current);
-    console.log(`📝 Added ${channelName} to subscribedChannels (now has ${current.size} channels)`);
-  }
-
-  // Reconnect event (emitted when connection is established/re-established)
-  private static onReconnect = new BehaviorSubject<void>(undefined);
-  public onReconnect$: Observable<void> = WebSocketManagerService.onReconnect.asObservable();
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SESSION MANAGEMENT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  private getSessionId(): string {
-    return sessionStorage.getItem('WSID') ?? (() => {
-      const uuid = UUID_STR()
-      sessionStorage.setItem('WSID', uuid)
-      return uuid
-    })()
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CONNECTION MANAGEMENT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Connect to WebSocket server
-   *
-   * IMPORTANT: Only the first call across ALL instances will establish a connection.
-   * Subsequent calls will detect the existing connection and return immediately.
-   *
-   * @param options - WebSocket configuration options
-   * @param jwtToken - Optional JWT token for authentication
-   */
-  connect(options: WSOptions, jwtToken: string): void {
-    // Cancel any pending retry timer before attempting a new connection
-    WebSocketManagerService.retrySubscription?.unsubscribe();
-    WebSocketManagerService.retrySubscription = null;
-
-    // Check if connection already exists and is open
-    if (WebSocketManagerService.socket) {
-      if (WebSocketManagerService.socket.readyState === WebSocket.OPEN) {
-        console.log('✓ WebSocket connection already OPEN (singleton).');
-        return;
-      }
-
-      if (WebSocketManagerService.socket.readyState === WebSocket.CONNECTING) {
-        console.log('⏳ WebSocket is already CONNECTING (singleton). Waiting for handshake.');
-        return;
-      }
-
-      // Clean up stale connection
-      if (WebSocketManagerService.socket.readyState === WebSocket.CLOSING ||
-          WebSocketManagerService.socket.readyState === WebSocket.CLOSED) {
-        console.log(`🧹 Cleaning up stale socket (State: ${WebSocketManagerService.socket.readyState}).`);
-        WebSocketManagerService.socket.close();
-        WebSocketManagerService.socket = null;
-      }
-    }
-
-    // Prevent duplicate connection attempts
-    if (WebSocketManagerService.isConnecting) {
-      console.log('⏳ Connection already in progress...');
-      return;
-    }
-
-    // Store jwt token for retry
-    WebSocketManagerService.lastJwtToken = jwtToken;
-    WebSocketManagerService.lastOptions = options;
-
-    // Always set maxRetries and delay from latest options
-    if (options?.retry?.times) {
-      WebSocketManagerService.maxRetries = options.retry.times;
-      WebSocketManagerService.maxRetriesSubject.next(options.retry.times);
-    } else {
-      WebSocketManagerService.maxRetries = 10;
-      WebSocketManagerService.maxRetriesSubject.next(10);
-    }
-
-    if (options?.retry?.delay) {
-      WebSocketManagerService.retryDelay = options.retry.delay * 1000;
-    } else {
-      WebSocketManagerService.retryDelay = 5000;
-    }
-
-    // Mark as connecting — connectionStatus true while connecting/retrying, false only when exhausted
-    WebSocketManagerService.isConnecting = true;
-    WebSocketManagerService.isSubscribed = false;
-    WebSocketManagerService.connectionReadyNotified = false;
-    WebSocketManagerService.subscribedChannels.next(new Set());
-    WebSocketManagerService.connectionStatus.next(true);
-
-    const sessionId = this.getSessionId();
-    const URL = (jwtToken) ? `${options.wsServer}?token=${jwtToken}&sessionId=${sessionId}` : `${options.wsServer}?sessionId=${sessionId}`;
-
-    console.log(`🔌 Initiating WebSocket connection to: ${options.wsServer}`);
-
-    // Create new WebSocket instance (static)
-    WebSocketManagerService.socket = new WebSocket(URL);
-
-    WebSocketManagerService.socket.onopen = () => {
-      console.log(`📡 WebSocket handshake complete — awaiting server confirmation`);
-      // Force clear subscribedChannels on new connection - server lost our subscriptions
-      console.log('🧹 Clearing subscribedChannels on connect (was:', WebSocketManagerService.subscribedChannels.value.size, 'channels)');
-      WebSocketManagerService.subscribedChannels.next(new Set());
-
-      // Do NOT reset retryCount here — reset happens only on confirmed stable connection
-      // (onmessage first valid response). Resetting here would cause the counter to always
-      // show 1/N because onopen fires before onclose increments the counter.
-      WebSocketManagerService.isConnecting = false;
-      WebSocketManagerService.connectionInitialized = true;
-    };
-
-    WebSocketManagerService.socket.onmessage = (event) => {
-      try {
-        const data = JSON.parse(event.data);
-
-        if (data.error) {
-          WebSocketManagerService.messages.next(data);
-          // Log the server error and close — onclose will drive the retry logic
-          if (data.error === 'JWT_INVALID' || data.error === 'AUTH_BLOCKED') {
-            console.error(`🚫 ${data.error}: ${data.message || 'Authentication error'} — will retry`);
-          } else {
-            console.error(`❌ Server error: ${data.error} — will retry`);
-          }
-          WebSocketManagerService.socket?.close();
-          return;
-        }
-
-        // First valid (non-error) message confirms the server accepted auth.
-        // Notify readiness once per connection so pending intended subscriptions
-        // are replayed after the socket is actually usable.
-        if (!WebSocketManagerService.connectionReadyNotified) {
-          if (WebSocketManagerService.retryCount > 0) {
-            console.log(`✅ Server confirmed connection after ${WebSocketManagerService.retryCount} retries.`);
-            WebSocketManagerService.retryCount = 0;
-            WebSocketManagerService.retryCountSubject.next(0);
-          }
-
-          WebSocketManagerService.connectionReadyNotified = true;
-          console.log(`🔄 Emitting reconnect event for MessageTrackerService`);
-          WebSocketManagerService.onReconnect.next();
-        }
-
-        WebSocketManagerService.messages.next(data);
-
-      } catch (error) {
-        console.error('Error parsing WebSocket message:', event.data);
-      }
-    };
-
-    WebSocketManagerService.socket.onclose = (event: CloseEvent) => {
-      console.log(`🔴 WebSocket closed (code: ${event.code})`);
-      WebSocketManagerService.isConnecting = false;
-      WebSocketManagerService.connectionReadyNotified = false;
-      WebSocketManagerService.socket = null;
-      WebSocketManagerService.subscribedChannels.next(new Set());
-
-      const maxRetries = WebSocketManagerService.maxRetries;
-      const retryDelay = WebSocketManagerService.retryDelay;
-
-      if (WebSocketManagerService.lastOptions && WebSocketManagerService.retryCount < maxRetries) {
-        WebSocketManagerService.retryCount++;
-        WebSocketManagerService.retryCountSubject.next(WebSocketManagerService.retryCount);
-        console.log(`🔄 Reconnect attempt ${WebSocketManagerService.retryCount}/${maxRetries}...`);
-        // connectionStatus stays true — still actively retrying
-        WebSocketManagerService.retrySubscription = timer(retryDelay).pipe(take(1)).subscribe(() => this.connect(WebSocketManagerService.lastOptions!, WebSocketManagerService.lastJwtToken));
-      } else {
-        console.error(`❌ WebSocket failed after ${maxRetries} retries. Giving up.`);
-        WebSocketManagerService.connectionStatus.next(false);
-        WebSocketManagerService.retryCount = maxRetries;
-        WebSocketManagerService.retryCountSubject.next(maxRetries);
-      }
-    };
-
-    WebSocketManagerService.socket.onerror = (error) => {
-      console.error('❌ WebSocket error:', error);
-      WebSocketManagerService.isConnecting = false;
-      // onclose will fire after onerror and drive retry/give-up logic
-    };
-  }
-
-  /**
-   * Disconnect from WebSocket server
-   */
-  disconnect(): void {
-    WebSocketManagerService.retrySubscription?.unsubscribe();
-    WebSocketManagerService.retrySubscription = null;
-    if (WebSocketManagerService.socket) {
-      console.log('🔌 Disconnecting WebSocket...');
-      WebSocketManagerService.socket.close();
-      WebSocketManagerService.socket = null;
-      WebSocketManagerService.connectionStatus.next(false);
-      WebSocketManagerService.subscribedChannels.next(new Set());
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SUBSCRIPTION MANAGEMENT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  private sendSubscribe(channelName: string, user: any): void {
-    const alreadySubscribed = WebSocketManagerService.subscribedChannels.value.has(channelName);
-
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN && !alreadySubscribed) {
-      const message = {
-        type: 'subscribe',
-        subscribedChannel: channelName,
-        content: {
-          id: this.getSessionId(),
-          ...user
-        }
-      };
-      WebSocketManagerService.socket.send(JSON.stringify(message));
-
-      // Track this channel as subscribed
-      const current = new Set(WebSocketManagerService.subscribedChannels.value);
-      current.add(channelName);
-      WebSocketManagerService.subscribedChannels.next(current);
-
-      WebSocketManagerService.isSubscribed = true;
-      console.log(`[CLIENT] Sent initial subscription to: ${channelName}`);
-    } else {
-      console.warn(`[CLIENT] Subscription prevented. Open: ${WebSocketManagerService.socket?.readyState === WebSocket.OPEN}, Already subscribed to ${channelName}: ${alreadySubscribed}`);
-    }
-  }
-
-  /**
-   * Send subscribe with lastSeenId for message sync support
-   * @param channelName - Channel name to subscribe to
-   * @param user - User data
-   * @param lastSeenId - Last message ID seen (for replay)
-   */
-  sendSubscribeWithLastSeen(channelName: string, user: any, lastSeenId: number): void {
-    const alreadySubscribed = WebSocketManagerService.subscribedChannels.value.has(channelName);
-    const isOpen = WebSocketManagerService.socket?.readyState === WebSocket.OPEN;
-
-    console.log(`🔍 Subscription check for "${channelName}": isOpen=${isOpen}, alreadySubscribed=${alreadySubscribed}`);
-
-    if (isOpen && !alreadySubscribed && WebSocketManagerService.socket) {
-      const message = {
-        type: 'subscribe',
-        subscribedChannel: channelName,
-        lastSeenId,  // NEW: For message replay
-        content: {
-          id: this.getSessionId(),
-          ...user
-        }
-      };
-      WebSocketManagerService.socket.send(JSON.stringify(message));
-
-      // DON'T track as subscribed yet - wait for server confirmation ('subscribed' message)
-      // This prevents race conditions where we think we're subscribed but server doesn't
-
-      WebSocketManagerService.isSubscribed = true;
-      console.log(`[CLIENT] Sent subscription with lastSeenId=${lastSeenId} to: ${channelName}`);
-    } else {
-      console.warn(`[CLIENT] Subscription prevented. Open: ${isOpen}, Already subscribed to ${channelName}: ${alreadySubscribed}`);
-    }
-  }
-
-  /**
-   * Subscribe to a channel
-   * @param channelName - Channel name to subscribe to
-   */
-  subscribeToChannel(channelName: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      try {
-        const message = {
-          type: 'subscribe',
-          subscribedChannel: channelName,
-          content: {}
-        };
-
-        WebSocketManagerService.socket.send(JSON.stringify(message));
-
-        // Track locally - create new Set to trigger change detection
-        const current = new Set(WebSocketManagerService.subscribedChannels.value);
-        current.add(channelName);
-        WebSocketManagerService.subscribedChannels.next(current);
-        console.log(`📝 Subscribed to channel: ${channelName}`);
-      } catch (error) {
-        console.error(`❌ Failed to subscribe to channel "${channelName}":`, error);
-      }
-    } else {
-      console.warn(`Cannot subscribe to channel "${channelName}": WebSocket not yet open.`);
-    }
-  }
-
-  /**
-   * Subscribe to multiple channels
-   * @param channelNames - Array of channel names to subscribe to
-   */
-  subscribeToChannels(channelNames: string[]): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      channelNames.forEach(channel => this.subscribeToChannel(channel));
-    } else {
-      console.warn('Cannot subscribe: WebSocket not yet open.');
-    }
-  }
-
-  /**
-   * Unsubscribe from a channel
-   * @param channel - Channel name to unsubscribe from
-   */
-  unsubscribeFromChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({ type: 'unsubscribe', subscribedChannel: channel }));
-
-      // Remove from local tracking - create new Set to trigger change detection
-      const current = new Set(WebSocketManagerService.subscribedChannels.value);
-      current.delete(channel);
-      WebSocketManagerService.subscribedChannels.next(current);
-      console.log(`💬 Unsubscribed from channel: ${channel}`);
-    } else {
-      console.error('WebSocket is not open. Cannot unsubscribe from channel.');
-    }
-  }
-
-  /**
-   * Get currently subscribed channels
-   * @returns Set of subscribed channel names
-   */
-  getSubscribedChannels(): Set<string> {
-    return WebSocketManagerService.subscribedChannels.value;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // MESSAGE SENDING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Generic send method for message tracking (acks, gap requests, etc.)
-   * @param message - Message object to send
-   */
-  send(message: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify(message));
-    } else {
-      console.warn('⚠️ Cannot send message: WebSocket not open', message);
-    }
-  }
-
-  /**
-   * Send broadcast message
-   * @param content - Message content to broadcast
-   */
-  sendBroadcast(content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({ type: 'broadcast', content }));
-      console.log(`📢 Send broadcast: ${content}`);
-    } else {
-      console.error('WebSocket is not open. Cannot send broadcast.');
-    }
-  }
-
-  /**
-   * Send message in channel (state manager message)
-   * @param channel - Channel name
-   * @param content - Message content
-   */
-  sendMessageInChannel(channel: string, content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      const message = {
-        type: 'statemanagerMessage',
-        subscribedChannel: channel,
-        content
-      };
-
-      // DEBUG: Log the exact message being sent
-      // console.log('🔍 [DEBUG] sendMessageInChannel:', {
-      //   channel,
-      //   channelType: typeof channel,
-      //   channelEmpty: channel === '' || channel === null || channel === undefined,
-      //   content,
-      //   fullMessage: message,
-      //   jsonString: JSON.stringify(message)
-      // });
-
-      WebSocketManagerService.socket.send(JSON.stringify(message));
-      console.log(`💬 Send message:`, content);
-    } else {
-      console.error('WebSocket is not open. Cannot send message.');
-    }
-  }
-
-  /**
-   * Send channel message (broadcasts to all subscribers in the channel)
-   * @param channel - Channel name
-   * @param content - Message content
-   */
-  sendChannelMessage(channel: string, content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'message',
-        subscribedChannel: channel,
-        content
-      }));
-      console.log(`💬 Send channel message to [${channel}]:`, content);
-    } else {
-      console.error('WebSocket is not open. Cannot send channel message.');
-    }
-  }
-
-  /**
-   * Send message to multiple channels at once (batch)
-   * @param channels - Array of channel names
-   * @param content - Message content
-   */
-  sendChannelMessageToChannels(channels: string[], content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      try {
-        // New batch format
-        WebSocketManagerService.socket.send(JSON.stringify({
-          type: 'channelMessage',
-          channels: channels,
-          data: content
-        }));
-        console.log(`💬 Send channel message to channels [${channels.join(', ')}]:`, content);
-      } catch (error) {
-        console.error('❌ Failed to send channelMessage batch:', error);
-      }
-
-      // Legacy fallback - send individual messages to each channel
-      try {
-        channels.forEach(channel => {
-          WebSocketManagerService.socket?.send(JSON.stringify({
-            type: 'message',
-            subscribedChannel: channel,
-            content
-          }));
-        });
-      } catch (err) {
-        console.warn('⚠️ Legacy fallback failed sending individual messages', err);
-      }
-
-    } else {
-      console.error('WebSocket is not open. Cannot send message to channels.');
-    }
-  }
-
-  /**
-   * Send message to specific user
-   * @param user - User identifier
-   * @param content - Message content
-   */
-  sendMessageToUser(user: string, content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'userMessage',
-        subscribedChannel: user,
-        content
-      }));
-      console.log(`💬 Send message:`, content);
-    } else {
-      console.error('WebSocket is not open. Cannot send message.');
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CHANNEL MANAGEMENT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Request list of all channels from server
-   */
-  getAllChannels(): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({ type: 'getChannels' }));
-      console.log('🗂️ List of all channels');
-    } else {
-      console.error('WebSocket is not open. Cannot request channels.');
-    }
-  }
-
-  /**
-   * Create a new channel on server
-   * @param channel - Channel name to create
-   */
-  createChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'createChannel',
-        content: channel
-      }));
-      console.log('🗂️ Created channel:', channel);
-    } else {
-      console.error('WebSocket is not open. Cannot request channels.');
-    }
-  }
-
-  /**
-   * Delete a channel from server
-   * @param channel - Channel name to delete
-   */
-  deleteChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'deleteChannel',
-        content: channel
-      }));
-      console.log('🗂️ Delete channel:', channel);
-    } else {
-      console.error('WebSocket is not open. Cannot request channels.');
-    }
-  }
-
-  /**
-   * Get users in a specific channel
-   * @param channel - Channel name
-   */
-  getUsersInChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'getUsers',
-        subscribedChannel: channel
-      }));
-      console.log(`👥 List all users in channel: ${channel}`);
-    } else {
-      console.error('WebSocket is not open. Cannot request users.');
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // NOTIFICATION CHANNELS (MES- prefix)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Create a notification channel
-   * @param channel - Channel name (should include MES- prefix)
-   */
-  createNotificationChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'createNotificationChannel',
-        content: channel
-      }));
-      console.log('📢 Created notification channel:', channel);
-    } else {
-      console.error('WebSocket is not open. Cannot create notification channel.');
-    }
-  }
-
-  /**
-   * Get all notification channels (in-memory)
-   */
-  getNotificationChannels(): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({ type: 'getNotificationChannels' }));
-      console.log('📢 Requested notification channels list');
-    } else {
-      console.error('WebSocket is not open. Cannot request notification channels.');
-    }
-  }
-
-  /**
-   * Get today's notification channels from database
-   */
-  getTodaysNotificationChannels(): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({ type: 'getTodaysNotificationChannels' }));
-      console.log('📢 Requested today\'s notification channels from DB');
-    } else {
-      console.error('WebSocket is not open. Cannot request today\'s notification channels.');
-    }
-  }
-
-  /**
-   * Subscribe to a notification channel with optional date filters
-   * @param channel - Channel name
-   * @param options - Optional start/end epoch filters
-   * @param user - User information
-   */
-  subscribeToNotificationChannel(channel: string, options?: { startEpoch?: number; endEpoch?: number }, user?: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'subscribeNotifications',
-        subscribedChannel: channel,
-        content: {
-          ...options,
-          user: user
-        }
-      }));
-      console.log(`📢 Subscribed to notification channel: ${channel}`);
-    } else {
-      console.error('WebSocket is not open. Cannot subscribe to notification channel.');
-    }
-  }
-
-  /**
-   * Unsubscribe from a notification channel
-   * @param channel - Channel name
-   */
-  unsubscribeFromNotificationChannel(channel: string): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'unsubscribeNotifications',
-        subscribedChannel: channel
-      }));
-      console.log(`📢 Unsubscribed from notification channel: ${channel}`);
-    } else {
-      console.error('WebSocket is not open. Cannot unsubscribe from notification channel.');
-    }
-  }
-
-  /**
-   * Send notification to channel
-   * @param channel - Channel name (should include MES- prefix)
-   * @param content - Notification content
-   */
-  sendNotification(channel: string, content: any): void {
-    if (WebSocketManagerService.socket?.readyState === WebSocket.OPEN) {
-      WebSocketManagerService.socket.send(JSON.stringify({
-        type: 'notification',
-        subscribedChannel: channel,
-        content
-      }));
-      console.log(`📢 Sent notification to channel: ${channel}`, content);
-    } else {
-      console.error('WebSocket is not open. Cannot send notification.');
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CONNECTION STATUS (Static getter for direct access)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Check if WebSocket connection is currently open
-   * @returns true if connected, false otherwise
-   */
-  static isConnected(): boolean {
-    return WebSocketManagerService.socket?.readyState === WebSocket.OPEN;
-  }
-
-  /**
-   * Check if connection has been initialized (attempted at least once)
-   * @returns true if connection was initialized, false otherwise
-   */
-  static isInitialized(): boolean {
-    return WebSocketManagerService.connectionInitialized;
-  }
-
-}