use common::metrics::{CPU, Disk, Memory, Metrics, Network, SystemInfo};
use sysinfo::{Disks, Networks, System};

use crate::cpu::CpuStatReader;

pub struct Collector {
    sys: System,
    disks: Disks,
    networks: Networks,
    cpu_reader: CpuStatReader,
}

impl Collector {
    pub fn new() -> Self {
        Collector {
            sys: System::new_all(),
            disks: Disks::new_with_refreshed_list(),
            networks: Networks::new_with_refreshed_list(),
            cpu_reader: CpuStatReader::new(),
        }
    }

    pub fn collect_all(&mut self) -> Metrics {
        let system_info = self.collect_sysinfo();

        self.sys.refresh_all();
        self.networks.refresh(true);

        let cpu = self.collect_cpu();
        let disk = self.collect_disk();
        let memory = self.collect_memory();
        let network = self.collect_network();

        Metrics {
            system_info,
            cpu,
            disk,
            memory,
            network,
        }
    }

    fn collect_sysinfo(&self) -> SystemInfo {
        SystemInfo {
            uptime: System::uptime(),
            host: System::host_name(),
            name: System::name(),
            kernel: System::kernel_version(),
            os_version: System::os_version(),
        }
    }

    fn collect_cpu(&mut self) -> CPU {
        CPU {
            usage: self.sys.global_cpu_usage(),
            threads: self.sys.cpus().len(),
            breakdown: self.cpu_reader.read_global_cpu_stats().unwrap_or_default(),
        }
    }

    fn collect_disk(&self) -> Disk {
        let disk = self
            .disks
            .iter()
            .max_by_key(|disk| disk.total_space())
            .unwrap();

        Disk {
            free: disk.available_space(),
            total: disk.total_space(),
        }
    }

    fn collect_memory(&self) -> Memory {
        Memory {
            used: self.sys.used_memory(),
            total: self.sys.total_memory(),
            swap_used: self.sys.used_swap(),
            swap_total: self.sys.total_swap(),
        }
    }

    fn collect_network(&self) -> Network {
        let (down, up): (u64, u64) = self
            .networks
            .values()
            .map(|data| (data.received(), data.transmitted()))
            .fold((0, 0), |(acc_down, acc_up), (down, up)| {
                (acc_down + down, acc_up + up)
            });

        Network { down, up }
    }
}