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 TierProcessor struct {
	tierRepo *repository.TierRepository
}

func NewTierProcessor(tierRepo *repository.TierRepository) *TierProcessor {
	return &TierProcessor{
		tierRepo: tierRepo,
	}
}

// CreateTier creates a new tier
func (p *TierProcessor) CreateTier(ctx context.Context, req *models.CreateTierRequest) (*models.TierResponse, error) {
	// Convert request to entity
	tier := mappers.ToTierEntity(req)

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

	return mappers.ToTierResponse(tier), nil
}

// GetTier retrieves a tier by ID
func (p *TierProcessor) GetTier(ctx context.Context, id uuid.UUID) (*models.TierResponse, error) {
	tier, err := p.tierRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("tier not found: %w", err)
	}

	return mappers.ToTierResponse(tier), nil
}

// ListTiers retrieves tiers with pagination and filtering
func (p *TierProcessor) ListTiers(ctx context.Context, query *models.ListTiersQuery) (*models.PaginatedResponse[models.TierResponse], 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 tiers from repository
	tiers, total, err := p.tierRepo.List(
		ctx,
		offset,
		query.Limit,
		query.Search,
		query.SortBy,
		query.SortOrder,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to list tiers: %w", err)
	}

	// Convert to responses
	responses := mappers.ToTierResponses(tiers)

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

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

// UpdateTier updates an existing tier
func (p *TierProcessor) UpdateTier(ctx context.Context, id uuid.UUID, req *models.UpdateTierRequest) (*models.TierResponse, error) {
	// Get existing tier
	tier, err := p.tierRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("tier not found: %w", err)
	}

	// Update tier fields
	mappers.UpdateTierEntity(tier, req)

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

	return mappers.ToTierResponse(tier), nil
}

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

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

	return nil
}

// GetTierByPoints gets the appropriate tier for a given point amount
func (p *TierProcessor) GetTierByPoints(ctx context.Context, points int64) (*models.TierResponse, error) {
	tier, err := p.tierRepo.GetTierByPoints(ctx, points)
	if err != nil {
		return nil, fmt.Errorf("tier not found for points: %w", err)
	}

	return mappers.ToTierResponse(tier), nil
}