package handler

import (
	"apskel-pos-be/internal/constants"
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/logger"
	"apskel-pos-be/internal/service"
	"apskel-pos-be/internal/util"
	"apskel-pos-be/internal/validator"

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

type ProductOutletPriceHandler struct {
	service   service.ProductOutletPriceService
	validator validator.ProductOutletPriceValidator
}

func NewProductOutletPriceHandler(svc service.ProductOutletPriceService, v validator.ProductOutletPriceValidator) *ProductOutletPriceHandler {
	return &ProductOutletPriceHandler{
		service:   svc,
		validator: v,
	}
}

func (h *ProductOutletPriceHandler) Upsert(c *gin.Context) {
	ctx := c.Request.Context()

	var req contract.CreateProductOutletPriceRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::Upsert -> request binding failed")
		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
		return
	}

	if validationErr, code := h.validator.ValidateCreateRequest(&req); validationErr != nil {
		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
		return
	}

	resp := h.service.Upsert(ctx, &req)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Upsert")
}

func (h *ProductOutletPriceHandler) GetByProductAndOutlet(c *gin.Context) {
	ctx := c.Request.Context()

	productIDStr := c.Param("product_id")
	productID, err := uuid.Parse(productIDStr)
	if err != nil {
		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
		return
	}

	outletIDStr := c.Param("outlet_id")
	outletID, err := uuid.Parse(outletIDStr)
	if err != nil {
		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
		return
	}

	resp := h.service.GetByProductAndOutlet(ctx, productID, outletID)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProductAndOutlet")
}

func (h *ProductOutletPriceHandler) GetByProduct(c *gin.Context) {
	ctx := c.Request.Context()

	productIDStr := c.Param("product_id")
	productID, err := uuid.Parse(productIDStr)
	if err != nil {
		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProduct")
		return
	}

	resp := h.service.GetByProduct(ctx, productID)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProduct")
}

func (h *ProductOutletPriceHandler) GetByOutlet(c *gin.Context) {
	ctx := c.Request.Context()

	outletIDStr := c.Param("outlet_id")
	outletID, err := uuid.Parse(outletIDStr)
	if err != nil {
		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByOutlet")
		return
	}

	resp := h.service.GetByOutlet(ctx, outletID)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByOutlet")
}

func (h *ProductOutletPriceHandler) Delete(c *gin.Context) {
	ctx := c.Request.Context()

	idStr := c.Param("id")
	id, err := uuid.Parse(idStr)
	if err != nil {
		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ID")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Delete")
		return
	}

	resp := h.service.Delete(ctx, id)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Delete")
}

func (h *ProductOutletPriceHandler) BulkUpsert(c *gin.Context) {
	ctx := c.Request.Context()

	var req contract.BulkCreateProductOutletPriceRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::BulkUpsert -> request binding failed")
		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
		return
	}

	if validationErr, code := h.validator.ValidateBulkCreateRequest(&req); validationErr != nil {
		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
		return
	}

	resp := h.service.BulkUpsert(ctx, &req)
	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::BulkUpsert")
}