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

package processor

import (
	"apskel-pos-be/internal/constants"
	"apskel-pos-be/internal/entities"
	"context"
	"errors"
	"fmt"

	"apskel-pos-be/internal/mappers"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/repository"

	"github.com/google/uuid"
)

type PaymentMethodProcessor interface {
	CreatePaymentMethod(ctx context.Context, req *models.CreatePaymentMethodRequest) (*models.PaymentMethodResponse, error)
	GetPaymentMethodByID(ctx context.Context, id uuid.UUID) (*models.PaymentMethodResponse, error)
	ListPaymentMethods(ctx context.Context, req *models.ListPaymentMethodsRequest) (*models.ListPaymentMethodsResponse, error)
	UpdatePaymentMethod(ctx context.Context, id uuid.UUID, req *models.UpdatePaymentMethodRequest) (*models.PaymentMethodResponse, error)
	DeletePaymentMethod(ctx context.Context, id uuid.UUID) error
	GetActivePaymentMethodsByOrganization(ctx context.Context, organizationID uuid.UUID) ([]models.PaymentMethodResponse, error)
}

// ErrSystemPaymentMethod means an attempt to create, delete or retype the EnakPoint
// method, which the system owns (docs/prd-point-coin.md F9).
var ErrSystemPaymentMethod = errors.New("the EnakPoint payment method is managed by the system: it cannot be created, deleted or change type")

type PaymentMethodProcessorImpl struct {
	paymentMethodRepo repository.PaymentMethodRepository
	outletSettings    outletSettingsReader
}

func NewPaymentMethodProcessorImpl(paymentMethodRepo repository.PaymentMethodRepository, outletSettings outletSettingsReader) *PaymentMethodProcessorImpl {
	return &PaymentMethodProcessorImpl{
		paymentMethodRepo: paymentMethodRepo,
		outletSettings:    outletSettings,
	}
}

func (p *PaymentMethodProcessorImpl) CreatePaymentMethod(ctx context.Context, req *models.CreatePaymentMethodRequest) (*models.PaymentMethodResponse, error) {
	if req.Type == constants.PaymentMethodTypePoint {
		return nil, ErrSystemPaymentMethod
	}
	exists, err := p.paymentMethodRepo.ExistsByName(ctx, req.OrganizationID, req.Name, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to check payment method name uniqueness: %w", err)
	}
	if exists {
		return nil, fmt.Errorf("payment method with name '%s' already exists for this organization", req.Name)
	}

	paymentMethodEntity := mappers.CreatePaymentMethodRequestToEntity(req)
	if err := p.paymentMethodRepo.Create(ctx, paymentMethodEntity); err != nil {
		return nil, fmt.Errorf("failed to create payment method: %w", err)
	}

	createdPaymentMethod, err := p.paymentMethodRepo.GetByID(ctx, paymentMethodEntity.ID)
	if err != nil {
		return nil, fmt.Errorf("failed to retrieve created payment method: %w", err)
	}

	response := mappers.PaymentMethodEntityToResponse(createdPaymentMethod)
	return response, nil
}

func (p *PaymentMethodProcessorImpl) GetPaymentMethodByID(ctx context.Context, id uuid.UUID) (*models.PaymentMethodResponse, error) {
	paymentMethod, err := p.paymentMethodRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("payment method not found: %w", err)
	}

	response := mappers.PaymentMethodEntityToResponse(paymentMethod)
	return response, nil
}

func (p *PaymentMethodProcessorImpl) ListPaymentMethods(ctx context.Context, req *models.ListPaymentMethodsRequest) (*models.ListPaymentMethodsResponse, error) {
	filters := make(map[string]interface{})
	if req.OrganizationID != nil {
		filters["organization_id"] = *req.OrganizationID
	}
	if req.Type != nil {
		filters["type"] = string(*req.Type)
	}
	if req.IsActive != nil {
		filters["is_active"] = *req.IsActive
	}
	if req.Search != "" {
		filters["search"] = req.Search
	}
	// At the cashier EnakPoint only shows where the outlet accepts it (F9). Filtered in
	// the query so paging stays right.
	if req.OutletID != nil && p.outletSettings != nil {
		settings, err := p.outletSettings.Outlet(ctx, *req.OutletID)
		if err != nil {
			return nil, fmt.Errorf("failed to read outlet loyalty settings: %w", err)
		}
		if !settings.PointPayment.AcceptPayment {
			filters["exclude_type"] = string(constants.PaymentMethodTypePoint)
		}
	}

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

	paymentMethods, total, err := p.paymentMethodRepo.List(ctx, filters, req.Limit, offset)
	if err != nil {
		return nil, fmt.Errorf("failed to list payment methods: %w", err)
	}

	// Convert to responses
	paymentMethodResponses := make([]models.PaymentMethodResponse, len(paymentMethods))
	for i, paymentMethod := range paymentMethods {
		response := mappers.PaymentMethodEntityToResponse(paymentMethod)
		if response != nil {
			paymentMethodResponses[i] = *response
		}
	}

	// Calculate total pages
	totalPages := int(total) / req.Limit
	if int(total)%req.Limit > 0 {
		totalPages++
	}

	return &models.ListPaymentMethodsResponse{
		PaymentMethods: paymentMethodResponses,
		TotalCount:     int(total),
		Page:           req.Page,
		Limit:          req.Limit,
		TotalPages:     totalPages,
	}, nil
}

func (p *PaymentMethodProcessorImpl) UpdatePaymentMethod(ctx context.Context, id uuid.UUID, req *models.UpdatePaymentMethodRequest) (*models.PaymentMethodResponse, error) {
	// Get existing payment method
	existingPaymentMethod, err := p.paymentMethodRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("payment method not found: %w", err)
	}

	// The EnakPoint method keeps its type, and no other method can become one.
	if req.Type != nil {
		wasPoint := existingPaymentMethod.Type == entities.PaymentMethodTypePoint
		isPoint := *req.Type == constants.PaymentMethodTypePoint
		if wasPoint != isPoint {
			return nil, ErrSystemPaymentMethod
		}
	}

	// Check name uniqueness if name is being updated
	if req.Name != nil && *req.Name != existingPaymentMethod.Name {
		exists, err := p.paymentMethodRepo.ExistsByName(ctx, existingPaymentMethod.OrganizationID, *req.Name, &id)
		if err != nil {
			return nil, fmt.Errorf("failed to check payment method name uniqueness: %w", err)
		}
		if exists {
			return nil, fmt.Errorf("payment method with name '%s' already exists for this organization", *req.Name)
		}
	}

	// Apply updates
	mappers.UpdatePaymentMethodEntityFromRequest(existingPaymentMethod, req)

	// Update payment method
	if err := p.paymentMethodRepo.Update(ctx, existingPaymentMethod); err != nil {
		return nil, fmt.Errorf("failed to update payment method: %w", err)
	}

	// Get updated payment method
	updatedPaymentMethod, err := p.paymentMethodRepo.GetByID(ctx, id)
	if err != nil {
		return nil, fmt.Errorf("failed to retrieve updated payment method: %w", err)
	}

	response := mappers.PaymentMethodEntityToResponse(updatedPaymentMethod)
	return response, nil
}

func (p *PaymentMethodProcessorImpl) DeletePaymentMethod(ctx context.Context, id uuid.UUID) error {
	// Check if payment method exists
	existing, err := p.paymentMethodRepo.GetByID(ctx, id)
	if err != nil {
		return fmt.Errorf("payment method not found: %w", err)
	}
	if existing.Type == entities.PaymentMethodTypePoint {
		return ErrSystemPaymentMethod
	}

	// TODO: Check if payment method is being used in any payments
	// For now, allow deletion

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

	return nil
}

func (p *PaymentMethodProcessorImpl) GetActivePaymentMethodsByOrganization(ctx context.Context, organizationID uuid.UUID) ([]models.PaymentMethodResponse, error) {
	paymentMethods, err := p.paymentMethodRepo.GetActiveByOrganizationID(ctx, organizationID)
	if err != nil {
		return nil, fmt.Errorf("failed to get active payment methods: %w", err)
	}

	responses := make([]models.PaymentMethodResponse, len(paymentMethods))
	for i, paymentMethod := range paymentMethods {
		response := mappers.PaymentMethodEntityToResponse(paymentMethod)
		if response != nil {
			responses[i] = *response
		}
	}

	return responses, nil
}