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
	//MobileCmdIDs                          []int // cache for received cmdIDs
	//mobileCmdIDMu                         sync.Mutex
	//MobileCmdIDsByBackend                 []*A
	//mobileCmdIDsByBackendMu               sync.Mutex
	CurrentMobileSendMessageCmdIDIndexByBackend int
	VoiceConn                                   *websocket.Conn
	voiceConnMu                                 sync.Mutex
	//VoiceCmdIDs                           []int // cache for received cmdIDs
	//voiceCmdIDMu                          sync.Mutex
	//VoiceCmdIDsByBackend                  []*A // messages from backend to voice, when response from voice then response to target requester
	//voiceCmdIDsByBackendMu                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 (webClient *WebClient) RemoveVoiceCmdID(cmdID int) {
	webClient.voiceCmdIDMu.Lock()
	defer webClient.voiceCmdIDMu.Unlock()

	newArr, err := removeCmdIDFromList(webClient.VoiceCmdIDs, cmdID)

	if err != nil {
		logger.WebVoice.Warnln("removeCmdIDFromList:", err)
	} else {
		webClient.VoiceCmdIDs = newArr
	}
}

func (webClient *WebClient) RemoveMobileCmdID(cmdID int) {
	webClient.mobileCmdIDMu.Lock()
	defer webClient.mobileCmdIDMu.Unlock()

	newArr, err := removeCmdIDFromList(webClient.MobileCmdIDs, cmdID)

	if err != nil {
		logger.WebMobile.Warnln("removeCmdIDFromList:", err)
	} else {
		webClient.MobileCmdIDs = newArr
	}
}

func (webClient *WebClient) RemoveVoiceCmdIDByBackend(cmdID int) {
	webClient.voiceCmdIDsByBackendMu.Lock()
	defer webClient.voiceCmdIDsByBackendMu.Unlock()

	for i, data := range webClient.VoiceCmdIDsByBackend {
		if data.WebCmdID == cmdID {
			newArr := append(webClient.VoiceCmdIDsByBackend[:i], webClient.VoiceCmdIDsByBackend[i+1:]...)
			webClient.VoiceCmdIDsByBackend = newArr
			return
		}
	}
}

func (webClient *WebClient) RemoveMobileCmdIDByBackend(cmdID int) {
	webClient.mobileCmdIDsByBackendMu.Lock()
	defer webClient.mobileCmdIDsByBackendMu.Unlock()

	for i, data := range webClient.MobileCmdIDsByBackend {
		if data.WebCmdID == cmdID {
			newArr := append(webClient.MobileCmdIDsByBackend[:i], webClient.MobileCmdIDsByBackend[i+1:]...)
			webClient.MobileCmdIDsByBackend = newArr
			return
		}
	}
}

func removeCmdIDFromList(arr []int, cmdID int) ([]int, error) {
	index := getCmdIDIndexFromList(arr, cmdID)

	if index == -1 {
		return []int{}, errors.New("index not found")
	}

	newArr := append(arr[:index], arr[index+1:]...)

	return newArr, nil
}

func getCmdIDIndexFromList(arr []int, cmdID int) int {
	for i := 0; i < len(arr); i++ {
		if arr[i] == cmdID {
			return i
		}
	}
	return -1
}
*/
func GenerateWebCmdID(currentIndex int) int {
	if currentIndex >= 250 || currentIndex < 10 {
		return 10
	}

	currentIndex++

	return currentIndex
}