use std::collections::VecDeque;
use std::time::{Duration, Instant};

/// Monitor market conditions and pause trading during unfavorable regimes
pub struct MarketRegimeMonitor {
    /// Rolling window of price observations
    price_history: VecDeque<PriceObservation>,

    /// Rolling window of opportunity frequency
    opportunity_history: VecDeque<OpportunityCount>,

    /// Current regime state
    current_regime: MarketRegime,

    /// Configuration thresholds
    config: RegimeConfig,
}

#[derive(Debug, Clone)]
pub struct PriceObservation {
    timestamp: Instant,
    price: f64,  // SOL or LST price in USDC
}

#[derive(Debug, Clone)]
pub struct OpportunityCount {
    timestamp: Instant,
    count: u32,  // Opportunities detected in last hour
}

#[derive(Debug, Clone, PartialEq)]
pub enum MarketRegime {
    Favorable,    // Trade actively
    Marginal,     // Trade cautiously (reduce size)
    Unfavorable,  // Pause trading
}

#[derive(Debug, Clone)]
pub struct RegimeConfig {
    /// Minimum 1-hour price volatility (std dev %)
    min_volatility_percent: f64,  // e.g., 0.5%

    /// Minimum 24h pool volume (USD)
    min_daily_volume: f64,  // e.g., $200k

    /// Minimum opportunities per hour
    min_opportunities_per_hour: u32,  // e.g., 5

    /// Maximum time in unfavorable regime before alerting
    max_unfavorable_duration: Duration,  // e.g., 4 hours
}

impl MarketRegimeMonitor {
    /// Calculate 1-hour price volatility (standard deviation)
    fn calculate_volatility(&self) -> f64 {
        let recent_prices: Vec<f64> = self.price_history
            .iter()
            .filter(|obs| obs.timestamp.elapsed() < Duration::from_secs(3600))
            .map(|obs| obs.price)
            .collect();

        if recent_prices.len() < 10 {
            return 0.0; // Not enough data
        }

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

        let std_dev = variance.sqrt();
        let volatility_percent = (std_dev / mean) * 100.0;

        volatility_percent
    }

    /// Calculate opportunity frequency (per hour)
    fn calculate_opportunity_frequency(&self) -> f64 {
        let recent_count: u32 = self.opportunity_history
            .iter()
            .filter(|obs| obs.timestamp.elapsed() < Duration::from_secs(3600))
            .map(|obs| obs.count)
            .sum();

        recent_count as f64
    }

    /// Determine current market regime
    pub fn assess_regime(&mut self) -> MarketRegime {
        let volatility = self.calculate_volatility();
        let opp_frequency = self.calculate_opportunity_frequency();

        // Get 24h volume from external source (e.g., Birdeye API)
        let daily_volume = self.fetch_24h_volume().await?;

        // Count criteria met
        let mut favorable_count = 0;
        let mut unfavorable_count = 0;

        // Criterion 1: Volatility
        if volatility >= self.config.min_volatility_percent {
            favorable_count += 1;
        } else if volatility < self.config.min_volatility_percent * 0.5 {
            unfavorable_count += 1;
        }

        // Criterion 2: Volume
        if daily_volume >= self.config.min_daily_volume {
            favorable_count += 1;
        } else if daily_volume < self.config.min_daily_volume * 0.5 {
            unfavorable_count += 1;
        }

        // Criterion 3: Opportunity frequency
        if opp_frequency >= self.config.min_opportunities_per_hour as f64 {
            favorable_count += 1;
        } else if opp_frequency < (self.config.min_opportunities_per_hour / 2) as f64 {
            unfavorable_count += 1;
        }

        // Decision logic
        let regime = if unfavorable_count >= 2 {
            MarketRegime::Unfavorable
        } else if favorable_count >= 2 {
            MarketRegime::Favorable
        } else {
            MarketRegime::Marginal
        };

        // Log regime changes
        if regime != self.current_regime {
            info!("🔄 Market regime changed: {:?} → {:?}",
                self.current_regime, regime);
            info!("   Volatility: {:.2}%, Volume: ${:.0}k, Opps/hr: {:.1}",
                volatility, daily_volume / 1000.0, opp_frequency);
        }

        self.current_regime = regime;
        regime
    }

    /// Should we execute this trade given current regime?
    pub fn should_trade(&self, opportunity: &Opportunity) -> Result<TradeDecision> {
        match self.current_regime {
            MarketRegime::Favorable => {
                Ok(TradeDecision::Execute {
                    size_multiplier: 1.0,
                })
            }

            MarketRegime::Marginal => {
                Ok(TradeDecision::Execute {
                    size_multiplier: 0.5,  // Half position size
                })
            }

            MarketRegime::Unfavorable => {
                Err("Market regime unfavorable, trading paused".into())
            }
        }
    }

    /// Alert if stuck in unfavorable regime too long
    pub async fn check_stuck_in_unfavorable(&self) -> Option<String> {
        if self.current_regime != MarketRegime::Unfavorable {
            return None;
        }

        // Check how long we've been unfavorable
        let duration_unfavorable = self.regime_duration();

        if duration_unfavorable > self.config.max_unfavorable_duration {
            return Some(format!(
                "⚠️ Stuck in unfavorable regime for {} hours. Consider pivoting strategy.",
                duration_unfavorable.as_secs() / 3600
            ));
        }

        None
    }
}

/// Monitor Solana network health
pub struct NetworkHealthMonitor {
    /// Recent block time observations
    block_times: VecDeque<BlockTimeObservation>,

    /// Recent transaction failure rates
    tx_failure_rates: VecDeque<FailureRateObservation>,

    /// Jito tip statistics
    jito_tips: VecDeque<TipObservation>,

    /// Current health status
    health_status: NetworkHealth,
}

#[derive(Debug, Clone)]
pub struct BlockTimeObservation {
    slot: u64,
    duration_ms: u64,  // Time since previous block
    timestamp: Instant,
}

#[derive(Debug, Clone, PartialEq)]
pub enum NetworkHealth {
    Healthy,      // Normal conditions (400-600ms blocks)
    Degraded,     // Slight congestion (600-1000ms blocks)
    Congested,    // Heavy congestion (1000-1500ms blocks)
    Critical,     // Severe issues (>1500ms blocks)
}

impl NetworkHealthMonitor {
    /// Calculate average block time over last 10 minutes
    fn avg_block_time_10min(&self) -> u64 {
        let recent: Vec<u64> = self.block_times
            .iter()
            .filter(|obs| obs.timestamp.elapsed() < Duration::from_secs(600))
            .map(|obs| obs.duration_ms)
            .collect();

        if recent.is_empty() {
            return 400; // Default to healthy
        }

        recent.iter().sum::<u64>() / recent.len() as u64
    }

    /// Calculate transaction failure rate (last 100 attempts)
    fn tx_failure_rate(&self) -> f64 {
        let recent: Vec<bool> = self.tx_failure_rates
            .iter()
            .take(100)
            .map(|obs| obs.failed)
            .collect();

        if recent.is_empty() {
            return 0.0;
        }

        let failures = recent.iter().filter(|&&f| f).count();
        failures as f64 / recent.len() as f64
    }

    /// Calculate median Jito tip (indicator of competition)
    fn median_jito_tip(&self) -> u64 {
        let mut recent: Vec<u64> = self.jito_tips
            .iter()
            .filter(|obs| obs.timestamp.elapsed() < Duration::from_secs(600))
            .map(|obs| obs.tip_lamports)
            .collect();

        if recent.is_empty() {
            return 10_000; // Default 0.00001 SOL
        }

        recent.sort();
        recent[recent.len() / 2]
    }

    /// Assess current network health
    pub fn assess_health(&mut self) -> NetworkHealth {
        let avg_block_time = self.avg_block_time_10min();
        let failure_rate = self.tx_failure_rate();
        let median_tip = self.median_jito_tip();

        let health = match avg_block_time {
            0..=600 if failure_rate < 0.10 => NetworkHealth::Healthy,
            601..=1000 if failure_rate < 0.20 => NetworkHealth::Degraded,
            1001..=1500 if failure_rate < 0.40 => NetworkHealth::Congested,
            _ => NetworkHealth::Critical,
        };

        // Log health changes
        if health != self.health_status {
            warn!("🌐 Network health changed: {:?} → {:?}",
                self.health_status, health);
            warn!("   Avg block time: {}ms, Failure rate: {:.1}%, Median tip: {} lamports",
                avg_block_time, failure_rate * 100.0, median_tip);
        }

        self.health_status = health;
        health
    }

    /// Should we trade given network health?
    pub fn trading_recommendation(&self) -> TradingRecommendation {
        match self.health_status {
            NetworkHealth::Healthy => TradingRecommendation {
                should_trade: true,
                size_multiplier: 1.0,
                tip_multiplier: 1.0,
            },

            NetworkHealth::Degraded => TradingRecommendation {
                should_trade: true,
                size_multiplier: 0.7,   // Reduce position size
                tip_multiplier: 1.2,    // Increase tips slightly
            },

            NetworkHealth::Congested => TradingRecommendation {
                should_trade: true,
                size_multiplier: 0.3,   // Minimal positions
                tip_multiplier: 1.5,    // Significantly higher tips
            },

            NetworkHealth::Critical => TradingRecommendation {
                should_trade: false,    // Pause trading
                size_multiplier: 0.0,
                tip_multiplier: 2.0,
            },
        }
    }
}

/// Wallet pool manager with rotation strategy
pub struct WalletPool {
    /// Master seed for deriving wallets
    master_seed: [u8; 32],

    /// Derived wallets (HD wallet pattern)
    wallets: Vec<Keypair>,

    /// Current wallet index (round-robin)
    current_index: Arc<AtomicUsize>,

    /// Per-wallet usage statistics
    usage_stats: Arc<RwLock<HashMap<Pubkey, WalletStats>>>,
}

#[derive(Debug, Clone)]
pub struct WalletStats {
    pub pubkey: Pubkey,
    pub bundles_submitted_today: u32,
    pub bundles_landed_today: u32,
    pub last_used: Instant,
    pub jito_reputation_score: f64,  // Heuristic
}

impl WalletPool {
    /// Create wallet pool from master seed
    pub fn from_seed(master_seed: [u8; 32], count: usize) -> Self {
        let wallets = (0..count)
            .map(|i| derive_keypair_from_seed(&master_seed, i as u32))
            .collect();

        Self {
            master_seed,
            wallets,
            current_index: Arc::new(AtomicUsize::new(0)),
            usage_stats: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    /// Get next wallet (round-robin)
    pub fn next_wallet(&self) -> &Keypair {
        let index = self.current_index.fetch_add(1, Ordering::SeqCst) % self.wallets.len();
        &self.wallets[index]
    }

    /// Get least-used wallet today
    pub async fn least_used_wallet(&self) -> &Keypair {
        let stats = self.usage_stats.read().await;

        let (index, _) = self.wallets
            .iter()
            .enumerate()
            .min_by_key(|(_, kp)| {
                stats.get(&kp.pubkey())
                    .map(|s| s.bundles_submitted_today)
                    .unwrap_or(0)
            })
            .unwrap();

        &self.wallets[index]
    }

    /// Record bundle submission
    pub async fn record_submission(&self, wallet: &Pubkey, success: bool) {
        let mut stats = self.usage_stats.write().await;
        let entry = stats.entry(*wallet).or_insert(WalletStats::default());

        entry.bundles_submitted_today += 1;
        if success {
            entry.bundles_landed_today += 1;
        }
        entry.last_used = Instant::now();

        // Update reputation score (heuristic)
        let success_rate = entry.bundles_landed_today as f64
            / entry.bundles_submitted_today as f64;
        entry.jito_reputation_score = success_rate * 100.0;
    }

    /// Reset daily counters (call at midnight UTC)
    pub async fn reset_daily_stats(&self) {
        let mut stats = self.usage_stats.write().await;
        for stat in stats.values_mut() {
            stat.bundles_submitted_today = 0;
            stat.bundles_landed_today = 0;
        }
    }
}

/// Derive keypair from master seed (BIP32-style)
fn derive_keypair_from_seed(seed: &[u8; 32], index: u32) -> Keypair {
    use solana_sdk::signature::Keypair;
    use solana_sdk::derivation_path::DerivationPath;

    // Simplified derivation (use proper BIP32 in production)
    let mut derived_seed = *seed;
    derived_seed[0] ^= (index >> 24) as u8;
    derived_seed[1] ^= (index >> 16) as u8;
    derived_seed[2] ^= (index >> 8) as u8;
    derived_seed[3] ^= index as u8;

    Keypair::from_seed(&derived_seed).unwrap()
}

// Phase 1-4: Single wallet
let wallet_pool = WalletPool::from_seed(master_seed, 1);

// Phase 5: Expand to 5 wallets
let wallet_pool = WalletPool::from_seed(master_seed, 5);

// Execute trade with rotation
let wallet = wallet_pool.least_used_wallet().await;
let result = execute_trade(opportunity, wallet).await?;
wallet_pool.record_submission(&wallet.pubkey(), result.success).await;

/// Detect when competitors enter your niche
pub struct CopyBotDetector {
    /// Historical success rates per route
    route_history: HashMap<String, VecDeque<RoutePerformance>>,

    /// Baseline success rates (30-day average)
    route_baselines: HashMap<String, f64>,
}

#[derive(Debug, Clone)]
pub struct RoutePerformance {
    timestamp: Instant,
    attempts: u32,
    successes: u32,
    avg_profit: f64,
}

impl CopyBotDetector {
    /// Check if a route shows signs of new competition
    pub fn check_competition(&self, route_id: &str) -> Option<CompetitionAlert> {
        let history = self.route_history.get(route_id)?;
        let baseline = self.route_baselines.get(route_id)?;

        // Calculate last 24h success rate
        let recent: Vec<_> = history.iter()
            .filter(|perf| perf.timestamp.elapsed() < Duration::from_secs(86400))
            .collect();

        if recent.is_empty() {
            return None;
        }

        let total_attempts: u32 = recent.iter().map(|p| p.attempts).sum();
        let total_successes: u32 = recent.iter().map(|p| p.successes).sum();
        let recent_success_rate = total_successes as f64 / total_attempts as f64;

        // Check for >30% drop
        let drop_percent = (baseline - recent_success_rate) / baseline * 100.0;

        if drop_percent > 30.0 {
            // Verify volume/volatility are stable (not market issue)
            let volume_stable = self.check_volume_stable(route_id);
            let volatility_stable = self.check_volatility_stable(route_id);

            if volume_stable && volatility_stable {
                return Some(CompetitionAlert {
                    route_id: route_id.to_string(),
                    baseline_success_rate: *baseline,
                    recent_success_rate,
                    drop_percent,
                    recommendation: if drop_percent > 50.0 {
                        "Consider pausing this route or increasing profit buffer"
                    } else {
                        "Monitor closely, may need to optimize latency"
                    },
                });
            }
        }

        None
    }

    /// Recommend action based on competition detection
    pub fn recommend_action(&self, route_id: &str) -> RouteAction {
        if let Some(alert) = self.check_competition(route_id) {
            if alert.drop_percent > 50.0 {
                RouteAction::Pause {
                    duration: Duration::from_secs(3600), // 1 hour
                }
            } else {
                RouteAction::IncreaseProfitBuffer {
                    multiplier: 1.5, // Only trade if >1.5x historical avg
                }
            }
        } else {
            RouteAction::Continue
        }
    }
}