use std::path::PathBuf;

use embed_nu::IntoValue;

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

use self::exec_builder::ExecBuilder;
pub mod base_tasks;
pub mod exec_builder;
pub mod task_executor;

pub trait TaskTrait {
    fn up(&self, config: &OSConfig) -> AppResult<ExecBuilder>;
    fn down(&self, config: &OSConfig) -> AppResult<ExecBuilder>;
}

#[derive(Clone, Debug)]
pub enum Task {
    Base(BaseTask),
    Custom(CustomTask),
}

impl TaskTrait for Task {
    #[inline]
    fn up(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        match self {
            Task::Base(b) => b.up(config),
            Task::Custom(c) => c.up(config),
        }
    }

    #[inline]
    fn down(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        match self {
            Task::Base(b) => b.down(config),
            Task::Custom(c) => c.down(config),
        }
    }
}

#[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,
        })
    }
}

#[derive(Clone, Debug)]
pub struct CustomTask {
    config_key: String,
    up_script: PathBuf,
    down_script: PathBuf,
}

impl TaskTrait for CustomTask {
    fn up(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        let task_config = config.get_nu_value(&self.config_key)?;

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

    fn down(&self, config: &OSConfig) -> AppResult<ExecBuilder> {
        let task_config = config.get_nu_value(&self.config_key)?;

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