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

package services

import (
	"context"
	"fmt"
	"time"

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

// GetTenantMetrics retrieves tenant metrics
func (s *TenantServiceImpl) GetTenantMetrics(ctx context.Context, tenantID string) (*tenant.TenantMetrics, error) {
	// Get usage stats
	usageStats, err := s.GetUsageStats(ctx, tenantID)
	if err != nil {
		return nil, fmt.Errorf("failed to get usage stats: %w", err)
	}

	// Get recent events
	events, err := s.repository.ListEvents(ctx, tenantID, 100)
	if err != nil {
		return nil, fmt.Errorf("failed to get tenant events: %w", err)
	}

	// Calculate metrics
	metrics := &tenant.TenantMetrics{
		TenantID:     tenantID,
		ActiveUsers:  usageStats.ActiveUsers,
		StorageUsed:  0, // Would be calculated from actual storage usage
		HealthScore:  100.0,
		Alerts:       []string{},
	}

	// Calculate last activity
	if len(events) > 0 {
		metrics.LastActivity = events[0].Timestamp
	}

	// Calculate error rate and response time from events
	errorCount := 0
	totalRequests := 0
	var totalResponseTime time.Duration

	for _, event := range events {
		if event.EventType == "api_request" {
			totalRequests++
			if statusCode, exists := event.EventData["status_code"]; exists {
				if code, ok := statusCode.(float64); ok && code >= 400 {
					errorCount++
				}
			}
			if responseTime, exists := event.EventData["response_time"]; exists {
				if rt, ok := responseTime.(float64); ok {
					totalResponseTime += time.Duration(rt) * time.Millisecond
				}
			}
		}
	}

	if totalRequests > 0 {
		metrics.ErrorRate = float64(errorCount) / float64(totalRequests) * 100
		metrics.ResponseTime = float64(totalResponseTime) / float64(totalRequests) / float64(time.Millisecond)
	}

	// Check for alerts
	for resourceType, quotaStatus := range usageStats.QuotaStatus {
		if quotaStatus.Critical {
			metrics.Alerts = append(metrics.Alerts, fmt.Sprintf("Critical: %s quota at %.1f%%", resourceType, quotaStatus.Percent))
			metrics.HealthScore -= 20
		} else if quotaStatus.Warning {
			metrics.Alerts = append(metrics.Alerts, fmt.Sprintf("Warning: %s quota at %.1f%%", resourceType, quotaStatus.Percent))
			metrics.HealthScore -= 10
		}
	}

	return metrics, nil
}

// GetTenantEvents retrieves tenant events
func (s *TenantServiceImpl) GetTenantEvents(ctx context.Context, tenantID string, limit int) ([]*tenant.TenantEvent, error) {
	events, err := s.repository.ListEvents(ctx, tenantID, limit)
	if err != nil {
		return nil, fmt.Errorf("failed to get tenant events: %w", err)
	}

	return events, nil
}

// LogTenantEvent logs a tenant event
func (s *TenantServiceImpl) LogTenantEvent(ctx context.Context, event *tenant.TenantEvent) error {
	if err := s.repository.CreateEvent(ctx, event); err != nil {
		return fmt.Errorf("failed to create tenant event: %w", err)
	}

	return nil
}

// GetTenantDashboard returns dashboard data for a tenant
func (s *TenantServiceImpl) GetTenantDashboard(ctx context.Context, tenantID string) (*tenant.TenantDashboard, error) {
	// TODO: Implement proper dashboard when type conversion issues are resolved
	// For now, return a basic dashboard
	dashboard := &tenant.TenantDashboard{
		TenantID:     tenantID,
		UsageStats:   nil,
		Metrics:      nil,
		RecentEvents: nil,
		QuotaStatus:  nil,
		LastUpdated:  time.Now(),
	}

	return dashboard, nil
}

// GetUsageAnalytics returns detailed usage analytics for a tenant
func (s *TenantServiceImpl) GetUsageAnalytics(ctx context.Context, tenantID string, timeRange string) (*tenant.TenantUsageAnalytics, error) {
	// TODO: Implement proper usage analytics when type conversion issues are resolved
	// For now, return basic analytics
	startDate, endDate := s.parseTimeRange(timeRange)
	
	analytics := &tenant.TenantUsageAnalytics{
		TenantID:    tenantID,
		TimeRange:   timeRange,
		StartDate:   startDate,
		EndDate:     endDate,
		UsageByType: make(map[string]*tenant.ResourceUsageAnalytics),
		Trends:      make(map[string][]*tenant.UsageTrend),
		Peaks:       make(map[string]*tenant.UsagePeak),
	}

	return analytics, nil
}

// GetPerformanceAnalytics returns performance analytics for a tenant
func (s *TenantServiceImpl) GetPerformanceAnalytics(ctx context.Context, tenantID string, timeRange string) (*tenant.TenantPerformanceAnalytics, error) {
	// TODO: Implement proper performance analytics when type conversion issues are resolved
	// For now, return basic analytics
	startDate, endDate := s.parseTimeRange(timeRange)
	
	analytics := &tenant.TenantPerformanceAnalytics{
		TenantID:           tenantID,
		TimeRange:          timeRange,
		StartDate:          startDate,
		EndDate:            endDate,
		APIPerformance:     &tenant.APIPerformance{},
		ResourcePerformance: make(map[string]*tenant.ResourcePerformance),
		Errors:             []*tenant.ErrorEvent{},
		SlowQueries:        []*tenant.SlowQuery{},
	}

	return analytics, nil
}

// Helper functions
func (s *TenantServiceImpl) parseTimeRange(timeRange string) (time.Time, time.Time) {
	now := time.Now()

	switch timeRange {
	case "1h":
		return now.Add(-1 * time.Hour), now
	case "24h":
		return now.Add(-24 * time.Hour), now
	case "7d":
		return now.Add(-7 * 24 * time.Hour), now
	case "30d":
		return now.Add(-30 * 24 * time.Hour), now
	case "90d":
		return now.Add(-90 * 24 * time.Hour), now
	default:
		return now.Add(-24 * time.Hour), now
	}
}

func (s *TenantServiceImpl) parseAPIRequestEvent(event *tenant.TenantEvent) *tenant.APIRequestEvent {
	// Implementation depends on event structure
	return &tenant.APIRequestEvent{
		Timestamp:    event.Timestamp,
		Endpoint:     "",
		Method:       "",
		StatusCode:   200,
		ResponseTime: 0,
		UserID:       event.UserID,
	}
}

func (s *TenantServiceImpl) parseErrorEvent(event *tenant.TenantEvent) *tenant.ErrorEvent {
	// Implementation depends on event structure
	return &tenant.ErrorEvent{
		Timestamp: event.Timestamp,
		Error:     "",
		Context:   event.EventData,
		UserID:    event.UserID,
	}
}

func (s *TenantServiceImpl) parseSlowQueryEvent(event *tenant.TenantEvent) *tenant.SlowQuery {
	// Implementation depends on event structure
	return &tenant.SlowQuery{
		Timestamp: event.Timestamp,
		Query:     "",
		Duration:  0,
		Context:   event.EventData,
	}
}

func (s *TenantServiceImpl) calculateAPIPerformance(requests []*tenant.APIRequestEvent) *tenant.APIPerformance {
	// Implementation would calculate performance metrics
	return &tenant.APIPerformance{
		TotalRequests:       len(requests),
		AverageResponseTime: 0,
		P95ResponseTime:     0,
		ErrorRate:           0,
		RequestsPerSecond:   0,
	}
}