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

package services

import (
	"context"
	"fmt"
	"time"

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

// PricingService implements the pricing business logic
type PricingService struct {
	repository pricing.Repository
	engine     pricing.RuleEngine
	validator  pricing.PricingValidator
	logger     *logrus.Logger
}

// NewPricingService creates a new pricing service
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,
	}
}

// CreateRule creates a new pricing rule
func (s *PricingService) CreateRule(ctx context.Context, rule *pricing.PricingRule) (*pricing.PricingRule, error) {
	// Validate rule
	if err := s.validator.ValidateRule(ctx, rule); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	// Create rule
	if err := s.repository.CreateRule(ctx, rule); err != nil {
		s.logger.WithError(err).Error("Failed to create pricing rule")
		return nil, fmt.Errorf("failed to create rule: %w", err)
	}

	s.logger.WithFields(logrus.Fields{
		"rule_id":   rule.ID,
		"tenant_id": rule.TenantID,
		"type":      rule.Type,
	}).Info("Pricing rule created successfully")

	return rule, nil
}

// GetRule retrieves a pricing rule by ID
func (s *PricingService) GetRule(ctx context.Context, id string) (*pricing.PricingRule, error) {
	rule, err := s.repository.GetRule(ctx, id)
	if err != nil {
		s.logger.WithError(err).WithField("rule_id", id).Error("Failed to get pricing rule")
		return nil, err
	}

	return rule, nil
}

// UpdateRule updates an existing pricing rule
func (s *PricingService) UpdateRule(ctx context.Context, id string, rule *pricing.PricingRule) (*pricing.PricingRule, error) {
	// Validate rule
	if err := s.validator.ValidateRule(ctx, rule); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	// Update rule
	if err := s.repository.UpdateRule(ctx, rule); err != nil {
		s.logger.WithError(err).WithField("rule_id", id).Error("Failed to update pricing rule")
		return nil, fmt.Errorf("failed to update rule: %w", err)
	}

	s.logger.WithFields(logrus.Fields{
		"rule_id":   rule.ID,
		"tenant_id": rule.TenantID,
		"type":      rule.Type,
	}).Info("Pricing rule updated successfully")

	return rule, nil
}

// DeleteRule deletes a pricing rule
func (s *PricingService) DeleteRule(ctx context.Context, id string) error {
	// Get rule for logging
	rule, err := s.repository.GetRule(ctx, id)
	if err != nil {
		return err
	}

	// Delete rule
	if err := s.repository.DeleteRule(ctx, id); err != nil {
		s.logger.WithError(err).WithField("rule_id", id).Error("Failed to delete pricing rule")
		return fmt.Errorf("failed to delete rule: %w", err)
	}

	s.logger.WithFields(logrus.Fields{
		"rule_id":   rule.ID,
		"tenant_id": rule.TenantID,
		"type":      rule.Type,
	}).Info("Pricing rule deleted successfully")

	return nil
}

// ListRules lists pricing rules with filtering
func (s *PricingService) ListRules(ctx context.Context, filter *pricing.PricingFilter) ([]*pricing.PricingRule, error) {
	rules, err := s.repository.ListRules(ctx, filter)
	if err != nil {
		s.logger.WithError(err).Error("Failed to list pricing rules")
		return nil, fmt.Errorf("failed to list rules: %w", err)
	}

	return rules, nil
}

// CalculatePrice calculates the final price based on active rules
func (s *PricingService) CalculatePrice(ctx context.Context, pricingCtx *pricing.PricingContext) (*pricing.PricingResult, error) {
	// Validate context
	if err := s.validator.ValidateContext(ctx, pricingCtx); err != nil {
		return nil, fmt.Errorf("invalid pricing context: %w", err)
	}

	// Get active rules for tenant
	rules, err := s.repository.GetActiveRules(ctx, pricingCtx.TenantID)
	if err != nil {
		s.logger.WithError(err).WithField("tenant_id", pricingCtx.TenantID).Error("Failed to get active rules")
		return nil, fmt.Errorf("failed to get active rules: %w", err)
	}

	// Apply rules to calculate final price
	result, err := s.ApplyRules(ctx, pricingCtx, rules)
	if err != nil {
		return nil, err
	}

	s.logger.WithFields(logrus.Fields{
		"tenant_id":      pricingCtx.TenantID,
		"product_id":     pricingCtx.ProductID,
		"original_price": result.OriginalPrice,
		"final_price":    result.FinalPrice,
		"rules_applied":  len(result.AppliedRules),
	}).Info("Price calculated successfully")

	return result, nil
}

// ApplyRules applies specific rules to a pricing context
func (s *PricingService) ApplyRules(ctx context.Context, pricingCtx *pricing.PricingContext, rules []*pricing.PricingRule) (*pricing.PricingResult, error) {
	result := &pricing.PricingResult{
		OriginalPrice: pricingCtx.BasePrice,
		AdjustedPrice: pricingCtx.BasePrice,
		FinalPrice:    pricingCtx.BasePrice,
		Currency:      pricingCtx.Currency,
		AppliedRules:  make([]pricing.AppliedRule, 0),
		Metadata:      make(map[string]any),
	}

	currentPrice := pricingCtx.BasePrice

	// Apply rules in priority order
	for _, rule := range rules {
		shouldApply, err := s.engine.EvaluateRule(ctx, rule, pricingCtx)
		if err != nil {
			s.logger.WithError(err).WithField("rule_id", rule.ID).Error("Failed to evaluate rule")
			continue
		}

		if shouldApply {
			adjustedPrice, err := s.engine.ApplyRule(ctx, rule, pricingCtx, currentPrice)
			if err != nil {
				s.logger.WithError(err).WithField("rule_id", rule.ID).Error("Failed to apply rule")
				continue
			}

			// Calculate discount amount
			discount := currentPrice - adjustedPrice

			// Update result
			currentPrice = adjustedPrice
			result.AppliedRules = append(result.AppliedRules, pricing.AppliedRule{
				RuleID:     rule.ID,
				RuleName:   rule.Name,
				Type:       string(rule.Type),
				Adjustment: discount,
			})

			s.logger.WithFields(logrus.Fields{
				"rule_id":    rule.ID,
				"rule_name":  rule.Name,
				"adjustment": discount,
				"new_price":  adjustedPrice,
			}).Debug("Rule applied")
		}
	}

	// Finalize result
	result.FinalPrice = currentPrice
	result.Discount = result.OriginalPrice - result.FinalPrice

	return result, nil
}

// 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: s.getCurrentTime(),
	}

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

	// TODO: Calculate actual usage statistics from pricing history
	// For now, return placeholder data
	analytics.DiscountStats = pricing.DiscountStatistics{
		TotalDiscounts:     0,
		AverageDiscount:    0.0,
		LargestDiscount:    0.0,
		SmallestDiscount:   0.0,
		TotalDiscountValue: 0.0,
	}

	return analytics, nil
}

func (s *PricingService) getCurrentTime() time.Time {
	return time.Now()
}