package controllers

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

	"github.com/gin-gonic/gin"

	"example.com/gin/test/models"
	"example.com/gin/test/repositories"
)

type CRUDController interface {
	Create(*gin.Context)
	GetAll(*gin.Context) 
	GetById(*gin.Context)
	Update(*gin.Context)
	Delete(*gin.Context)
}

type RoomController interface {
	CRUDController
	GetUsers(*gin.Context)
	AddUser(*gin.Context)
}

type roomController struct {}

func NewRoomController() RoomController {
	return &roomController{}
}

func (rc *roomController) GetAll(c *gin.Context) {
	rooms, err := repositories.Rooms.GetAll()

	if err != nil {
		ReplyError(c, fmt.Errorf("Could not query rooms"))
		return
	}

	c.JSON(http.StatusOK, rooms)
}

func (rc *roomController) GetById(c *gin.Context) {
	room, err := repositories.Rooms.GetById(c.Param("id"))

	if err != nil {
		ReplyError(c, fmt.Errorf("Could not query room: %v", err))
		return
	}

	ReplyOK(c, room)
}

func (rc *roomController) Create(c *gin.Context) {
	user, exists := c.Get("user")
	if !exists {
		c.AbortWithStatus(http.StatusUnauthorized)
		return
	}

	room, err := models.NewRoom(c)
	room.Admins = append(room.Admins, user.(models.User))

	if err != nil {
		ReplyError(c, err)
	}

	_, err = repositories.Rooms.Create(room)
	if err != nil {
		ReplyError(c, fmt.Errorf("Room creation failed: %s", err))
		return
	}

	//userID := user.(models.User).ID
	//rc.DB.Model(&models.Room{}).Where("id = ?"), room.ID).Association("Admins").Append(&models.User{ID: userID})

	//if result.Error != nil {
	//	ReplyError(c, fmt.Errorf("Room creation failed: %s", result.Error))
	//	return
	//}

	ReplyOK(c, "Room was created")
}


func (rc *roomController) Update(c *gin.Context) {
	roomId, err := strconv.Atoi(c.Param("id"))

	if err != nil {
		ReplyError(c, fmt.Errorf("Room with Id '%s' does not exist", c.Param("id")))
		return
	}

	room, err := models.NewRoom(c)

	if err != nil {
		ReplyError(c, err)
		return
	}

	room.ID = uint(roomId)
	_, err = repositories.Rooms.Update(room)

	if err != nil {
		ReplyError(c, fmt.Errorf("Room creation failed: %s", err))
		return
	}

	ReplyOK(c, "Room was updated")
}

func (rc *roomController) Delete(c *gin.Context) {
	err := repositories.Rooms.DeleteById(c.Param("id"))

	if err != nil {
		ReplyError(c, fmt.Errorf("Room deletion failed: %s", err))
		return
	}

	ReplyOK(c, "Room was deleted")
}

func (rc *roomController) GetUsers(c *gin.Context) {
	//only allow room admin

	users, err := repositories.Rooms.GetRoomUsersById(c.Param("id"))

	if err != nil {
		ReplyError(c, fmt.Errorf("Could not get users for room '%s'", c.Param("id")))
		return
	}
	
	var emails []string
	for _, user := range users {
		emails = append(emails, user.Email)
	}

	ReplyOK(c, emails)
}

func (rc *roomController) AddUser(c *gin.Context) {
	//only allow room admin

	var body struct {
		Email string
	}

	err := c.Bind(&body)

	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to read body",
		})

		return
	}

	//lookup requested user
	user, err := repositories.Users.GetByEmail(body.Email)

	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Invalid user",
		})

		return
	}

	err = repositories.Rooms.AddRoomUserById(c.Param("id"), user)

	if err != nil {
		ReplyError(c, fmt.Errorf("Could not add user to room."))
		return
	}

	ReplyOK(c, "Added User to Room")
}

func ReplyError(ctx *gin.Context, err error) {
	ctx.JSON(http.StatusBadRequest, gin.H{ "error": err.Error() })
}

func ReplyOK(ctx *gin.Context, message any) {
	ctx.JSON(http.StatusOK, message)
}