package product

import (
	"enaklo-pos-be/internal/common/errors"
	"enaklo-pos-be/internal/entity"
	"enaklo-pos-be/internal/handlers/request"
	"enaklo-pos-be/internal/handlers/response"
	"enaklo-pos-be/internal/services"
	"net/http"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
)

type Handler struct {
	service services.Product
}

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

	route.POST("/create", jwt, h.Create)
	route.GET("/pos", jwt, h.GetPOSProduct)
	route.GET("/list", jwt, h.GetAll)
	route.PUT("/:id", jwt, h.Update)
	route.GET("/:id", jwt, h.GetByID)
	route.DELETE("/:id", jwt, h.Delete)
}

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

// Create handles the creation of a new product.
// @Summary Create a new product
// @Description Create a new product with the provided details.
// @Accept json
// @Produce json
// @Param Authorization header string true "JWT token"
// @Param req body request.Product true "Product details to create"
// @Success 200 {object} response.BaseResponse{data=response.Product} "Product created successfully"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Tags Product APIs
// @Router /api/v1/product/ [post]
func (h *Handler) Create(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	req.PartnerID = *ctx.GetPartnerID()
	req.SiteID = *ctx.GetSiteID()

	res, err := h.service.Create(ctx, req.ToEntity())

	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

// Update handles the update of an existing product.
// @Summary Update an existing product
// @Description Update the details of an existing product based on the provided ID.
// @Accept json
// @Produce json
// @Param Authorization header string true "JWT token"
// @Param id path int64 true "Product ID to update"
// @Param req body request.Product true "Updated product details"
// @Success 200 {object} response.BaseResponse{data=response.Product} "Product updated successfully"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Tags Product APIs
// @Router /api/v1/product/{id} [put]
func (h *Handler) Update(c *gin.Context) {
	ctx := request.GetMyContext(c)

	id := c.Param("id")

	productID, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	var req request.Product
	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
	}

	updatedProduct, err := h.service.Update(ctx, productID, req.ToEntity())
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

// GetAll retrieves a list of products.
// @Summary Get a list of products
// @Description Get a paginated list of products based on query parameters.
// @Accept json
// @Produce json
// @Param Authorization header string true "JWT token"
// @Param Limit query int false "Number of items to retrieve (default 10)"
// @Param Offset query int false "Offset for pagination (default 0)"
// @Success 200 {object} response.BaseResponse{data=response.ProductList} "List of products"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Router /api/v1/product/list [get]
// @Tags Product APIs
func (h *Handler) GetAll(c *gin.Context) {
	var req request.ProductParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	products, total, err := h.service.GetAll(c.Request.Context(), req.ToEntity())
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    h.toProductResponseList(products, int64(total), req),
	})
}

func (h *Handler) GetPOSProduct(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	if !ctx.IsCasheer() {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	products, err := h.service.GetProductPOS(c.Request.Context(), entity.ProductPOS{
		PartnerID: *ctx.GetPartnerID(),
		SiteID:    *ctx.GetSiteID(),
	})

	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    h.toProductResponseList(products, int64(len(products)), req),
	})
}

// Delete handles the deletion of a product by ID.
// @Summary Delete a product by ID
// @Description Delete a product based on the provided ID.
// @Accept json
// @Produce json
// @Param Authorization header string true "JWT token"
// @Param id path int64 true "Product ID to delete"
// @Success 200 {object} response.BaseResponse "Product deleted successfully"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Router /api/v1/product/{id} [delete]
// @Tags Product APIs
func (h *Handler) Delete(c *gin.Context) {
	ctx := request.GetMyContext(c)
	id := c.Param("id")

	// Parse the ID into a uint
	productID, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	err = h.service.Delete(ctx, productID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, response.BaseResponse{
			Success: false,
			Status:  http.StatusInternalServerError,
			Message: err.Error(),
			Data:    nil,
		})
		return
	}

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

// GetByID retrieves details of a specific product by ID.
// @Summary Get details of a product by ID
// @Description Get details of a product based on the provided ID.
// @Accept json
// @Produce json
// @Param Authorization header string true "JWT token"
// @Param id path int64 true "Product ID to retrieve"
// @Success 200 {object} response.BaseResponse{data=response.Product} "Product details"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Router /api/v1/product/{id} [get]
// @Tags Product APIs
func (h *Handler) GetByID(c *gin.Context) {
	id := c.Param("id")

	// Parse the ID into a uint
	productID, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

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

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

func (h *Handler) toProductResponse(resp *entity.Product) response.Product {
	return response.Product{
		ID:          resp.ID,
		Name:        resp.Name,
		Type:        resp.Type,
		Price:       resp.Price,
		Status:      resp.Status,
		Description: resp.Description,
		CreatedAt:   resp.CreatedAt.Format(time.RFC3339),
		UpdatedAt:   resp.CreatedAt.Format(time.RFC3339),
		PartnerID:   resp.PartnerID,
		SiteID:      resp.SiteID,
	}
}

func (h *Handler) toProductResponseList(resp []*entity.Product, total int64, req request.ProductParam) response.ProductList {
	var products []response.Product
	for _, b := range resp {
		products = append(products, h.toProductResponse(b))
	}

	return response.ProductList{
		Products: products,
		Total:    total,
		Limit:    req.Limit,
		Offset:   req.Offset,
	}
}