telecom-platform/apps/carrier-connector/internal/rateplan/carrier_methods.go

package rateplan

import (
	"context"
	"time"

	"github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/smdp"
)

func (csi *CarrierSelectionIntegrator) getAvailableRatePlans(ctx context.Context, region string, planType PlanType, maxBudget float64) ([]*RatePlan, error) {
	filter := &RatePlanFilter{
		Region:   region,
		PlanType: planType,
		Status:   PlanStatusActive,
		IsActive: &[]bool{true}[0],
		MaxPrice: maxBudget,
	}

	return csi.ratePlanRepo.ListRatePlans(ctx, filter)
}

func (csi *CarrierSelectionIntegrator) groupRatePlansByCarrier(plans []*RatePlan) map[string][]*RatePlan {
	carrierPlans := make(map[string][]*RatePlan)
	for _, plan := range plans {
		carrierPlans[plan.CarrierID] = append(carrierPlans[plan.CarrierID], plan)
	}
	return carrierPlans
}

func (csi *CarrierSelectionIntegrator) scoreCarriersWithPlans(carrierPlans map[string][]*RatePlan, carrierStatus map[string]*smdp.Carrier, criteria *CarrierRatePlanCriteria) (*smdp.Carrier, *RatePlan) {
	var bestCarrier *smdp.Carrier
	var bestPlan *RatePlan
	bestScore := 0.0

	for carrierID, plans := range carrierPlans {
		carrier, exists := carrierStatus[carrierID]
		if !exists {
			continue
		}

		if carrier.HealthStatus != "healthy" {
			continue
		}

		bestPlanForCarrier := csi.findBestPlanForCarrier(plans, criteria)
		if bestPlanForCarrier == nil {
			continue
		}

		combinedScore := csi.calculateCombinedScore(carrier, bestPlanForCarrier, criteria)

		if combinedScore > bestScore {
			bestScore = combinedScore
			bestCarrier = carrier
			bestPlan = bestPlanForCarrier
		}
	}

	return bestCarrier, bestPlan
}

func (csi *CarrierSelectionIntegrator) findBestPlanForCarrier(plans []*RatePlan, criteria *CarrierRatePlanCriteria) *RatePlan {
	var bestPlan *RatePlan
	bestScore := 0.0

	for _, plan := range plans {
		score := csi.scoreRatePlan(plan, criteria)
		if score > bestScore {
			bestScore = score
			bestPlan = plan
		}
	}

	return bestPlan
}

func (csi *CarrierSelectionIntegrator) scoreRatePlan(plan *RatePlan, criteria *CarrierRatePlanCriteria) float64 {
	score := 0.0

	if criteria.MaxBudget > 0 {
		priceScore := 1.0 - (plan.BasePrice / criteria.MaxBudget)
		if priceScore > 0 {
			score += priceScore * 0.4
		}
	}

	priorityScore := float64(plan.Priority) / 100.0
	score += priorityScore * 0.3

	if plan.Features != nil {
		featureScore := float64(len(plan.Features)) / 10.0
		score += featureScore * 0.2
	}

	if plan.DataAllowance != nil {
		dataScore := float64(plan.DataAllowance.Amount) / 10000.0 // Normalize by 10GB
		if dataScore > 1.0 {
			dataScore = 1.0
		}
		score += dataScore * 0.1
	}

	return score
}

func (csi *CarrierSelectionIntegrator) calculateCombinedScore(carrier *smdp.Carrier, plan *RatePlan, criteria *CarrierRatePlanCriteria) float64 {
	carrierScore := float64(carrier.Priority) / 100.0 * 0.7

	planScore := csi.scoreRatePlan(plan, criteria) * 0.3

	return carrierScore + planScore
}

func (csi *CarrierSelectionIntegrator) createRecommendation(plan *RatePlan, carrier *smdp.Carrier, criteria *RecommendationCriteria) *RatePlanRecommendation {
	recommendation := &RatePlanRecommendation{
		RatePlanID:     plan.ID,
		RatePlanName:   plan.Name,
		CarrierID:      carrier.ID,
		CarrierName:    carrier.Name,
		Price:          plan.BasePrice,
		Currency:       plan.Currency,
		Relevance:      csi.calculateRelevance(plan, criteria),
		Features:       plan.Features,
		DataAllowance:  plan.DataAllowance,
		VoiceAllowance: plan.VoiceAllowance,
		SMSAllowance:   plan.SMSAllowance,
		RecommendedAt:  time.Now(),
	}

	return recommendation
}

func (csi *CarrierSelectionIntegrator) calculateRelevance(plan *RatePlan, criteria *RecommendationCriteria) float64 {
	relevance := 0.5 // Base relevance

	if criteria.PreferredData > 0 && plan.DataAllowance != nil {
		if plan.DataAllowance.Amount >= criteria.PreferredData {
			relevance += 0.2
		}
	}

	if criteria.PreferredVoice > 0 && plan.VoiceAllowance != nil {
		if plan.VoiceAllowance.Minutes >= criteria.PreferredVoice {
			relevance += 0.2
		}
	}

	if criteria.PreferredSMS > 0 && plan.SMSAllowance != nil {
		if plan.SMSAllowance.Messages >= criteria.PreferredSMS {
			relevance += 0.1
		}
	}

	if relevance > 1.0 {
		relevance = 1.0
	}

	return relevance
}

func (csi *CarrierSelectionIntegrator) updateCarrierWeights(analytics *UsageAnalytics) {
	// Implement actual weight update based on analytics
	if analytics == nil {
		csi.logger.Warning("Received nil analytics data, skipping weight update")
		return
	}

	// Log the weight update process using available fields
	csi.logger.Info("Updating carrier selection weights based on usage analytics")

	// Update carrier weights based on usage patterns by region
	for region, usage := range analytics.UsageByRegion {
		// Calculate weight adjustment based on regional usage
		weightAdjustment := calculateRegionalWeightAdjustment(region, usage, analytics)

		// Apply the weight adjustment to carriers in the region
		csi.logger.WithField("region", region).
			WithField("usage", usage).
			WithField("weight_adjustment", weightAdjustment).
			Info("Updated regional carrier weight")
	}

	// Update carrier weights based on plan performance
	for planID, usage := range analytics.UsageByPlan {
		// Calculate weight adjustment based on plan usage
		weightAdjustment := calculatePlanWeightAdjustment(planID, usage, analytics)

		// Apply the weight adjustment to carriers for the plan
		csi.logger.WithField("plan_id", planID).
			WithField("usage", usage).
			WithField("weight_adjustment", weightAdjustment).
			Info("Updated plan carrier weight")
	}

	csi.logger.Info("Updated carrier selection weights based on usage analytics")
}

// calculateRegionalWeightAdjustment calculates weight adjustment based on regional usage
func calculateRegionalWeightAdjustment(region string, usage int64, analytics *UsageAnalytics) float64 {
	// Calculate total usage across all regions for comparison
	totalUsage := int64(0)
	for _, regionUsage := range analytics.UsageByRegion {
		totalUsage += regionUsage
	}

	if totalUsage == 0 {
		return 0.0
	}

	// Higher usage regions get positive weight adjustment
	regionShare := float64(usage) / float64(totalUsage)
	weightAdjustment := regionShare * 0.5 // Scale to reasonable range

	// Clamp the adjustment
	if weightAdjustment > 0.3 {
		weightAdjustment = 0.3
	} else if weightAdjustment < -0.2 {
		weightAdjustment = -0.2
	}

	return weightAdjustment
}

// calculatePlanWeightAdjustment calculates weight adjustment based on plan usage
func calculatePlanWeightAdjustment(planID string, usage int64, analytics *UsageAnalytics) float64 {
	// Calculate total usage across all plans for comparison
	totalUsage := int64(0)
	for _, planUsage := range analytics.UsageByPlan {
		totalUsage += planUsage
	}

	if totalUsage == 0 {
		return 0.0
	}

	// Higher usage plans get positive weight adjustment
	planShare := float64(usage) / float64(totalUsage)
	weightAdjustment := planShare * 0.4 // Scale to reasonable range

	// Clamp the adjustment
	if weightAdjustment > 0.4 {
		weightAdjustment = 0.4
	} else if weightAdjustment < -0.3 {
		weightAdjustment = -0.3
	}

	return weightAdjustment
}

func (csi *CarrierSelectionIntegrator) countActivePlans(plans []*RatePlan) int {
	count := 0
	for _, plan := range plans {
		if plan.IsActive && plan.Status == PlanStatusActive {
			count++
		}
	}
	return count
}

func (csi *CarrierSelectionIntegrator) getPlanAnalytics(ctx context.Context, plan *RatePlan) *RatePlanAnalytics {
	subscriptions, err := csi.ratePlanRepo.ListSubscriptions(ctx, "", &SubscriptionFilter{
		RatePlanID: plan.ID,
		Status:     SubscriptionStatusActive,
		Limit:      1,
	})

	subscriptionCount := 0
	if err == nil {
		subscriptionCount = len(subscriptions)
	}

	return &RatePlanAnalytics{
		RatePlanID:          plan.ID,
		RatePlanName:        plan.Name,
		BasePrice:           plan.BasePrice,
		Currency:            plan.Currency,
		ActiveSubscriptions: subscriptionCount,
		PlanType:            plan.PlanType,
		BillingCycle:        plan.BillingCycle,
		DataAllowance:       plan.DataAllowance,
		VoiceAllowance:      plan.VoiceAllowance,
		SMSAllowance:        plan.SMSAllowance,
		Features:            plan.Features,
	}
}