foxhunt/services/backtesting_service/src/main.rs

#![warn(missing_docs)]
#![deny(clippy::unwrap_used)]
#![deny(clippy::expect_used)]

//! # Foxhunt Backtesting Service
//!
//! Standalone backtesting service for the Foxhunt HFT trading system.
//! This service provides comprehensive strategy testing and performance analysis capabilities.

use anyhow::{Context, Result};
use std::net::SocketAddr;
use tonic::transport::Server;
use tracing::{error, info, warn};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod performance;
mod repositories;
mod repository_impl;
mod service;
mod storage;
mod strategy_engine;

// Import the generated gRPC code
mod foxhunt {
    pub mod tli {
        tonic::include_proto!("foxhunt.tli");
    }
}

use config::{ConfigManager, DatabaseConfig, VaultConfig, BacktestingDatabaseConfig};
use model_loader::{BacktestCacheConfig, BacktestingModelCache};
use repository_impl::create_repositories;
use service::BacktestingServiceImpl;
use std::sync::Arc;
use storage::StorageManager;

/// Main entry point for the backtesting service
#[tokio::main]
async fn main() -> Result<()> {
    // Initialize logging
    init_logging()?;

    info!("Starting Foxhunt Backtesting Service");

    // Load configuration using central config manager
    let config_manager = ConfigManager::from_env()
        .await
        .context("Failed to initialize ConfigManager")?;

    // Get database configuration from central config
    let database_config = BacktestingDatabaseConfig::default();

    // Configuration loaded from central config manager
    info!("Configuration loaded from centralized config system");

    info!("Backtesting configuration loaded from central config manager");

    info!("Configuration loaded successfully");

    // Initialize storage manager
    let storage_manager = Arc::new(
        StorageManager::new(&database_config)
            .await
            .context("Failed to initialize storage manager")?,
    );

    // Initialize model cache for backtesting with shared directory
    let cache_config = BacktestCacheConfig {
        cache_dir: std::env::var("MODEL_CACHE_DIR")
            .unwrap_or_else(|_| "/tmp/foxhunt/model_cache".to_string())
            .into(),
        ..Default::default()
    };

    let mut model_cache = BacktestingModelCache::new(cache_config)
        .await
        .context("Failed to create BacktestingModelCache for backtesting")?;

    // Initialize model cache - this will scan for existing models
    model_cache
        .initialize()
        .await
        .context("Failed to initialize ModelCache")?;

    let model_cache = Arc::new(model_cache);
    info!("Backtesting model cache initialized with historical version support");

    // Create repositories with dependency injection
    let repositories = Arc::new(
        create_repositories(storage_manager)
            .await
            .context("Failed to create repositories")?,
    );

    // Initialize the service with repository injection and model cache
    let service = BacktestingServiceImpl::new(repositories, Some(Arc::clone(&model_cache)))
        .await
        .context("Failed to initialize backtesting service")?;

    // Setup gRPC server
    let grpc_port = std::env::var("GRPC_PORT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(50052);
    let addr: SocketAddr = format!("0.0.0.0:{}", grpc_port)
        .parse()
        .context("Invalid server address in configuration")?;

    info!("Starting gRPC server on {}", addr);

    // Start the server
    Server::builder()
        .add_service(
            foxhunt::tli::backtesting_service_server::BacktestingServiceServer::new(service),
        )
        .serve(addr)
        .await
        .context("gRPC server failed")?;

    Ok(())
}

/// Initialize logging with structured output
fn init_logging() -> Result<()> {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "backtesting_service=info,tower=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .try_init()
        .context("Failed to initialize logging")?;

    Ok(())
}