anya-core 1.2.0

use std::error::Error;
use std::process::Command;
use log::{info, warn, error};
use semver::Version;
use std::path::Path;

pub fn check_system_requirements() -> Result<(), String> {
    info!("Checking system requirements...");
    
    // Check for Rust
    check_rust_version()?;
    
    // Check for Docker
    check_docker_version()?;
    
    // Check for disk space
    check_disk_space()?;
    
    // Check for memory
    check_memory()?;
    
    info!("System requirements checked successfully");
    Ok(())
}

pub fn verify_installation() -> Result<(), String> {
    info!("Verifying installation...");
    
    // Verify core components
    verify_core_components()?;
    
    // Verify Bitcoin components if installed
    if Path::new("config/bitcoin").exists() {
        verify_bitcoin_components()?;
    }
    
    // Verify DAO components if installed
    if Path::new("config/dao").exists() {
        verify_dao_components()?;
    }
    
    // Verify Web5 components if installed
    if Path::new("config/web5").exists() {
        verify_web5_components()?;
    }
    
    // Verify ML components if installed
    if Path::new("config/ml").exists() {
        verify_ml_components()?;
    }
    
    info!("Installation verified successfully");
    Ok(())
}

fn check_rust_version() -> Result<(), String> {
    let output = Command::new("rustc")
        .arg("--version")
        .output();
        
    match output {
        Ok(output) => {
            if !output.status.success() {
                return Err("Failed to execute rustc".to_string());
            }
            
            let version_str = String::from_utf8_lossy(&output.stdout);
            // Extract version from format "rustc 1.70.0 (90c541806 2023-05-31)"
            let version_parts: Vec<&str> = version_str.split(' ').collect();
            if version_parts.len() < 2 {
                return Err(format!("Invalid rustc version format: {}", version_str));
            }
            
            let version = match Version::parse(version_parts[1]) {
                Ok(v) => v,
                Err(e) => return Err(format!("Failed to parse rustc version: {}", e)),
            };
            
            let min_version = Version::parse("1.70.0")?;
            if version < min_version {
                return Err(format!("Rust version {} is too old, minimum required is 1.70.0", version));
            }
            
            info!("Rust version {} detected", version);
            Ok(())
        },
        Err(e) => Err(format!("Failed to check Rust version: {}", e)),
    }
}

fn check_docker_version() -> Result<(), String> {
    let output = Command::new("docker")
        .arg("--version")
        .output();
        
    match output {
        Ok(output) => {
            if !output.status.success() {
                return Err("Failed to execute docker".to_string());
            }
            
            let version_str = String::from_utf8_lossy(&output.stdout);
            info!("Docker version detected: {}", version_str.trim());
            Ok(())
        },
        Err(e) => Err(format!("Failed to check Docker version: {}", e)),
    }
}

fn check_disk_space() -> Result<(), String> {
    // Implementation for checking disk space
    // This is platform-specific, so a simplified version:
    
    info!("Checking disk space requirements...");
    // Minimum requirement: 10GB
    
    // On Unix-like systems, use 'df' command
    #[cfg(unix)]
    {
        let output = Command::new("df")
            .args(&["-h", "."])
            .output();
            
        match output {
            Ok(output) => {
                if !output.status.success() {
                    return Err("Failed to execute df command".to_string());
                }
                
                let output_str = String::from_utf8_lossy(&output.stdout);
                info!("Disk space check: {}", output_str.trim());
                // In a real implementation, we would parse the output to get available space
                
                Ok(())
            },
            Err(e) => Err(format!("Failed to check disk space: {}", e)),
        }
    }
    
    // On Windows, simplify for this example
    #[cfg(windows)]
    {
        info!("Disk space check: Windows implementation");
        Ok(())
    }
}

fn check_memory() -> Result<(), String> {
    // Implementation for checking memory
    // This is platform-specific, so a simplified version:
    
    info!("Checking memory requirements...");
    // Minimum requirement: 4GB
    
    // On Unix-like systems, use 'free' command
    #[cfg(unix)]
    {
        let output = Command::new("free")
            .args(&["-h"])
            .output();
            
        match output {
            Ok(output) => {
                if !output.status.success() {
                    return Err("Failed to execute free command".to_string());
                }
                
                let output_str = String::from_utf8_lossy(&output.stdout);
                info!("Memory check: {}", output_str.trim());
                // In a real implementation, we would parse the output to get available memory
                
                Ok(())
            },
            Err(e) => Err(format!("Failed to check memory: {}", e)),
        }
    }
    
    // On Windows, simplify for this example
    #[cfg(windows)]
    {
        info!("Memory check: Windows implementation");
        Ok(())
    }
}

fn verify_core_components() -> Result<(), String> {
    // Implementation for verifying core components
    
    info!("Verifying core components...");
    
    // Check for required binaries
    for binary in &["anya-core", "anya-cli"] {
        let binary_path = format!("bin/{}", binary);
        if !Path::new(&binary_path).exists() {
            return Err(format!("Core binary not found: {}", binary_path));
        }
    }
    
    // Check for required configuration files
    if !Path::new("config/core.toml").exists() {
        return Err("Core configuration file not found".to_string());
    }
    
    Ok(())
}

fn verify_bitcoin_components() -> Result<(), String> {
    // Implementation for verifying Bitcoin components
    
    info!("Verifying Bitcoin components...");
    
    // Check for Bitcoin Core
    let output = Command::new("bitcoin-cli")
        .arg("--version")
        .output();
        
    match output {
        Ok(output) => {
            if !output.status.success() {
                return Err("Bitcoin Core is not properly installed".to_string());
            }
            
            let version_str = String::from_utf8_lossy(&output.stdout);
            info!("Bitcoin Core version: {}", version_str.trim());
            
            Ok(())
        },
        Err(e) => Err(format!("Failed to verify Bitcoin Core: {}", e)),
    }
}

fn verify_dao_components() -> Result<(), String> {
    // Implementation for verifying DAO components
    
    info!("Verifying DAO components...");
    
    // Check for Clarity contracts
    if !Path::new("config/dao/contracts").exists() {
        return Err("DAO contracts directory not found".to_string());
    }
    
    // Check for Clarinet
    let output = Command::new("clarinet")
        .arg("--version")
        .output();
        
    match output {
        Ok(output) => {
            if !output.status.success() {
                return Err("Clarinet is not properly installed".to_string());
            }
            
            let version_str = String::from_utf8_lossy(&output.stdout);
            info!("Clarinet version: {}", version_str.trim());
            
            Ok(())
        },
        Err(e) => Err(format!("Failed to verify Clarinet: {}", e)),
    }
}

fn verify_web5_components() -> Result<(), String> {
    // Implementation for verifying Web5 components
    
    info!("Verifying Web5 components...");
    
    // Check for DWN
    if !Path::new("config/web5/dwn").exists() {
        return Err("Web5 DWN directory not found".to_string());
    }
    
    Ok(())
}

fn verify_ml_components() -> Result<(), String> {
    // Implementation for verifying ML components
    
    info!("Verifying ML components...");
    
    // Check for ML models
    if !Path::new("config/ml/models").exists() {
        return Err("ML models directory not found".to_string());
    }
    
    Ok(())
}