foxhunt/tests/fixtures/builders.rs

//! Test Data Builders for Foxhunt HFT Trading System
//!
//! This module provides builder patterns for creating test data objects
//! with sensible defaults and fluent configuration APIs.
//!
//! ## Usage
//!
//! ```rust
//! use tests::fixtures::builders::{PortfolioBuilder, InstrumentBuilder, PositionBuilder};
//! use tests::fixtures::{TEST_EQUITY_1, TEST_PORTFOLIO_1};
//!
//! // Build a test portfolio
//! let portfolio = PortfolioBuilder::new()
//!     .with_id(TEST_PORTFOLIO_1)
//!     .with_name("Test Portfolio")
//!     .with_base_currency("USD")
//!     .build();
//!
//! // Build a test instrument
//! let instrument = InstrumentBuilder::new()
//!     .with_symbol(TEST_EQUITY_1)
//!     .with_name("Test Equity 1")
//!     .equity()
//!     .build();
//!
//! // Build a test position
//! let position = PositionBuilder::new()
//!     .with_portfolio_id(TEST_PORTFOLIO_1)
//!     .with_symbol(TEST_EQUITY_1)
//!     .with_quantity(Decimal::from(100))
//!     .with_price(Decimal::from(150))
//!     .build();
//! ```

use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
use serde_json::json;
use uuid::Uuid;

use risk_data::models::*;
use super::*;

// =============================================================================
// INSTRUMENT BUILDER
// =============================================================================

/// Builder for creating test Instrument objects
#[derive(Debug, Clone)]
pub struct InstrumentBuilder {
    id: Uuid,
    symbol: String,
    isin: Option<String>,
    cusip: Option<String>,
    bloomberg_id: Option<String>,
    reuters_id: Option<String>,
    name: String,
    instrument_type: InstrumentType,
    asset_class: AssetClass,
    sector: Option<MarketSector>,
    currency: String,
    exchange: Option<String>,
    tick_size: Option<Decimal>,
    lot_size: Option<Decimal>,
    multiplier: Option<Decimal>,
    maturity_date: Option<DateTime<Utc>>,
    strike_price: Option<Decimal>,
    option_type: Option<String>,
    underlying_symbol: Option<String>,
    is_active: bool,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
    metadata: serde_json::Value,
}

impl Default for InstrumentBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl InstrumentBuilder {
    pub fn new() -> Self {
        let now = Utc::now();
        Self {
            id: Uuid::new_v4(),
            symbol: TEST_EQUITY_1.to_string(),
            isin: None,
            cusip: None,
            bloomberg_id: None,
            reuters_id: None,
            name: "Test Instrument".to_string(),
            instrument_type: InstrumentType::Equity,
            asset_class: AssetClass::Equities,
            sector: Some(MarketSector::Technology),
            currency: "USD".to_string(),
            exchange: Some("TEST_EXCHANGE".to_string()),
            tick_size: Some(Decimal::new(1, 2)), // 0.01
            lot_size: Some(Decimal::from(1)),
            multiplier: Some(Decimal::from(1)),
            maturity_date: None,
            strike_price: None,
            option_type: None,
            underlying_symbol: None,
            is_active: true,
            created_at: now,
            updated_at: now,
            metadata: json!({"test_data": true}),
        }
    }

    pub fn with_id(mut self, id: Uuid) -> Self {
        self.id = id;
        self
    }

    pub fn with_symbol(mut self, symbol: impl Into<String>) -> Self {
        self.symbol = symbol.into();
        self
    }

    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = name.into();
        self
    }

    pub fn with_currency(mut self, currency: impl Into<String>) -> Self {
        self.currency = currency.into();
        self
    }

    pub fn with_exchange(mut self, exchange: impl Into<String>) -> Self {
        self.exchange = Some(exchange.into());
        self
    }

    pub fn with_sector(mut self, sector: MarketSector) -> Self {
        self.sector = Some(sector);
        self
    }

    pub fn with_tick_size(mut self, tick_size: Decimal) -> Self {
        self.tick_size = Some(tick_size);
        self
    }

    pub fn with_lot_size(mut self, lot_size: Decimal) -> Self {
        self.lot_size = Some(lot_size);
        self
    }

    pub fn with_multiplier(mut self, multiplier: Decimal) -> Self {
        self.multiplier = Some(multiplier);
        self
    }

    pub fn with_maturity_date(mut self, maturity_date: DateTime<Utc>) -> Self {
        self.maturity_date = Some(maturity_date);
        self
    }

    pub fn with_strike_price(mut self, strike_price: Decimal) -> Self {
        self.strike_price = Some(strike_price);
        self
    }

    pub fn with_option_type(mut self, option_type: impl Into<String>) -> Self {
        self.option_type = Some(option_type.into());
        self
    }

    pub fn with_underlying_symbol(mut self, underlying_symbol: impl Into<String>) -> Self {
        self.underlying_symbol = Some(underlying_symbol.into());
        self
    }

    pub fn inactive(mut self) -> Self {
        self.is_active = false;
        self
    }

    pub fn with_metadata(mut self, metadata: serde_json::Value) -> Self {
        self.metadata = metadata;
        self
    }

    // Asset class convenience methods
    pub fn equity(mut self) -> Self {
        self.instrument_type = InstrumentType::Equity;
        self.asset_class = AssetClass::Equities;
        self.sector = Some(MarketSector::Technology);
        self
    }

    pub fn bond(mut self) -> Self {
        self.instrument_type = InstrumentType::Bond;
        self.asset_class = AssetClass::FixedIncome;
        self.sector = Some(MarketSector::Government);
        self
    }

    pub fn currency(mut self) -> Self {
        self.instrument_type = InstrumentType::Currency;
        self.asset_class = AssetClass::Currencies;
        self.sector = None;
        self
    }

    pub fn future(mut self) -> Self {
        self.instrument_type = InstrumentType::Future;
        self.asset_class = AssetClass::Derivatives;
        self.sector = None;
        self
    }

    pub fn option(mut self) -> Self {
        self.instrument_type = InstrumentType::Option;
        self.asset_class = AssetClass::Derivatives;
        self.sector = None;
        self
    }

    pub fn commodity(mut self) -> Self {
        self.instrument_type = InstrumentType::Commodity;
        self.asset_class = AssetClass::Commodities;
        self.sector = Some(MarketSector::Materials);
        self
    }

    pub fn crypto(mut self) -> Self {
        self.instrument_type = InstrumentType::Crypto;
        self.asset_class = AssetClass::Alternatives;
        self.sector = None;
        self
    }

    pub fn build(self) -> Instrument {
        Instrument {
            id: self.id,
            symbol: self.symbol,
            isin: self.isin,
            cusip: self.cusip,
            bloomberg_id: self.bloomberg_id,
            reuters_id: self.reuters_id,
            name: self.name,
            instrument_type: self.instrument_type,
            asset_class: self.asset_class,
            sector: self.sector,
            currency: self.currency,
            exchange: self.exchange,
            tick_size: self.tick_size,
            lot_size: self.lot_size,
            multiplier: self.multiplier,
            maturity_date: self.maturity_date,
            strike_price: self.strike_price,
            option_type: self.option_type,
            underlying_symbol: self.underlying_symbol,
            is_active: self.is_active,
            created_at: self.created_at,
            updated_at: self.updated_at,
            metadata: self.metadata,
        }
    }
}

// =============================================================================
// PORTFOLIO BUILDER
// =============================================================================

/// Builder for creating test Portfolio objects
#[derive(Debug, Clone)]
pub struct PortfolioBuilder {
    id: String,
    name: String,
    description: Option<String>,
    base_currency: String,
    portfolio_type: String,
    inception_date: DateTime<Utc>,
    manager_id: String,
    benchmark: Option<String>,
    risk_budget: Option<Decimal>,
    var_limit: Option<Decimal>,
    max_drawdown_limit: Option<Decimal>,
    is_active: bool,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
    metadata: serde_json::Value,
}

impl Default for PortfolioBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl PortfolioBuilder {
    pub fn new() -> Self {
        let now = Utc::now();
        Self {
            id: TEST_PORTFOLIO_1.to_string(),
            name: "Test Portfolio".to_string(),
            description: Some("Test portfolio for automated testing".to_string()),
            base_currency: "USD".to_string(),
            portfolio_type: "Test".to_string(),
            inception_date: now,
            manager_id: "test_manager".to_string(),
            benchmark: Some("SPY".to_string()),
            risk_budget: Some(Decimal::new(15, 2)), // 0.15 (15%)
            var_limit: Some(Decimal::from(100000)),
            max_drawdown_limit: Some(Decimal::new(20, 2)), // 0.20 (20%)
            is_active: true,
            created_at: now,
            updated_at: now,
            metadata: json!({"test_data": true}),
        }
    }

    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.id = id.into();
        self
    }

    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = name.into();
        self
    }

    pub fn with_description(mut self, description: impl Into<String>) -> Self {
        self.description = Some(description.into());
        self
    }

    pub fn with_base_currency(mut self, currency: impl Into<String>) -> Self {
        self.base_currency = currency.into();
        self
    }

    pub fn with_portfolio_type(mut self, portfolio_type: impl Into<String>) -> Self {
        self.portfolio_type = portfolio_type.into();
        self
    }

    pub fn with_inception_date(mut self, date: DateTime<Utc>) -> Self {
        self.inception_date = date;
        self
    }

    pub fn with_manager_id(mut self, manager_id: impl Into<String>) -> Self {
        self.manager_id = manager_id.into();
        self
    }

    pub fn with_benchmark(mut self, benchmark: impl Into<String>) -> Self {
        self.benchmark = Some(benchmark.into());
        self
    }

    pub fn with_risk_budget(mut self, risk_budget: Decimal) -> Self {
        self.risk_budget = Some(risk_budget);
        self
    }

    pub fn with_var_limit(mut self, var_limit: Decimal) -> Self {
        self.var_limit = Some(var_limit);
        self
    }

    pub fn with_max_drawdown_limit(mut self, limit: Decimal) -> Self {
        self.max_drawdown_limit = Some(limit);
        self
    }

    pub fn inactive(mut self) -> Self {
        self.is_active = false;
        self
    }

    pub fn with_metadata(mut self, metadata: serde_json::Value) -> Self {
        self.metadata = metadata;
        self
    }

    // Portfolio type convenience methods
    pub fn strategy_portfolio(mut self) -> Self {
        self.portfolio_type = "Strategy".to_string();
        self
    }

    pub fn hedge_fund(mut self) -> Self {
        self.portfolio_type = "Hedge Fund".to_string();
        self
    }

    pub fn long_only(mut self) -> Self {
        self.portfolio_type = "Long Only".to_string();
        self
    }

    pub fn market_neutral(mut self) -> Self {
        self.portfolio_type = "Market Neutral".to_string();
        self
    }

    pub fn build(self) -> Portfolio {
        Portfolio {
            id: self.id,
            name: self.name,
            description: self.description,
            base_currency: self.base_currency,
            portfolio_type: self.portfolio_type,
            inception_date: self.inception_date,
            manager_id: self.manager_id,
            benchmark: self.benchmark,
            risk_budget: self.risk_budget,
            var_limit: self.var_limit,
            max_drawdown_limit: self.max_drawdown_limit,
            is_active: self.is_active,
            created_at: self.created_at,
            updated_at: self.updated_at,
            metadata: self.metadata,
        }
    }
}

// =============================================================================
// POSITION BUILDER
// =============================================================================

/// Builder for creating test Position objects
#[derive(Debug, Clone)]
pub struct PositionBuilder {
    id: Uuid,
    portfolio_id: String,
    symbol: String,
    quantity: Decimal,
    average_price: Decimal,
    market_price: Decimal,
    market_value: Decimal,
    unrealized_pnl: Decimal,
    currency: String,
    entry_date: DateTime<Utc>,
    last_updated: DateTime<Utc>,
    weight: Option<Decimal>,
    beta: Option<Decimal>,
    duration: Option<Decimal>,
    delta: Option<Decimal>,
    gamma: Option<Decimal>,
    vega: Option<Decimal>,
    theta: Option<Decimal>,
}

impl Default for PositionBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl PositionBuilder {
    pub fn new() -> Self {
        let now = Utc::now();
        let quantity = Decimal::from(100);
        let price = Decimal::from(100);
        let market_value = quantity * price;

        Self {
            id: Uuid::new_v4(),
            portfolio_id: TEST_PORTFOLIO_1.to_string(),
            symbol: TEST_EQUITY_1.to_string(),
            quantity,
            average_price: price,
            market_price: price,
            market_value,
            unrealized_pnl: Decimal::ZERO,
            currency: "USD".to_string(),
            entry_date: now,
            last_updated: now,
            weight: Some(Decimal::new(5, 2)), // 0.05 (5%)
            beta: Some(Decimal::new(12, 1)), // 1.2
            duration: None,
            delta: None,
            gamma: None,
            vega: None,
            theta: None,
        }
    }

    pub fn with_id(mut self, id: Uuid) -> Self {
        self.id = id;
        self
    }

    pub fn with_portfolio_id(mut self, portfolio_id: impl Into<String>) -> Self {
        self.portfolio_id = portfolio_id.into();
        self
    }

    pub fn with_symbol(mut self, symbol: impl Into<String>) -> Self {
        self.symbol = symbol.into();
        self
    }

    pub fn with_quantity(mut self, quantity: Decimal) -> Self {
        self.quantity = quantity;
        // Recalculate market value
        self.market_value = quantity * self.market_price;
        self.unrealized_pnl = (self.market_price - self.average_price) * quantity;
        self
    }

    pub fn with_average_price(mut self, price: Decimal) -> Self {
        self.average_price = price;
        // Recalculate unrealized PnL
        self.unrealized_pnl = (self.market_price - price) * self.quantity;
        self
    }

    pub fn with_market_price(mut self, price: Decimal) -> Self {
        self.market_price = price;
        // Recalculate market value and unrealized PnL
        self.market_value = self.quantity * price;
        self.unrealized_pnl = (price - self.average_price) * self.quantity;
        self
    }

    pub fn with_currency(mut self, currency: impl Into<String>) -> Self {
        self.currency = currency.into();
        self
    }

    pub fn with_entry_date(mut self, date: DateTime<Utc>) -> Self {
        self.entry_date = date;
        self
    }

    pub fn with_weight(mut self, weight: Decimal) -> Self {
        self.weight = Some(weight);
        self
    }

    pub fn with_beta(mut self, beta: Decimal) -> Self {
        self.beta = Some(beta);
        self
    }

    pub fn with_duration(mut self, duration: Decimal) -> Self {
        self.duration = Some(duration);
        self
    }

    pub fn with_greeks(mut self, delta: Decimal, gamma: Decimal, vega: Decimal, theta: Decimal) -> Self {
        self.delta = Some(delta);
        self.gamma = Some(gamma);
        self.vega = Some(vega);
        self.theta = Some(theta);
        self
    }

    // Position type convenience methods
    pub fn long_position(mut self, quantity: i64) -> Self {
        self.quantity = Decimal::from(quantity.abs());
        self.market_value = self.quantity * self.market_price;
        self.unrealized_pnl = (self.market_price - self.average_price) * self.quantity;
        self
    }

    pub fn short_position(mut self, quantity: i64) -> Self {
        self.quantity = Decimal::from(-quantity.abs());
        self.market_value = self.quantity * self.market_price;
        self.unrealized_pnl = (self.market_price - self.average_price) * self.quantity;
        self
    }

    pub fn profitable(mut self, profit_pct: f64) -> Self {
        let profit_multiplier = 1.0 + (profit_pct / 100.0);
        let new_market_price = self.average_price * Decimal::try_from(profit_multiplier).unwrap_or(Decimal::from(1));
        self.with_market_price(new_market_price)
    }

    pub fn losing(mut self, loss_pct: f64) -> Self {
        let loss_multiplier = 1.0 - (loss_pct / 100.0);
        let new_market_price = self.average_price * Decimal::try_from(loss_multiplier).unwrap_or(Decimal::from(1));
        self.with_market_price(new_market_price)
    }

    pub fn build(self) -> Position {
        Position {
            id: self.id,
            portfolio_id: self.portfolio_id,
            symbol: self.symbol,
            quantity: self.quantity,
            average_price: self.average_price,
            market_price: self.market_price,
            market_value: self.market_value,
            unrealized_pnl: self.unrealized_pnl,
            currency: self.currency,
            entry_date: self.entry_date,
            last_updated: self.last_updated,
            weight: self.weight,
            beta: self.beta,
            duration: self.duration,
            delta: self.delta,
            gamma: self.gamma,
            vega: self.vega,
            theta: self.theta,
        }
    }
}

// =============================================================================
// COUNTERPARTY BUILDER
// =============================================================================

/// Builder for creating test Counterparty objects
#[derive(Debug, Clone)]
pub struct CounterpartyBuilder {
    id: String,
    name: String,
    counterparty_type: String,
    country: String,
    credit_rating: Option<String>,
    lei_code: Option<String>,
    parent_company: Option<String>,
    is_active: bool,
    exposure_limit: Option<Decimal>,
    margin_requirement: Option<Decimal>,
    netting_agreement: bool,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
    metadata: serde_json::Value,
}

impl Default for CounterpartyBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl CounterpartyBuilder {
    pub fn new() -> Self {
        let now = Utc::now();
        Self {
            id: "TEST_COUNTERPARTY_001".to_string(),
            name: "Test Counterparty".to_string(),
            counterparty_type: "Bank".to_string(),
            country: "US".to_string(),
            credit_rating: Some("AA".to_string()),
            lei_code: None,
            parent_company: None,
            is_active: true,
            exposure_limit: Some(Decimal::from(10000000)), // $10M
            margin_requirement: Some(Decimal::new(5, 2)), // 5%
            netting_agreement: true,
            created_at: now,
            updated_at: now,
            metadata: json!({"test_data": true}),
        }
    }

    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.id = id.into();
        self
    }

    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = name.into();
        self
    }

    pub fn with_type(mut self, counterparty_type: impl Into<String>) -> Self {
        self.counterparty_type = counterparty_type.into();
        self
    }

    pub fn with_country(mut self, country: impl Into<String>) -> Self {
        self.country = country.into();
        self
    }

    pub fn with_credit_rating(mut self, rating: impl Into<String>) -> Self {
        self.credit_rating = Some(rating.into());
        self
    }

    pub fn with_exposure_limit(mut self, limit: Decimal) -> Self {
        self.exposure_limit = Some(limit);
        self
    }

    pub fn with_margin_requirement(mut self, margin: Decimal) -> Self {
        self.margin_requirement = Some(margin);
        self
    }

    pub fn without_netting_agreement(mut self) -> Self {
        self.netting_agreement = false;
        self
    }

    pub fn inactive(mut self) -> Self {
        self.is_active = false;
        self
    }

    // Counterparty type convenience methods
    pub fn bank(mut self) -> Self {
        self.counterparty_type = "Bank".to_string();
        self.credit_rating = Some("AA".to_string());
        self
    }

    pub fn broker(mut self) -> Self {
        self.counterparty_type = "Broker".to_string();
        self.credit_rating = Some("A".to_string());
        self
    }

    pub fn exchange(mut self) -> Self {
        self.counterparty_type = "Exchange".to_string();
        self.credit_rating = Some("AAA".to_string());
        self
    }

    pub fn hedge_fund(mut self) -> Self {
        self.counterparty_type = "Hedge Fund".to_string();
        self.credit_rating = Some("BBB".to_string());
        self
    }

    pub fn build(self) -> Counterparty {
        Counterparty {
            id: self.id,
            name: self.name,
            counterparty_type: self.counterparty_type,
            country: self.country,
            credit_rating: self.credit_rating,
            lei_code: self.lei_code,
            parent_company: self.parent_company,
            is_active: self.is_active,
            exposure_limit: self.exposure_limit,
            margin_requirement: self.margin_requirement,
            netting_agreement: self.netting_agreement,
            created_at: self.created_at,
            updated_at: self.updated_at,
            metadata: self.metadata,
        }
    }
}

// =============================================================================
// BATCH BUILDERS
// =============================================================================

/// Utility for building multiple test objects
pub struct BatchBuilder;

impl BatchBuilder {
    /// Create multiple test instruments with different asset classes
    pub fn create_diverse_instruments(count: usize) -> Vec<Instrument> {
        let asset_classes = [
            AssetClass::Equities,
            AssetClass::Currencies,
            AssetClass::FixedIncome,
            AssetClass::Derivatives,
            AssetClass::Commodities,
            AssetClass::Alternatives,
        ];

        (0..count)
            .map(|i| {
                let asset_class = asset_classes[i % asset_classes.len()];
                let symbol = generate_test_symbol(asset_class);
                
                let mut builder = InstrumentBuilder::new()
                    .with_symbol(&symbol)
                    .with_name(format!("Test Instrument {}", i + 1));

                builder = match asset_class {
                    AssetClass::Equities => builder.equity(),
                    AssetClass::Currencies => builder.currency(),
                    AssetClass::FixedIncome => builder.bond(),
                    AssetClass::Derivatives => builder.future(),
                    AssetClass::Commodities => builder.commodity(),
                    AssetClass::Alternatives => builder.crypto(),
                    AssetClass::Cash => builder.equity(), // Default to equity for cash
                };

                builder.build()
            })
            .collect()
    }

    /// Create multiple test portfolios
    pub fn create_test_portfolios(count: usize) -> Vec<Portfolio> {
        (0..count)
            .map(|i| {
                PortfolioBuilder::new()
                    .with_id(format!("TEST_PORTFOLIO_{:03}", i + 1))
                    .with_name(format!("Test Portfolio {}", i + 1))
                    .with_manager_id(format!("test_manager_{}", i + 1))
                    .build()
            })
            .collect()
    }

    /// Create multiple test positions for a portfolio
    pub fn create_test_positions(portfolio_id: &str, symbols: &[&str]) -> Vec<Position> {
        symbols
            .iter()
            .enumerate()
            .map(|(i, &symbol)| {
                let quantity = Decimal::from((i + 1) * 100);
                let price = Decimal::from(get_test_price_for_symbol(symbol));
                
                PositionBuilder::new()
                    .with_portfolio_id(portfolio_id)
                    .with_symbol(symbol)
                    .with_quantity(quantity)
                    .with_average_price(price)
                    .with_market_price(price)
                    .build()
            })
            .collect()
    }
}

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

    #[test]
    fn test_instrument_builder() {
        let instrument = InstrumentBuilder::new()
            .with_symbol("TEST_SYMBOL")
            .with_name("Test Name")
            .equity()
            .build();

        assert_eq!(instrument.symbol, "TEST_SYMBOL");
        assert_eq!(instrument.name, "Test Name");
        assert_eq!(instrument.instrument_type, InstrumentType::Equity);
        assert_eq!(instrument.asset_class, AssetClass::Equities);
        assert!(instrument.is_active);
    }

    #[test]
    fn test_portfolio_builder() {
        let portfolio = PortfolioBuilder::new()
            .with_id("TEST_PORT")
            .with_name("Test Portfolio")
            .strategy_portfolio()
            .build();

        assert_eq!(portfolio.id, "TEST_PORT");
        assert_eq!(portfolio.name, "Test Portfolio");
        assert_eq!(portfolio.portfolio_type, "Strategy");
        assert!(portfolio.is_active);
    }

    #[test]
    fn test_position_builder() {
        let position = PositionBuilder::new()
            .with_symbol("TEST")
            .long_position(500)
            .profitable(10.0)
            .build();

        assert_eq!(position.symbol, "TEST");
        assert_eq!(position.quantity, Decimal::from(500));
        assert!(position.unrealized_pnl > Decimal::ZERO);
    }

    #[test]
    fn test_batch_builder() {
        let instruments = BatchBuilder::create_diverse_instruments(6);
        assert_eq!(instruments.len(), 6);
        
        // Should have different asset classes
        let asset_classes: std::collections::HashSet<_> = instruments
            .iter()
            .map(|i| i.asset_class)
            .collect();
        assert!(asset_classes.len() > 1);
    }
}