package handler

import (
	"modelRT/logger"
	"modelRT/network"
	realtimedata "modelRT/real-time-data"

	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	jsoniter "github.com/json-iterator/go"
)

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
}

// RealTimeDataReceivehandler define real time data receive and process API
func RealTimeDataReceivehandler(c *gin.Context) {
	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		logger.Error(c, "upgrade http protocol to websocket protocal failed", "error", err)
		return
	}
	defer conn.Close()

	for {
		messageType, p, err := conn.ReadMessage()
		if err != nil {
			logger.Error(c, "read message from websocket connection failed", "error", err)

			respByte := processResponse(-1, "read message from websocket connection failed", nil)
			if len(respByte) == 0 {
				logger.Error(c, "process message from byte failed", "error", err)
				continue
			}

			err = conn.WriteMessage(messageType, respByte)
			if err != nil {
				logger.Error(c, "write message to websocket connection failed", "error", err)
				continue
			}
			continue
		}

		var request network.RealTimeDataReceiveRequest
		err = jsoniter.Unmarshal([]byte(p), &request)
		if err != nil {
			logger.Error(c, "unmarshal message from byte failed", "error", err)

			respByte := processResponse(-1, "unmarshal message from byte failed", nil)
			if len(respByte) == 0 {
				logger.Error(c, "process message from byte failed", "error", err)
				continue
			}

			err = conn.WriteMessage(messageType, respByte)
			if err != nil {
				logger.Error(c, "write message to websocket connection failed", "error", err)
				continue
			}
			continue
		}

		realtimedata.RealTimeDataChan <- request

		payload := map[string]interface{}{
			"component_uuid": request.PayLoad.ComponentUUID,
			"point":          request.PayLoad.Point,
		}
		respByte := processResponse(0, "success", payload)
		if len(respByte) == 0 {
			logger.Error(c, "process message from byte failed", "error", err)
			continue
		}

		err = conn.WriteMessage(messageType, respByte)
		if err != nil {
			logger.Error(c, "write message to websocket connection failed", "error", err)
			continue
		}
	}
}

func processResponse(code int64, msg string, payload map[string]interface{}) []byte {
	resp := map[string]interface{}{
		"code":    code,
		"msg":     msg,
		"payload": payload,
	}

	respByte, err := jsoniter.Marshal(resp)
	if err != nil {
		return []byte("")
	}

	return respByte
}