package handlers import ( "encoding/json" "net/http" "strings" "github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/smdp" "github.com/sirupsen/logrus" ) // SelectionHandler handles carrier selection API endpoints type SelectionHandler struct { manager *smdp.SMDPManager logger *logrus.Logger } // NewSelectionHandler creates a new selection handler func NewSelectionHandler(manager *smdp.SMDPManager) *SelectionHandler { logger := logrus.New() logger.SetLevel(logrus.InfoLevel) return &SelectionHandler{ manager: manager, logger: logger, } } // RegisterRoutes registers selection-related routes func (h *SelectionHandler) RegisterRoutes(mux *http.ServeMux) { // Carrier selection endpoints mux.HandleFunc("/api/v1/selection/optimal", h.SelectOptimalCarrier) mux.HandleFunc("/api/v1/selection/carrier", h.SelectCarrier) mux.HandleFunc("/api/v1/selection/history/", h.GetSelectionHistory) mux.HandleFunc("/api/v1/selection/learning", h.UpdateLearning) // Analytics endpoints mux.HandleFunc("/api/v1/selection/analytics/selection", h.GetSelectionAnalytics) mux.HandleFunc("/api/v1/selection/analytics/performance", h.GetPerformanceAnalytics) } // SelectOptimalCarrierRequest represents the request for optimal carrier selection type SelectOptimalCarrierRequest struct { Region string `json:"region"` ProfileType string `json:"profile_type"` Urgency string `json:"urgency"` CostSensitivity float64 `json:"cost_sensitivity"` PerformanceWeight float64 `json:"performance_weight"` ReliabilityWeight float64 `json:"reliability_weight"` } // SelectOptimalCarrierResponse represents the response for optimal carrier selection type SelectOptimalCarrierResponse struct { Success bool `json:"success"` CarrierScore *smdp.CarrierScore `json:"carrier_score,omitempty"` Error string `json:"error,omitempty"` } // SelectOptimalCarrier selects the optimal carrier based on criteria func (h *SelectionHandler) SelectOptimalCarrier(w http.ResponseWriter, r *http.Request) { var req SelectOptimalCarrierRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { h.writeErrorResponse(w, http.StatusBadRequest, "Invalid request body") return } // Validate request if req.Urgency == "" { req.Urgency = "medium" } if req.CostSensitivity < 0 || req.CostSensitivity > 1 { req.CostSensitivity = 0.5 } if req.PerformanceWeight < 0 || req.PerformanceWeight > 1 { req.PerformanceWeight = 0.4 } if req.ReliabilityWeight < 0 || req.ReliabilityWeight > 1 { req.ReliabilityWeight = 0.4 } criteria := &smdp.SelectionCriteria{ Region: req.Region, ProfileType: req.ProfileType, Urgency: req.Urgency, CostSensitivity: req.CostSensitivity, PerformanceWeight: req.PerformanceWeight, ReliabilityWeight: req.ReliabilityWeight, } score, err := h.manager.SelectOptimalCarrier(r.Context(), criteria) if err != nil { h.logger.WithError(err).Error("Failed to select optimal carrier") h.writeErrorResponse(w, http.StatusInternalServerError, err.Error()) return } response := SelectOptimalCarrierResponse{ Success: true, CarrierScore: score, } h.writeJSONResponse(w, http.StatusOK, response) } // SelectCarrierResponse represents the response for carrier selection type SelectCarrierResponse struct { Success bool `json:"success"` Carrier *smdp.Carrier `json:"carrier,omitempty"` Error string `json:"error,omitempty"` } // SelectCarrier selects a carrier using default criteria func (h *SelectionHandler) SelectCarrier(w http.ResponseWriter, r *http.Request) { carrier, err := h.manager.SelectCarrier(r.Context()) if err != nil { h.logger.WithError(err).Error("Failed to select carrier") h.writeErrorResponse(w, http.StatusInternalServerError, err.Error()) return } response := SelectCarrierResponse{ Success: true, Carrier: carrier, } h.writeJSONResponse(w, http.StatusOK, response) } // SelectionHistoryResponse represents the response for selection history type SelectionHistoryResponse struct { Success bool `json:"success"` History []smdp.CarrierScore `json:"history,omitempty"` Error string `json:"error,omitempty"` } // GetSelectionHistory returns the selection history for a carrier func (h *SelectionHandler) GetSelectionHistory(w http.ResponseWriter, r *http.Request) { // Extract carrier ID from URL path path := strings.TrimPrefix(r.URL.Path, "/api/v1/selection/history/") carrierID := strings.TrimSuffix(path, "/") if carrierID == "" { h.writeErrorResponse(w, http.StatusBadRequest, "Carrier ID is required") return } history := h.manager.GetSelectionHistory(carrierID) response := SelectionHistoryResponse{ Success: true, History: history, } h.writeJSONResponse(w, http.StatusOK, response) } // UpdateLearningRequest represents the request for updating learning type UpdateLearningRequest struct { CarrierID string `json:"carrier_id"` ActualPerformance float64 `json:"actual_performance"` } // UpdateLearningResponse represents the response for updating learning type UpdateLearningResponse struct { Success bool `json:"success"` Message string `json:"message,omitempty"` Error string `json:"error,omitempty"` } // UpdateLearning updates the selection algorithm with performance feedback func (h *SelectionHandler) UpdateLearning(w http.ResponseWriter, r *http.Request) { var req UpdateLearningRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { h.writeErrorResponse(w, http.StatusBadRequest, "Invalid request body") return } // Validate request if req.CarrierID == "" { h.writeErrorResponse(w, http.StatusBadRequest, "Carrier ID is required") return } if req.ActualPerformance < 0 || req.ActualPerformance > 100 { h.writeErrorResponse(w, http.StatusBadRequest, "Actual performance must be between 0 and 100") return } h.manager.UpdateLearning(req.CarrierID, req.ActualPerformance) response := UpdateLearningResponse{ Success: true, Message: "Learning updated successfully", } h.writeJSONResponse(w, http.StatusOK, response) } // SelectionAnalyticsResponse represents the response for selection analytics type SelectionAnalyticsResponse struct { Success bool `json:"success"` Analytics *SelectionAnalytics `json:"analytics,omitempty"` Error string `json:"error,omitempty"` } // SelectionAnalytics represents carrier selection analytics type SelectionAnalytics struct { TotalSelections int `json:"total_selections"` CarrierStats map[string]*CarrierStat `json:"carrier_stats"` AveragePerformance float64 `json:"average_performance"` TopPerformers []string `json:"top_performers"` SelectionTrends map[string]int `json:"selection_trends"` } // CarrierStat represents statistics for a carrier type CarrierStat struct { CarrierID string `json:"carrier_id"` SelectionCount int `json:"selection_count"` AverageScore float64 `json:"average_score"` SuccessRate float64 `json:"success_rate"` LastSelected string `json:"last_selected"` } // GetSelectionAnalytics returns selection analytics func (h *SelectionHandler) GetSelectionAnalytics(w http.ResponseWriter, r *http.Request) { // Get carrier status carriers := h.manager.GetCarrierStatus() analytics := &SelectionAnalytics{ TotalSelections: 0, CarrierStats: make(map[string]*CarrierStat), AveragePerformance: 0, TopPerformers: []string{}, SelectionTrends: make(map[string]int), } totalScore := 0.0 totalSelections := 0 for carrierID, carrier := range carriers { history := h.manager.GetSelectionHistory(carrierID) stat := &CarrierStat{ CarrierID: carrierID, SelectionCount: len(history), AverageScore: 0, SuccessRate: 0, LastSelected: "", } if len(history) > 0 { var scoreSum float64 for _, score := range history { scoreSum += score.TotalScore } stat.AverageScore = scoreSum / float64(len(history)) stat.LastSelected = history[len(history)-1].SelectedAt.Format("2006-01-02 15:04:05") // Calculate success rate from carrier metrics if carrier.Metrics.TotalRequests > 0 { stat.SuccessRate = float64(carrier.Metrics.SuccessfulRequests) / float64(carrier.Metrics.TotalRequests) * 100 } } analytics.CarrierStats[carrierID] = stat totalScore += stat.AverageScore totalSelections += stat.SelectionCount } analytics.TotalSelections = totalSelections if len(carriers) > 0 { analytics.AveragePerformance = totalScore / float64(len(carriers)) } response := SelectionAnalyticsResponse{ Success: true, Analytics: analytics, } h.writeJSONResponse(w, http.StatusOK, response) } // PerformanceAnalyticsResponse represents the response for performance analytics type PerformanceAnalyticsResponse struct { Success bool `json:"success"` Analytics *PerformanceAnalytics `json:"analytics,omitempty"` Error string `json:"error,omitempty"` } // PerformanceAnalytics represents performance analytics type PerformanceAnalytics struct { CarrierPerformance map[string]*PerformanceMetrics `json:"carrier_performance"` SystemHealth *SystemHealth `json:"system_health"` Recommendations []string `json:"recommendations"` } // PerformanceMetrics represents performance metrics for a carrier type PerformanceMetrics struct { CarrierID string `json:"carrier_id"` ResponseTime float64 `json:"response_time_ms"` SuccessRate float64 `json:"success_rate"` RequestRate float64 `json:"requests_per_second"` HealthScore float64 `json:"health_score"` Recommendation string `json:"recommendation"` } // SystemHealth represents overall system health type SystemHealth struct { HealthyCarriers int `json:"healthy_carriers"` DegradedCarriers int `json:"degraded_carriers"` UnhealthyCarriers int `json:"unhealthy_carriers"` OverallHealth float64 `json:"overall_health"` } // GetPerformanceAnalytics returns performance analytics func (h *SelectionHandler) GetPerformanceAnalytics(w http.ResponseWriter, r *http.Request) { carriers := h.manager.GetCarrierStatus() analytics := &PerformanceAnalytics{ CarrierPerformance: make(map[string]*PerformanceMetrics), SystemHealth: &SystemHealth{ HealthyCarriers: 0, DegradedCarriers: 0, UnhealthyCarriers: 0, OverallHealth: 0, }, Recommendations: []string{}, } for carrierID, carrier := range carriers { metrics := &PerformanceMetrics{ CarrierID: carrierID, ResponseTime: float64(carrier.Metrics.AverageResponseTime.Milliseconds()), SuccessRate: 0, RequestRate: carrier.Metrics.RequestRate, HealthScore: 0, Recommendation: "", } // Calculate success rate if carrier.Metrics.TotalRequests > 0 { metrics.SuccessRate = float64(carrier.Metrics.SuccessfulRequests) / float64(carrier.Metrics.TotalRequests) * 100 } // Calculate health score switch carrier.HealthStatus { case "healthy": analytics.SystemHealth.HealthyCarriers++ metrics.HealthScore = 100 case "degraded": analytics.SystemHealth.DegradedCarriers++ metrics.HealthScore = 50 default: analytics.SystemHealth.UnhealthyCarriers++ metrics.HealthScore = 0 } // Generate recommendations if metrics.SuccessRate < 95 { metrics.Recommendation = "Monitor success rate - below optimal threshold" } else if metrics.ResponseTime > 500 { metrics.Recommendation = "Consider optimizing response time" } else if metrics.HealthScore < 50 { metrics.Recommendation = "Carrier health degraded - investigate issues" } else { metrics.Recommendation = "Carrier performing well" } analytics.CarrierPerformance[carrierID] = metrics } // Calculate overall health totalCarriers := len(carriers) if totalCarriers > 0 { analytics.SystemHealth.OverallHealth = float64(analytics.SystemHealth.HealthyCarriers) / float64(totalCarriers) * 100 } // Generate system recommendations if analytics.SystemHealth.OverallHealth < 80 { analytics.Recommendations = append(analytics.Recommendations, "System health below optimal - investigate carrier issues") } if analytics.SystemHealth.UnhealthyCarriers > 0 { analytics.Recommendations = append(analytics.Recommendations, "Some carriers are unhealthy - consider failover") } response := PerformanceAnalyticsResponse{ Success: true, Analytics: analytics, } h.writeJSONResponse(w, http.StatusOK, response) } // Helper methods func (h *SelectionHandler) writeJSONResponse(w http.ResponseWriter, statusCode int, data interface{}) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(statusCode) json.NewEncoder(w).Encode(data) } func (h *SelectionHandler) writeErrorResponse(w http.ResponseWriter, statusCode int, message string) { response := struct { Success bool `json:"success"` Error string `json:"error"` }{ Success: false, Error: message, } h.writeJSONResponse(w, statusCode, response) }