apskel-pos-backend/internal/service/reward_service.go

package service

import (
	"context"
	"fmt"

	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/processor"
)

type RewardService interface {
	CreateReward(ctx context.Context, req *contract.CreateRewardRequest) (*models.RewardResponse, error)
	GetReward(ctx context.Context, id string) (*models.RewardResponse, error)
	ListRewards(ctx context.Context, req *contract.ListRewardsRequest) (*models.ListRewardsResponse, error)
	UpdateReward(ctx context.Context, req *contract.UpdateRewardRequest) (*models.RewardResponse, error)
	DeleteReward(ctx context.Context, id string) error
	UpdateRewardStock(ctx context.Context, id string, newStock int) error
	GetRewardsByType(ctx context.Context, rewardType string) ([]models.RewardResponse, error)
}

type rewardService struct {
	rewardProcessor processor.RewardProcessor
}

func NewRewardService(rewardProcessor processor.RewardProcessor) RewardService {
	return &rewardService{
		rewardProcessor: rewardProcessor,
	}
}

func (s *rewardService) CreateReward(ctx context.Context, req *contract.CreateRewardRequest) (*models.RewardResponse, error) {
	// Validate reward type
	if err := s.validateRewardType(req.RewardType); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	// Validate cost points
	if req.CostPoints <= 0 {
		return nil, fmt.Errorf("cost points must be greater than 0")
	}

	// Validate stock for physical rewards
	if req.RewardType == "PHYSICAL" && req.Stock != nil && *req.Stock <= 0 {
		return nil, fmt.Errorf("physical rewards must have positive stock or unlimited stock")
	}

	// Validate max per customer
	if req.MaxPerCustomer <= 0 {
		return nil, fmt.Errorf("max per customer must be greater than 0")
	}

	// Create reward
	response, err := s.rewardProcessor.CreateReward(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create reward: %w", err)
	}

	return response, nil
}

func (s *rewardService) GetReward(ctx context.Context, id string) (*models.RewardResponse, error) {
	if id == "" {
		return nil, fmt.Errorf("reward ID is required")
	}

	response, err := s.rewardProcessor.GetReward(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("failed to get reward: %w", err)
	}

	return response, nil
}

func (s *rewardService) ListRewards(ctx context.Context, req *contract.ListRewardsRequest) (*models.ListRewardsResponse, error) {
	// Set default pagination
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.Limit <= 0 {
		req.Limit = 10
	}
	if req.Limit > 100 {
		req.Limit = 100
	}

	// Validate reward type filter if provided
	if req.RewardType != "" {
		if err := s.validateRewardType(req.RewardType); err != nil {
			return nil, fmt.Errorf("validation failed: %w", err)
		}
	}

	// Validate points range if provided
	if req.MinPoints != nil && req.MaxPoints != nil {
		if *req.MinPoints > *req.MaxPoints {
			return nil, fmt.Errorf("min points cannot be greater than max points")
		}
	}

	response, err := s.rewardProcessor.ListRewards(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to list rewards: %w", err)
	}

	return response, nil
}

func (s *rewardService) UpdateReward(ctx context.Context, req *contract.UpdateRewardRequest) (*models.RewardResponse, error) {
	if req.ID.String() == "" {
		return nil, fmt.Errorf("reward ID is required")
	}

	// Validate reward type
	if err := s.validateRewardType(req.RewardType); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	// Validate cost points
	if req.CostPoints <= 0 {
		return nil, fmt.Errorf("cost points must be greater than 0")
	}

	// Validate stock for physical rewards
	if req.RewardType == "PHYSICAL" && req.Stock != nil && *req.Stock <= 0 {
		return nil, fmt.Errorf("physical rewards must have positive stock or unlimited stock")
	}

	// Validate max per customer
	if req.MaxPerCustomer <= 0 {
		return nil, fmt.Errorf("max per customer must be greater than 0")
	}

	response, err := s.rewardProcessor.UpdateReward(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to update reward: %w", err)
	}

	return response, nil
}

func (s *rewardService) DeleteReward(ctx context.Context, id string) error {
	if id == "" {
		return fmt.Errorf("reward ID is required")
	}

	err := s.rewardProcessor.DeleteReward(ctx, id)
	if err != nil {
		return fmt.Errorf("failed to delete reward: %w", err)
	}

	return nil
}

func (s *rewardService) UpdateRewardStock(ctx context.Context, id string, newStock int) error {
	if id == "" {
		return fmt.Errorf("reward ID is required")
	}

	if newStock < 0 {
		return fmt.Errorf("stock cannot be negative")
	}

	err := s.rewardProcessor.UpdateRewardStock(ctx, id, newStock)
	if err != nil {
		return fmt.Errorf("failed to update reward stock: %w", err)
	}

	return nil
}

func (s *rewardService) GetRewardsByType(ctx context.Context, rewardType string) ([]models.RewardResponse, error) {
	if rewardType == "" {
		return nil, fmt.Errorf("reward type is required")
	}

	// Validate reward type
	if err := s.validateRewardType(rewardType); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	rewards, err := s.rewardProcessor.GetRewardsByType(ctx, rewardType)
	if err != nil {
		return nil, fmt.Errorf("failed to get rewards by type: %w", err)
	}

	return rewards, nil
}

func (s *rewardService) validateRewardType(rewardType string) error {
	validTypes := []string{"VOUCHER", "PHYSICAL", "DIGITAL", "BALANCE"}
	for _, validType := range validTypes {
		if rewardType == validType {
			return nil
		}
	}
	return fmt.Errorf("invalid reward type: %s. Valid types are: VOUCHER, PHYSICAL, DIGITAL, BALANCE", rewardType)
}