package structs

import (
	"errors"
	"sync"
	"time"

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

type MinecraftClient struct {
	Name                    string
	Dest                    int
	Conn                    *websocket.Conn
	connMu                  sync.Mutex
	CurrentCmdID            int // cmdID for the messages sent to the mc servers from backend
	SendQueueMessages       []*SendQueueMessage
	sendQueueMessagesMu     sync.Mutex
	ReceivedQueueMessages   []*ReceivedQueueMessage
	receivedQueueMessagesMu sync.Mutex
}

func (mcClient *MinecraftClient) SendBinaryMessage(msg []byte) error {
	mcClient.connMu.Lock()
	defer mcClient.connMu.Unlock()
	logger.Minecraft.Infoln("SendBinaryMessage")
	return mcClient.Conn.WriteMessage(websocket.BinaryMessage, msg)
}

func (mcClient *MinecraftClient) GenerateMinecraftCmdID() int {
	if mcClient.CurrentCmdID >= 4294967296 || mcClient.CurrentCmdID < 10 {
		return 10
	}

	mcClient.CurrentCmdID++

	return mcClient.CurrentCmdID
}

func (mcClient *MinecraftClient) AddMessageToSendQueue(originDest int, originCmdID int, messageRaw []byte, cmdID int) {
	mcClient.SendQueueMessages = append(mcClient.SendQueueMessages, &SendQueueMessage{MessageRaw: messageRaw, CmdID: cmdID, TrySendCount: 0, OriginDest: originDest, OriginCmdID: originCmdID, Time: time.Now()})
}

func (mcClient *MinecraftClient) AddMessageToReceivedQueue(originDest int, originCmdID int, messageRaw []byte) {
	mcClient.ReceivedQueueMessages = append(mcClient.ReceivedQueueMessages, &ReceivedQueueMessage{MessageRaw: messageRaw, OriginDest: originCmdID, OriginCmdID: originCmdID})
}

func (mcClient *MinecraftClient) IsCmdIDInSendMessagesQueue(cmdID int) bool {
	for _, queueMsg := range mcClient.SendQueueMessages {
		if cmdID == queueMsg.CmdID {
			return true
		}
	}
	return false
}

func (mcClient *MinecraftClient) IsCmdIDInReceivedMessagesQueue(cmdID int) bool {
	for _, queueMsg := range mcClient.ReceivedQueueMessages {
		if cmdID == queueMsg.OriginCmdID {
			return true
		}
	}
	return false
}

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

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

func (mcClient *MinecraftClient) RemoveMessageFromSendQueueByCmdID(cmdID int) {
	mcClient.sendQueueMessagesMu.Lock()
	defer mcClient.sendQueueMessagesMu.Unlock()

	for index, message := range mcClient.SendQueueMessages {
		if message.CmdID == cmdID {
			logger.Minecraft.Debugln("RemoveMessageFromSendQueueByCmdID before", mcClient.SendQueueMessages)
			newArr := append(mcClient.SendQueueMessages[:index], mcClient.SendQueueMessages[index+1:]...)
			mcClient.SendQueueMessages = newArr
			logger.Minecraft.Debugln("RemoveMessageFromSendQueueByCmdID after", mcClient.SendQueueMessages)
			break
		}
	}
}

func (mcClient *MinecraftClient) RemoveMessageFromReceivedQueueByCmdID(cmdID int) {
	mcClient.receivedQueueMessagesMu.Lock()
	defer mcClient.receivedQueueMessagesMu.Unlock()

	for index, message := range mcClient.ReceivedQueueMessages {
		if message.OriginCmdID == cmdID {
			logger.Minecraft.Debugln("RemoveMessageFromReceivedQueueByCmdID before", mcClient.ReceivedQueueMessages)
			newArr := append(mcClient.ReceivedQueueMessages[:index], mcClient.ReceivedQueueMessages[index+1:]...)
			mcClient.ReceivedQueueMessages = newArr
			logger.Minecraft.Debugln("RemoveMessageFromReceivedQueueByCmdID after", mcClient.ReceivedQueueMessages)
			break
		}
	}
}