//! Trading arena for multi-agent simulation.

use algoarena_shared::{AgentResult, MarketStats, TournamentConfig, TournamentResult};

use crate::AlgoArenaError;
use crate::agents::{TradingAgent, create_agent};
use crate::market::MarketSimulator;

/// Trading arena orchestrating multi-agent tournaments.
#[derive(Debug, Default)]
pub struct TradingArena {
    /// Current step.
    step: usize,
}

impl TradingArena {
    /// Create a new trading arena.
    #[must_use]
    pub fn new() -> Self {
        Self { step: 0 }
    }

    /// Run a tournament.
    pub fn run(&mut self, config: &TournamentConfig) -> Result<TournamentResult, AlgoArenaError> {
        let seed = config.seed.unwrap_or(42);
        let num_assets = config.assets.len();

        // Create market simulator
        let mut market =
            MarketSimulator::new(config.assets.clone(), config.transaction_cost_bps, seed);

        // Create agents
        let mut agents: Vec<Box<dyn TradingAgent>> = config
            .agents
            .iter()
            .map(|agent_config| create_agent(agent_config.clone(), num_assets))
            .collect();

        // Run simulation
        for step in 0..config.num_steps {
            self.step = step;

            // Advance market
            market.step();

            // Get market state
            let state = market.get_state();

            // Each agent observes and decides
            for agent in &mut agents {
                agent.observe(&state);
            }

            // Collect orders from all agents
            let mut all_orders = Vec::new();
            for agent in &agents {
                let orders = agent.decide(&state);
                all_orders.extend(orders);
            }

            // Execute orders and update agents
            for order in &all_orders {
                let execution = market.execute_order(order);

                // Find the agent and update it
                for agent in &mut agents {
                    if agent.id() == order.agent_id {
                        agent.update(&[execution.clone()]);
                        break;
                    }
                }
            }
        }

        // Calculate results
        let rankings = self.calculate_rankings(&agents, &config.agents);
        let price_paths = market.price_history().to_vec();
        let market_stats = self.calculate_market_stats(config, &price_paths);

        Ok(TournamentResult {
            config: config.clone(),
            rankings,
            price_paths,
            market_stats,
        })
    }

    /// Calculate agent rankings.
    fn calculate_rankings(
        &self,
        agents: &[Box<dyn TradingAgent>],
        configs: &[algoarena_shared::AgentConfig],
    ) -> Vec<AgentResult> {
        let mut results: Vec<AgentResult> = agents
            .iter()
            .map(|agent| {
                let state = agent.get_state();
                let config = configs.iter().find(|c| c.id == state.agent_id).unwrap();

                let initial_capital = config.initial_capital;
                let total_return =
                    (state.portfolio_value - initial_capital) / initial_capital * 100.0;

                let sharpe_ratio = self.calculate_sharpe(&state.pnl_history);
                let max_drawdown = self.calculate_max_drawdown(&state.pnl_history);
                let win_rate = self.calculate_win_rate(&state.pnl_history);

                AgentResult {
                    agent_id: state.agent_id,
                    agent_name: config.name.clone(),
                    strategy: config.strategy,
                    rank: 0, // Will be set after sorting
                    final_value: state.portfolio_value,
                    total_return,
                    sharpe_ratio,
                    max_drawdown,
                    win_rate,
                    trade_count: state.trade_count,
                    pnl_history: state.pnl_history,
                }
            })
            .collect();

        // Sort by total return (descending)
        results.sort_by(|a, b| {
            b.total_return
                .partial_cmp(&a.total_return)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        // Assign ranks
        for (i, result) in results.iter_mut().enumerate() {
            result.rank = i + 1;
        }

        results
    }

    /// Calculate Sharpe ratio from P&L history.
    fn calculate_sharpe(&self, pnl_history: &[f64]) -> f64 {
        if pnl_history.len() < 2 {
            return 0.0;
        }

        // Calculate returns
        let returns: Vec<f64> = pnl_history
            .windows(2)
            .map(|w| (w[1] - w[0]) / w[0])
            .collect();

        if returns.is_empty() {
            return 0.0;
        }

        let mean: f64 = returns.iter().sum::<f64>() / returns.len() as f64;
        let variance: f64 =
            returns.iter().map(|r| (r - mean).powi(2)).sum::<f64>() / returns.len() as f64;
        let std_dev = variance.sqrt();

        if std_dev < 1e-10 {
            return 0.0;
        }

        // Annualized (assuming 252 trading days)
        mean / std_dev * (252.0_f64).sqrt()
    }

    /// Calculate maximum drawdown from P&L history.
    fn calculate_max_drawdown(&self, pnl_history: &[f64]) -> f64 {
        if pnl_history.is_empty() {
            return 0.0;
        }

        let mut peak = pnl_history[0];
        let mut max_dd: f64 = 0.0;

        for &value in pnl_history {
            if value > peak {
                peak = value;
            }
            let drawdown = (peak - value) / peak * 100.0;
            if drawdown > max_dd {
                max_dd = drawdown;
            }
        }

        max_dd
    }

    /// Calculate win rate from P&L history.
    fn calculate_win_rate(&self, pnl_history: &[f64]) -> f64 {
        if pnl_history.len() < 2 {
            return 0.0;
        }

        let returns: Vec<f64> = pnl_history
            .windows(2)
            .map(|w| (w[1] - w[0]) / w[0])
            .collect();

        if returns.is_empty() {
            return 0.0;
        }

        let wins = returns.iter().filter(|&&r| r > 0.0).count();
        wins as f64 / returns.len() as f64 * 100.0
    }

    /// Calculate market statistics.
    fn calculate_market_stats(
        &self,
        config: &TournamentConfig,
        price_paths: &[Vec<f64>],
    ) -> MarketStats {
        let mut asset_returns: Vec<(String, f64)> = config
            .assets
            .iter()
            .zip(price_paths.iter())
            .map(|(asset, prices)| {
                let initial = prices.first().unwrap_or(&1.0);
                let final_price = prices.last().unwrap_or(&1.0);
                let ret = (final_price - initial) / initial * 100.0;
                (asset.symbol.clone(), ret)
            })
            .collect();

        asset_returns.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

        let best_asset = asset_returns
            .first()
            .map(|(s, _)| s.clone())
            .unwrap_or_default();
        let worst_asset = asset_returns
            .last()
            .map(|(s, _)| s.clone())
            .unwrap_or_default();

        let market_return =
            asset_returns.iter().map(|(_, r)| r).sum::<f64>() / asset_returns.len().max(1) as f64;

        // Calculate market volatility from first asset
        let market_volatility = if let Some(prices) = price_paths.first() {
            self.calculate_volatility(prices)
        } else {
            0.0
        };

        MarketStats {
            market_return,
            market_volatility,
            best_asset,
            worst_asset,
        }
    }

    /// Calculate annualized volatility from price series.
    fn calculate_volatility(&self, prices: &[f64]) -> f64 {
        if prices.len() < 2 {
            return 0.0;
        }

        let returns: Vec<f64> = prices.windows(2).map(|w| (w[1] / w[0]).ln()).collect();

        if returns.is_empty() {
            return 0.0;
        }

        let mean: f64 = returns.iter().sum::<f64>() / returns.len() as f64;
        let variance: f64 =
            returns.iter().map(|r| (r - mean).powi(2)).sum::<f64>() / returns.len() as f64;

        variance.sqrt() * (252.0_f64).sqrt() * 100.0 // Annualized %
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use algoarena_shared::{
        AgentConfig, AgentParameters, AssetConfig, StrategyType, sample_tournament,
    };

    #[test]
    fn test_arena_creation() {
        let arena = TradingArena::new();
        assert_eq!(arena.step, 0);
    }

    #[test]
    fn test_run_tournament() {
        let mut arena = TradingArena::new();
        let config = sample_tournament();

        let result = arena.run(&config);
        assert!(result.is_ok());

        let tournament = result.unwrap();
        assert_eq!(tournament.rankings.len(), config.agents.len());
        assert_eq!(tournament.rankings[0].rank, 1);
    }

    #[test]
    fn test_rankings_ordered() {
        let mut arena = TradingArena::new();
        let config = sample_tournament();

        let result = arena.run(&config).unwrap();

        // Check rankings are in order
        for (i, ranking) in result.rankings.iter().enumerate() {
            assert_eq!(ranking.rank, i + 1);
        }

        // Check total returns are descending
        for window in result.rankings.windows(2) {
            assert!(window[0].total_return >= window[1].total_return);
        }
    }

    #[test]
    fn test_sharpe_calculation() {
        let arena = TradingArena::new();

        // Growth with some volatility - positive Sharpe
        // Alternating between 0.5% and 1.5% returns (avg 1%, std ~0.5%)
        let mut volatile_growth: Vec<f64> = vec![100.0];
        for i in 0..100 {
            let ret = if i % 2 == 0 { 0.005 } else { 0.015 };
            volatile_growth.push(volatile_growth.last().unwrap() * (1.0 + ret));
        }
        let sharpe = arena.calculate_sharpe(&volatile_growth);
        assert!(
            sharpe > 0.0,
            "Sharpe should be positive for upward trend: {}",
            sharpe
        );

        // Empty history
        let empty: Vec<f64> = vec![];
        assert_eq!(arena.calculate_sharpe(&empty), 0.0);

        // Single element - not enough data
        let single: Vec<f64> = vec![100.0];
        assert_eq!(arena.calculate_sharpe(&single), 0.0);
    }

    #[test]
    fn test_max_drawdown_calculation() {
        let arena = TradingArena::new();

        // No drawdown case
        let up_only: Vec<f64> = vec![100.0, 110.0, 120.0, 130.0];
        assert_eq!(arena.calculate_max_drawdown(&up_only), 0.0);

        // 10% drawdown
        let with_dd: Vec<f64> = vec![100.0, 110.0, 99.0, 105.0];
        let dd = arena.calculate_max_drawdown(&with_dd);
        assert!((dd - 10.0).abs() < 0.5); // ~10% drawdown from 110 to 99
    }

    #[test]
    fn test_win_rate_calculation() {
        let arena = TradingArena::new();

        // All wins
        let all_up: Vec<f64> = vec![100.0, 101.0, 102.0, 103.0];
        assert!((arena.calculate_win_rate(&all_up) - 100.0).abs() < 0.01);

        // All losses
        let all_down: Vec<f64> = vec![100.0, 99.0, 98.0, 97.0];
        assert_eq!(arena.calculate_win_rate(&all_down), 0.0);

        // 50% wins
        let mixed: Vec<f64> = vec![100.0, 101.0, 100.0, 101.0, 100.0];
        let wr = arena.calculate_win_rate(&mixed);
        assert!((wr - 50.0).abs() < 0.1);
    }

    #[test]
    fn test_market_stats() {
        let mut arena = TradingArena::new();
        let config = sample_tournament();

        let result = arena.run(&config).unwrap();

        assert!(!result.market_stats.best_asset.is_empty());
        assert!(!result.market_stats.worst_asset.is_empty());
    }

    #[test]
    fn test_multiple_strategies() {
        let mut arena = TradingArena::new();
        let config = sample_tournament();

        let result = arena.run(&config).unwrap();

        // Check all strategies are represented
        let strategies: Vec<StrategyType> = result.rankings.iter().map(|r| r.strategy).collect();
        assert!(strategies.contains(&StrategyType::Momentum));
        assert!(strategies.contains(&StrategyType::MeanReversion));
        assert!(strategies.contains(&StrategyType::TrendFollowing));
    }

    #[test]
    fn test_short_tournament() {
        let mut arena = TradingArena::new();
        let config = TournamentConfig {
            name: "Short Test".to_string(),
            num_steps: 10,
            assets: vec![AssetConfig {
                symbol: "TEST".to_string(),
                initial_price: 100.0,
                volatility: 0.01,
                drift: 0.0,
            }],
            agents: vec![AgentConfig {
                id: "test".to_string(),
                name: "Test Agent".to_string(),
                strategy: StrategyType::BuyAndHold,
                initial_capital: 100_000.0,
                parameters: AgentParameters::default(),
            }],
            transaction_cost_bps: 10.0,
            seed: Some(42),
        };

        let result = arena.run(&config);
        assert!(result.is_ok());
    }
}