fix chat messages

src/app/services/Repositorys/chat/infra/socket/socket.ts

@@ -0,0 +1,130 @@
+import { Injectable } from '@angular/core';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { webSocket, WebSocketSubject } from 'rxjs/webSocket';
+import { catchError, retryWhen, tap, delay } from 'rxjs/operators';
+import { SessionStore } from 'src/app/store/session.service';
+import { v4 as uuidv4 } from 'uuid'
+
+
+export interface WebSocketMessage {
+  type: string;
+  payload: any;
+  requestId?: string;
+}
+
+interface WebSocketError {
+  type: string;
+  error: any;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class WebSocketService {
+  private socket$: WebSocketSubject<WebSocketMessage>;
+  private messageSubject$: Subject<WebSocketMessage>;
+  private connectionStatus$: BehaviorSubject<boolean>;
+  private reconnectAttempts = 0;
+  private readonly maxReconnectAttempts = 5;
+
+  callback: {[key: string]: Function} = {}
+
+  constructor() {
+    this.messageSubject$ = new Subject<WebSocketMessage>();
+    this.connectionStatus$ = new BehaviorSubject<boolean>(false);
+
+    this.connect('http://5.180.182.151:8080/')
+
+    this.messages$.subscribe(({payload, requestId}) => {
+      if(this.callback[requestId]) {
+        this.callback[requestId]({payload, requestId})
+        delete this.callback[requestId]
+
+        
+      }
+      console.log({payload, requestId})
+    })
+  }
+
+  public connect(url: string) {
+    this.socket$ = webSocket<WebSocketMessage>(url);
+
+    this.socket$.pipe(
+      tap({
+
+        error: () => {
+          this.connectionStatus$.next(false);
+        }
+      }),
+      retryWhen(errors => errors.pipe(
+        tap(() => {
+          this.reconnectAttempts++;
+          if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            throw new Error('Max reconnect attempts reached');
+          }
+        }),
+        delay(1000)
+      ))
+    ).subscribe(
+      (message) => {
+        this.messageSubject$.next(message);
+
+        if (!this.connectionStatus$.getValue()) {
+          this.connectionStatus$.next(true);
+          this.reconnectAttempts = 0;
+
+          // Send a message when the connection is established
+          this.sendMessage(SessionStore.user.UserId as any).subscribe();
+        }
+      },
+      (err) => {
+        console.error('WebSocket connection error:', err);
+      },
+      () => {
+        console.log('WebSocket connection closed');
+        this.connectionStatus$.next(false);
+      }
+    );
+  }
+
+  public sendMessage(message: WebSocketMessage): Observable<any> {
+    return new Observable<void>(observer => {
+
+      
+
+      if(typeof message == 'object') {
+        message.requestId = uuidv4()
+        this.socket$.next(message);
+
+        this.callback[message.requestId] = ({payload, requestId})=> {
+          observer.next(payload as any);
+          observer.complete();
+        }
+
+      } else {
+        this.socket$.next(message);
+        observer.next({} as any);
+        observer.complete();
+      }
+
+
+      
+    }).pipe(
+      catchError(err => {
+        console.error('Send message error:', err);
+        return new Observable<never>(observer => {
+          observer.error({ type: 'SEND_ERROR', error: err });
+        });
+      })
+    );
+  }
+
+
+  public get messages$(): Observable<WebSocketMessage> {
+    return this.messageSubject$.asObservable();
+  }
+
+  public get connectionStatus(): Observable<boolean> {
+    return this.connectionStatus$.asObservable();
+  }
+}