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"

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

type CustomerPointsHandler struct {
	customerPointsService service.CustomerPointsService
}

func NewCustomerPointsHandler(customerPointsService service.CustomerPointsService) *CustomerPointsHandler {
	return &CustomerPointsHandler{
		customerPointsService: customerPointsService,
	}
}

func (h *CustomerPointsHandler) GetCustomerPoints(c *gin.Context) {
	ctx := c.Request.Context()

	// Get customer ID from context (set by middleware)
	customerID, exists := c.Get("customer_id")
	if !exists {
		logger.FromContext(ctx).Error("Customer ID not found in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Customer ID not found"),
		}), "CustomerPointsHandler::GetCustomerPoints")
		return
	}

	customerIDStr, ok := customerID.(string)
	if !ok {
		logger.FromContext(ctx).Error("Invalid customer ID type in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Invalid customer ID"),
		}), "CustomerPointsHandler::GetCustomerPoints")
		return
	}

	response, err := h.customerPointsService.GetCustomerPoints(ctx, customerIDStr)
	if err != nil {
		logger.FromContext(ctx).WithError(err).Error("CustomerPointsHandler::GetCustomerPoints -> service call failed")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
		}), "CustomerPointsHandler::GetCustomerPoints")
		return
	}

	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(response), "CustomerPointsHandler::GetCustomerPoints")
}

func (h *CustomerPointsHandler) GetCustomerTokens(c *gin.Context) {
	ctx := c.Request.Context()

	// Get customer ID from context (set by middleware)
	customerID, exists := c.Get("customer_id")
	if !exists {
		logger.FromContext(ctx).Error("Customer ID not found in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Customer ID not found"),
		}), "CustomerPointsHandler::GetCustomerTokens")
		return
	}

	customerIDStr, ok := customerID.(string)
	if !ok {
		logger.FromContext(ctx).Error("Invalid customer ID type in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Invalid customer ID"),
		}), "CustomerPointsHandler::GetCustomerTokens")
		return
	}

	response, err := h.customerPointsService.GetCustomerTokens(ctx, customerIDStr)
	if err != nil {
		logger.FromContext(ctx).WithError(err).Error("CustomerPointsHandler::GetCustomerTokens -> service call failed")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
		}), "CustomerPointsHandler::GetCustomerTokens")
		return
	}

	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(response), "CustomerPointsHandler::GetCustomerTokens")
}

func (h *CustomerPointsHandler) GetCustomerWallet(c *gin.Context) {
	ctx := c.Request.Context()

	// Get customer ID from context (set by middleware)
	customerID, exists := c.Get("customer_id")
	if !exists {
		logger.FromContext(ctx).Error("Customer ID not found in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Customer ID not found"),
		}), "CustomerPointsHandler::GetCustomerWallet")
		return
	}

	customerIDStr, ok := customerID.(string)
	if !ok {
		logger.FromContext(ctx).Error("Invalid customer ID type in context")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.ValidationErrorCode, constants.AuthHandlerEntity, "Invalid customer ID"),
		}), "CustomerPointsHandler::GetCustomerWallet")
		return
	}

	response, err := h.customerPointsService.GetCustomerWallet(ctx, customerIDStr)
	if err != nil {
		logger.FromContext(ctx).WithError(err).Error("CustomerPointsHandler::GetCustomerWallet -> service call failed")
		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
		}), "CustomerPointsHandler::GetCustomerWallet")
		return
	}

	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(response), "CustomerPointsHandler::GetCustomerWallet")
}