use anyhow::Result;
use sysinfo::{Components, Disks, System};

#[derive(Debug)]
pub struct DiskInfo {
    pub total: Option<f64>,
    pub used: Option<f64>,
    pub free: Option<f64>,
}

pub async fn get_disk_info() -> Result<DiskInfo> {
    let disks = Disks::new_with_refreshed_list();
    let mut total = 0;
    let mut used = 0;

    for disk in disks.list() {
        if disk.total_space() > 100 * 1024 * 1024 {
            // > 100MB
            total += disk.total_space();
            used += disk.total_space() - disk.available_space();
        }
    }

    Ok(DiskInfo {
        total: Some(total as f64),
        used: Some(used as f64),
        free: Some((total - used) as f64),
    })
}

pub fn get_disk_usage() -> (f64, f64, f64) {
    let mut sys = System::new();
    sys.refresh_all();
    //sys.refresh_disks_list();

    let mut total_size = 0u64;
    let mut total_used = 0u64;
    let mut count = 0;

    let disks = Disks::new_with_refreshed_list();
    for disk in disks.list() {
        // Ignoriere CD-ROMs und kleine Systempartitionen
        println!(
            "Disk_Name: {:?}, Disk_Kind: {}, Total: {}, Available: {}",
            disk.name(),
            disk.kind(),
            disk.total_space(),
            disk.available_space()
        );
        if disk.total_space() > 100 * 1024 * 1024 {
            // > 100MB
            total_size += disk.total_space();
            total_used += disk.total_space() - disk.available_space();
            count += 1;
        }
    }
    let components = Components::new_with_refreshed_list();
    for component in &components {
        if let Some(temperature) = component.temperature() {
            println!(
                "Component_Label: {}, Temperature: {}°C",
                component.label(),
                temperature
            );
        }
    }

    // Berechnungen
    let size_b = if count > 0 {
        total_size as f64 // in Bytes
    } else {
        // Fallback: Versuche df unter Linux
        println!("Fallback: Using 'df' command to get disk info.");
        #[cfg(target_os = "linux")]
        {
            use std::process::Command;
            if let Ok(output) = Command::new("df")
                .arg("-B1")
                .arg("--output=size,used")
                .output()
            {
                let stdout = String::from_utf8_lossy(&output.stdout);
                for line in stdout.lines().skip(1) {
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    if parts.len() == 2 {
                        if let (Ok(size), Ok(used)) =
                            (parts[0].parse::<u64>(), parts[1].parse::<u64>())
                        {
                            total_size += size;
                            total_used += used;
                            count += 1;
                        }
                    }
                }
                total_size as f64 // in Bytes
            } else {
                0.0
            }
        }
        #[cfg(not(target_os = "linux"))]
        {
            0.0
        }
    };

    let usage = if total_size > 0 {
        (total_used as f64 / total_size as f64) * 100.0
    } else {
        0.0
    };

    (size_b, usage, 0.0) // Disk-Temp bleibt 0.0 ohne spezielle Hardware
}