litellm-rs 0.1.1

//! Advanced analytics and reporting system
//!
//! This module provides comprehensive analytics, cost optimization suggestions,
//! and detailed reporting capabilities.

use crate::storage::database::Database;
use crate::utils::error::{GatewayError, Result};
use chrono::{DateTime, Duration, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tracing::info;

/// Analytics engine for processing usage data and generating insights
pub struct AnalyticsEngine {
    /// Database connection
    database: Arc<Database>,
    /// Metrics collector
    metrics_collector: MetricsCollector,
    /// Cost optimizer
    cost_optimizer: CostOptimizer,
    /// Report generator
    report_generator: ReportGenerator,
}

/// Metrics collector for gathering usage statistics
#[derive(Debug, Clone)]
pub struct MetricsCollector {
    /// Request metrics
    request_metrics: HashMap<String, RequestMetrics>,
    /// Provider metrics
    provider_metrics: HashMap<String, ProviderMetrics>,
    /// User metrics
    user_metrics: HashMap<String, UserMetrics>,
    /// Cost metrics
    cost_metrics: CostMetrics,
}

/// Request metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RequestMetrics {
    /// Total requests
    pub total_requests: u64,
    /// Successful requests
    pub successful_requests: u64,
    /// Failed requests
    pub failed_requests: u64,
    /// Average response time
    pub avg_response_time_ms: f64,
    /// P95 response time
    pub p95_response_time_ms: f64,
    /// P99 response time
    pub p99_response_time_ms: f64,
    /// Total tokens processed
    pub total_tokens: u64,
    /// Total cost
    pub total_cost: f64,
    /// Time period
    pub period_start: DateTime<Utc>,
    /// End of analysis period
    pub period_end: DateTime<Utc>,
}

/// Provider-specific metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderMetrics {
    /// Provider name
    pub provider_name: String,
    /// Request count
    pub request_count: u64,
    /// Success rate
    pub success_rate: f64,
    /// Average latency
    pub avg_latency_ms: f64,
    /// Error rate
    pub error_rate: f64,
    /// Cost efficiency (tokens per dollar)
    pub cost_efficiency: f64,
    /// Uptime percentage
    pub uptime_percentage: f64,
    /// Rate limit hits
    pub rate_limit_hits: u64,
}

/// User-specific metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserMetrics {
    /// User ID
    pub user_id: String,
    /// Request count
    pub request_count: u64,
    /// Token usage
    pub token_usage: TokenUsage,
    /// Cost breakdown
    pub cost_breakdown: CostBreakdown,
    /// Most used models
    pub top_models: Vec<ModelUsage>,
    /// Usage patterns
    pub usage_patterns: UsagePatterns,
}

/// Token usage statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenUsage {
    /// Input tokens
    pub input_tokens: u64,
    /// Output tokens
    pub output_tokens: u64,
    /// Total tokens
    pub total_tokens: u64,
    /// Average tokens per request
    pub avg_tokens_per_request: f64,
}

/// Cost breakdown
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CostBreakdown {
    /// Total cost
    pub total_cost: f64,
    /// Cost by provider
    pub by_provider: HashMap<String, f64>,
    /// Cost by model
    pub by_model: HashMap<String, f64>,
    /// Cost by operation type
    pub by_operation: HashMap<String, f64>,
    /// Daily costs
    pub daily_costs: Vec<DailyCost>,
}

/// Daily cost information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DailyCost {
    /// Date
    pub date: DateTime<Utc>,
    /// Cost amount
    pub cost: f64,
    /// Request count
    pub requests: u64,
}

/// Model usage statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelUsage {
    /// Model name
    pub model: String,
    /// Request count
    pub requests: u64,
    /// Token count
    pub tokens: u64,
    /// Cost
    pub cost: f64,
    /// Success rate
    pub success_rate: f64,
}

/// Usage patterns analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UsagePatterns {
    /// Peak usage hours
    pub peak_hours: Vec<u8>,
    /// Usage by day of week
    pub usage_by_weekday: HashMap<String, u64>,
    /// Request size distribution
    pub request_size_distribution: RequestSizeDistribution,
    /// Seasonal trends
    pub seasonal_trends: Vec<SeasonalTrend>,
}

/// Request size distribution
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RequestSizeDistribution {
    /// Small requests (< 100 tokens)
    pub small: u64,
    /// Medium requests (100-1000 tokens)
    pub medium: u64,
    /// Large requests (1000-10000 tokens)
    pub large: u64,
    /// Extra large requests (> 10000 tokens)
    pub extra_large: u64,
}

/// Seasonal trend data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SeasonalTrend {
    /// Period (week, month, quarter)
    pub period: String,
    /// Start date
    pub start_date: DateTime<Utc>,
    /// End date
    pub end_date: DateTime<Utc>,
    /// Usage count
    pub usage: u64,
    /// Growth rate compared to previous period
    pub growth_rate: f64,
}

/// Overall cost metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CostMetrics {
    /// Total cost across all users
    pub total_cost: f64,
    /// Cost by time period
    pub cost_by_period: HashMap<String, f64>,
    /// Cost trends
    pub cost_trends: Vec<CostTrend>,
    /// Budget utilization
    pub budget_utilization: HashMap<String, BudgetUtilization>,
}

/// Cost trend information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CostTrend {
    /// Period
    pub period: DateTime<Utc>,
    /// Cost amount
    pub cost: f64,
    /// Change from previous period
    pub change_percentage: f64,
    /// Projected cost for next period
    pub projected_cost: f64,
}

/// Budget utilization tracking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BudgetUtilization {
    /// Budget limit
    pub budget_limit: f64,
    /// Current usage
    pub current_usage: f64,
    /// Utilization percentage
    pub utilization_percentage: f64,
    /// Projected end-of-period usage
    pub projected_usage: f64,
    /// Days remaining in period
    pub days_remaining: u32,
}

/// Cost optimization suggestions
pub struct CostOptimizer {
    /// Optimization rules
    optimization_rules: Vec<OptimizationRule>,
}

/// Optimization rule
#[derive(Debug, Clone)]
pub struct OptimizationRule {
    /// Rule name
    pub name: String,
    /// Rule description
    pub description: String,
    /// Potential savings
    pub potential_savings: f64,
    /// Implementation difficulty
    pub difficulty: OptimizationDifficulty,
    /// Rule type
    pub rule_type: OptimizationType,
}

/// Optimization difficulty levels
#[derive(Debug, Clone)]
pub enum OptimizationDifficulty {
    /// Easy to implement optimization
    Easy,
    /// Medium difficulty optimization
    Medium,
    /// Hard to implement optimization
    Hard,
}

/// Types of optimizations
#[derive(Debug, Clone)]
pub enum OptimizationType {
    /// Switch to cheaper provider
    ProviderSwitch,
    /// Use smaller model
    ModelDowngrade,
    /// Implement caching
    Caching,
    /// Batch requests
    Batching,
    /// Optimize prompts
    PromptOptimization,
    /// Use different pricing tier
    PricingTier,
}

/// Cost optimization suggestion
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationSuggestion {
    /// Suggestion title
    pub title: String,
    /// Description
    pub description: String,
    /// Potential monthly savings
    pub potential_savings: f64,
    /// Implementation effort
    pub effort: String,
    /// Priority level
    pub priority: u8,
    /// Specific recommendations
    pub recommendations: Vec<String>,
}

/// Report generator for creating detailed reports
pub struct ReportGenerator {
    /// Report templates
    templates: HashMap<String, ReportTemplate>,
}

/// Report template
#[derive(Debug, Clone)]
pub struct ReportTemplate {
    /// Template name
    pub name: String,
    /// Template description
    pub description: String,
    /// Report sections
    pub sections: Vec<ReportSection>,
    /// Output format
    pub format: ReportFormat,
}

/// Report section
#[derive(Debug, Clone)]
pub struct ReportSection {
    /// Section title
    pub title: String,
    /// Section type
    pub section_type: ReportSectionType,
    /// Data queries
    pub queries: Vec<String>,
}

/// Types of report sections
#[derive(Debug, Clone)]
pub enum ReportSectionType {
    /// Summary section
    Summary,
    /// Chart section
    Chart,
    /// Table section
    Table,
    /// Metrics section
    Metrics,
    /// Recommendations section
    Recommendations,
}

/// Report output formats
#[derive(Debug, Clone)]
pub enum ReportFormat {
    /// PDF format
    PDF,
    /// HTML format
    HTML,
    /// JSON format
    JSON,
    /// CSV format
    CSV,
    /// Excel format
    Excel,
}

/// Generated report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GeneratedReport {
    /// Report ID
    pub id: String,
    /// Report title
    pub title: String,
    /// Generation timestamp
    pub generated_at: DateTime<Utc>,
    /// Report period
    pub period_start: DateTime<Utc>,
    /// End of report period
    pub period_end: DateTime<Utc>,
    /// Report sections
    pub sections: Vec<ReportSectionData>,
    /// Summary statistics
    pub summary: ReportSummary,
}

/// Report section data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReportSectionData {
    /// Section title
    pub title: String,
    /// Section data
    pub data: serde_json::Value,
    /// Charts or visualizations
    pub charts: Vec<ChartData>,
}

/// Chart data for visualizations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChartData {
    /// Chart type
    pub chart_type: String,
    /// Chart title
    pub title: String,
    /// Data points
    pub data: Vec<DataPoint>,
    /// Chart configuration
    pub config: serde_json::Value,
}

/// Data point for charts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataPoint {
    /// X-axis value
    pub x: serde_json::Value,
    /// Y-axis value
    pub y: serde_json::Value,
    /// Additional metadata
    pub metadata: Option<serde_json::Value>,
}

/// Report summary
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReportSummary {
    /// Total requests
    pub total_requests: u64,
    /// Total cost
    pub total_cost: f64,
    /// Average response time
    pub avg_response_time: f64,
    /// Success rate
    pub success_rate: f64,
    /// Top insights
    pub key_insights: Vec<String>,
    /// Recommendations
    pub recommendations: Vec<String>,
}

impl AnalyticsEngine {
    /// Create a new analytics engine
    pub fn new(database: Arc<Database>) -> Self {
        Self {
            database,
            metrics_collector: MetricsCollector::new(),
            cost_optimizer: CostOptimizer::new(),
            report_generator: ReportGenerator::new(),
        }
    }

    /// Generate usage analytics for a user
    pub async fn generate_user_analytics(
        &self,
        user_id: &str,
        start_date: DateTime<Utc>,
        end_date: DateTime<Utc>,
    ) -> Result<UserMetrics> {
        info!("Generating analytics for user: {}", user_id);

        // Fetch usage data from database
        let usage_data = self
            .database
            .get_user_usage(user_id, start_date, end_date)
            .await?;

        // Process and analyze the data
        let metrics = self
            .metrics_collector
            .process_user_data(user_id, &usage_data)
            .await?;

        Ok(metrics)
    }

    /// Generate cost optimization suggestions
    pub async fn generate_cost_suggestions(
        &self,
        user_id: &str,
        period_days: u32,
    ) -> Result<Vec<OptimizationSuggestion>> {
        info!(
            "Generating cost optimization suggestions for user: {}",
            user_id
        );

        let end_date = Utc::now();
        let start_date = end_date - Duration::days(period_days as i64);

        // Get user metrics
        let metrics = self
            .generate_user_analytics(user_id, start_date, end_date)
            .await?;

        // Generate suggestions
        let suggestions = self.cost_optimizer.analyze_and_suggest(&metrics).await?;

        Ok(suggestions)
    }

    /// Generate comprehensive report
    pub async fn generate_report(
        &self,
        template_name: &str,
        user_id: Option<&str>,
        start_date: DateTime<Utc>,
        end_date: DateTime<Utc>,
    ) -> Result<GeneratedReport> {
        info!(
            "Generating report: {} for period {} to {}",
            template_name, start_date, end_date
        );

        let report = self
            .report_generator
            .generate(template_name, user_id, start_date, end_date, &self.database)
            .await?;

        Ok(report)
    }
}

impl MetricsCollector {
    /// Create a new metrics collector
    pub fn new() -> Self {
        Self {
            request_metrics: HashMap::new(),
            provider_metrics: HashMap::new(),
            user_metrics: HashMap::new(),
            cost_metrics: CostMetrics {
                total_cost: 0.0,
                cost_by_period: HashMap::new(),
                cost_trends: Vec::new(),
                budget_utilization: HashMap::new(),
            },
        }
    }

    /// Process user data and generate metrics
    pub async fn process_user_data(
        &self,
        user_id: &str,
        usage_data: &[serde_json::Value],
    ) -> Result<UserMetrics> {
        // Process the usage data and calculate metrics
        // This is a simplified implementation

        let request_count = usage_data.len() as u64;
        let total_tokens = usage_data
            .iter()
            .filter_map(|data| data.get("total_tokens")?.as_u64())
            .sum();

        let total_cost = usage_data
            .iter()
            .filter_map(|data| data.get("cost")?.as_f64())
            .sum();

        Ok(UserMetrics {
            user_id: user_id.to_string(),
            request_count,
            token_usage: TokenUsage {
                input_tokens: 0,  // Calculate from data
                output_tokens: 0, // Calculate from data
                total_tokens,
                avg_tokens_per_request: if request_count > 0 {
                    total_tokens as f64 / request_count as f64
                } else {
                    0.0
                },
            },
            cost_breakdown: CostBreakdown {
                total_cost,
                by_provider: HashMap::new(),  // Calculate from data
                by_model: HashMap::new(),     // Calculate from data
                by_operation: HashMap::new(), // Calculate from data
                daily_costs: Vec::new(),      // Calculate from data
            },
            top_models: Vec::new(), // Calculate from data
            usage_patterns: UsagePatterns {
                peak_hours: Vec::new(),           // Calculate from data
                usage_by_weekday: HashMap::new(), // Calculate from data
                request_size_distribution: RequestSizeDistribution {
                    small: 0,
                    medium: 0,
                    large: 0,
                    extra_large: 0,
                },
                seasonal_trends: Vec::new(),
            },
        })
    }
}

impl CostOptimizer {
    /// Create a new cost optimizer
    pub fn new() -> Self {
        Self {
            optimization_rules: Self::default_rules(),
        }
    }

    /// Analyze metrics and generate suggestions
    pub async fn analyze_and_suggest(
        &self,
        metrics: &UserMetrics,
    ) -> Result<Vec<OptimizationSuggestion>> {
        let mut suggestions = Vec::new();

        // Analyze cost patterns and generate suggestions
        if metrics.cost_breakdown.total_cost > 100.0 {
            suggestions.push(OptimizationSuggestion {
                title: "Consider Model Optimization".to_string(),
                description:
                    "Your usage patterns suggest potential savings through model optimization"
                        .to_string(),
                potential_savings: metrics.cost_breakdown.total_cost * 0.2,
                effort: "Medium".to_string(),
                priority: 8,
                recommendations: vec![
                    "Evaluate if smaller models can meet your needs".to_string(),
                    "Implement request caching for repeated queries".to_string(),
                ],
            });
        }

        Ok(suggestions)
    }

    /// Default optimization rules
    fn default_rules() -> Vec<OptimizationRule> {
        vec![
            OptimizationRule {
                name: "Provider Cost Comparison".to_string(),
                description: "Compare costs across different providers".to_string(),
                potential_savings: 0.3,
                difficulty: OptimizationDifficulty::Easy,
                rule_type: OptimizationType::ProviderSwitch,
            },
            OptimizationRule {
                name: "Model Right-sizing".to_string(),
                description: "Use appropriately sized models for tasks".to_string(),
                potential_savings: 0.4,
                difficulty: OptimizationDifficulty::Medium,
                rule_type: OptimizationType::ModelDowngrade,
            },
        ]
    }
}

impl ReportGenerator {
    /// Create a new report generator
    pub fn new() -> Self {
        Self {
            templates: Self::default_templates(),
        }
    }

    /// Generate a report
    pub async fn generate(
        &self,
        template_name: &str,
        _user_id: Option<&str>,
        start_date: DateTime<Utc>,
        end_date: DateTime<Utc>,
        _database: &Database,
    ) -> Result<GeneratedReport> {
        let template = self
            .templates
            .get(template_name)
            .ok_or_else(|| GatewayError::NotFound("Report template not found".to_string()))?;

        // Generate report sections
        let sections = Vec::new(); // Implement section generation

        Ok(GeneratedReport {
            id: uuid::Uuid::new_v4().to_string(),
            title: template.name.clone(),
            generated_at: Utc::now(),
            period_start: start_date,
            period_end: end_date,
            sections,
            summary: ReportSummary {
                total_requests: 0,
                total_cost: 0.0,
                avg_response_time: 0.0,
                success_rate: 0.0,
                key_insights: Vec::new(),
                recommendations: Vec::new(),
            },
        })
    }

    /// Default report templates
    fn default_templates() -> HashMap<String, ReportTemplate> {
        let mut templates = HashMap::new();

        templates.insert(
            "usage_summary".to_string(),
            ReportTemplate {
                name: "Usage Summary Report".to_string(),
                description: "Comprehensive usage and cost summary".to_string(),
                sections: vec![
                    ReportSection {
                        title: "Executive Summary".to_string(),
                        section_type: ReportSectionType::Summary,
                        queries: vec!["summary_stats".to_string()],
                    },
                    ReportSection {
                        title: "Cost Analysis".to_string(),
                        section_type: ReportSectionType::Chart,
                        queries: vec!["cost_trends".to_string()],
                    },
                ],
                format: ReportFormat::PDF,
            },
        );

        templates
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_metrics_collection() {
        let collector = MetricsCollector::new();
        let usage_data = vec![serde_json::json!({
            "total_tokens": 100,
            "cost": 0.01
        })];

        let metrics = collector
            .process_user_data("user123", &usage_data)
            .await
            .unwrap();
        assert_eq!(metrics.request_count, 1);
        assert_eq!(metrics.token_usage.total_tokens, 100);
    }

    #[test]
    fn test_cost_optimizer() {
        let optimizer = CostOptimizer::new();
        assert!(!optimizer.optimization_rules.is_empty());
    }
}