package controller

import (
	"net/http"

	dtodomain "github.com/Caknoooo/go-gin-clean-starter/modules/uom/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/uom/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/uom/service"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/constants"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/samber/do"
	"gorm.io/gorm"
)

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

type uomController struct {
	uomService service.UomService
	db         *gorm.DB
}

func NewUomController(i *do.Injector, uomService service.UomService) UomController {
	db := do.MustInvokeNamed[*gorm.DB](i, constants.DB)
	return &uomController{
		uomService: uomService,
		db:         db,
	}
}

func (c *uomController) Create(ctx *gin.Context) {
	var req dtodomain.UomCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	created, err := c.uomService.Create(ctx, req)
	if err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_CREATE_UOM, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}
	res := utils.BuildResponseSuccess(dtodomain.MESSAGE_SUCCESS_CREATE_UOM, created)
	ctx.JSON(http.StatusOK, res)
}

func (c *uomController) Update(ctx *gin.Context) {
	id := ctx.Param("id")
	var req dtodomain.UomUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	updated, err := c.uomService.Update(ctx, req, id)
	if err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_UPDATE_UOM, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}
	res := utils.BuildResponseSuccess(dtodomain.MESSAGE_SUCCESS_UPDATE_UOM, updated)
	ctx.JSON(http.StatusOK, res)
}

func (c *uomController) Delete(ctx *gin.Context) {
	id := ctx.Param("id")
	if err := c.uomService.Delete(ctx, id); err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_DELETE_UOM, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}
	res := utils.BuildResponseSuccess(dtodomain.MESSAGE_SUCCESS_DELETE_UOM, nil)
	ctx.JSON(http.StatusOK, res)
}

func (c *uomController) GetById(ctx *gin.Context) {
	id := ctx.Param("id")
	uom, err := c.uomService.GetById(ctx, id)
	if err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_GET_UOM, err.Error(), nil)
		ctx.JSON(http.StatusNotFound, res)
		return
	}
	res := utils.BuildResponseSuccess(dtodomain.MESSAGE_SUCCESS_GET_UOM, uom)
	ctx.JSON(http.StatusOK, res)
}

func (c *uomController) GetAll(ctx *gin.Context) {
	var filter query.UomFilter
	if err := ctx.ShouldBindQuery(&filter); err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_GET_UOM, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	perPage := utils.ParseInt(ctx.DefaultQuery("per_page", "10"))
	page := utils.ParseInt(ctx.DefaultQuery("page", "1"))
	filter.PerPage = perPage
	filter.Page = (page - 1) * perPage
	uoms, total, err := c.uomService.GetAll(ctx, filter)
	if err != nil {
		res := utils.BuildResponseFailed(dtodomain.MESSAGE_FAILED_GET_UOM, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	paginationResponse := utils.BuildPaginationResponse(perPage, page, total)
	response := utils.BuildResponseSuccessWithPagination(http.StatusOK, dtodomain.MESSAGE_SUCCESS_GET_UOM, uoms, paginationResponse)
	ctx.JSON(http.StatusOK, response)
}