package handler

import (
	"apskel-pos-be/internal/appcontext"
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/service"
	"apskel-pos-be/internal/transformer"
	"apskel-pos-be/internal/util"

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

type HPPHandler struct {
	hppService  service.HPPService
	transformer transformer.Transformer
}

func NewHPPHandler(hppService service.HPPService, t transformer.Transformer) *HPPHandler {
	return &HPPHandler{
		hppService:  hppService,
		transformer: t,
	}
}

func (h *HPPHandler) GetStandardHPP(c *gin.Context) {
	ctx := c.Request.Context()
	contextInfo := appcontext.FromGinContext(ctx)

	var req contract.StandardHPPRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "HPPHandler::GetStandardHPP", err.Error())}), "HPPHandler::GetStandardHPP")
		return
	}

	req.OrganizationID = contextInfo.OrganizationID
	modelReq := transformer.StandardHPPContractToModel(&req)

	response, err := h.hppService.GetStandardHPP(ctx, modelReq)
	if err != nil {
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "HPPHandler::GetStandardHPP", err.Error())}), "HPPHandler::GetStandardHPP")
		return
	}

	contractResp := transformer.StandardHPPModelToContract(response)
	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(contractResp), "HPPHandler::GetStandardHPP")
}

func (h *HPPHandler) GetRealHPP(c *gin.Context) {
	ctx := c.Request.Context()
	contextInfo := appcontext.FromGinContext(ctx)

	var req contract.RealHPPRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "HPPHandler::GetRealHPP", err.Error())}), "HPPHandler::GetRealHPP")
		return
	}

	req.OrganizationID = contextInfo.OrganizationID
	if contextInfo.OutletID != uuid.Nil {
		req.OutletID = &contextInfo.OutletID
	}
	modelReq := transformer.RealHPPContractToModel(&req)

	response, err := h.hppService.GetRealHPP(ctx, modelReq)
	if err != nil {
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "HPPHandler::GetRealHPP", err.Error())}), "HPPHandler::GetRealHPP")
		return
	}

	contractResp := transformer.RealHPPModelToContract(response)
	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(contractResp), "HPPHandler::GetRealHPP")
}