package license

import (
	"furtuna-be/internal/common/errors"
	"furtuna-be/internal/handlers/request"
	"furtuna-be/internal/handlers/response"
	"furtuna-be/internal/middlewares"
	"furtuna-be/internal/services"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"net/http"
)

type Handler struct {
	service services.License
}

func (h *Handler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	route := group.Group("/license")
	isAdmin := middlewares.IsAdminMiddleware()

	route.POST("/", jwt, isAdmin, h.Create)
	route.GET("/", jwt, isAdmin, h.GetAll)
	route.PUT("/:id", jwt, isAdmin, h.Update)
	route.GET("/:id", jwt, isAdmin, h.GetByID)
}

func NewHandler(service services.License) *Handler {
	return &Handler{
		service: service,
	}
}

// Create handles the creation of a new license.
func (h *Handler) Create(c *gin.Context) {
	ctx := request.GetMyContext(c)

	var req request.License
	if err := c.ShouldBindJSON(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	licenseEntity, err := req.ToEntity()
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	res, err := h.service.Create(ctx, licenseEntity)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	var licenseResponse response.License
	licenseResponse.FromEntity(res)

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    licenseResponse,
	})
}

// Update handles the update of an existing license.
func (h *Handler) Update(c *gin.Context) {
	ctx := request.GetMyContext(c)

	licenseID := c.Param("id")

	var req request.License
	if err := c.ShouldBindJSON(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	licenseEntity, err := req.ToEntity()
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	updatedLicense, err := h.service.Update(ctx, licenseID, licenseEntity)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	var licenseResponse response.License
	licenseResponse.FromEntity(updatedLicense)

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    licenseResponse,
	})
}

// GetAll retrieves a list of licenses.
func (h *Handler) GetAll(c *gin.Context) {
	var req request.LicenseParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)

	licenses, total, err := h.service.GetAll(ctx, req.Limit, req.Offset, req.Status)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	licenseResponses := response.FromEntityListAll(licenses)

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    response.LicenseList{Licenses: licenseResponses, Total: total, Limit: req.Limit, Offset: req.Offset},
	})
}

// GetByID retrieves details of a specific license by ID.
func (h *Handler) GetByID(c *gin.Context) {
	licenseID := c.Param("id")

	res, err := h.service.GetByID(c.Request.Context(), licenseID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, response.BaseResponse{
			Success: false,
			Status:  http.StatusInternalServerError,
			Message: err.Error(),
			Data:    nil,
		})
		return
	}

	var licenseResponse response.License
	licenseResponse.FromEntity(res)

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    licenseResponse,
	})
}