package api

import (
	"fmt"
	"net/http"
	"strconv"
	"time"

	"git.tek.govt.hu/dowerx/chat/server/model"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
)

const (
	CHANNEL_ID            string = "id"
	DEFAULT_MESSAGE_LIMIT int    = 100
)

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin:     func(r *http.Request) bool { return true },
}

func listAvailableChannels(c *gin.Context) {
	channels, err := chatController.ListAvailableChannels(c.GetInt(USER_ID))
	if err != nil {
		sendError(c, err)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message":  "channels listed",
		"channels": channels,
	})
}

func getMessages(c *gin.Context) {
	id, err := strconv.Atoi(c.Param(CHANNEL_ID))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "invalid channel id",
		})
		return
	}

	limitStr := c.Query("limit")
	fromStr := c.Query("from")

	var limit int = DEFAULT_MESSAGE_LIMIT
	var from time.Time = time.Now().UTC()
	var parseErr error

	if limitStr != "" {
		limit, parseErr = strconv.Atoi(limitStr)
		if parseErr != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"error": "invalid limit parameter",
			})
			return
		}
	}

	if fromStr != "" {
		from, parseErr = time.Parse(time.RFC3339, fromStr)
		if parseErr != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"error": "invalid from parameter",
			})
			return
		}
	}

	messages, msgErr := chatController.GetMessages(c.GetInt(USER_ID), id, from, limit)
	if msgErr != nil {
		sendError(c, msgErr)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message":  "messages listed",
		"messages": messages,
	})
}

func sendMessage(c *gin.Context) {
	message := model.Message{}
	if err := c.Bind(&message); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": err.Error(),
		})
		return
	}

	err := chatController.SendMessage(c.GetInt(USER_ID), message.Channel, message.Content)
	if err != nil {
		fmt.Println(err.Error())

		sendError(c, err)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": "message sent",
	})
}

func subscribeToChannel(c *gin.Context) {
	id, err := strconv.Atoi(c.Param(CHANNEL_ID))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "invalid channel id",
		})
		return
	}

	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	messages, chanErr := chatController.SubscribeToChannel(c, id, c.GetInt(USER_ID))

	for {
		select {
		case msg := <-messages:
			if err := conn.WriteJSON(msg); err != nil {
				return
			}

		case err := <-chanErr:
			fmt.Println(err.Error())
			return
		}
	}
}