foxhunt/examples/dual_provider_integration.rs

//! Dual-Provider Configuration Integration Example
//!
//! This example demonstrates how to integrate the enhanced configuration loader
//! with dual-provider support (Databento + Benzinga) into trading services.

use anyhow::Result;
use std::time::Duration;
use tokio::time::sleep;
use tracing::{error, info, warn};

// Import the enhanced configuration loader
use crate::enhanced_config_loader::{
    EnhancedPostgresConfigLoader, ProviderConfigValue, ProviderEndpoint, ProviderSubscription,
};

/// Example service that uses dual-provider configuration
pub struct DualProviderTradingService {
    config_loader: EnhancedPostgresConfigLoader,
    environment: String,
}

impl DualProviderTradingService {
    /// Create a new dual-provider trading service
    pub async fn new(database_url: &str, environment: &str) -> Result<Self> {
        let config_loader = EnhancedPostgresConfigLoader::new(
            database_url,
            Duration::from_secs(300), // 5-minute cache TTL
        )
        .await?;

        Ok(Self {
            config_loader,
            environment: environment.to_string(),
        })
    }

    /// Initialize provider configurations
    pub async fn initialize_providers(&self) -> Result<()> {
        info!("🔧 Initializing dual-provider configuration...");

        // Get active providers for this environment
        let active_providers = self
            .config_loader
            .get_active_providers(Some(&self.environment))
            .await?;

        info!(
            "📡 Active providers for {}: {:?}",
            self.environment, active_providers
        );

        // Initialize each active provider
        for provider in &active_providers {
            match provider.as_str() {
                "databento" => self.initialize_databento().await?,
                "benzinga" => self.initialize_benzinga().await?,
                _ => warn!("⚠️  Unknown provider: {}", provider),
            }
        }

        info!("✅ All providers initialized successfully");
        Ok(())
    }

    /// Initialize Databento provider
    async fn initialize_databento(&self) -> Result<()> {
        info!("🌊 Initializing Databento provider...");

        // Get Databento configuration
        let api_key = self
            .config_loader
            .get_databento_api_key(Some(&self.environment))
            .await?
            .unwrap_or_default();

        let dataset = self
            .config_loader
            .get_databento_dataset(Some(&self.environment))
            .await?
            .unwrap_or_else(|| "XNAS.ITCH".to_string());

        let symbols = self
            .config_loader
            .get_databento_symbols(Some(&self.environment))
            .await?
            .unwrap_or_else(|| {
                // Default symbols for example - in production, always use config
                vec!["SYMBOL1".to_string(), "SYMBOL2".to_string()]
            });

        let connection_timeout = self
            .config_loader
            .get_provider_connection_timeout("databento", Some(&self.environment))
            .await?
            .unwrap_or(30000);

        let rate_limit = self
            .config_loader
            .get_provider_rate_limit("databento", Some(&self.environment))
            .await?
            .unwrap_or(100);

        info!("📊 Databento Configuration:");
        info!(
            "   API Key: {} chars",
            if api_key.is_empty() { 0 } else { api_key.len() }
        );
        info!("   Dataset: {}", dataset);
        info!("   Symbols: {:?}", symbols);
        info!("   Connection Timeout: {}ms", connection_timeout);
        info!("   Rate Limit: {} req/sec", rate_limit);

        // Get Databento endpoints
        let endpoints = self
            .config_loader
            .get_provider_endpoints(Some("databento"), None, Some(&self.environment))
            .await?;

        info!("🌐 Databento Endpoints: {} configured", endpoints.len());
        for endpoint in &endpoints {
            info!(
                "   {} ({}): {} [{}]",
                endpoint.endpoint_type,
                endpoint.priority,
                endpoint.base_url,
                if endpoint.is_primary {
                    "PRIMARY"
                } else {
                    "SECONDARY"
                }
            );
        }

        // Get Databento subscriptions
        let subscriptions = self
            .config_loader
            .get_provider_subscriptions(Some("databento"), Some(&self.environment))
            .await?;

        info!("📡 Databento Subscriptions: {} active", subscriptions.len());
        for sub in &subscriptions {
            info!(
                "   {}: {} ({})",
                sub.subscription_type,
                sub.dataset,
                sub.symbols
                    .as_ref()
                    .map_or("All".to_string(), |s| format!("{} symbols", s.len()))
            );
        }

        info!("✅ Databento provider initialized");
        Ok(())
    }

    /// Initialize Benzinga provider
    async fn initialize_benzinga(&self) -> Result<()> {
        info!("📰 Initializing Benzinga provider...");

        // Get Benzinga configuration
        let api_key = self
            .config_loader
            .get_benzinga_api_key(Some(&self.environment))
            .await?
            .unwrap_or_default();

        let subscription_tier = self
            .config_loader
            .get_benzinga_subscription_tier(Some(&self.environment))
            .await?
            .unwrap_or_else(|| "basic".to_string());

        let connection_timeout = self
            .config_loader
            .get_provider_connection_timeout("benzinga", Some(&self.environment))
            .await?
            .unwrap_or(30000);

        let rate_limit = self
            .config_loader
            .get_provider_rate_limit("benzinga", Some(&self.environment))
            .await?
            .unwrap_or(1000);

        // Get additional Benzinga settings
        let enable_news = self
            .config_loader
            .get_provider_config::<bool>("benzinga", "enable_news_feed", Some(&self.environment))
            .await?
            .unwrap_or(true);

        let enable_analyst_ratings = self
            .config_loader
            .get_provider_config::<bool>(
                "benzinga",
                "enable_analyst_ratings",
                Some(&self.environment),
            )
            .await?
            .unwrap_or(true);

        let news_categories = self
            .config_loader
            .get_provider_config::<Vec<String>>(
                "benzinga",
                "news_categories",
                Some(&self.environment),
            )
            .await?
            .unwrap_or_else(|| vec!["earnings".to_string()]);

        info!("📊 Benzinga Configuration:");
        info!(
            "   API Key: {} chars",
            if api_key.is_empty() { 0 } else { api_key.len() }
        );
        info!("   Subscription Tier: {}", subscription_tier);
        info!("   Connection Timeout: {}ms", connection_timeout);
        info!("   Rate Limit: {} req/min", rate_limit);
        info!("   News Feed: {}", if enable_news { "✅" } else { "❌" });
        info!(
            "   Analyst Ratings: {}",
            if enable_analyst_ratings { "✅" } else { "❌" }
        );
        info!("   News Categories: {:?}", news_categories);

        // Get Benzinga endpoints
        let endpoints = self
            .config_loader
            .get_provider_endpoints(Some("benzinga"), None, Some(&self.environment))
            .await?;

        info!("🌐 Benzinga Endpoints: {} configured", endpoints.len());
        for endpoint in &endpoints {
            info!(
                "   {} ({}): {} [{}]",
                endpoint.endpoint_type,
                endpoint.priority,
                endpoint.base_url,
                if endpoint.is_primary {
                    "PRIMARY"
                } else {
                    "SECONDARY"
                }
            );
        }

        // Get Benzinga subscriptions
        let subscriptions = self
            .config_loader
            .get_provider_subscriptions(Some("benzinga"), Some(&self.environment))
            .await?;

        info!("📡 Benzinga Subscriptions: {} active", subscriptions.len());
        for sub in &subscriptions {
            info!(
                "   {}: {} ({})",
                sub.subscription_type,
                sub.dataset,
                sub.symbols
                    .as_ref()
                    .map_or("All".to_string(), |s| format!("{} symbols", s.len()))
            );
        }

        info!("✅ Benzinga provider initialized");
        Ok(())
    }

    /// Start hot-reload configuration monitoring
    pub async fn start_config_monitoring(&self) -> Result<()> {
        info!("🔥 Starting configuration hot-reload monitoring...");

        let mut change_receiver = self.config_loader.subscribe_to_changes().await?;

        tokio::spawn(async move {
            while let Some((channel, payload)) = change_receiver.recv().await {
                info!("🔄 Configuration change received on channel: {}", channel);

                // Parse the notification payload
                if let Ok(change_data) = serde_json::from_str::<serde_json::Value>(&payload) {
                    if let (Some(table), Some(operation)) = (
                        change_data.get("table").and_then(|t| t.as_str()),
                        change_data.get("operation").and_then(|o| o.as_str()),
                    ) {
                        info!("   Table: {}, Operation: {}", table, operation);

                        // Handle provider configuration changes
                        if table.starts_with("provider_") {
                            if let Some(provider) =
                                change_data.get("provider").and_then(|p| p.as_str())
                            {
                                info!("   Provider: {}", provider);

                                match table {
                                    "provider_configurations" => {
                                        if let Some(config_key) =
                                            change_data.get("config_key").and_then(|k| k.as_str())
                                        {
                                            info!("   Config Key: {}", config_key);
                                            // Handle specific configuration changes
                                            handle_provider_config_change(
                                                provider, config_key, operation,
                                            )
                                            .await;
                                        }
                                    }
                                    "provider_subscriptions" => {
                                        if let Some(sub_type) = change_data
                                            .get("subscription_type")
                                            .and_then(|s| s.as_str())
                                        {
                                            info!("   Subscription Type: {}", sub_type);
                                            // Handle subscription changes
                                            handle_provider_subscription_change(
                                                provider, sub_type, operation,
                                            )
                                            .await;
                                        }
                                    }
                                    "provider_endpoints" => {
                                        if let Some(endpoint_type) = change_data
                                            .get("endpoint_type")
                                            .and_then(|e| e.as_str())
                                        {
                                            info!("   Endpoint Type: {}", endpoint_type);
                                            // Handle endpoint changes
                                            handle_provider_endpoint_change(
                                                provider,
                                                endpoint_type,
                                                operation,
                                            )
                                            .await;
                                        }
                                    }
                                    _ => info!("   Unknown provider table: {}", table),
                                }
                            }
                        }
                    }
                } else {
                    warn!(
                        "⚠️  Failed to parse configuration change payload: {}",
                        payload
                    );
                }
            }

            error!("❌ Configuration monitoring stopped unexpectedly");
        });

        info!("✅ Configuration hot-reload monitoring started");
        Ok(())
    }

    /// Update provider configuration at runtime
    pub async fn update_provider_config<T: serde::Serialize>(
        &self,
        provider: &str,
        key: &str,
        value: &T,
        description: Option<&str>,
    ) -> Result<()> {
        info!("🔧 Updating provider configuration: {}.{}", provider, key);

        self.config_loader
            .set_provider_config(provider, key, value, Some(&self.environment), description)
            .await?;

        info!("✅ Provider configuration updated successfully");
        Ok(())
    }

    /// Get cache statistics
    pub async fn get_cache_stats(&self) -> (usize, usize) {
        self.config_loader.cache_stats().await
    }

    /// Clear configuration cache
    pub async fn clear_cache(&self) {
        self.config_loader.clear_cache().await;
    }
}

/// Handle provider configuration changes
async fn handle_provider_config_change(provider: &str, config_key: &str, operation: &str) {
    info!(
        "🔄 Handling {} configuration change: {}.{}",
        operation, provider, config_key
    );

    match (provider, config_key) {
        ("databento", "api_key") => {
            info!("   🔑 Databento API key changed - reconnection required");
            // Trigger Databento reconnection
        }
        ("databento", "dataset") => {
            info!("   📊 Databento dataset changed - subscription update required");
            // Update Databento subscription
        }
        ("benzinga", "api_key") => {
            info!("   🔑 Benzinga API key changed - reconnection required");
            // Trigger Benzinga reconnection
        }
        ("benzinga", "subscription_tier") => {
            info!("   🎯 Benzinga subscription tier changed - feature update required");
            // Update Benzinga features
        }
        (_, "connection_timeout_ms") => {
            info!(
                "   ⏱️  Connection timeout changed for {} - applying new timeout",
                provider
            );
            // Update connection timeouts
        }
        _ => {
            info!("   ℹ️  General configuration change for {}", provider);
        }
    }
}

/// Handle provider subscription changes
async fn handle_provider_subscription_change(
    provider: &str,
    subscription_type: &str,
    operation: &str,
) {
    info!(
        "🔄 Handling {} subscription change: {}.{}",
        operation, provider, subscription_type
    );

    match operation {
        "INSERT" => {
            info!("   ➕ New subscription added - starting data stream");
            // Start new data stream
        }
        "UPDATE" => {
            info!("   🔄 Subscription updated - reconfiguring data stream");
            // Reconfigure existing stream
        }
        "DELETE" => {
            info!("   ➖ Subscription removed - stopping data stream");
            // Stop data stream
        }
        _ => {
            info!("   ℹ️  Unknown subscription operation: {}", operation);
        }
    }
}

/// Handle provider endpoint changes
async fn handle_provider_endpoint_change(provider: &str, endpoint_type: &str, operation: &str) {
    info!(
        "🔄 Handling {} endpoint change: {}.{}",
        operation, provider, endpoint_type
    );

    match operation {
        "INSERT" => {
            info!("   ➕ New endpoint added - updating connection pool");
            // Add new endpoint to pool
        }
        "UPDATE" => {
            info!("   🔄 Endpoint updated - reconfiguring connections");
            // Update existing connections
        }
        "DELETE" => {
            info!("   ➖ Endpoint removed - removing from pool");
            // Remove from connection pool
        }
        _ => {
            info!("   ℹ️  Unknown endpoint operation: {}", operation);
        }
    }
}

/// Example usage of the dual-provider trading service
pub async fn example_usage() -> Result<()> {
    // Initialize the service
    let database_url = std::env::var("DATABASE_URL")
        .unwrap_or_else(|_| "postgresql://localhost/foxhunt".to_string());
    let environment = std::env::var("ENVIRONMENT").unwrap_or_else(|_| "development".to_string());

    let service = DualProviderTradingService::new(&database_url, &environment).await?;

    // Initialize providers
    service.initialize_providers().await?;

    // Start configuration monitoring
    service.start_config_monitoring().await?;

    // Example: Update a configuration at runtime
    service
        .update_provider_config(
            "databento",
            "connection_timeout_ms",
            &45000u32,
            Some("Increased timeout for better reliability"),
        )
        .await?;

    // Get cache statistics
    let (total_entries, expired_entries) = service.get_cache_stats().await;
    info!(
        "📊 Cache Statistics: {} total, {} expired",
        total_entries, expired_entries
    );

    // Keep the service running
    info!("🚀 Dual-provider service running with hot-reload support...");
    loop {
        sleep(Duration::from_secs(60)).await;

        // Periodic health check
        let active_providers = service
            .config_loader
            .get_active_providers(Some(&environment))
            .await?;
        info!("💓 Health check - Active providers: {:?}", active_providers);
    }
}

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

    #[tokio::test]
    async fn test_dual_provider_service_creation() {
        // This test would require a database connection
        // In practice, you would use a test database

        let database_url = "postgresql://localhost/foxhunt_test";
        let result = DualProviderTradingService::new(database_url, "test").await;

        // This will fail without a database, but demonstrates the API
        assert!(result.is_err() || result.is_ok());
    }
}