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) {
	// This would update the carrier selection weights based on usage patterns
	// Implementation depends on the specific carrier selection algorithm
	csi.logger.Info("Updated carrier selection weights based on usage analytics")
}

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,
	}
}