use chrono::prelude::*;
use log::{info, warn};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::convert::TryFrom;
use std::ffi::{OsStr, OsString};
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::time::{Duration, Instant};

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
/// A data structure to hold the infomation about a std::process::Command that
/// has been executed.
pub struct Command {
    /// The working directory
    dir: PathBuf,
    /// The command name
    name: String,
    /// The command arguments
    args: Vec<String>,
    /// The standard output text
    stdout: String,
    /// The standard error text
    stderr: String,
    /// Indication of success or failure
    success: bool,
    /// The exit code of the process
    exit_code: i32,
    /// The duration of the command execution
    duration: Duration,
    /// The start time of the command execution
    start: String,
    /// Tags
    tags: HashSet<String>,
}

impl Command {
    /// execute a command
    ///
    /// # Example
    /// ```
    /// use reef::command::Command;
    /// let git_version = Command::exec("git --version");
    /// ```
    pub fn exec(command: &str) -> Command {
        let (name, args) = parse_command(command);
        let mut c = Command::default();
        c.name = name;
        c.args = args;
        _execute(&mut c);
        c
    }

    pub fn exec2(dir: &Path, command: &str) -> Command {
        let (name, args) = parse_command(command);
        let mut c = Command::default();
        c.name = name;
        c.args = args;
        match std::env::current_dir() {
            Ok(orig_dir) => match std::env::set_current_dir(dir) {
                Ok(_) => {
                    _execute(&mut c);
                    match std::env::set_current_dir(orig_dir) {
                        Ok(_) => c,
                        Err(e) => {
                            c.success = false;
                            c.exit_code = 1;
                            c.stderr = e.to_string();
                            c
                        }
                    }
                }
                Err(e) => {
                    c.success = false;
                    c.exit_code = 1;
                    c.stderr = e.to_string();
                    c
                }
            },
            Err(e) => {
                c.success = false;
                c.exit_code = 1;
                c.stderr = e.to_string();
                c
            }
        }
    }

    /// 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 duration(&self) -> &Duration {
        &self.duration
    }

    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 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(),
        }
    }
}

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

impl TryFrom<&Command> for Vec<u8> {
    type Error = super::error::Error;
    fn try_from(value: &Command) -> Result<Self, Self::Error> {
        match serde_json::to_vec(value) {
            Ok(bytes) => Ok(bytes),
            Err(e) => Err(super::error::Error::from(e)),
        }
    }
}

impl TryFrom<&Vec<u8>> for Command {
    type Error = super::error::Error;
    fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error> {
        match serde_json::from_slice(bytes) {
            Ok(command) => Ok(command),
            Err(e) => Err(super::error::Error::from(e)),
        }
    }
}
fn _execute(command: &mut Command) {
    match std::env::current_dir() {
        Ok(p) => command.dir = p,
        Err(_) => command.dir = PathBuf::new(),
    };

    let now = Instant::now();
    let mut process_command = std::process::Command::new(&command.name);
    if command.dir().exists() {
        process_command.current_dir(command.dir());
    }
    process_command.args(get_vec_osstring(&command.args.clone()));
    command.start = Utc::now().to_string();

    match process_command.output() {
        Ok(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();
            info!("{}", command.summary());
        }
        Err(e) => {
            command.success = false;
            command.exit_code = 1;
            command.stderr = e.to_string();
            warn!("{}", command.summary())
        }
    };
}

impl FromStr for Command {
    type Err = super::error::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match serde_json::from_str::<Command>(s) {
            Ok(c) => Ok(c),
            Err(e) => Err(super::error::Error::from(e)),
        }
    }
}

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 super::path::which(&name) {
        Some(path) => match super::path::shebang(&path) {
            Ok(shebang) => match super::path::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)
}

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