http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,716 @@
+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;
+  }
+
+}