mudra_cli/api/

exchange_service.rs

//! Enhanced exchange rate service with caching and historical data support

use crate::{
    CurrencyError, Result,
    api::{
        client::CurrencyClient,
        types::{
            ApiErrorResponse, ConversionResponse, ExchangeRateResponse,
            HistoricalConversionRequest, HistoricalRateResponse, SupportedCurrenciesResponse,
            is_valid_currency_code, is_valid_date_format,
        },
    },
    cache::{CacheKey, ExchangeRateCache},
};

/// Enhanced service for exchange rate operations with caching
#[derive(Debug, Clone)]
pub struct ExchangeRateService {
    client: CurrencyClient,
    cache: ExchangeRateCache,
}

impl ExchangeRateService {
    /// Create a new exchange rate service with caching
    pub fn new(client: CurrencyClient) -> Self {
        Self {
            client,
            cache: ExchangeRateCache::new(),
        }
    }

    /// Create a service from environment variables
    pub fn from_env() -> Result<Self> {
        let client = CurrencyClient::from_env()?;
        Ok(Self::new(client))
    }

    /// Create a service with custom cache configuration
    pub fn with_cache_config(
        client: CurrencyClient,
        cache_config: crate::cache::CacheConfig,
    ) -> Self {
        Self {
            client,
            cache: ExchangeRateCache::with_config(cache_config),
        }
    }

    /// Fetch latest exchange rates for a base currency (with caching)
    pub async fn get_latest_rates(&self, base_currency: &str) -> Result<ExchangeRateResponse> {
        // Validate currency code format
        self.validate_currency_code(base_currency)?;

        let cache_key = CacheKey::latest(base_currency);

        // Try cache first
        if let Some(cached_rates) = self.cache.get(&cache_key).await {
            return Ok(cached_rates);
        }

        // Cache miss - fetch from API

        // Get API key for the request
        let api_key = self.get_api_key()?;

        // Build endpoint URL
        let endpoint = format!("{}/latest/{}", api_key, base_currency.to_uppercase());

        // Make the API request
        match self.client.get::<ExchangeRateResponse>(&endpoint).await {
            Ok(response) => {
                if response.is_success() {
                    // Cache the response
                    self.cache.put(cache_key, response.clone()).await;
                    Ok(response)
                } else {
                    Err(CurrencyError::api(format!(
                        "API returned unsuccessful result: {}",
                        response.result
                    )))
                }
            }
            Err(e) => {
                // Try to parse as an error response for better error messages
                if let Ok(error_response) = self.try_parse_error_response(&endpoint).await {
                    return Err(CurrencyError::api(format!(
                        "API error: {} - {}",
                        error_response.error_type,
                        error_response.extra_info.unwrap_or_default()
                    )));
                }
                Err(e)
            }
        }
    }

    /// Fetch historical exchange rates for a specific date
    pub async fn get_historical_rates(
        &self,
        base_currency: &str,
        date: &str,
    ) -> Result<HistoricalRateResponse> {
        // Validate inputs
        self.validate_currency_code(base_currency)?;
        self.validate_date_format(date)?;

        let cache_key = CacheKey::historical(base_currency, date);

        // Try cache first - convert standard response to historical if cached
        if let Some(cached_rates) = self.cache.get(&cache_key).await {
            println!(
                "📋 Using cached historical rates for {} on {}",
                base_currency.to_uppercase(),
                date
            );
            return Ok(cached_rates.to_historical(date));
        }

        // Cache miss - fetch from API
        println!(
            "📊 Fetching historical rates for {} on {}",
            base_currency.to_uppercase(),
            date
        );

        let api_key = self.get_api_key()?;
        let endpoint = format!(
            "history/{}/{}/{}",
            api_key,
            base_currency.to_uppercase(),
            date
        );

        // Try to fetch as historical response, fallback to standard response
        match self.client.get::<HistoricalRateResponse>(&endpoint).await {
            Ok(response) => {
                if response.is_success() {
                    println!("✅ Successfully fetched historical rates for {}", date);

                    // Cache as standard response
                    let standard_response = response.to_standard();
                    self.cache.put(cache_key, standard_response).await;

                    Ok(response)
                } else {
                    Err(CurrencyError::api(format!(
                        "Historical data request failed: {}",
                        response.result
                    )))
                }
            }
            Err(_) => {
                // Fallback: try to get current rates and convert to historical format
                match self.get_latest_rates(base_currency).await {
                    Ok(current_rates) => {
                        println!("⚠️ Using current rates as historical fallback for {}", date);
                        Ok(current_rates.to_historical(date))
                    }
                    Err(e) => Err(e),
                }
            }
        }
    }

    /// Convert currency with historical data support
    pub async fn convert_historical(
        &self,
        request: HistoricalConversionRequest,
    ) -> Result<ConversionResponse> {
        // Validate inputs
        self.validate_currency_code(&request.from)?;
        self.validate_currency_code(&request.to)?;
        self.validate_amount(request.amount)?;
        self.validate_date_format(&request.date)?;

        println!(
            "💱 Historical conversion: {} {} to {} on {}",
            request.amount,
            request.from.to_uppercase(),
            request.to.to_uppercase(),
            request.date
        );

        // Get historical rates for the base currency
        let rates = self
            .get_historical_rates(&request.from, &request.date)
            .await?;

        // Find the target currency rate
        let rate = rates.get_rate(&request.to.to_uppercase()).ok_or_else(|| {
            CurrencyError::api(format!(
                "Historical rate not available for {} on {}",
                request.to.to_uppercase(),
                request.date
            ))
        })?;

        let converted_amount = request.amount * rate;

        println!(
            "✅ Historical conversion: {} {} = {:.6} {} (rate: {:.6})",
            request.amount,
            request.from.to_uppercase(),
            converted_amount,
            request.to.to_uppercase(),
            rate
        );

        Ok(ConversionResponse {
            result: "success".to_string(),
            base_code: request.from.to_uppercase(),
            target_code: request.to.to_uppercase(),
            conversion_rate: rate,
            conversion_result: converted_amount,
        })
    }

    /// Convert a specific amount between two currencies (current rates)
    pub async fn convert_currency(
        &self,
        from: &str,
        to: &str,
        amount: f64,
    ) -> Result<ConversionResponse> {
        // Validate inputs
        self.validate_currency_code(from)?;
        self.validate_currency_code(to)?;
        self.validate_amount(amount)?;

        let api_key = self.get_api_key()?;

        // Build endpoint URL for pair conversion
        let endpoint = format!(
            "pair/{}/{}/{}/{}",
            api_key,
            from.to_uppercase(),
            to.to_uppercase(),
            amount
        );

        println!(
            "💱 Converting {} {} to {}",
            amount,
            from.to_uppercase(),
            to.to_uppercase()
        );

        // Make the API request
        match self.client.get::<ConversionResponse>(&endpoint).await {
            Ok(response) => {
                if response.is_success() {
                    println!(
                        "✅ Conversion successful: {} {} = {} {}",
                        amount,
                        from.to_uppercase(),
                        response.conversion_result,
                        to.to_uppercase()
                    );
                    Ok(response)
                } else {
                    Err(CurrencyError::api(format!(
                        "Conversion failed: {}",
                        response.result
                    )))
                }
            }
            Err(e) => {
                if let Ok(error_response) = self.try_parse_error_response(&endpoint).await {
                    return Err(CurrencyError::api(format!(
                        "Conversion error: {} - {}",
                        error_response.error_type,
                        error_response.extra_info.unwrap_or_default()
                    )));
                }
                Err(e)
            }
        }
    }

    /// Get list of supported currencies (cached)
    pub async fn get_supported_currencies(&self) -> Result<SupportedCurrenciesResponse> {
        let api_key = self.get_api_key()?;
        let endpoint = format!("codes/{}", api_key);

        println!("📋 Fetching supported currencies");

        let response = self
            .client
            .get::<SupportedCurrenciesResponse>(&endpoint)
            .await?;

        if response.result == "success" {
            println!(
                "✅ Found {} supported currencies",
                response.supported_codes.len()
            );
            Ok(response)
        } else {
            Err(CurrencyError::api(format!(
                "Failed to fetch supported currencies: {}",
                response.result
            )))
        }
    }

    /// Check if a currency is supported by fetching a small set of rates
    pub async fn is_currency_supported(&self, currency: &str) -> Result<bool> {
        match self.get_latest_rates(currency).await {
            Ok(_) => Ok(true),
            Err(CurrencyError::Api { message }) if message.contains("unsupported-code") => {
                Ok(false)
            }
            Err(e) => Err(e),
        }
    }

    /// Batch convert multiple currency pairs efficiently
    pub async fn batch_convert(
        &self,
        base_currency: &str,
        target_currencies: &[String],
        amount: f64,
    ) -> Result<Vec<Result<ConversionResponse>>> {
        // Get rates for the base currency once
        let rates = self.get_latest_rates(base_currency).await?;

        println!(
            "🔄 Batch converting {} {} to {} currencies",
            amount,
            base_currency.to_uppercase(),
            target_currencies.len()
        );

        let mut results = Vec::new();

        for target in target_currencies {
            let result = if let Some(rate) = rates.get_rate(&target.to_uppercase()) {
                let converted_amount = amount * rate;
                Ok(ConversionResponse {
                    result: "success".to_string(),
                    base_code: base_currency.to_uppercase(),
                    target_code: target.to_uppercase(),
                    conversion_rate: rate,
                    conversion_result: converted_amount,
                })
            } else {
                Err(CurrencyError::api(format!(
                    "Exchange rate not available for {}",
                    target.to_uppercase()
                )))
            };
            results.push(result);
        }

        println!("✅ Completed batch conversion");
        Ok(results)
    }

    /// Get cache statistics
    pub fn get_cache_stats(&self) -> crate::cache::CacheStats {
        self.cache.get_stats()
    }

    /// Clear cache manually
    pub async fn clear_cache(&self) {
        self.cache.clear().await;
        println!("🗑️ Cache cleared");
    }

    /// Force cache cleanup of expired entries
    pub async fn cleanup_cache(&self) {
        self.cache.cleanup_expired().await;
        println!("🧹 Cache cleanup completed");
    }

    /// Validate currency code format
    fn validate_currency_code(&self, code: &str) -> Result<()> {
        if !is_valid_currency_code(code) {
            return Err(CurrencyError::invalid_currency(format!(
                "{} (must be 3 uppercase letters, e.g., USD, EUR, GBP)",
                code
            )));
        }
        Ok(())
    }

    /// Validate date format (YYYY-MM-DD)
    fn validate_date_format(&self, date: &str) -> Result<()> {
        if !is_valid_date_format(date) {
            return Err(CurrencyError::conversion(format!(
                "Invalid date format: '{}'. Use YYYY-MM-DD format (e.g., 2024-01-15)",
                date
            )));
        }
        Ok(())
    }

    /// Validate amount for conversion
    fn validate_amount(&self, amount: f64) -> Result<()> {
        if amount <= 0.0 {
            return Err(CurrencyError::invalid_amount(amount));
        }
        if amount.is_nan() || amount.is_infinite() {
            return Err(CurrencyError::invalid_amount(amount));
        }
        // Reasonable upper limit to prevent abuse
        if amount > 1_000_000_000.0 {
            return Err(CurrencyError::invalid_amount(amount));
        }
        Ok(())
    }

    /// Get API key from client configuration
    fn get_api_key(&self) -> Result<String> {
        if !self.client.has_api_key() {
            return Err(CurrencyError::configuration(
                "API key required. Set EXCHANGE_API_KEY environment variable",
            ));
        }
        // For now, we'll assume the API key is available
        // In a real implementation, you'd extract it from the client
        std::env::var("EXCHANGE_API_KEY")
            .map_err(|_| CurrencyError::configuration("EXCHANGE_API_KEY not found"))
    }

    /// Try to parse an error response for better error messages
    async fn try_parse_error_response(&self, endpoint: &str) -> Result<ApiErrorResponse> {
        // This is a simplified approach - in practice you might want to
        // capture the original response body in the error
        self.client.get::<ApiErrorResponse>(endpoint).await
    }
}