anya-core 1.2.0

use std::error::Error;
/// Transaction throughput performance testing

use crate::testing::performance::{
    PerformanceTestable, TestConfig, TestResult, PerfTestError, Result, Timer, MetricType
};
use bitcoin::{Transaction, Network};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;
use rand::{thread_rng, Rng};
// Remove TransactionValidator import since it's causing issues
// use crate::bitcoin::validation::TransactionValidator;

/// Transaction generation configuration
#[derive(Debug, Clone)]
pub struct TxGenConfig {
    /// Number of inputs per transaction
    pub inputs_per_tx: usize,
    
    /// Number of outputs per transaction
    pub outputs_per_tx: usize,
    
    /// Use Taproot
    pub use_taproot: bool,
    
    /// Network
    pub network: Network,
    
    /// Use multiple threads
    pub multithreaded: bool,
    
    /// Number of threads
    pub thread_count: usize,
}

impl Default for TxGenConfig {
    fn default() -> Self {
        Self {
            inputs_per_tx: 2,
            outputs_per_tx: 2,
            use_taproot: true,
            network: Network::Testnet,
            multithreaded: false,
            thread_count: 4,
        }
    }
}

/// Transaction throughput test
pub struct TransactionThroughputTest {
    /// Transaction generation configuration
    tx_gen_config: TxGenConfig,
}

impl TransactionThroughputTest {
    /// Create a new transaction throughput test
    pub fn new(tx_gen_config: TxGenConfig) -> Self {
        Self {
            tx_gen_config,
        }
    }
    
    /// Generate a random transaction
    fn generate_transaction(&self) -> Result<Transaction> {
        // In a real implementation, we would create actual transactions
        // This is a simplified mock implementation
        
        // Create a mock transaction with random-looking properties
        let tx = Transaction {
            version: bitcoin::transaction::Version(2),
            lock_time: bitcoin::absolute::LockTime::ZERO,
            input: vec![],
            output: vec![],
        };
        
        Ok(tx)
    }
    
    /// Run a single-threaded transaction throughput test
    fn run_single_threaded_test(&self, config: &TestConfig) -> Result<TestResult> {
        let iterations = config.iterations;
        let warmup_iterations = config.warmup_iterations;
        
        // Parameters
        let mut parameters = HashMap::new();
        parameters.insert("inputs_per_tx".to_string(), self.tx_gen_config.inputs_per_tx.to_string());
        parameters.insert("outputs_per_tx".to_string(), self.tx_gen_config.outputs_per_tx.to_string());
        parameters.insert("use_taproot".to_string(), self.tx_gen_config.use_taproot.to_string());
        parameters.insert("network".to_string(), format!("{:?}", self.tx_gen_config.network));
        parameters.insert("multithreaded".to_string(), "false".to_string());
        
        // Warmup
        println!("Warming up for {} iterations...", warmup_iterations);
        for _ in 0..warmup_iterations {
            let tx = self.generate_transaction()?;
            let _ = self.validator.validate_taproot_transaction(&tx);
        }
        
        // Actual test
        println!("Running test for {} iterations...", iterations);
        
        let mut timer = Timer::new();
        timer.start();
        
        for i in 0..iterations {
            if i % 100 == 0 {
                println!("Progress: {}/{}", i, iterations);
            }
            
            let tx = self.generate_transaction()?;
            let _ = self.validator.validate_taproot_transaction(&tx);
        }
        
        timer.stop();
        
        // Calculate results
        let duration_ms = timer.elapsed_ms()?;
        let transactions_per_second = (iterations as f64) / (duration_ms as f64 / 1000.0);
        
        // Create result
        let mut metrics = HashMap::new();
        metrics.insert("transactions_per_second".to_string(), transactions_per_second);
        
        let mut metric_types = HashMap::new();
        metric_types.insert("transactions_per_second".to_string(), MetricType::TPS);
        
        Ok(TestResult {
            name: format!("{}_single_threaded", self.name()),
            timestamp: chrono::Utc::now().to_rfc3339(),
            duration_ms,
            metrics,
            metric_types,
            parameters,
        })
    }
    
    /// Run a multi-threaded transaction throughput test
    fn run_multi_threaded_test(&self, config: &TestConfig) -> Result<TestResult> {
        let iterations = config.iterations;
        let warmup_iterations = config.warmup_iterations;
        let thread_count = self.tx_gen_config.thread_count;
        
        // Parameters
        let mut parameters = HashMap::new();
        parameters.insert("inputs_per_tx".to_string(), self.tx_gen_config.inputs_per_tx.to_string());
        parameters.insert("outputs_per_tx".to_string(), self.tx_gen_config.outputs_per_tx.to_string());
        parameters.insert("use_taproot".to_string(), self.tx_gen_config.use_taproot.to_string());
        parameters.insert("network".to_string(), format!("{:?}", self.tx_gen_config.network));
        parameters.insert("multithreaded".to_string(), "true".to_string());
        parameters.insert("thread_count".to_string(), thread_count.to_string());
        
        // Warmup
        println!("Warming up for {} iterations...", warmup_iterations);
        for _ in 0..warmup_iterations {
            let tx = self.generate_transaction()?;
            let _ = self.validator.validate_taproot_transaction(&tx);
        }
        
        // Actual test
        println!("Running test for {} iterations with {} threads...", iterations, thread_count);
        
        let iterations_per_thread = iterations / thread_count;
        
        let mut timer = Timer::new();
        timer.start();
        
        let counter = Arc::new(Mutex::new(0));
        let mut handles = Vec::new();
        
        for _ in 0..thread_count {
            let counter = Arc::clone(&counter);
            let tx_gen_config = self.tx_gen_config.clone();
            
            let handle = thread::spawn(move || -> std::result::Result<(), String> {
                let validator = TransactionValidator::new();
                let test = TransactionThroughputTest::new(validator, tx_gen_config);
                
                for _ in 0..iterations_per_thread {
                    match test.generate_transaction() {
                        Ok(tx) => {
                            let _ = test.validator.validate_taproot_transaction(&tx);
                            let mut counter = counter.lock().map_err(|e| format!("Mutex lock error: {}", e))?;
                            *counter += 1;
                            
                            if *counter % 100 == 0 {
                                println!("Progress: {}/{}", *counter, iterations);
                            }
                        }
                        Err(_) => {
                            // Just continue on error for benchmarking
                        }
                    }
                }
                Ok(())
            });
            
            handles.push(handle);
        }
        
        // Wait for all threads to complete
        for handle in handles {
            let _ = handle.join();
        }
        
        timer.stop();
        
        // Calculate results
        let duration_ms = timer.elapsed_ms()?;
        let transactions_per_second = (iterations as f64) / (duration_ms as f64 / 1000.0);
        
        // Create result
        let mut metrics = HashMap::new();
        metrics.insert("transactions_per_second".to_string(), transactions_per_second);
        
        let mut metric_types = HashMap::new();
        metric_types.insert("transactions_per_second".to_string(), MetricType::TPS);
        
        Ok(TestResult {
            name: format!("{}_multi_threaded", self.name()),
            timestamp: chrono::Utc::now().to_rfc3339(),
            duration_ms,
            metrics,
            metric_types,
            parameters,
        })
    }
}

impl PerformanceTestable for TransactionThroughputTest {
    fn run_test(&self, config: &TestConfig) -> Result<TestResult> {
        if self.tx_gen_config.multithreaded {
            self.run_multi_threaded_test(config)
        } else {
            self.run_single_threaded_test(config)
        }
    }
    
    fn name(&self) -> &str {
        "transaction_throughput"
    }
}