path: root/src/data_conversion.rs

//! This mainly concerns converting collected data into things that the canvas
//! can actually handle.
use crate::app::data_harvester::temperature::TemperatureType;
use crate::app::text_table::TextTableData;
use crate::app::DataCollection;
use crate::{app::data_harvester, utils::gen_util::*};
use crate::{app::AxisScaling, units::data_units::DataUnit, Pid};

use std::borrow::Cow;

/// Point is of time, data
type Point = (f64, f64);

#[derive(Debug)]
pub enum BatteryDuration {
    Charging { short: String, long: String },
    Discharging { short: String, long: String },
    Neither,
}

impl Default for BatteryDuration {
    fn default() -> Self {
        Self::Neither
    }
}

#[derive(Default, Debug)]
pub struct ConvertedBatteryData {
    pub battery_name: String,
    pub charge_percentage: f64,
    pub watt_consumption: String,
    pub charge_times: BatteryDuration,
    pub health: String,
}

#[derive(Default, Debug)]
pub struct ConvertedNetworkData {
    pub rx: Vec<Point>,
    pub tx: Vec<Point>,
    pub rx_display: String,
    pub tx_display: String,
    pub total_rx_display: Option<String>,
    pub total_tx_display: Option<String>,
    // TODO: [Feature] Networking - add the following stats in the future!
    // min_rx : f64,
    // max_rx : f64,
    // mean_rx: f64,
    // min_tx: f64,
    // max_tx: f64,
    // mean_tx: f64,
}

// TODO: [Refactor] Process data might need some refactoring lol
#[derive(Clone, Default, Debug)]
pub struct ConvertedProcessData {
    pub pid: Pid,
    pub ppid: Option<Pid>,
    pub name: String,
    pub command: String,
    pub is_thread: Option<bool>,
    pub cpu_percent_usage: f64,
    pub mem_percent_usage: f64,
    pub mem_usage_bytes: u64,
    pub mem_usage_str: (f64, String),
    pub group_pids: Vec<Pid>,
    pub read_per_sec: String,
    pub write_per_sec: String,
    pub total_read: String,
    pub total_write: String,
    pub rps_f64: f64,
    pub wps_f64: f64,
    pub tr_f64: f64,
    pub tw_f64: f64,
    pub process_state: String,
    pub process_char: char,
    pub user: Option<String>,

    /// Prefix printed before the process when displayed.
    pub process_description_prefix: Option<String>,
    /// Whether to mark this process entry as disabled (mostly for tree mode).
    pub is_disabled_entry: bool,
    /// Whether this entry is collapsed, hiding all its children (for tree mode).
    pub is_collapsed_entry: bool,
}

#[derive(Clone, Default, Debug)]
pub struct ConvertedCpuData {
    pub cpu_name: String,
    pub short_cpu_name: String,
    /// Tuple is time, value
    pub cpu_data: Vec<Point>,
    /// Represents the value displayed on the legend.
    pub legend_value: String,
}

pub fn convert_temp_row(
    current_data: &DataCollection, temp_type: &TemperatureType,
) -> TextTableData {
    if current_data.temp_harvest.is_empty() {
        vec![vec![
            ("No Sensors Found".into(), Some("N/A".into()), None),
            ("".into(), None, None),
        ]]
    } else {
        let (unit_long, unit_short) = match temp_type {
            data_harvester::temperature::TemperatureType::Celsius => ("°C", "C"),
            data_harvester::temperature::TemperatureType::Kelvin => ("K", "K"),
            data_harvester::temperature::TemperatureType::Fahrenheit => ("°F", "F"),
        };

        current_data
            .temp_harvest
            .iter()
            .map(|temp_harvest| {
                let val = temp_harvest.temperature.ceil().to_string();
                vec![
                    (temp_harvest.name.clone().into(), None, None),
                    (
                        format!("{}{}", val, unit_long).into(),
                        Some(format!("{}{}", val, unit_short).into()),
                        None,
                    ),
                ]
            })
            .collect()
    }
}

pub fn convert_disk_row(current_data: &DataCollection) -> TextTableData {
    if current_data.disk_harvest.is_empty() {
        vec![vec![
            ("No Disks Found".into(), Some("N/A".into()), None),
            ("".into(), None, None),
        ]]
    } else {
        current_data
            .disk_harvest
            .iter()
            .zip(&current_data.io_labels)
            .map(|(disk, (io_read, io_write))| {
                let free_space_fmt = if let Some(free_space) = disk.free_space {
                    let converted_free_space = get_decimal_bytes(free_space);
                    Cow::Owned(format!(
                        "{:.*}{}",
                        0, converted_free_space.0, converted_free_space.1
                    ))
                } else {
                    "N/A".into()
                };
                let total_space_fmt = if let Some(total_space) = disk.total_space {
                    let converted_total_space = get_decimal_bytes(total_space);
                    Cow::Owned(format!(
                        "{:.*}{}",
                        0, converted_total_space.0, converted_total_space.1
                    ))
                } else {
                    "N/A".into()
                };

                let usage_fmt = if let (Some(used_space), Some(total_space)) =
                    (disk.used_space, disk.total_space)
                {
                    Cow::Owned(format!(
                        "{:.0}%",
                        used_space as f64 / total_space as f64 * 100_f64
                    ))
                } else {
                    "N/A".into()
                };

                vec![
                    (disk.name.clone().into(), None, None),
                    (disk.mount_point.clone().into(), None, None),
                    (usage_fmt, None, None),
                    (free_space_fmt, None, None),
                    (total_space_fmt, None, None),
                    (io_read.clone().into(), None, None),
                    (io_write.clone().into(), None, None),
                ]
            })
            .collect::<Vec<_>>()
    }
}

pub fn convert_cpu_data_points(
    current_data: &DataCollection, existing_cpu_data: &mut Vec<ConvertedCpuData>,
) {
    let current_time = current_data.current_instant;

    // Initialize cpu_data_vector if the lengths don't match...
    if let Some((_time, data)) = &current_data.timed_data_vec.last() {
        if data.cpu_data.len() + 1 != existing_cpu_data.len() {
            *existing_cpu_data = vec![ConvertedCpuData