//use super::errors::*;
use chrono::prelude::*;
use log::{debug, info, warn};
use std::collections::HashSet;
use std::convert::TryFrom;
use std::ffi::{OsStr, OsString};
use std::io::Write;
use std::path::{Path, PathBuf};
//use std::str::FromStr;
use std::time::{Duration, Instant};
use uuid::Uuid;

impl super::Command {
    pub fn execute(command: &str) -> super::errors::Result<super::Command> {
        let cmd = super::Command::exec(command);
        if !cmd.success() {
            bail!(format!(
                "{}\n{}\n{}",
                cmd.summary(),
                cmd.stdout(),
                cmd.stderr()
            ));
        }
        Ok(cmd)
    }

    pub fn execute_in(dir: &Path, command: &str) -> super::errors::Result<super::Command> {
        let orig_dir = std::env::current_dir()?;
        std::env::set_current_dir(&dir)?;
        let cmd = super::Command::execute(command)?;
        std::env::set_current_dir(orig_dir)?;
        if !cmd.success() {
            bail!(format!("{}", cmd.summary()));
        }
        Ok(cmd)
    }

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

    /// execute a command in a specific directory
    ///
    /// # Example
    /// ```
    /// use reef::Command;
    /// let path = std::env::temp_dir().join("test.rb");
    /// let git_version = Command::exec_in(&path,"git --version");
    /// ```
    pub fn exec_in(dir: &Path, command: &str) -> super::Command {
        let (name, args) = parse_command(command);
        let mut c = super::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 stderr(&self) -> &str {
        &self.stderr
    }

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

    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) -> super::errors::Result<String> {
        Ok(serde_json::to_string_pretty(&self)?)
    }

    pub fn log(&self) -> super::errors::Result<()> {
        let filename = super::Paths::log()
            .join("reef")
            .join("Command")
            .join(&format!("{}.json", self.uuid()));
        self.log_to(&filename)
    }

    pub fn log_to(&self, path: &Path) -> super::errors::Result<()> {
        debug!("command log filename: {}", path.display());
        match super::Paths::parent(&path) {
            Ok(parent) => {
                if !parent.exists() {
                    std::fs::create_dir_all(&parent)?;
                }
                let mut file = std::fs::File::create(&path)?;
                file.write(&self.to_json()?.as_bytes())?;
                Ok(())
            }
            Err(_) => {
                bail!(format!("unable to get parent of filename {}", path.display()).as_str())
            }
        }
    }
}

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
    }
}

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

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

    let now = Instant::now();
    command.env = super::Env::default();
    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();
    command.success = true;
    command.exit_code = 0;
    command.uuid = format!("{}", Uuid::new_v4());

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

    match command.to_json() {
        Ok(json) => info!("{}", json),
        Err(e) => warn!("reef::Command error converting to json: {}", e),
    }
}

/*
impl FromStr for super::Command {
    type Err = super::errors::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match serde_json::from_str::<super::Command>(s) {
            Ok(c) => Ok(c),
            Err(e) => Err(super::errors::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::Paths::which(&name) {
        Some(path) => match super::Paths::shebang(&path) {
            Ok(shebang) => match super::Paths::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::Paths::which("rake") {
        Some(_) => {
            let (name, args) = parse_command("rake default");
            assert!(name.contains("ruby"), "name");
            assert_eq!(2, args.len(), "args: {:?}", args)
        }
        None => {}
    }
}