apskel-pos-backend/internal/processor/game_prize_processor.go

package processor

import (
	"apskel-pos-be/internal/mappers"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/repository"
	"context"
	"fmt"

	"github.com/google/uuid"
)

type GamePrizeProcessor struct {
	gamePrizeRepo *repository.GamePrizeRepository
}

func NewGamePrizeProcessor(gamePrizeRepo *repository.GamePrizeRepository) *GamePrizeProcessor {
	return &GamePrizeProcessor{
		gamePrizeRepo: gamePrizeRepo,
	}
}

// CreateGamePrize creates a new game prize
func (p *GamePrizeProcessor) CreateGamePrize(ctx context.Context, req *models.CreateGamePrizeRequest) (*models.GamePrizeResponse, error) {
	// Convert request to entity
	gamePrize := mappers.ToGamePrizeEntity(req)

	// Create game prize
	err := p.gamePrizeRepo.Create(ctx, gamePrize)
	if err != nil {
		return nil, fmt.Errorf("failed to create game prize: %w", err)
	}

	return mappers.ToGamePrizeResponse(gamePrize), nil
}

// GetGamePrize retrieves a game prize by ID
func (p *GamePrizeProcessor) GetGamePrize(ctx context.Context, id uuid.UUID) (*models.GamePrizeResponse, error) {
	gamePrize, err := p.gamePrizeRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("game prize not found: %w", err)
	}

	return mappers.ToGamePrizeResponse(gamePrize), nil
}

// GetGamePrizesByGameID retrieves all prizes for a specific game
func (p *GamePrizeProcessor) GetGamePrizesByGameID(ctx context.Context, gameID uuid.UUID) ([]models.GamePrizeResponse, error) {
	gamePrizes, err := p.gamePrizeRepo.GetByGameID(ctx, gameID)
	if err != nil {
		return nil, fmt.Errorf("failed to get game prizes: %w", err)
	}

	return mappers.ToGamePrizeResponses(gamePrizes), nil
}

// ListGamePrizes retrieves game prizes with pagination and filtering
func (p *GamePrizeProcessor) ListGamePrizes(ctx context.Context, query *models.ListGamePrizesQuery) (*models.PaginatedResponse[models.GamePrizeResponse], error) {
	// Set default values
	if query.Page <= 0 {
		query.Page = 1
	}
	if query.Limit <= 0 {
		query.Limit = 10
	}
	if query.Limit > 100 {
		query.Limit = 100
	}

	offset := (query.Page - 1) * query.Limit

	// Get game prizes from repository
	gamePrizes, total, err := p.gamePrizeRepo.List(
		ctx,
		offset,
		query.Limit,
		query.Search,
		query.GameID,
		query.SortBy,
		query.SortOrder,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to list game prizes: %w", err)
	}

	// Convert to responses
	responses := mappers.ToGamePrizeResponses(gamePrizes)

	// Calculate pagination info
	totalPages := int((total + int64(query.Limit) - 1) / int64(query.Limit))

	return &models.PaginatedResponse[models.GamePrizeResponse]{
		Data: responses,
		Pagination: models.Pagination{
			Page:       query.Page,
			Limit:      query.Limit,
			Total:      total,
			TotalPages: totalPages,
		},
	}, nil
}

// UpdateGamePrize updates an existing game prize
func (p *GamePrizeProcessor) UpdateGamePrize(ctx context.Context, id uuid.UUID, req *models.UpdateGamePrizeRequest) (*models.GamePrizeResponse, error) {
	// Get existing game prize
	gamePrize, err := p.gamePrizeRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("game prize not found: %w", err)
	}

	// Update game prize fields
	mappers.UpdateGamePrizeEntity(gamePrize, req)

	// Save updated game prize
	err = p.gamePrizeRepo.Update(ctx, gamePrize)
	if err != nil {
		return nil, fmt.Errorf("failed to update game prize: %w", err)
	}

	return mappers.ToGamePrizeResponse(gamePrize), nil
}

// DeleteGamePrize deletes a game prize
func (p *GamePrizeProcessor) DeleteGamePrize(ctx context.Context, id uuid.UUID) error {
	// Get existing game prize
	_, err := p.gamePrizeRepo.GetByID(ctx, id)
	if err != nil {
		return fmt.Errorf("game prize not found: %w", err)
	}

	// Delete game prize
	err = p.gamePrizeRepo.Delete(ctx, id)
	if err != nil {
		return fmt.Errorf("failed to delete game prize: %w", err)
	}

	return nil
}

// GetAvailablePrizes gets all available prizes for a game (with stock > 0)
func (p *GamePrizeProcessor) GetAvailablePrizes(ctx context.Context, gameID uuid.UUID) ([]models.GamePrizeResponse, error) {
	gamePrizes, err := p.gamePrizeRepo.GetAvailablePrizes(ctx, gameID)
	if err != nil {
		return nil, fmt.Errorf("failed to get available prizes: %w", err)
	}

	return mappers.ToGamePrizeResponses(gamePrizes), nil
}