ferrix_app/

messages.rs

/* messages.rs
 *
 * Copyright 2025 Michail Krasnov <mskrasnov07@ya.ru>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

//! UI events handler & Data Updater

use ferrix_lib::{
    battery::BatInfo,
    cpu::{Processors, Stat},
    cpu_freq::CpuFreq,
    drm::Video,
    init::{Connection, SystemdServices},
    parts::Mounts,
    ram::{RAM, Swaps},
    soft::InstalledPackages,
    sys::{Groups, KModules, Kernel, OsRelease, Users},
    traits::ToJson,
    vulnerabilities::Vulnerabilities,
};
use iced::{Task, color};

use crate::{
    DataLoadingState, Page, SETTINGS_PATH, System,
    dmi::DMIData,
    export::{ExportData, ExportFormat, ExportMode},
    ferrix::{Ferrix, FerrixData},
    settings::Style,
    styles::CPU_CHARTS_COLORS,
    utils::get_home,
    widgets::line_charts::LineSeries,
};

#[derive(Debug, Clone)]
pub enum Message {
    DataReceiver(DataReceiverMessage),
    ExportManager(ExportManagerMessage),
    Settings(SettingsMessage),
    Buttons(ButtonsMessage),

    SelectPage(Page),
    Dummy,
}

impl Message {
    pub fn update<'a>(self, state: &'a mut Ferrix) -> Task<Message> {
        match self {
            Self::DataReceiver(data) => data.update(&mut state.data, state.current_page),
            Self::ExportManager(export) => export.update(state),
            Self::Settings(settings) => settings.update(state),
            Self::Buttons(buttons) => buttons.update(state),

            Self::SelectPage(page) => state.select_page(page),
            Self::Dummy => Task::none(),
        }
    }
}

impl Ferrix {
    fn select_page(&mut self, page: Page) -> Task<Message> {
        self.current_page = page;
        Task::none()
    }
}

#[derive(Debug, Clone)]
pub enum DataReceiverMessage {
    GetCPUData,
    CPUDataReceived(DataLoadingState<Processors>),

    // AddTotalCPUUsage,
    AddCPUCoreLineSeries,
    ChangeShowCPUChartElements(usize),

    GetProcStat,
    ProcStatReceived(DataLoadingState<Stat>),

    GetCPUFrequency,
    CPUFrequencyReceived(DataLoadingState<CpuFreq>),

    GetCPUVulnerabilities,
    CPUVulnerabilitiesReveived(DataLoadingState<Vulnerabilities>),

    GetRAMData,
    RAMDataReceived(DataLoadingState<RAM>),

    GetSwapData,
    SwapDataReceived(DataLoadingState<Swaps>),

    AddTotalRAMUsage,

    GetStorageData,
    StorageDataReceived(DataLoadingState<Mounts>),

    GetDMIData,
    DMIDataReceived(DataLoadingState<DMIData>),

    GetBatInfo,
    BatInfoReceived(DataLoadingState<BatInfo>),

    GetDRMData,
    DRMDataReceived(DataLoadingState<Video>),

    GetOsReleaseData,
    OsReleaseDataReceived(DataLoadingState<OsRelease>),

    GetKernelData,
    KernelDataReceived(DataLoadingState<Kernel>),

    GetKModsData,
    KModsDataReceived(DataLoadingState<KModules>),

    GetUsersData,
    UsersDataReceived(DataLoadingState<Users>),

    GetGroupsData,
    GroupsDataReceived(DataLoadingState<Groups>),

    GetSystemdServices,
    SystemdServicesReceived(DataLoadingState<SystemdServices>),

    GetPackagesList,
    PackagesListReceived(DataLoadingState<InstalledPackages>),

    GetSystemData,
    SystemDataReceived(DataLoadingState<System>),
}

impl DataReceiverMessage {
    pub fn update<'a>(self, fx: &'a mut FerrixData, cur_page: Page) -> Task<Message> {
        match self {
            Self::CPUDataReceived(state) => {
                fx.proc_data = state;
                Task::none()
            }
            Self::GetCPUData => Task::perform(
                async move {
                    let proc = Processors::new();
                    match proc {
                        Ok(proc) => DataLoadingState::Loaded(proc),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::CPUDataReceived(val)),
            ),
            Self::ProcStatReceived(state) => {
                if fx.curr_proc_stat.is_some() {
                    fx.prev_proc_stat = fx.curr_proc_stat.clone();
                } else if fx.curr_proc_stat.is_none() && fx.prev_proc_stat.is_none() {
                    fx.prev_proc_stat = state.clone();
                }
                fx.curr_proc_stat = state;
                Task::none()
            }
            Self::GetProcStat => Task::perform(
                async move {
                    let stat = Stat::new();
                    match stat {
                        Ok(stat) => DataLoadingState::Loaded(stat),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::ProcStatReceived(val)),
            ),
            // Self::AddTotalCPUUsage => {
            //     fx.cpu_usage_chart.push_value(match &fx.curr_proc_stat {
            //         DataLoadingState::Loaded(val) => val.cpu.unwrap().usage_percentage({
            //             let prev = fx.prev_proc_stat.clone().unwrap();
            //             prev.cpu
            //         }) as f64,
            //         _ => 0.,
            //     });
            //     Task::none()
            // }
            Self::AddCPUCoreLineSeries => {
                let curr_proc = &fx.curr_proc_stat;
                let prev_proc = &fx.prev_proc_stat;

                if curr_proc.is_none() || prev_proc.is_none() {
                    return Task::none();
                }
                let curr_proc = curr_proc.to_option().unwrap();
                let prev_proc = prev_proc.to_option().unwrap();

                if curr_proc.cpus.len() != prev_proc.cpus.len() {
                    return Task::none();
                }
                let len = curr_proc.cpus.len();

                let colors = CPU_CHARTS_COLORS;
                for id in 0..len {
                    let percent =
                        curr_proc.cpus[id].usage_percentage(Some(prev_proc.cpus[id])) as f64;

                    if fx.show_cpus_chart.get(&id).is_none() {
                        let color = {
                            if colors.len() - 1 < id {
                                color!(255, 255, 255)
                            } else {
                                colors[id]
                            }
                        };
                        let mut line =
                            LineSeries::new(format!("CPU #{id}"), color, fx.show_chart_elements);
                        line.push(percent);

                        fx.cpu_usage_chart.push_series(line);
                        fx.show_cpus_chart.insert(id);
                    } else {
                        fx.cpu_usage_chart.push_to(id, percent);
                    }
                }

                Task::none()
            }
            Self::ChangeShowCPUChartElements(elems) => {
                fx.show_chart_elements = elems;

                fx.cpu_usage_chart.set_max_values(elems);
                fx.ram_usage_chart.set_max_values(elems);

                Task::none()
            }
            Self::CPUFrequencyReceived(state) => {
                fx.cpu_freq = state;
                Task::none()
            }
            Self::GetCPUFrequency => Task::perform(
                async move {
                    let cpu_freq = CpuFreq::new();
                    match cpu_freq {
                        Ok(cpu_freq) => DataLoadingState::Loaded(cpu_freq),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(DataReceiverMessage::CPUFrequencyReceived(val)),
            ),
            Self::CPUVulnerabilitiesReveived(state) => {
                fx.cpu_vulnerabilities = state;
                Task::none()
            }
            Self::GetCPUVulnerabilities => Task::perform(
                async move {
                    let vuln = Vulnerabilities::new();
                    match vuln {
                        Ok(vuln) => DataLoadingState::Loaded(vuln),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::CPUVulnerabilitiesReveived(val)),
            ),
            Self::StorageDataReceived(state) => {
                fx.storages = state;
                Task::none()
            }
            Self::GetStorageData => Task::perform(
                async move {
                    let storage = Mounts::new();
                    match storage {
                        Ok(storage) => DataLoadingState::Loaded(storage),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(DataReceiverMessage::StorageDataReceived(val)),
            ),
            Self::DMIDataReceived(state) => {
                if state.some_value() && fx.is_polkit {
                    fx.dmi_data = state;
                } else if !fx.is_polkit {
                    fx.dmi_data = state;
                }
                Task::none()
            }
            Self::GetDMIData => {
                if !fx.is_polkit && fx.dmi_data.is_none() && cur_page == Page::DMI {
                    fx.is_polkit = true;
                    Task::perform(async move { crate::dmi::get_dmi_data().await }, |val| {
                        Message::DataReceiver(Self::DMIDataReceived(val))
                    })
                } else {
                    Task::none()
                }
            }
            Self::BatInfoReceived(state) => {
                fx.bat_data = state;
                Task::none()
            }
            Self::GetBatInfo => Task::perform(
                async move {
                    let bat = BatInfo::new();
                    match bat {
                        Ok(bat) => DataLoadingState::Loaded(bat),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::BatInfoReceived(val)),
            ),
            Self::DRMDataReceived(state) => {
                fx.drm_data = state;
                Task::none()
            }
            Self::GetDRMData => Task::perform(
                async move {
                    let drm = Video::new();
                    match drm {
                        Ok(drm) => DataLoadingState::Loaded(drm),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::DRMDataReceived(val)),
            ),
            Self::RAMDataReceived(state) => {
                fx.ram_data = state;
                Task::none()
            }
            Self::GetRAMData => Task::perform(
                async move {
                    let ram = RAM::new();
                    match ram {
                        Ok(ram) => DataLoadingState::Loaded(ram),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::RAMDataReceived(val)),
            ),
            Self::SwapDataReceived(state) => {
                fx.swap_data = state;
                Task::none()
            }
            Self::GetSwapData => Task::perform(
                async move {
                    let swap = Swaps::new();
                    match swap {
                        Ok(swap) => DataLoadingState::Loaded(swap),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::SwapDataReceived(val)),
            ),
            Self::AddTotalRAMUsage => {
                let ram = &fx.ram_data;
                let swap = &fx.swap_data;

                if ram.is_none() {
                    return Task::none();
                }
                let ram = ram.to_option().unwrap();
                let ram_color = color!(128, 64, 255);

                let ram_usage = ram.usage_percentage().unwrap_or(0.);

                if fx.ram_usage_chart.series_count() == 0 {
                    let mut ram_line = LineSeries::new(
                        format!("RAM"),
                        ram_color,
                        fx.show_chart_elements,
                        // fx.show_chart_elements,
                    );
                    ram_line.push(ram_usage);
                    fx.ram_usage_chart.push_series(ram_line);
                } else {
                    fx.ram_usage_chart.push_to(0, ram_usage);
                }

                if let Some(swap) = swap.to_option() {
                    let len = swap.swaps.len();
                    let colors = CPU_CHARTS_COLORS;

                    let current_series_cnt = fx.ram_usage_chart.series_count();

                    for id in 0..len {
                        let series_idx = id + 1;
                        let swap_usage = swap.swaps[id].usage_percentage().unwrap_or(0.);

                        if series_idx >= current_series_cnt {
                            let color = if colors.len() - 1 < id {
                                color!(255, 255, 128)
                            } else {
                                colors[id]
                            };
                            let mut line = LineSeries::new(
                                swap.swaps[id].filename.clone(),
                                color,
                                fx.show_chart_elements,
                            );
                            line.push(swap_usage);

                            fx.ram_usage_chart.push_series(line);
                        } else {
                            fx.ram_usage_chart.push_to(series_idx, swap_usage);
                        }
                    }
                }
                Task::none()
            }
            Self::OsReleaseDataReceived(state) => {
                fx.osrel_data = state;
                Task::none()
            }
            Self::GetOsReleaseData => Task::perform(
                async move {
                    let osrel = OsRelease::new();
                    match osrel {
                        Ok(osrel) => DataLoadingState::Loaded(osrel),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::OsReleaseDataReceived(val)),
            ),
            Self::KernelDataReceived(state) => {
                fx.kernel_data = state;
                Task::none()
            }
            Self::GetKernelData => Task::perform(
                async move {
                    let kern = Kernel::new();
                    match kern {
                        Ok(kern) => {
                            // kern.mods.modules.sort_by_key(|md| md.name.clone());
                            DataLoadingState::Loaded(kern)
                        }
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::KernelDataReceived(val)),
            ),
            Self::KModsDataReceived(state) => {
                fx.kmods_data = state;
                Task::none()
            }
            Self::GetKModsData => Task::perform(
                async move {
                    let kern = KModules::new();
                    match kern {
                        Ok(mut kern) => {
                            kern.modules.sort_by_key(|module| module.name.clone());
                            DataLoadingState::Loaded(kern)
                        }
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::KModsDataReceived(val)),
            ),
            Self::UsersDataReceived(state) => {
                fx.users_list = state;
                Task::none()
            }
            Self::GetUsersData => Task::perform(
                async move {
                    let users = Users::new();
                    match users {
                        Ok(mut users) => {
                            users.users.sort_by_key(|usr| usr.uid);
                            DataLoadingState::Loaded(users)
                        }
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::UsersDataReceived(val)),
            ),
            Self::GroupsDataReceived(state) => {
                fx.groups_list = state;
                Task::none()
            }
            Self::GetGroupsData => Task::perform(
                async move {
                    let groups = Groups::new();
                    match groups {
                        Ok(mut groups) => {
                            groups.groups.sort_by_key(|grp| grp.gid);
                            DataLoadingState::Loaded(groups)
                        }
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::GroupsDataReceived(val)),
            ),
            Self::SystemdServicesReceived(state) => {
                fx.sysd_services_list = state;
                Task::none()
            }
            Self::GetSystemdServices => Task::perform(
                async move {
                    let conn = Connection::session().await;
                    if let Err(why) = conn {
                        return DataLoadingState::Error(why.to_string());
                    }
                    let conn = conn.unwrap();

                    let srv_list = SystemdServices::new_from_connection(&conn).await;
                    match srv_list {
                        Ok(srv_list) => DataLoadingState::Loaded(srv_list),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::SystemdServicesReceived(val)),
            ),
            Self::SystemDataReceived(state) => {
                fx.system = state;
                Task::none()
            }
            Self::GetPackagesList => Task::perform(
                async move {
                    let pkglist = InstalledPackages::get();
                    match pkglist {
                        Ok(pkglist) => DataLoadingState::Loaded(pkglist),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::PackagesListReceived(val)),
            ),
            Self::PackagesListReceived(state) => {
                fx.installed_pkgs_list = state;
                Task::none()
            }
            Self::GetSystemData => Task::perform(
                async move {
                    let sys = System::new();
                    match sys {
                        Ok(sys) => DataLoadingState::Loaded(sys),
                        Err(why) => DataLoadingState::Error(why.to_string()),
                    }
                },
                |val| Message::DataReceiver(Self::SystemDataReceived(val)),
            ),
        }
    }
}

pub type ExportToFilePath = String;

#[derive(Debug, Clone)]
pub enum ExportManagerMessage {
    ExportData(ExportToFilePath),
    ExportFormatSelected(ExportFormat),
    ExportModeSelected(ExportMode),
}

impl ExportManagerMessage {
    pub fn update<'a>(self, fx: &'a mut Ferrix) -> Task<Message> {
        match self {
            Self::ExportData(path) => fx.export_data(&path),
            _ => Task::none(),
        }
    }
}

impl Ferrix {
    fn export_data(&mut self, path: &str) -> Task<Message> {
        let json = ExportData::from(self)
            .to_json()
            .unwrap_or("{error}".to_string());
        let _ = std::fs::write(path, json);
        Task::none()
    }
}

#[derive(Debug, Clone)]
pub enum SettingsMessage {
    ChangeStyle(Style),
    ChangeUpdatePeriod(u8),
}

impl SettingsMessage {
    pub fn update<'a>(self, fx: &'a mut Ferrix) -> Task<Message> {
        match self {
            Self::ChangeStyle(style) => fx.change_style(style),
            Self::ChangeUpdatePeriod(secs) => fx.change_update_period(secs),
        }
    }
}

impl Ferrix {
    fn change_style(&mut self, style: Style) -> Task<Message> {
        self.settings.style = style;
        self.data.cpu_usage_chart.set_style(&style.to_theme());
        self.data.ram_usage_chart.set_style(&style.to_theme());
        Task::none()
    }

    fn change_update_period(&mut self, per: u8) -> Task<Message> {
        self.settings.update_period = per;
        Task::none()
    }
}

#[derive(Debug, Clone)]
pub enum ButtonsMessage {
    LinkButtonPressed(String),
    SaveSettingsButtonPressed,
    CopyButtonPressed(String),
}

impl ButtonsMessage {
    pub fn update<'a>(self, fx: &'a mut Ferrix) -> Task<Message> {
        match self {
            Self::LinkButtonPressed(url) => fx.go_to_url(&url),
            Self::SaveSettingsButtonPressed => fx.save_settings(),
            Self::CopyButtonPressed(s) => iced::clipboard::write(s),
        }
    }
}

impl Ferrix {
    fn go_to_url(&self, url: &str) -> Task<Message> {
        // TODO: add error handling
        let _ = crate::utils::xdg_open(url);
        Task::none()
    }

    fn save_settings(&mut self) -> Task<Message> {
        // TODO: add error handling
        let _ = self
            .settings
            .write(get_home().join(".config").join(SETTINGS_PATH));
        Task::none()
    }
}