use crate::client::ssh;
use crate::client::ssh::ProgramKind;
use crate::Protocol;
use bstr::{BString, ByteSlice, ByteVec};
use std::ffi::OsStr;

impl ProgramKind {
    /// Provide the name of the executable that belongs to this kind, or `None` if the kind is `Simple`.
    pub fn exe(&self) -> Option<&'static OsStr> {
        Some(OsStr::new(match self {
            ProgramKind::Ssh => "ssh",
            ProgramKind::Plink => "plink",
            ProgramKind::Putty => "putty",
            ProgramKind::TortoisePlink => "tortoiseplink.exe",
            ProgramKind::Simple => return None,
        }))
    }

    /// Prepare all information needed to invoke the ssh command
    pub(crate) fn prepare_invocation(
        &self,
        ssh_cmd: &OsStr,
        url: &git_url::Url,
        desired_version: Protocol,
        disallow_shell: bool,
    ) -> Result<git_command::Prepare, ssh::invocation::Error> {
        let mut prepare = git_command::prepare(ssh_cmd).with_shell();
        if disallow_shell {
            prepare.use_shell = false;
        }
        let host = url.host().expect("present in ssh urls");
        match self {
            ProgramKind::Ssh => {
                if desired_version != Protocol::V1 {
                    prepare = prepare
                        .args(["-o", "SendEnv=GIT_PROTOCOL"])
                        .env("GIT_PROTOCOL", format!("version={}", desired_version as usize))
                }
                if let Some(port) = url.port {
                    prepare = prepare.arg(format!("-p{}", port));
                }
            }
            ProgramKind::Plink | ProgramKind::Putty | ProgramKind::TortoisePlink => {
                if *self == ProgramKind::TortoisePlink {
                    prepare = prepare.arg("-batch");
                }
                if let Some(port) = url.port {
                    prepare = prepare.arg(format!("-P{}", port));
                }
            }
            ProgramKind::Simple => {
                if url.port.is_some() {
                    return Err(ssh::invocation::Error {
                        command: ssh_cmd.into(),
                        function: "setting the port",
                    });
                }
            }
        };
        let host_as_ssh_arg = match url.user() {
            Some(user) => format!("{user}@{host}"),
            None => host.into(),
        };

        // Try to force ssh to yield english messages (for parsing later)
        Ok(prepare.arg(host_as_ssh_arg).env("LANG", "C").env("LC_ALL", "C"))
    }

    /// Note that the caller has to assure that the ssh program is launched in English by setting the locale.
    pub(crate) fn line_to_permission_err(&self, line: BString) -> Result<std::io::Error, BString> {
        let is_perm_err = match self {
            ProgramKind::Ssh | ProgramKind::Simple => {
                line.contains_str(b"Permission denied") || line.contains_str(b"permission denied")
            }
            ProgramKind::Plink | ProgramKind::Putty | ProgramKind::TortoisePlink => line.contains_str(b"publickey"),
        };
        if is_perm_err {
            Ok(std::io::Error::new(
                std::io::ErrorKind::PermissionDenied,
                Vec::from(line).into_string_lossy(),
            ))
        } else {
            Err(line)
        }
    }
}

impl<'a> From<&'a OsStr> for ProgramKind {
    fn from(v: &'a OsStr) -> Self {
        let p = std::path::Path::new(v);
        match p.file_stem().and_then(|s| s.to_str()) {
            None => ProgramKind::Simple,
            Some(stem) => {
                if stem.eq_ignore_ascii_case("ssh") {
                    ProgramKind::Ssh
                } else if stem.eq_ignore_ascii_case("plink") {
                    ProgramKind::Plink
                } else if stem.eq_ignore_ascii_case("putty") {
                    ProgramKind::Putty
                } else if stem.eq_ignore_ascii_case("tortoiseplink") {
                    ProgramKind::TortoisePlink
                } else {
                    ProgramKind::Simple
                }
            }
        }
    }
}