use std::process::{Command, Stdio};

use super::{Package, PackageManager};

use crate::error::{Error, Result};

pub struct Pacman;

impl PackageManager for Pacman {
    fn get_installed(&self) -> Result<Vec<super::Package>> {
        let pm_pkgs = Command::new("pacman").args(["-Q"]).output().unwrap();
        let pm_e_pkgs = Command::new("pacman")
            .args(["-Q", "--explicit"])
            .output()
            .unwrap();

        let pm_pkgs_out = String::from_utf8(pm_pkgs.stdout).unwrap();
        let pm_e_pkgs_out = String::from_utf8(pm_e_pkgs.stdout).unwrap();

        let mut pkgs: Vec<Package> = Vec::new();
        let pacman_pkgs: Vec<&str> = pm_pkgs_out.split('\n').collect();
        for pkg in pacman_pkgs {
            if pkg.is_empty() {
                continue;
            };
            let split: Vec<&str> = pkg.split_whitespace().collect();
            if split.len() != 2 {
                return Err(Error::UnknownOutput);
            };

            let explicit = pm_e_pkgs_out.contains(pkg);

            pkgs.push(Package {
                id: split[0].to_string(),
                version: split[1].to_string(),
                explicit,
            });
        }

        Ok(pkgs)
    }

    fn install(&self, pkgs: Vec<super::Package>) -> Result<()> {
        let mut args = vec!["--noconfirm".to_string(), "-S".to_string()];

        for pkg in pkgs {
            args.push(pkg.id);
        }
        Command::new("pacman")
            .stdout(Stdio::inherit())
            .args(args)
            .spawn()?
            .wait_with_output()?;
        Ok(())
    }
}