use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

/// A comprehensive example of a decentralized oracle network using BFT-CRDTs
/// that eliminates the need for consensus on price updates.

// ==== Core Types ====

#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct OracleId(pub String);

#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct AssetPair(pub String);

#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct AttestationId(pub String);

/// A price attestation from an oracle
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PriceAttestation {
    pub id: AttestationId,
    pub oracle_id: OracleId,
    pub asset_pair: AssetPair,
    pub price: u128,
    pub confidence: u8, // 0-100
    pub timestamp: u64,
    pub sources: Vec<DataSource>,
    pub proof: AttestationProof,
    pub signature: Vec<u8>,
}

/// Data source information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataSource {
    pub name: String,
    pub price: u128,
    pub volume: u128,
    pub timestamp: u64,
}

/// Proof that the price data is authentic
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AttestationProof {
    /// TLS proof from HTTPS API
    TlsProof {
        server_cert: Vec<u8>,
        response_hash: Vec<u8>,
        timestamp: u64,
    },
    /// Signed data from WebSocket feed
    SignedFeed {
        exchange_signature: Vec<u8>,
        sequence_number: u64,
    },
    /// On-chain proof (e.g., from DEX)
    OnChainProof {
        chain_id: String,
        block_number: u64,
        transaction_hash: Vec<u8>,
    },
}

/// Oracle reputation and performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OracleMetrics {
    pub oracle_id: OracleId,
    pub total_attestations: u64,
    pub average_deviation: f64,
    pub uptime_percentage: f64,
    pub last_submission: u64,
    pub quality_score: f64,
}

/// The main CRDT structure for the oracle network
#[derive(Debug, Clone)]
pub struct OracleNetworkCRDT {
    /// All price attestations
    attestations: HashMap<AttestationId, PriceAttestation>,

    /// Index by asset pair and time for efficient queries
    price_index: BTreeMap<(AssetPair, u64), Vec<AttestationId>>,

    /// Oracle performance metrics
    oracle_metrics: HashMap<OracleId, OracleMetrics>,

    /// Detected anomalies and disputes
    anomalies: HashMap<AttestationId, AnomalyReport>,

    /// Network parameters
    params: NetworkParams,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkParams {
    pub min_oracle_stake: u128,
    pub max_price_age: Duration,
    pub outlier_threshold: f64,
    pub min_sources: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnomalyReport {
    pub attestation_id: AttestationId,
    pub report_type: AnomalyType,
    pub reporter: OracleId,
    pub evidence: String,
    pub timestamp: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AnomalyType {
    OutlierPrice { deviation_percentage: f64 },
    InvalidProof,
    StaleData { age_seconds: u64 },
    SuspiciousPattern,
}

impl OracleNetworkCRDT {
    pub fn new(params: NetworkParams) -> Self {
        Self {
            attestations: HashMap::new(),
            price_index: BTreeMap::new(),
            oracle_metrics: HashMap::new(),
            anomalies: HashMap::new(),
            params,
        }
    }

    /// Submit a new price attestation to the network
    pub fn submit_attestation(
        &mut self,
        attestation: PriceAttestation,
    ) -> Result<(), String> {
        // Validate attestation
        self.validate_attestation(&attestation)?;

        // Check for duplicate
        if self.attestations.contains_key(&attestation.id) {
            return Ok(()); // Idempotent
        }

        // Add to main storage
        let id = attestation.id.clone();
        let asset_pair = attestation.asset_pair.clone();
        let timestamp = attestation.timestamp;
        let oracle_id = attestation.oracle_id.clone();

        self.attestations.insert(id.clone(), attestation);

        // Update index
        self.price_index
            .entry((asset_pair, timestamp))
            .or_insert_with(Vec::new)
            .push(id);

        // Update oracle metrics
        self.update_oracle_metrics(&oracle_id);

        Ok(())
    }

    /// Validate an attestation before accepting it
    fn validate_attestation(&self, attestation: &PriceAttestation) -> Result<(), String> {
        // Check timestamp is reasonable
        let now = Self::timestamp();
        if attestation.timestamp > now + 60 {
            return Err("Attestation timestamp is in the future".to_string());
        }
        if attestation.timestamp < now - self.params.max_price_age.as_secs() {
            return Err("Attestation is too old".to_string());
        }

        // Verify minimum sources
        if attestation.sources.len() < self.params.min_sources {
            return Err("Insufficient data sources".to_string());
        }

        // Verify signature (placeholder - real implementation would verify cryptographically)
        if attestation.signature.is_empty() {
            return Err("Missing signature".to_string());
        }

        // Validate proof
        match &attestation.proof {
            AttestationProof::TlsProof { timestamp, .. } => {
                if *timestamp < attestation.timestamp - 300 {
                    return Err("TLS proof too old".to_string());
                }
            }
            AttestationProof::SignedFeed { .. } => {
                // Verify exchange signature in real implementation
            }
            AttestationProof::OnChainProof { .. } => {
                // Verify on-chain data in real implementation
            }
        }

        Ok(())
    }

    /// Get aggregated price for an asset pair within a time window
    pub fn get_aggregate_price(
        &self,
        asset_pair: &AssetPair,
        time_window: Duration,
    ) -> Option<AggregatedPrice> {
        let now = Self::timestamp();
        let start_time = now.saturating_sub(time_window.as_secs());

        // Collect all attestations in time window
        let mut attestations = Vec::new();

        for ((pair, timestamp), attestation_ids) in self.price_index.range(
            (asset_pair.clone(), start_time)..=(asset_pair.clone(), now)
        ) {
            if pair == asset_pair {
                for id in attestation_ids {
                    if let Some(attestation) = self.attestations.get(id) {
                        attestations.push(attestation);
                    }
                }
            }
        }

        if attestations.is_empty() {
            return None;
        }

        // Calculate aggregated price
        self.aggregate_prices(attestations, now)
    }

    /// Aggregate multiple price attestations into a single price
    fn aggregate_prices(
        &self,
        attestations: Vec<&PriceAttestation>,
        current_time: u64,
    ) -> Option<AggregatedPrice> {
        let mut weighted_prices = Vec::new();

        for attestation in &attestations {
            // Calculate weight based on:
            // 1. Oracle quality score
            // 2. Attestation confidence
            // 3. Recency
            let oracle_score = self.oracle_metrics
                .get(&attestation.oracle_id)
                .map(|m| m.quality_score)
                .unwrap_or(0.5);

            let confidence_weight = attestation.confidence as f64 / 100.0;

            let age = current_time.saturating_sub(attestation.timestamp);
            let recency_weight = 1.0 / (1.0 + (age as f64 / 300.0)); // 5-minute half-life

            let total_weight = oracle_score * confidence_weight * recency_weight;

            weighted_prices.push((attestation.price, total_weight));
        }

        // Remove outliers
        let filtered_prices = self.remove_outliers(weighted_prices);

        if filtered_prices.is_empty() {
            return None;
        }

        // Calculate weighted average
        let total_weight: f64 = filtered_prices.iter().map(|(_, w)| w).sum();
        let weighted_sum: f64 = filtered_prices
            .iter()
            .map(|(price, weight)| *price as f64 * weight)
            .sum();

        let average_price = (weighted_sum / total_weight) as u128;

        // Calculate confidence metrics
        let prices: Vec<u128> = filtered_prices.iter().map(|(p, _)| *p).collect();
        let std_dev = self.calculate_std_dev(&prices, average_price);
        let confidence = self.calculate_confidence(&prices, std_dev, average_price);

        Some(AggregatedPrice {
            price: average_price,
            confidence,
            num_sources: filtered_prices.len(),
            std_deviation: std_dev,
            timestamp: current_time,
        })
    }

    /// Remove statistical outliers from price data
    fn remove_outliers(&self, mut prices: Vec<(u128, f64)>) -> Vec<(u128, f64)> {
        if prices.len() < 3 {
            return prices; // Not enough data to detect outliers
        }

        // Sort by price
        prices.sort_by_key(|(price, _)| *price);

        // Calculate IQR (Interquartile Range)
        let q1_idx = prices.len() / 4;
        let q3_idx = 3 * prices.len() / 4;
        let q1 = prices[q1_idx].0;
        let q3 = prices[q3_idx].0;
        let iqr = q3.saturating_sub(q1);

        // Filter out outliers (prices outside 1.5 * IQR)
        let lower_bound = q1.saturating_sub(iqr * 3 / 2);
        let upper_bound = q3.saturating_add(iqr * 3 / 2);

        prices
            .into_iter()
            .filter(|(price, _)| *price >= lower_bound && *price <= upper_bound)
            .collect()
    }

    /// Calculate standard deviation
    fn calculate_std_dev(&self, prices: &[u128], mean: u128) -> u128 {
        if prices.is_empty() {
            return 0;
        }

        let variance: f64 = prices
            .iter()
            .map(|price| {
                let diff = if *price > mean {
                    (*price - mean) as f64
                } else {
                    (mean - *price) as f64
                };
                diff * diff
            })
            .sum::<f64>() / prices.len() as f64;

        variance.sqrt() as u128
    }

    /// Calculate confidence score based on data quality
    fn calculate_confidence(&self, prices: &[u128], std_dev: u128, mean: u128) -> u8 {
        // Base confidence on:
        // 1. Number of sources
        // 2. Standard deviation relative to mean
        // 3. Agreement between sources

        let num_sources_score = (prices.len().min(10) * 10) as u8;

        let deviation_ratio = if mean > 0 {
            (std_dev as f64) / (mean as f64)
        } else {
            1.0
        };

        let deviation_score = if deviation_ratio < 0.01 {
            100
        } else if deviation_ratio < 0.05 {
            80
        } else if deviation_ratio < 0.10 {
            60
        } else {
            40
        };

        (num_sources_score.min(100) + deviation_score) / 2
    }

    /// Update oracle performance metrics
    fn update_oracle_metrics(&mut self, oracle_id: &OracleId) {
        let attestations: Vec<_> = self.attestations
            .values()
            .filter(|a| &a.oracle_id == oracle_id)
            .collect();

        if attestations.is_empty() {
            return;
        }

        let metrics = self.oracle_metrics
            .entry(oracle_id.clone())
            .or_insert(OracleMetrics {
                oracle_id: oracle_id.clone(),
                total_attestations: 0,
                average_deviation: 0.0,
                uptime_percentage: 100.0,
                last_submission: 0,
                quality_score: 0.5,
            });

        metrics.total_attestations = attestations.len() as u64;
        metrics.last_submission = attestations
            .iter()
            .map(|a| a.timestamp)
            .max()
            .unwrap_or(0);

        // Calculate quality score based on historical performance
        // (simplified - real implementation would track accuracy over time)
        metrics.quality_score = 0.5 + (metrics.total_attestations.min(100) as f64 / 200.0);
    }

    /// Report an anomaly in an attestation
    pub fn report_anomaly(
        &mut self,
        attestation_id: AttestationId,
        reporter: OracleId,
        anomaly_type: AnomalyType,
        evidence: String,
    ) -> Result<(), String> {
        if !self.attestations.contains_key(&attestation_id) {
            return Err("Attestation not found".to_string());
        }

        let report = AnomalyReport {
            attestation_id: attestation_id.clone(),
            report_type: anomaly_type,
            reporter,
            evidence,
            timestamp: Self::timestamp(),
        };

        self.anomalies.insert(attestation_id, report);
        Ok(())
    }

    /// Get oracle reputation score
    pub fn get_oracle_reputation(&self, oracle_id: &OracleId) -> Option<OracleReputation> {
        let metrics = self.oracle_metrics.get(oracle_id)?;

        // Count anomalies reported against this oracle
        let anomaly_count = self.anomalies
            .values()
            .filter(|report| {
                self.attestations
                    .get(&report.attestation_id)
                    .map(|a| &a.oracle_id == oracle_id)
                    .unwrap_or(false)
            })
            .count();

        Some(OracleReputation {
            oracle_id: oracle_id.clone(),
            quality_score: metrics.quality_score,
            total_attestations: metrics.total_attestations,
            anomaly_reports: anomaly_count as u64,
            last_active: metrics.last_submission,
        })
    }

    /// Merge another CRDT instance
    pub fn merge(&mut self, other: &Self) {
        // Merge attestations
        for (id, attestation) in &other.attestations {
            if !self.attestations.contains_key(id) {
                let _ = self.submit_attestation(attestation.clone());
            }
        }

        // Merge anomaly reports
        for (id, report) in &other.anomalies {
            self.anomalies.entry(id.clone()).or_insert(report.clone());
        }

        // Recalculate metrics after merge
        for oracle_id in other.oracle_metrics.keys() {
            self.update_oracle_metrics(oracle_id);
        }
    }

    fn timestamp() -> u64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs()
    }
}

/// Aggregated price result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AggregatedPrice {
    pub price: u128,
    pub confidence: u8,
    pub num_sources: usize,
    pub std_deviation: u128,
    pub timestamp: u64,
}

/// Oracle reputation information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OracleReputation {
    pub oracle_id: OracleId,
    pub quality_score: f64,
    pub total_attestations: u64,
    pub anomaly_reports: u64,
    pub last_active: u64,
}

/// Example oracle client implementation
pub struct OracleClient {
    oracle_id: OracleId,
    network: OracleNetworkCRDT,
    data_sources: Vec<Box<dyn DataSourceClient>>,
}

trait DataSourceClient {
    fn fetch_price(&self, asset_pair: &AssetPair) -> Result<DataSource, String>;
}

impl OracleClient {
    pub async fn submit_price(&mut self, asset_pair: AssetPair) -> Result<(), String> {
        // Fetch prices from multiple sources
        let mut sources = Vec::new();
        for client in &self.data_sources {
            match client.fetch_price(&asset_pair) {
                Ok(source) => sources.push(source),
                Err(_) => continue, // Skip failed sources
            }
        }

        if sources.len() < self.network.params.min_sources {
            return Err("Insufficient data sources available".to_string());
        }

        // Calculate aggregate price from sources
        let total_volume: u128 = sources.iter().map(|s| s.volume).sum();
        let weighted_sum: u128 = sources
            .iter()
            .map(|s| s.price * s.volume)
            .sum();
        let price = weighted_sum / total_volume;

        // Calculate confidence based on source agreement
        let prices: Vec<u128> = sources.iter().map(|s| s.price).collect();
        let std_dev = self.network.calculate_std_dev(&prices, price);
        let confidence = if std_dev < price / 100 { 95 } else { 80 };

        // Create attestation
        let attestation = PriceAttestation {
            id: AttestationId(format!("{}_{}", self.oracle_id.0, Self::timestamp())),
            oracle_id: self.oracle_id.clone(),
            asset_pair,
            price,
            confidence,
            timestamp: Self::timestamp(),
            sources,
            proof: AttestationProof::SignedFeed {
                exchange_signature: vec![1, 2, 3], // Placeholder
                sequence_number: Self::timestamp(),
            },
            signature: vec![4, 5, 6], // Placeholder
        };

        // Submit to network
        self.network.submit_attestation(attestation)
    }

    fn timestamp() -> u64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs()
    }
}

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

    #[test]
    fn test_oracle_network() {
        let params = NetworkParams {
            min_oracle_stake: 1000,
            max_price_age: Duration::from_secs(3600),
            outlier_threshold: 0.1,
            min_sources: 2,
        };

        let mut network = OracleNetworkCRDT::new(params);

        // Create test oracles
        let oracle1 = OracleId("oracle1".to_string());
        let oracle2 = OracleId("oracle2".to_string());
        let oracle3 = OracleId("oracle3".to_string());

        let eth_usd = AssetPair("ETH/USD".to_string());

        // Submit prices from multiple oracles
        let attestation1 = PriceAttestation {
            id: AttestationId("att1".to_string()),
            oracle_id: oracle1.clone(),
            asset_pair: eth_usd.clone(),
            price: 2500_000_000, // $2500 with 6 decimals
            confidence: 95,
            timestamp: OracleNetworkCRDT::timestamp(),
            sources: vec![
                DataSource {
                    name: "Binance".to_string(),
                    price: 2501_000_000,
                    volume: 1000_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
                DataSource {
                    name: "Coinbase".to_string(),
                    price: 2499_000_000,
                    volume: 800_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
            ],
            proof: AttestationProof::SignedFeed {
                exchange_signature: vec![1, 2, 3],
                sequence_number: 1,
            },
            signature: vec![4, 5, 6],
        };

        network.submit_attestation(attestation1).unwrap();

        // Submit from oracle 2
        let attestation2 = PriceAttestation {
            id: AttestationId("att2".to_string()),
            oracle_id: oracle2.clone(),
            asset_pair: eth_usd.clone(),
            price: 2502_000_000,
            confidence: 90,
            timestamp: OracleNetworkCRDT::timestamp(),
            sources: vec![
                DataSource {
                    name: "Kraken".to_string(),
                    price: 2502_000_000,
                    volume: 500_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
                DataSource {
                    name: "Gemini".to_string(),
                    price: 2502_000_000,
                    volume: 300_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
            ],
            proof: AttestationProof::SignedFeed {
                exchange_signature: vec![7, 8, 9],
                sequence_number: 2,
            },
            signature: vec![10, 11, 12],
        };

        network.submit_attestation(attestation2).unwrap();

        // Submit outlier price from oracle 3
        let attestation3 = PriceAttestation {
            id: AttestationId("att3".to_string()),
            oracle_id: oracle3.clone(),
            asset_pair: eth_usd.clone(),
            price: 3000_000_000, // Outlier price
            confidence: 50,
            timestamp: OracleNetworkCRDT::timestamp(),
            sources: vec![
                DataSource {
                    name: "Unknown".to_string(),
                    price: 3000_000_000,
                    volume: 100_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
                DataSource {
                    name: "Sketchy".to_string(),
                    price: 3000_000_000,
                    volume: 50_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
            ],
            proof: AttestationProof::SignedFeed {
                exchange_signature: vec![13, 14, 15],
                sequence_number: 3,
            },
            signature: vec![16, 17, 18],
        };

        network.submit_attestation(attestation3).unwrap();

        // Get aggregated price
        let aggregated = network
            .get_aggregate_price(&eth_usd, Duration::from_secs(300))
            .unwrap();

        // Should filter out the outlier
        assert!(aggregated.price > 2490_000_000 && aggregated.price < 2510_000_000);
        assert!(aggregated.confidence > 80);
        assert_eq!(aggregated.num_sources, 2); // Outlier filtered out

        // Report anomaly
        network
            .report_anomaly(
                AttestationId("att3".to_string()),
                oracle1.clone(),
                AnomalyType::OutlierPrice {
                    deviation_percentage: 20.0,
                },
                "Price deviates significantly from market".to_string(),
            )
            .unwrap();

        // Check oracle reputation
        let reputation = network.get_oracle_reputation(&oracle3).unwrap();
        assert_eq!(reputation.anomaly_reports, 1);
    }

    #[test]
    fn test_crdt_merge() {
        let params = NetworkParams {
            min_oracle_stake: 1000,
            max_price_age: Duration::from_secs(3600),
            outlier_threshold: 0.1,
            min_sources: 2,
        };

        let mut network1 = OracleNetworkCRDT::new(params.clone());
        let mut network2 = OracleNetworkCRDT::new(params);

        let oracle1 = OracleId("oracle1".to_string());
        let btc_usd = AssetPair("BTC/USD".to_string());

        // Submit to network1
        let attestation1 = PriceAttestation {
            id: AttestationId("att1".to_string()),
            oracle_id: oracle1.clone(),
            asset_pair: btc_usd.clone(),
            price: 45000_000_000,
            confidence: 95,
            timestamp: OracleNetworkCRDT::timestamp(),
            sources: vec![
                DataSource {
                    name: "Binance".to_string(),
                    price: 45000_000_000,
                    volume: 2000_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
                DataSource {
                    name: "Coinbase".to_string(),
                    price: 45000_000_000,
                    volume: 1500_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
            ],
            proof: AttestationProof::OnChainProof {
                chain_id: "ethereum".to_string(),
                block_number: 18000000,
                transaction_hash: vec![1, 2, 3],
            },
            signature: vec![4, 5, 6],
        };

        network1.submit_attestation(attestation1).unwrap();

        // Submit different attestation to network2
        let attestation2 = PriceAttestation {
            id: AttestationId("att2".to_string()),
            oracle_id: oracle1.clone(),
            asset_pair: btc_usd.clone(),
            price: 45100_000_000,
            confidence: 90,
            timestamp: OracleNetworkCRDT::timestamp() + 1,
            sources: vec![
                DataSource {
                    name: "Kraken".to_string(),
                    price: 45100_000_000,
                    volume: 1000_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
                DataSource {
                    name: "Gemini".to_string(),
                    price: 45100_000_000,
                    volume: 800_000_000,
                    timestamp: OracleNetworkCRDT::timestamp(),
                },
            ],
            proof: AttestationProof::SignedFeed {
                exchange_signature: vec![7, 8, 9],
                sequence_number: 100,
            },
            signature: vec![10, 11, 12],
        };

        network2.submit_attestation(attestation2).unwrap();

        // Merge networks
        network1.merge(&network2);
        network2.merge(&network1);

        // Both should have same data
        assert_eq!(network1.attestations.len(), 2);
        assert_eq!(network2.attestations.len(), 2);

        // Both should calculate same aggregate price
        let price1 = network1
            .get_aggregate_price(&btc_usd, Duration::from_secs(300))
            .unwrap();
        let price2 = network2
            .get_aggregate_price(&btc_usd, Duration::from_secs(300))
            .unwrap();

        assert_eq!(price1.price, price2.price);
    }
}