package controller

import (
	"net/http"
	"users_management/m/middleware"
	"users_management/m/model/dto/req"
	"users_management/m/usecase"
	"users_management/m/utils/common"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type DeviceController struct {
	du usecase.DeviceUseCase
	rg *gin.RouterGroup
}

func (dc *DeviceController) Route() {
	rg := dc.rg.Group("/devices")
	rg.Use(middleware.AuthMiddleware())
	rg.Use(middleware.RateLimitMiddleware())
	rg.Use(middleware.CORSMiddleware())
	{
		rg.POST("", dc.CreateDevice())
		rg.GET("", dc.GetAllDevices())
		rg.GET("/:uuid", dc.GetDeviceByID())
		rg.PUT("/:uuid", dc.UpdateDevice())
	}
}

func NewDeviceController(du usecase.DeviceUseCase, rg *gin.RouterGroup) *DeviceController {
	return &DeviceController{
		du: du,
		rg: rg,
	}
}

func (dc *DeviceController) CreateDevice() gin.HandlerFunc {
	return func(c *gin.Context) {
		var deviceDTO req.DeviceDTO
		err := c.ShouldBindJSON(&deviceDTO)

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
			return
		}

		err = dc.du.CreateDevice(deviceDTO)

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
			return
		}

		common.SingleResponses(c, "Device has been created", nil)
	}
}

func (dc *DeviceController) GetAllDevices() gin.HandlerFunc {
	return func(c *gin.Context) {
		
		deviceType := c.Query("type")
		if deviceType != "" {
			deviceResp, err := dc.du.GetByType(deviceType)
			if err != nil {
				common.ErrorResponses(c, http.StatusBadRequest, "Device type not found")
				return
			}
			common.SingleResponses(c, "Success", deviceResp)
			return
		}

		devices, err := dc.du.GetAllDevices()

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, "something went wrong")
			return
		}

		common.SingleResponses(c, "Success", devices)
	}
}

func (dc *DeviceController) GetDeviceByID() gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("uuid")
		uuid, err := uuid.Parse(id)
		if err != nil{
			common.ErrorResponses(c, http.StatusBadGateway,"Invalid UUID")
			return
		}
		device, err := dc.du.GetByID(uuid)
		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, "Device not found")
			return
		}

		common.SingleResponses(c, "Success", device)
	}
}

func (dc *DeviceController) UpdateDevice() gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("uuid")
		uuid, err := uuid.Parse(id)
		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, "Invalid UUID")
			return
		}

		var deviceDTO req.UpdateDeviceDTO
		err = c.ShouldBindJSON(&deviceDTO)

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, "Invalid request")
			return
		}

		err = dc.du.UpdateDevice(uuid, deviceDTO)

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, "Device not found")	
			return
		}

		common.SingleResponses(c, "Device has been updated", nil)
	}
}