package controller

import (
	"net/http"

	"github.com/Caknoooo/go-gin-clean-starter/modules/permissions/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/permissions/service"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/gin-gonic/gin"
)

type PermissionsController interface {
	CreatePermission(ctx *gin.Context)
	GetPermissionByID(ctx *gin.Context)
	GetPermissionByName(ctx *gin.Context)
	GetAllPermissions(ctx *gin.Context)
	UpdatePermission(ctx *gin.Context)
	DeletePermission(ctx *gin.Context)
}

type permissionsController struct {
	service service.PermissionsService
}

// CreatePermission godoc
// @Summary      Create a new permission
// @Description  Create a new permission with the provided information
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Param        request body dto.PermissionsCreateRequest true "Permission creation data"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /permissions [post]
func (c *permissionsController) CreatePermission(ctx *gin.Context) {
	var req dto.PermissionsCreateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}
	res, err := c.service.Create(ctx.Request.Context(), req)
	if err != nil {
		resp := utils.BuildResponseFailed(dto.MESSAGE_FAILED_CREATE_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, resp)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_CREATE_PERMISSIONS, res)
	ctx.JSON(http.StatusOK, resp)
}

// GetPermissionByID godoc
// @Summary      Get permission by ID
// @Description  Get detailed information of a specific permission by its ID
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Permission ID"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      404  {object}  utils.Response
// @Router       /permissions/{id} [get]
func (c *permissionsController) GetPermissionByID(ctx *gin.Context) {
	id := ctx.Param("id")
	if id == "" {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_PERMISSIONS, "id is required", nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	res, err := c.service.GetById(ctx.Request.Context(), id)
	if err != nil {
		resErr := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, resErr)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_PERMISSIONS, res)
	ctx.JSON(http.StatusOK, resp)
}

// GetPermissionByName godoc
// @Summary      Get permission by name
// @Description  Get permission information by its name
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Param        name   query     string  true  "Permission name"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /permissions/by-name [get]
func (c *permissionsController) GetPermissionByName(ctx *gin.Context) {
	name := ctx.Query("name")
	if name == "" {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_PERMISSIONS, "name query is required", nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	res, err := c.service.GetByName(ctx.Request.Context(), name)
	if err != nil {
		resErr := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, resErr)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_PERMISSIONS, res)
	ctx.JSON(http.StatusOK, resp)
}

// GetAllPermissions godoc
// @Summary      Get list of permissions
// @Description  Get list of all permissions
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /permissions [get]
func (c *permissionsController) GetAllPermissions(ctx *gin.Context) {
	res, err := c.service.GetAll(ctx.Request.Context())
	if err != nil {
		resp := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, resp)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_PERMISSIONS, res)
	ctx.JSON(http.StatusOK, resp)
}

// UpdatePermission godoc
// @Summary      Update permission
// @Description  Update permission information by ID
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Param        id      path      string  true  "Permission ID"
// @Param        request body dto.PermissionsUpdateRequest true "Permission update data"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /permissions/{id} [put]
func (c *permissionsController) UpdatePermission(ctx *gin.Context) {
	var req dto.PermissionsUpdateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}
	id := ctx.Param("id")
	result, err := c.service.Update(ctx.Request.Context(), id, req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_UPDATE_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_UPDATE_PERMISSIONS, result)
	ctx.JSON(http.StatusOK, resp)
}

// DeletePermission godoc
// @Summary      Delete permission
// @Description  Delete a permission by ID
// @Tags         Permissions
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Permission ID"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      404  {object}  utils.Response
// @Router       /permissions/{id} [delete]
func (c *permissionsController) DeletePermission(ctx *gin.Context) {
	id := ctx.Param("id")
	if id == "" {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_PERMISSIONS, "id is required", nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	if err := c.service.Delete(ctx.Request.Context(), id); err != nil {
		resp := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_PERMISSIONS, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, resp)
		return
	}
	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_DELETE_PERMISSIONS, nil)
	ctx.JSON(http.StatusOK, resp)
}

// NewPermissionsController creates a new instance of PermissionsController with the provided service.
func NewPermissionsController(s service.PermissionsService) PermissionsController {
	return &permissionsController{
		service: s,
	}
}

// func NewPermissionsController(i *do.Injector, s service.PermissionsService) PermissionsController {
// 	db := do.MustInvokeNamed[*gorm.DB](i, constants.DB)
// 	return &permissionsController{
// 		service: s,
// 		db:      db,
// 	}
// }