Backend/modules/structs/WebClient.go

package structs

import (
	"errors"
	"sync"
	"time"

	"github.com/gofiber/websocket/v2"
	"krakatoa.net/backend/modules/logger"
)

type WebClientDb struct {
	Uuid               string
	VoiceSessionToken  string
	MobileSessionToken string
}

type A struct {
	WebCmdID                 int
	CmdIDFromMinecraftServer int
	DestFromMinecraftServer  int
}

type WebClient struct {
	Uuid                                        string
	MobileConn                                  *websocket.Conn
	mobileConnMu                                sync.Mutex
	CurrentMobileSendMessageCmdIDIndexByBackend int
	VoiceConn                                   *websocket.Conn
	voiceConnMu                                 sync.Mutex
	CurrentVoiceSendMessageCmdIDIndexByBackend  int
	SendVoiceQueueMessages                      []*SendQueueMessage
	sendVoiceQueueMessagesMu                    sync.Mutex
	SendMobileQueueMessages                     []*SendQueueMessage
	sendMobileQueueMessagesMu                   sync.Mutex
	ReceivedVoiceQueueMessages                  []*ReceivedQueueMessage
	receivedVoiceQueueMessagesMu                sync.Mutex
	ReceivedMobileQueueMessages                 []*ReceivedQueueMessage
	receivedMobileQueueMessagesMu               sync.Mutex
}

func (webClient *WebClient) AddMessageToVoiceSendQueue(originDest int, originCmdID int, messageRaw []byte, cmdID int) {
	webClient.SendVoiceQueueMessages = append(webClient.SendVoiceQueueMessages, &SendQueueMessage{MessageRaw: messageRaw, CmdID: cmdID, TrySendCount: 0, OriginDest: originDest, OriginCmdID: originCmdID, Time: time.Now()})
}

func (webClient *WebClient) AddMessageToVoiceReceivedQueue(originDest int, originCmdID int, messageRaw []byte) {
	webClient.ReceivedVoiceQueueMessages = append(webClient.ReceivedVoiceQueueMessages, &ReceivedQueueMessage{MessageRaw: messageRaw, OriginDest: originDest, OriginCmdID: originCmdID})
}

func (webClient *WebClient) AddMessageToMobileSendQueue(originDest int, originCmdID int, messageRaw []byte, cmdID int) {
	webClient.SendMobileQueueMessages = append(webClient.SendMobileQueueMessages, &SendQueueMessage{MessageRaw: messageRaw, CmdID: cmdID, TrySendCount: 0, OriginDest: originDest, OriginCmdID: originCmdID, Time: time.Now()})
}

func (webClient *WebClient) AddMessageToMobileReceivedQueue(originDest int, originCmdID int, messageRaw []byte) {
	webClient.ReceivedMobileQueueMessages = append(webClient.ReceivedMobileQueueMessages, &ReceivedQueueMessage{MessageRaw: messageRaw, OriginDest: originDest, OriginCmdID: originCmdID})
}

func (webClient *WebClient) IsCmdIDInSendVoiceMessagesQueue(cmdID int) bool {
	return isCmdIDInSendMessagesQueue(webClient.SendVoiceQueueMessages, cmdID)
}

func (webClient *WebClient) IsCmdIDInSendMobileMessagesQueue(cmdID int) bool {
	return isCmdIDInSendMessagesQueue(webClient.SendMobileQueueMessages, cmdID)
}

func isCmdIDInSendMessagesQueue(sendMessagesQueue []*SendQueueMessage, cmdID int) bool {
	for _, queueMsg := range sendMessagesQueue {
		if cmdID == queueMsg.CmdID {
			return true
		}
	}
	return false
}

func (webClient *WebClient) IsCmdIDInReceivedVoiceMessagesQueue(cmdID int) bool {
	return isCmdIDInReceivedMessagesQueue(webClient.ReceivedVoiceQueueMessages, cmdID)
}

func (webClient *WebClient) IsCmdIDInReceivedMobileMessagesQueue(cmdID int) bool {
	return isCmdIDInReceivedMessagesQueue(webClient.ReceivedMobileQueueMessages, cmdID)
}

func isCmdIDInReceivedMessagesQueue(receivedMessagesQueue []*ReceivedQueueMessage, cmdID int) bool {
	for _, queueMsg := range receivedMessagesQueue {
		if cmdID == queueMsg.OriginCmdID {
			return true
		}
	}
	return false
}

func (webClient *WebClient) GetMessageFromSendVoiceQueueByCmdID(cmdID int) (queueMsg SendQueueMessage, err error) {
	return getMessageFromSendQueueByCmdID(webClient.SendVoiceQueueMessages, cmdID)
}

func (webClient *WebClient) GetMessageFromSendMobileQueueByCmdID(cmdID int) (queueMsg SendQueueMessage, err error) {
	return getMessageFromSendQueueByCmdID(webClient.SendMobileQueueMessages, cmdID)
}

func getMessageFromSendQueueByCmdID(sendQueueMessages []*SendQueueMessage, cmdID int) (queueMsg SendQueueMessage, err error) {
	for _, queueMsg := range sendQueueMessages {
		if cmdID == queueMsg.CmdID {
			return *queueMsg, nil
		}
	}
	return SendQueueMessage{}, errors.New("message from send queue by cmdID not found")
}

func (webClient *WebClient) GetMessageFromReceivedVoiceQueueByCmdID(cmdID int) (queueMsg ReceivedQueueMessage, err error) {
	return getMessageFromReceivedQueueByCmdID(webClient.ReceivedVoiceQueueMessages, cmdID)
}

func (webClient *WebClient) GetMessageFromReceivedMobileQueueByCmdID(cmdID int) (queueMsg ReceivedQueueMessage, err error) {
	return getMessageFromReceivedQueueByCmdID(webClient.ReceivedMobileQueueMessages, cmdID)
}

func getMessageFromReceivedQueueByCmdID(receivedQueueMessages []*ReceivedQueueMessage, cmdID int) (queueMsg ReceivedQueueMessage, err error) {
	for _, queueMsg := range receivedQueueMessages {
		if cmdID == queueMsg.OriginCmdID {
			return *queueMsg, nil
		}
	}
	return ReceivedQueueMessage{}, errors.New("message from received queue by cmdID not found")
}

func (webClient *WebClient) RemoveMessageFromVoiceSendQueueByCmdID(cmdID int) {
	webClient.SendVoiceQueueMessages = removeMessageFromSendQueueByCmdID(webClient.SendVoiceQueueMessages, &webClient.sendVoiceQueueMessagesMu, cmdID)
}

func (webClient *WebClient) RemoveMessageFromMobileSendQueueByCmdID(cmdID int) {
	webClient.SendMobileQueueMessages = removeMessageFromSendQueueByCmdID(webClient.SendMobileQueueMessages, &webClient.sendMobileQueueMessagesMu, cmdID)
}

func removeMessageFromSendQueueByCmdID(queueMessages []*SendQueueMessage, mutex *sync.Mutex, cmdID int) []*SendQueueMessage {
	mutex.Lock()
	defer mutex.Unlock()

	for index, message := range queueMessages {
		if message.CmdID == cmdID {
			logger.Web.Debugln("removeMessageFromSendQueueByCmdID before", queueMessages)
			newArr := append(queueMessages[:index], queueMessages[index+1:]...)
			queueMessages = newArr
			logger.Web.Debugln("removeMessageFromSendQueueByCmdID after", queueMessages)
			break
		}
	}
	return queueMessages
}

func (webClient *WebClient) RemoveMessageFromVoiceReceivedQueueByCmdID(cmdID int) {
	webClient.ReceivedVoiceQueueMessages = removeMessageFromReceivedQueueByCmdID(webClient.ReceivedVoiceQueueMessages, &webClient.receivedVoiceQueueMessagesMu, cmdID)
}

func (webClient *WebClient) RemoveMessageFromMobileReceivedQueueByCmdID(cmdID int) {
	webClient.ReceivedMobileQueueMessages = removeMessageFromReceivedQueueByCmdID(webClient.ReceivedMobileQueueMessages, &webClient.receivedMobileQueueMessagesMu, cmdID)
}

func removeMessageFromReceivedQueueByCmdID(queueMessages []*ReceivedQueueMessage, mutex *sync.Mutex, cmdID int) []*ReceivedQueueMessage {
	mutex.Lock()
	defer mutex.Unlock()

	for index, message := range queueMessages {
		if message.OriginCmdID == cmdID {
			logger.Web.Debugln("removeMessageFromReceivedQueueByCmdID before", queueMessages)
			newArr := append(queueMessages[:index], queueMessages[index+1:]...)
			queueMessages = newArr
			logger.Web.Debugln("removeMessageFromReceivedQueueByCmdID after", queueMessages)
			break
		}
	}

	return queueMessages
}

func (webClient *WebClient) SendBinaryMessage(conn *websocket.Conn, msg []byte) error {
	logger.Web.Infoln("SendBinaryMessage")
	var err error
	if conn == webClient.MobileConn {
		webClient.mobileConnMu.Lock()
		defer webClient.mobileConnMu.Unlock()

		if conn == nil {
			logger.WebMobile.Warnln("err conn nil SendBinaryMessage")
			return errors.New("conn nil")
		}

		err = conn.WriteMessage(websocket.BinaryMessage, msg)

		if err != nil {
			logger.WebMobile.Warnln("err SendBinaryMessage to mobile client")
		}

		return err
	}
	webClient.voiceConnMu.Lock()
	defer webClient.voiceConnMu.Unlock()

	if conn == nil {
		logger.WebVoice.Warnln("err conn nil SendBinaryMessage")
		return errors.New("conn nil")
	}

	err = conn.WriteMessage(websocket.BinaryMessage, msg)

	if err != nil {
		logger.WebVoice.Warnln("err SendBinaryMessage to voice client")
	}

	return err
}

func GenerateWebCmdID(currentIndex int) int {
	if currentIndex >= 250 || currentIndex < 10 {
		return 10
	}

	currentIndex++

	return currentIndex
}