telecom-platform/apps/carrier-connector/internal/services/pricing_service.go

package services

import (
	"context"
	"fmt"

	"github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/id"
	"github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/pricing"
	"github.com/sirupsen/logrus"
)

type PricingService struct {
	repository pricing.Repository
	engine     pricing.RuleEngine
	validator  pricing.PricingValidator
	logger     *logrus.Logger
}

func NewPricingService(
	repository pricing.Repository,
	engine pricing.RuleEngine,
	validator pricing.PricingValidator,
	logger *logrus.Logger,
) pricing.Service {
	return &PricingService{
		repository: repository,
		engine:     engine,
		validator:  validator,
		logger:     logger,
	}
}

// ValidateRule validates a pricing rule
func (s *PricingService) ValidateRule(ctx context.Context, rule *pricing.PricingRule) error {
	return s.validator.ValidateRule(ctx, rule)
}

// GetAnalytics retrieves pricing analytics for a tenant
func (s *PricingService) GetAnalytics(ctx context.Context, tenantID string) (*pricing.PricingAnalytics, error) {
	// Get all rules for tenant
	allRules, err := s.repository.ListRules(ctx, &pricing.PricingFilter{
		TenantID: tenantID,
	})
	if err != nil {
		return nil, fmt.Errorf("failed to get rules for analytics: %w", err)
	}

	// Get active rules
	activeRules, err := s.repository.GetActiveRules(ctx, tenantID)
	if err != nil {
		return nil, fmt.Errorf("failed to get active rules for analytics: %w", err)
	}

	// Calculate analytics
	analytics := &pricing.PricingAnalytics{
		TotalRules:  len(allRules),
		ActiveRules: len(activeRules),
		RulesByType: make(map[string]int),
		UsageByRule: make(map[string]int64),
		GeneratedAt: id.GetCurrentTime(),
	}

	// Count rules by type
	for _, rule := range allRules {
		ruleType := string(rule.Type)
		analytics.RulesByType[ruleType]++
	}

	// Calculate actual usage statistics from pricing history
	discountStats, err := s.calculateDiscountStatistics(ctx)
	if err != nil {
		s.logger.WithError(err).Error("Failed to calculate discount statistics, using defaults")
		// Fallback to default values if calculation fails
		discountStats = pricing.DiscountStatistics{
			TotalDiscounts:     0,
			AverageDiscount:    0.0,
			LargestDiscount:    0.0,
			SmallestDiscount:   0.0,
			TotalDiscountValue: 0.0,
		}
	}
	analytics.DiscountStats = discountStats

	return analytics, nil
}

// calculateDiscountStatistics calculates actual discount statistics from pricing history
func (s *PricingService) calculateDiscountStatistics(ctx context.Context) (pricing.DiscountStatistics, error) {
	// Retrieve all rules and compute discount statistics from their action values
	filter := &pricing.PricingFilter{}
	allRules, err := s.repository.ListRules(ctx, filter)
	if err != nil {
		return pricing.DiscountStatistics{}, fmt.Errorf("failed to list rules: %w", err)
	}

	// Filter only active rules
	var activeRules []*pricing.PricingRule
	for _, rule := range allRules {
		if rule.IsActive {
			activeRules = append(activeRules, rule)
		}
	}

	// Calculate discount statistics based on active rules
	stats := pricing.DiscountStatistics{
		TotalDiscounts:     0,
		AverageDiscount:    0.0,
		LargestDiscount:    0.0,
		SmallestDiscount:   0.0,
		TotalDiscountValue: 0.0,
	}

	if len(activeRules) == 0 {
		return stats, nil
	}

	var totalDiscountValue float64
	var discountSum float64
	var largestDiscount float64
	var smallestDiscount float64 = -1

	for _, rule := range activeRules {
		discountValue := extractDiscountValue(rule)

		if discountValue > 0 {
			stats.TotalDiscounts++
			totalDiscountValue += discountValue
			discountSum += discountValue

			if discountValue > largestDiscount {
				largestDiscount = discountValue
			}

			if smallestDiscount == -1 || discountValue < smallestDiscount {
				smallestDiscount = discountValue
			}
		}
	}

	// Calculate final statistics
	stats.TotalDiscountValue = totalDiscountValue
	stats.LargestDiscount = largestDiscount
	stats.SmallestDiscount = smallestDiscount

	if stats.TotalDiscounts > 0 {
		stats.AverageDiscount = discountSum / float64(stats.TotalDiscounts)
	}

	s.logger.WithFields(logrus.Fields{
		"total_discounts":      stats.TotalDiscounts,
		"average_discount":     stats.AverageDiscount,
		"total_discount_value": stats.TotalDiscountValue,
	}).Info("Calculated discount statistics from pricing history")

	return stats, nil
}

// extractDiscountValue extracts discount value from rule actions
func extractDiscountValue(rule *pricing.PricingRule) float64 {
	// Extract the actual discount value from the rule's Actions field
	actionValue := rule.Actions.Value
	if actionValue == 0 {
		return 0.0
	}

	switch rule.Actions.AdjustmentType {
	case pricing.AdjustmentTypePercentage:
		// Value represents the percentage discount directly
		return actionValue
	case pricing.AdjustmentTypeFixed:
		// Value represents a fixed monetary discount
		return actionValue
	case pricing.AdjustmentTypeMultiply:
		// Multiplier < 1.0 implies a discount; convert to percentage
		if actionValue < 1.0 {
			return (1.0 - actionValue) * 100
		}
		return 0.0
	case pricing.AdjustmentTypeOverride:
		// Override replaces the price; if NewPrice is set, compute savings
		if rule.Actions.NewPrice != nil && *rule.Actions.NewPrice < actionValue {
			return actionValue - *rule.Actions.NewPrice
		}
		return 0.0
	default:
		return actionValue
	}
}