use super::{PackageError, PackageManager};
use std::process::Command;

pub struct Yay {
    dry_run: bool,
}

impl Yay {
    pub fn new() -> Self {
        Self { dry_run: false }
    }

    pub fn dry_run(mut self, dry_run: bool) -> Self {
        self.dry_run = dry_run;
        self
    }

    fn run_yay(&self, args: &[&str]) -> Result<(), PackageError> {
        if self.dry_run {
            println!("[dry-run] yay {}", args.join(" "));
            return Ok(());
        }

        let output = Command::new("yay").args(args).output()?;

        if !output.status.success() {
            return Err(PackageError::InstallFailed {
                package: args.join(" "),
                message: String::from_utf8_lossy(&output.stderr).to_string(),
            });
        }

        Ok(())
    }
}

impl PackageManager for Yay {
    fn name(&self) -> &'static str {
        "yay"
    }

    fn is_available(&self) -> bool {
        Command::new("yay")
            .arg("--version")
            .output()
            .map(|o| o.status.success())
            .unwrap_or(false)
    }

    fn needs_sudo(&self) -> bool {
        // yay handles sudo internally
        false
    }

    fn install(&self, packages: &[String]) -> Result<(), PackageError> {
        if packages.is_empty() {
            return Ok(());
        }

        let mut args = vec!["-S", "--noconfirm"];
        for pkg in packages {
            args.push(pkg);
        }

        self.run_yay(&args)
    }

    fn install_with_sudo(&self, packages: &[String], _password: &str) -> Result<(), PackageError> {
        // yay handles sudo internally, no need for password
        self.install(packages)
    }

    fn uninstall(&self, packages: &[String]) -> Result<(), PackageError> {
        if packages.is_empty() {
            return Ok(());
        }

        let mut args = vec!["-R", "--noconfirm"];
        for pkg in packages {
            args.push(pkg);
        }

        self.run_yay(&args)
    }

    fn is_installed(&self, package: &str) -> Result<bool, PackageError> {
        let output = Command::new("yay").args(["-Q", package]).output()?;

        Ok(output.status.success())
    }

    fn update(&self) -> Result<(), PackageError> {
        self.run_yay(&["-Sy"])
    }

    fn upgrade(&self) -> Result<(), PackageError> {
        self.run_yay(&["-Syu", "--noconfirm"])
    }
}

impl Default for Yay {
    fn default() -> Self {
        Self::new()
    }
}