tourmaline/src/task/base_task.rs

use std::path::PathBuf;

use crate::{distro::OSConfig, error::AppResult};

use super::{exec_builder::ExecBuilder, Task, TaskTrait};
use embed_nu::IntoValue;
use lazy_static::lazy_static;

#[derive(Clone, Debug)]
pub enum BaseTask {
    ConfigureLocale,
    ConfigureNetwork,
    CreatePartitions,
    InstallBase,
    InstallBootloader,
    InstallDesktop,
    InstallExtraPackages,
    SetupRootUser,
    SetupUsers,
}

impl BaseTask {
    fn config_key(&self) -> Option<&'static str> {
        let field = match self {
            BaseTask::ConfigureLocale => "locale",
            BaseTask::ConfigureNetwork => "network",
            BaseTask::CreatePartitions => "partitions",
            BaseTask::InstallBootloader => "bootloader",
            BaseTask::InstallDesktop => "desktop",
            BaseTask::InstallExtraPackages => "extra_packages",
            BaseTask::SetupRootUser => "root_user",
            BaseTask::SetupUsers => "users",
            _ => return None,
        };
        Some(field)
    }

    fn task_name(&self) -> &'static str {
        match self {
            BaseTask::ConfigureLocale => "configure-locale",
            BaseTask::ConfigureNetwork => "configure-network",
            BaseTask::CreatePartitions => "create-partitions",
            BaseTask::InstallBase => "install-base",
            BaseTask::InstallBootloader => "install-bootloader",
            BaseTask::InstallDesktop => "install-desktop",
            BaseTask::InstallExtraPackages => "install-extra-packages",
            BaseTask::SetupRootUser => "setup-root-user",
            BaseTask::SetupUsers => "setup-users",
        }
    }
}

impl TaskTrait for BaseTask {
    fn up(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        let script = PathBuf::from(self.task_name()).join("up.nu");

        let task_config = if let Some(key) = self.config_key() {
            config.get_nu_value(key)?
        } else {
            Option::<()>::None.into_value()
        };

        Ok(ExecBuilder {
            script,
            os_config: config.to_owned(),
            task_config,
        })
    }

    fn down(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        let script = PathBuf::from(self.task_name()).join("down.nu");
        let task_config = if let Some(key) = self.config_key() {
            config.get_nu_value(key)?
        } else {
            Option::<()>::None.into_value()
        };

        Ok(ExecBuilder {
            script,
            os_config: config.to_owned(),
            task_config,
        })
    }
}

lazy_static! {
    pub static ref ALL_BASE_TASKS: Vec<Task> = get_all_base_tasks();
}

fn get_all_base_tasks() -> Vec<Task> {
    vec![
        Task::Base(BaseTask::ConfigureLocale),
        Task::Base(BaseTask::ConfigureNetwork),
        Task::Base(BaseTask::CreatePartitions),
        Task::Base(BaseTask::InstallBase),
        Task::Base(BaseTask::InstallBootloader),
        Task::Base(BaseTask::InstallDesktop),
        Task::Base(BaseTask::InstallExtraPackages),
        Task::Base(BaseTask::SetupRootUser),
        Task::Base(BaseTask::SetupUsers),
    ]
}