use crate::utils::cmd::{Cmd, CmdOutput};

use super::{PackageError, PackageList, PackageManager};

/// This structure is mostly used as an indirection for testing purposes.
/// But you can use it to build your own apt commands.
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct AptCmd(pub Cmd);

impl AptCmd {
    pub fn new() -> AptCmd {
        AptCmd(
            Cmd::new("apt").env("DEBIAN_FRONTEND", "noninteractive")
        )
    }

    pub fn update() -> AptCmd {
        let mut cmd = Self::new();
        cmd.0 = cmd.0.arg("update");
        cmd
    }

    pub fn install(list: PackageList) -> AptCmd {
        let mut cmd = Self::new();
        cmd.0 = cmd.0.arg("install").args(list.list());
        cmd
    }

    pub fn remove(list: PackageList) -> AptCmd {
        let mut cmd = Self::new();
        cmd.0 = cmd.0.arg("remove").args(list.list());
        cmd
    }

    pub fn run(self) -> Result<CmdOutput, std::io::Error> {
        self.0.run()
    }
}

#[derive(Debug)]
pub struct AptManager;

impl PackageManager for AptManager {
    fn name(&self) -> &'static str {
        "apt"
    }
    
    fn update(&self) -> Result<(), PackageError> {
        let res = AptCmd::update().run()?;

        if ! res.success {
            return Err(PackageError::CmdFail(res));
        }
        Ok(())
    }

    fn install(&self, list: PackageList) -> Result<(), PackageError> {
        let res = AptCmd::install(list).run()?;
  
        if ! res.success {
            return Err(PackageError::CmdFail(res));
        }
        Ok(())
    }

    fn remove(&self, list: PackageList) -> Result<(), PackageError> {
        let res = AptCmd::remove(list).run()?;
  
        if ! res.success {
            return Err(PackageError::CmdFail(res));
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use super::super::IntoPackageList;
    use std::collections::HashMap;

    #[test]
    pub fn update_cmd() {
        let cmd = AptCmd::update();
        let mut env: HashMap<String, String> = HashMap::new();
        env.insert("DEBIAN_FRONTEND".to_string(), "noninteractive".to_string());

        assert_eq!(
            cmd.0,
            Cmd {
                program: "apt".to_string(),
                args: vec!("update".to_string()),
                stdin: None,
                chdir: None,
                env,
            }
        )
    }

    #[test]
    pub fn install_cmd() {
        let cmd = AptCmd::install(vec!("sl").into_package_list());
        let mut env: HashMap<String, String> = HashMap::new();
        env.insert("DEBIAN_FRONTEND".to_string(), "noninteractive".to_string());

        assert_eq!(
            cmd.0,
            Cmd {
                program: "apt".to_string(),
                args: vec!("install", "sl").iter().map(|x| x.to_string()).collect(),
                stdin: None,
                chdir: None,
                env,
            }
        )
    }

    #[test]
    pub fn install_cmd_multi() {
        let cmd = AptCmd::install(vec!("sl", "hello").into_package_list());
        let mut env: HashMap<String, String> = HashMap::new();
        env.insert("DEBIAN_FRONTEND".to_string(), "noninteractive".to_string());

        assert_eq!(
            cmd.0,
            Cmd {
                program: "apt".to_string(),
                args: vec!("install", "sl", "hello").iter().map(|x| x.to_string()).collect(),
                stdin: None,
                chdir: None,
                env,
            }
        )
    }

    #[test]
    pub fn remove_cmd() {
        let cmd = AptCmd::remove(vec!("sl").into_package_list());
        let mut env: HashMap<String, String> = HashMap::new();
        env.insert("DEBIAN_FRONTEND".to_string(), "noninteractive".to_string());

        assert_eq!(
            cmd.0,
            Cmd {
                program: "apt".to_string(),
                args: vec!("remove", "sl").iter().map(|x| x.to_string()).collect(),
                stdin: None,
                chdir: None,
                env,
            }
        )
    }

    #[test]
    pub fn remove_cmd_multi() {
        let cmd = AptCmd::remove(vec!("sl", "hello").into_package_list());
        let mut env: HashMap<String, String> = HashMap::new();
        env.insert("DEBIAN_FRONTEND".to_string(), "noninteractive".to_string());

        assert_eq!(
            cmd.0,
            Cmd {
                program: "apt".to_string(),
                args: vec!("remove", "sl", "hello").iter().map(|x| x.to_string()).collect(),
                stdin: None,
                chdir: None,
                env,
            }
        )
    }
}