Yimaru-BackEnd/internal/web_server/handlers/bonus.go

package handlers

import (
	"strconv"

	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
)

// func (h *Handler) CreateBonusMultiplier(c *fiber.Ctx) error {
// 	var req struct {
// 		Multiplier float32 `json:"multiplier"`
// 		BalanceCap int64   `json:"balance_cap"`
// 	}

// 	if err := c.BodyParser(&req); err != nil {
// 		h.logger.Error("failed to parse bonus multiplier request", "error", err)
// 		h.mongoLoggerSvc.Info("failed to parse bonus multiplier",
// 			zap.Int("status_code", fiber.StatusBadRequest),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body:"+err.Error())
// 	}

// 	// currently only one multiplier is allowed
// 	// we can add an active bool in the db and have mulitple bonus if needed
// 	multipliers, err := h.bonusSvc.GetBonusMultiplier(c.Context())
// 	if err != nil {
// 		h.logger.Error("failed to get bonus multiplier", "error", err)
// 		h.mongoLoggerSvc.Info("Failed to get bonus multiplier",
// 			zap.Int("status_code", fiber.StatusBadRequest),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body:"+err.Error())
// 	}

// 	if len(multipliers) > 0 {
// 		return fiber.NewError(fiber.StatusBadRequest, "only one multiplier is allowed")
// 	}

// 	if err := h.bonusSvc.CreateBonusMultiplier(c.Context(), req.Multiplier, req.BalanceCap); err != nil {
// 		h.mongoLoggerSvc.Error("failed to create bonus multiplier",
// 			zap.Int("status_code", fiber.StatusInternalServerError),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusInternalServerError, "failed to create bonus multiplier"+err.Error())
// 	}

// 	return response.WriteJSON(c, fiber.StatusOK, "Create bonus multiplier successfully", nil, nil)
// }

// func (h *Handler) GetBonusMultiplier(c *fiber.Ctx) error {
// 	multipliers, err := h.bonusSvc.GetBonusMultiplier(c.Context())
// 	if err != nil {
// 		h.mongoLoggerSvc.Info("failed to get bonus multiplier",
// 			zap.Int("status_code", fiber.StatusBadRequest),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body"+err.Error())
// 	}

// 	return response.WriteJSON(c, fiber.StatusOK, "Fetched bonus multiplier successfully", multipliers, nil)
// }

// func (h *Handler) UpdateBonusMultiplier(c *fiber.Ctx) error {
// 	var req struct {
// 		ID         int64   `json:"id"`
// 		Multiplier float32 `json:"multiplier"`
// 		BalanceCap int64   `json:"balance_cap"`
// 	}

// 	if err := c.BodyParser(&req); err != nil {
// 		h.mongoLoggerSvc.Info("failed to parse bonus multiplier",
// 			zap.Int("status_code", fiber.StatusBadRequest),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body:"+err.Error())
// 	}

// 	if err := h.bonusSvc.UpdateBonusMultiplier(c.Context(), req.ID, req.Multiplier, req.BalanceCap); err != nil {
// 		h.logger.Error("failed to update bonus multiplier", "error", err)
// 		h.mongoLoggerSvc.Error("failed to update bonus multiplier",
// 			zap.Int64("id", req.ID),
// 			zap.Int("status_code", fiber.StatusInternalServerError),
// 			zap.Error(err),
// 			zap.Time("timestamp", time.Now()),
// 		)
// 		return fiber.NewError(fiber.StatusInternalServerError, "failed to update bonus multiplier:"+err.Error())
// 	}

// 	return response.WriteJSON(c, fiber.StatusOK, "Updated bonus multiplier successfully", nil, nil)
// }

func (h *Handler) GetBonusesByUserID(c *fiber.Ctx) error {
	userID, ok := c.Locals("user_id").(int64)
	if !ok || userID == 0 {
		h.InternalServerErrorLogger().Error("Invalid user ID in context",
			zap.Int64("userID", userID),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Invalid user identification")
	}

	page := c.QueryInt("page", 1)
	pageSize := c.QueryInt("page_size", 10)
	limit := domain.ValidInt{
		Value: pageSize,
		Valid: true,
	}
	offset := domain.ValidInt{
		Value: page - 1,
		Valid: true,
	}

	filter := domain.BonusFilter{
		UserID: domain.ValidInt64{
			Value: userID,
			Valid: true,
		},
		Limit:  limit,
		Offset: offset,
	}

	bonuses, err := h.bonusSvc.GetAllUserBonuses(c.Context(), filter)

	if err != nil {
		h.InternalServerErrorLogger().Error("Failed to bonus by userID", zap.Int64("userId", userID))
		return fiber.NewError(fiber.StatusInternalServerError, "failed to get bonus by user ID")
	}

	count, err := h.bonusSvc.GetBonusCount(c.Context(), filter)
	if err != nil {
		h.InternalServerErrorLogger().Error("Failed to get bonus count", zap.Int64("userId", userID))
		return fiber.NewError(fiber.StatusInternalServerError, "failed to get bonus count by user ID")
	}

	res := domain.ConvertToBonusResList(bonuses)

	return response.WritePaginatedJSON(c, fiber.StatusOK, "Fetched User Bonuses", res, nil, page, int(count))

}

func (h *Handler) GetBonusStats(c *fiber.Ctx) error {
	userID, ok := c.Locals("user_id").(int64)
	if !ok || userID == 0 {
		h.InternalServerErrorLogger().Error("Invalid user ID in context",
			zap.Int64("userID", userID),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Invalid user identification")
	}

	stats, err := h.bonusSvc.GetBonusStats(c.Context(), domain.BonusFilter{
		UserID: domain.ValidInt64{
			Value: userID,
			Valid: true,
		},
	})

	if err != nil {
		h.InternalServerErrorLogger().Error("Failed to get bonus stats",
			zap.Int64("userID", userID),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to get bonus stats")
	}

	res := domain.ConvertToBonusStatsRes(stats)

	return response.WriteJSON(c, fiber.StatusOK, "Get Bonus Stats", res, nil)
}

// bonus/:id/claim
func (h *Handler) ClaimBonus(c *fiber.Ctx) error {
	bonusIDParam := c.Params("id")
	bonusID, err := strconv.ParseInt(bonusIDParam, 10, 64)
	if err != nil {
		h.BadRequestLogger().Error("Invalid bonus ID",
			zap.Int64("bonusID", bonusID),
		)
		return fiber.NewError(fiber.StatusBadRequest, "Invalid bonus id")
	}

	userID, ok := c.Locals("user_id").(int64)
	if !ok || userID == 0 {
		h.InternalServerErrorLogger().Error("Invalid user ID in context",
			zap.Int64("userID", userID),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Invalid user identification")
	}

	if err := h.bonusSvc.ProcessBonusClaim(c.Context(), bonusID, userID); err != nil {
		h.InternalServerErrorLogger().Error("Failed to update bonus claim",
			zap.Int64("userID", userID),
			zap.Int64("bonusID", bonusID),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update bonus claim")
	}

	return response.WriteJSON(c, fiber.StatusOK, "Bonus has successfully been claimed", nil, nil)

}