socket$ = webSocket(`${environment.websocket_url}/ws/dm`)
userOnChat = signal<string>("");

joinChat(chatid: string, userid: string) {
    if (this.userOnChat() != "") {
      this.socket$.next({
        Action: "leaveChat",
        Value: JSON.stringify({
          chatid: chatid,
          userid: userid
        }),
      })
    }

    this.socket$.next({
      Action: "joinChat",
      Value: JSON.stringify({
        chatid: chatid,
        userid: userid
      }),
    })
  }

  getNewMessages() {
    return new Observable<message>((subscriber) => {
      const getMsg = this.socket$.subscribe(
        (message) => {
          let action = (message as websocketDef).action
          switch (action) {
            case "newMessage":
              subscriber.next(message as message)
              break
          }
        },
        (error) => {
          console.error('WebSocket error:', error);
        }
      )
      return () => {
        getMsg.unsubscribe()
      }
    })
  }


/////////////// BACKEND
	package dm

	import (
		"ChateniumAPI/config"
		"encoding/json"
		"fmt"
		"net/http"
		"sync"

		"github.com/gin-gonic/gin"
		"github.com/gorilla/websocket"
	)

	var (
		upgrader = websocket.Upgrader{
			CheckOrigin: func(r *http.Request) bool {
				return true
			},
		}

		Rm = &roomManager{
			rooms: make(map[string]*Chat),
			mu:    sync.Mutex{},
		}
	)

	type roomManager struct {
		rooms map[string]*Chat
		mu    sync.Mutex
	}

	type Chat struct {
		users map[string]*User
	}

	type User struct {
		Connection *websocket.Conn
	}

	func (rm *roomManager) addUser(conn *websocket.Conn, chatid string, userid string) error {
		rm.mu.Lock()
		defer rm.mu.Unlock()

		chat, chatExist := rm.rooms[chatid]
		if !chatExist {
			rm.rooms[chatid] = &Chat{make(map[string]*User)}
			chat = &Chat{make(map[string]*User)}
		}

		_, userExist := chat.users[userid]
		if userExist {
			return fmt.Errorf("User %s already exists in chat %s", userid, chatid)
		}

		chat.users[userid] = &User{Connection: conn}
		return nil
	}

	func (rm *roomManager) deleteUser(chatid string, userid string) {
		rm.mu.Lock()
		defer rm.mu.Unlock()

		chat, chatExist := rm.rooms[chatid]
		if chatExist {
			delete(chat.users, userid)
		}
	}

	func (rm *roomManager) Broadcast(message interface{}, chatid string) {
		rm.mu.Lock()
		defer rm.mu.Unlock()
		fmt.Println(message)

		chat, chatExist := rm.rooms[chatid]
		if chatExist {
			for _, userConn := range chat.users {
				fmt.Println(userConn)
				if userConn.Connection != nil {
					if err := userConn.Connection.WriteJSON(message); err != nil {
						fmt.Println("Error broadcasting:", err)
					}
				}
			}
		}
	}

	func SetupDMWebsocket(c *gin.Context) {
		conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
		if err != nil {
			fmt.Println("WebSocket Upgrade Error:", err)
			return
		}

		for {
			_, p, err := conn.ReadMessage()
			if err != nil {
				fmt.Println("WebSocket Read Error:", err)
				return
			}

			var message config.Websocket_DefaultMessage
			if err := json.Unmarshal(p, &message); err != nil {
				fmt.Println("JSON Unmarshal Error:", err)
				return
			}

			switch message.Action {
			case "joinChat":
				var data struct {
					Chatid string `json:"chatid"`
					Userid string `json:"userid"`
				}

				if err := json.Unmarshal([]byte(message.Value), &data); err != nil {
					fmt.Println("JSON Unmarshal Error:", err)
					return
				}

				if err := AuthorizationDM(c, data.Chatid, data.Userid); err != nil {
					fmt.Println("Authorization Error:", err)
					return
				}

				if err := Rm.addUser(conn, data.Chatid, data.Userid); err != nil {
					fmt.Println("Add User Error:", err)
				}

			case "leaveChat":
				var data struct {
					Chatid string `json:"chatid"`
					Userid string `json:"userid"`
				}

				if err := json.Unmarshal([]byte(message.Value), &data); err != nil {
					fmt.Println("JSON Unmarshal Error:", err)
					return
				}

				Rm.deleteUser(data.Chatid, data.Userid)
			}
		}
	}