package socketserver

import (
	"fmt"

	"clickandjoin.app/websocketserver/modules/cache"
	"clickandjoin.app/websocketserver/modules/rabbitmq"
	"clickandjoin.app/websocketserver/modules/redis"
	"clickandjoin.app/websocketserver/modules/structs"
	"clickandjoin.app/websocketserver/modules/utils"
	"clickandjoin.app/websocketserver/socketclients"
	"github.com/gofiber/websocket/v2"
	"github.com/sirupsen/logrus"
)

var register = make(chan *structs.SocketClient)
var broadcast = make(chan structs.SocketMessage)
var unregister = make(chan *websocket.Conn)

func RunHub() {
	for {
		select {
		case newSocketClient := <-register:
			userId := fmt.Sprintf("%v", newSocketClient.Conn.Locals("userId"))
			wsSessionId := fmt.Sprintf("%v", newSocketClient.Conn.Locals("wsSessionId"))

			err := rabbitmq.CreateWSClientBinding(newSocketClient, userId)

			if err != nil {
				logrus.Errorln("Failed to create client binding, err:", err)
				break
			}

			newSocketClient.UserId = userId

			cache.SocketClients[wsSessionId] = newSocketClient

			logrus.Println("clients:", len(cache.SocketClients), cache.SocketClients)

			logrus.Debugln("REGISTER CLIENT:", wsSessionId)

			// for testing
			marshaled, err := utils.MarshalMessage(structs.SocketMessageTest{Cmd: 99999, Body: userId})

			if err != nil {
				logrus.Errorln("Failed to marshal uuid, err:", err)
				break
			}

			newSocketClient.Conn.WriteMessage(websocket.TextMessage, []byte(marshaled))

		case data := <-broadcast:
			var receivedMessage structs.ReceivedMessage

			err := utils.UnmarshalReceivedMessage(data.Msg, &receivedMessage)

			if err != nil {
				logrus.Errorln("Failed to unmarshal received msg, err:", err)
			}

			logrus.Debugln("RECEIVED WEBSOCKET MESSAGE:", receivedMessage)

			if len(receivedMessage.Rec) == utils.LenWebSocketSession {
				isConnected, recSocketClient := socketclients.IsReceiverConnectedToThisServer(receivedMessage.Rec)

				// send message to target receiver when connected to this server
				if isConnected {
					logrus.Debugln("FORWARDING MESSAGE: receiver is on connected to this server")
					recSocketClient.SendMessage(structs.SendSocketMessage{Cmd: receivedMessage.Cmd, Body: receivedMessage.Body})
				} else {
					logrus.Debugln("FORWARDING MESSAGE: receiver connected to other server")

					if !redis.IsUserConnectedToAnyWebSocketServer(receivedMessage.Rec) {
						logrus.Warnln("rec user not connected to any websocket server")
						break
					}

					err = rabbitmq.PublishClientMessage(structs.RabbitMqMessage{Cmd: receivedMessage.Cmd, Rec: receivedMessage.Rec, Body: receivedMessage.Body})

					if err != nil {
						logrus.Errorln("Failed to publish client message, err:", err)
					}
				}
			}

		case connection := <-unregister:
			for id, client := range cache.SocketClients {
				if connection == client.Conn {
					logrus.Debugln("UNREGISTER CLIENT:", id)
					delete(cache.SocketClients, id)

					client.CancelFunc()
					rabbitmq.DeleteWSClient(client.RabbitMqConsumerId, client.RabbitMqQueueName)
					redis.RemoveUserWebSocketSessionId(client.UserId, id)
				}
			}
		}
	}
}