use super::Command;
use chrono::prelude::*;
use regex::Regex;
use std::cmp::Ordering;
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
use std::fmt::{Display, Formatter, Result};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
use uuid::Uuid;

impl Command {
    /// uses the PATH environment variable to search
    /// for a filename matching the specified name.
    /// if a matching filename is not found, it
    /// will check for the existence of name.exe
    /// and name.bat
    ///
    /// Example
    ///
    /// ```
    /// use reef::Command;
    /// let git_path = Command::which("git").unwrap();
    /// assert!(git_path.exists());
    /// ```
    pub fn which(name: &str) -> Option<PathBuf> {
        _which(name)
    }

    /// extracts the text following the shebang #!
    ///
    /// Example
    ///
    /// given a file
    /// with the contents:
    ///
    /// #!C:/Ruby26-x64/bin/ruby.exe
    ///
    /// the shebang method will return C:/Ruby26-x64/bin/ruby.exe
    ///
    /// ```
    /// use reef::Command;
    /// use std::env;
    /// let path = std::env::temp_dir().join("test.rb");
    /// std::fs::write(&path,b"#!C:/Ruby26-x64/bin/ruby.exe")?;
    /// let target = Command::shebang(&path).unwrap();
    /// assert_eq!("C:/Ruby26-x64/bin/ruby.exe",target);
    /// # Ok::<(), std::io::Error>(())
    /// ```
    pub fn shebang(path: &Path) -> std::result::Result<String, Box<dyn std::error::Error>> {
        _shebang(path)
    }

    pub fn new(command: &str, path: &Path) -> super::Command {
        let (name, args) = parse_command(command);
        let mut c = super::Command::default();
        c.timeout = Duration::from_secs(300);
        c.name = name;
        c.args = args;
        c.dir = path.to_path_buf();
        c
    }

    /// execute a command
    pub fn exec(&self) -> std::result::Result<super::Command, Box<dyn std::error::Error>> {
        _exec(self)
    }

    /// The working directory
    pub fn dir(&self) -> PathBuf {
        let mut dir = PathBuf::new();
        dir.push(&self.dir);
        dir
    }
    /// The command name
    pub fn name(&self) -> &str {
        &self.name
    }
    // Indication of success or failure
    pub fn success(&self) -> bool {
        self.success
    }

    pub fn success_symbol(&self) -> String {
        match self.success() {
            true => "✓".to_string(),
            false => "X".to_string(),
        }
    }

    /// The exit code of the process
    pub fn exit_code(&self) -> i32 {
        self.exit_code
    }
    pub fn stdout(&self) -> &str {
        &self.stdout
    }

    pub fn stderr(&self) -> &str {
        &self.stderr
    }

    pub fn duration(&self) -> &Duration {
        &self.duration
    }

    pub fn timeout(&self) -> &Duration {
        &self.timeout
    }

    pub fn set_timeout(&self, timeout: Duration) -> super::Command {
        let mut command = self.clone();
        command.timeout = timeout;
        command
    }

    pub fn tags(&self) -> &HashSet<String> {
        &self.tags
    }

    pub fn set_tags(&mut self, tags: &HashSet<String>) {
        self.tags = tags.clone()
    }

    pub fn uuid(&self) -> &str {
        &self.uuid
    }

    pub fn duration_string(&self) -> String {
        let duration = self.duration();
        match duration.as_micros() > 999 {
            false => format!("{}\u{00b5}s", duration.as_micros()),
            true => match duration.as_millis() > 999 {
                false => format!("{}ms", duration.as_millis()),
                true => match duration.as_secs() > 300 {
                    false => format!("{}s", duration.as_secs()),
                    true => format!("{}m", duration.as_secs() / 60),
                },
            },
        }
    }

    pub fn summary(&self) -> String {
        format!(
            "{} {} {} {} ({})",
            &self.success_symbol(),
            &self.duration_string(),
            &self.name(),
            &self.args.join(" "),
            &self.dir.display()
        )
    }

    pub fn details(&self) -> Vec<String> {
        let mut details = Vec::new();
        details.push(self.summary());
        details.push("stdout".to_string());
        for line in self.stdout().lines() {
            details.push(line.to_string());
        }
        details.push("stderr".to_string());
        for line in self.stderr().lines() {
            details.push(line.to_string());
        }
        details.push(format!("success {:?}", self.success()));
        details.push(format!("exit code {:?}", self.exit_code()));
        details
    }

    pub fn start_utc(&self) -> DateTime<Utc> {
        match &self.start.parse::<DateTime<Utc>>() {
            Ok(dt) => *dt,
            Err(_) => Utc::now(),
        }
    }

    pub fn start_local(&self) -> DateTime<Local> {
        match &self.start.parse::<DateTime<Local>>() {
            Ok(lt) => *lt,
            Err(_) => Local::now(),
        }
    }

    pub fn env(&self) -> &super::Env {
        &self.env
    }

    pub fn to_json(&self) -> std::result::Result<String, Box<dyn std::error::Error>> {
        Ok(serde_json::to_string_pretty(&self)?)
    }
}

impl Display for Command {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.summary())
    }
}

impl PartialOrd for Command {
    fn partial_cmp(&self, other: &Command) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Command {
    fn cmp(&self, other: &Command) -> Ordering {
        self.start_utc().cmp(&other.start_utc())
    }
}
impl From<std::io::Error> for super::Command {
    fn from(error: std::io::Error) -> Self {
        let mut cmd = super::Command::default();
        cmd.exit_code = 1;
        cmd.stderr = format!("{}", error);
        cmd
    }
}

// TODO: add timeout support: https://docs.rs/wait-timeout/0.2.0/wait_timeout/
fn _exec(cmd: &super::Command) -> std::result::Result<super::Command, Box<dyn std::error::Error>> {
    let mut command = cmd.clone();
    let now = Instant::now();
    command.env = super::Env::default();
    let mut process_command = std::process::Command::new(&command.name);
    process_command.current_dir(command.dir());
    process_command.args(get_vec_osstring(&command.args.clone()));
    command.start = Utc::now().to_string();
    command.success = true;
    command.exit_code = 0;
    command.uuid = format!("{}", Uuid::new_v4());
    let output = process_command.output()?;
    command.stdout = match std::str::from_utf8(&output.stdout) {
        Ok(text) => text.to_string(),
        Err(_) => "".to_string(),
    };

    command.stderr = match std::str::from_utf8(&output.stderr) {
        Ok(text) => text.to_string(),
        Err(_) => "".to_string(),
    };
    command.success = output.status.success();
    command.duration = now.elapsed();
    Ok(command)
}

fn get_vec_osstring<I, S>(args: I) -> Vec<OsString>
where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>,
{
    let mut results = Vec::new();
    for arg in args.into_iter() {
        let s: &OsStr = arg.as_ref();
        results.push(s.to_os_string());
    }
    results
}

fn parse_command(command_text: &str) -> (String, Vec<String>) {
    let words: Vec<&str> = command_text.split(' ').collect();
    let mut name = "".to_string();
    let mut args = Vec::new();
    if words.len() > 0 {
        name = words[0].to_string();
        if words.len() > 1 {
            for i in 1..words.len() {
                args.push(words[i].to_string());
            }
        }
    }

    // test for file with content similar to:
    // #! ruby
    // #!/bin/bash
    match _which(&name) {
        Some(path) => match _shebang(&path) {
            Ok(shebang) => match _which(&shebang) {
                Some(_) => {
                    let name2 = shebang;
                    let mut args2 = Vec::new();
                    args2.push(path.display().to_string());
                    for arg in args {
                        args2.push(arg);
                    }
                    return (name2, args2);
                }
                None => {}
            },
            Err(_) => {}
        },
        None => {}
    };

    (name, args)
}

fn _which(name: &str) -> Option<PathBuf> {
    let extensions = vec!["", ".exe", ".bat"];
    for ext in extensions.iter() {
        let exe_name = format!("{}{}", name, ext);
        match _which_exact(&exe_name) {
            Some(path) => {
                return Some(path);
            }
            None => {}
        }
    }
    None
}

fn _shebang(path: &Path) -> std::result::Result<String, Box<dyn std::error::Error>> {
    //} super::Result<String> {
    match std::fs::read_to_string(path) {
        Ok(text) => match Regex::new(r"#!\s*([/:\.\w\-]+)") {
            Ok(re) => match re.captures(&text) {
                Some(caps) => {
                    if caps.len() > 1 {
                        Ok(caps[1].to_string())
                    } else {
                        Ok("".to_string())
                    }
                }
                None => Ok("".to_string()),
            },
            Err(e) => Err(Box::new(e)), // Err(super::errors::Error::from(e)),
        },
        Err(e) => Err(Box::new(e)), //super::errors::Error::from(e)),
    }
}
fn _which_exact(name: &str) -> Option<PathBuf> {
    std::env::var_os("PATH").and_then(|paths| {
        std::env::split_paths(&paths)
            .filter_map(|dir| {
                let full_path = dir.join(&name);
                if full_path.is_file() {
                    Some(full_path)
                } else {
                    None
                }
            })
            .next()
    })
}

#[cfg(test)]
#[test]
fn parse_command_test() {
    match super::Command::which("rake") {
        Some(_) => {
            let (name, args) = parse_command("rake default");
            assert!(name.contains("ruby"), "name");
            assert_eq!(2, args.len(), "args: {:?}", args)
        }
        None => {}
    }
}