//! Common build patterns

extern crate lazy_static;

use std::collections::HashMap;
use std::sync::Mutex;

/// Cargo toggle
pub static FEATURE : &str = "letmeout";

/// Environment name controlling verbosity
pub static VERBOSE_ENVIRONMENT_NAME : &str = "VERBOSE";

lazy_static::lazy_static! {
  static ref DEPENDENCY_CACHE_MUTEX : Mutex<HashMap<fn(), bool>> = Mutex::new(HashMap::new());
}

lazy_static::lazy_static! {
  pub static ref PHONY_TASK_MUTEX : Mutex<Vec<fn()>> = Mutex::new(Vec::new());
}

/// Query common host binary suffix
pub fn binary_suffix() -> String {
  if cfg!(windows) {
    ".exe".to_string()
  } else {
    "".to_string()
  }
}

/// Declare a dependency on a task that may panic
pub fn deps(task: fn()) {
  let phony : bool = PHONY_TASK_MUTEX
    .lock()
    .unwrap()
    .contains(&task);

  let has_run = DEPENDENCY_CACHE_MUTEX
    .lock()
    .unwrap()
    .contains_key(&task);

  if phony || !has_run {
    task();

    DEPENDENCY_CACHE_MUTEX
      .lock()
      .unwrap()
      .insert(task, true);
  }
}

/// Declare tasks with no obviously cacheable artifacts.
#[macro_export]
macro_rules! phony {
  ($t : expr) => {
    {
      tinyrick::PHONY_TASK_MUTEX
        .lock()
        .unwrap()
        .push($t);
    }
  };
  ($t : expr, $($u : expr),*) => {
    {
      let ref mut phony_tasks = tinyrick::PHONY_TASK_MUTEX
        .lock()
        .unwrap();

      phony_tasks.push($t);
      $( phony_tasks.push($u); )*
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the command object.
#[macro_export]
macro_rules! exec_mut_with_arguments {
  ($p : expr, $a : expr) => {
    {
      use std::env::var;
      use std::process::Command;

      if var(tinyrick::VERBOSE_ENVIRONMENT_NAME).is_ok() {
        println!("{} {}", $p, $a.join(" "));
      }

      Command::new($p)
        .args($a)
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program. Can also accept CLI arguments collection.
/// Returns the command object.
#[macro_export]
macro_rules! exec_mut {
  ($p : expr) => {
    {
      let args : &[&str] = &[];
      tinyrick::exec_mut_with_arguments!($p, args)
    }
  };
  ($p : expr, $a : expr) => {
    {
      tinyrick::exec_mut_with_arguments!($p, $a)
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the output object.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec_output {
  ($p : expr) => {
    {
      tinyrick::exec_mut!($p)
        .output()
        .unwrap()
    }
  };
  ($p : expr, $a : expr) => {
    {
      tinyrick::exec_mut!($p, $a)
        .output()
        .unwrap()
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the stdout stream.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec_stdout {
  ($p : expr) => {
    {
      tinyrick::exec_output!($p)
        .stdout
    }
  };
  ($p : expr, $a : expr) => {
    {
      tinyrick::exec_output!($p, $a)
        .stdout
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the stdout stream.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec_stderr {
  ($p : expr) => {
    {
      tinyrick::exec_output!($p)
        .stderr
    }
  };
  ($p : expr, $a : expr) => {
    {
      tinyrick::exec_output!($p, $a)
        .stderr
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the complete stdout string.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec_stdout_utf8 {
  ($p : expr) => {
    {
      String::from_utf8(tinyrick::exec_stdout!($p))
        .unwrap()
    }
  };
  ($p : expr, $a : expr) => {
    {
      String::from_utf8(tinyrick::exec_stdout!($p, $a))
        .unwrap()
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the complete stderr string.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec_stderr_utf8 {
  ($p : expr) => {
    {
      String::from_utf8(tinyrick::exec_stderr!($p))
        .unwrap()
    }
  };
  ($p : expr, $a : expr) => {
    {
      String::from_utf8(tinyrick::exec_stderr!($p, $a))
        .unwrap()
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Returns the status.
/// Panics if the command could not run to completion.
#[macro_export]
macro_rules! exec_status {
  ($p : expr) => {
    {
      tinyrick::exec_mut!($p)
        .status()
        .unwrap()
    }
  };
  ($p : expr, $a : expr) => {
    {
      tinyrick::exec_mut!($p, $a)
        .status()
        .unwrap()
    }
  };
}

/// Hey genius, avoid executing commands whenever possible! Look for Rust libraries instead.
///
/// Executes the given program with the given arguments.
/// Panics if the command exits with a failure status.
#[macro_export]
macro_rules! exec {
  ($p : expr) => {
    {
      assert!(
        tinyrick::exec_status!($p)
          .success()
      );
    }
  };
  ($p : expr, $a : expr) => {
    {
      assert!(
        tinyrick::exec_status!($p, $a)
          .success()
      )
    }
  };
}


/// Show registered tasks
#[macro_export]
macro_rules! list_tasks {
  ($t : expr) => {
    {
      use std::process::exit;

      println!("Registered tasks:\n");

      println!("* {}", stringify!($t));

      exit(0);
    }
  };
  ($t : expr, $($u : expr),*) => {
    {
      use std::process::exit;

      println!("Registered tasks:\n");

      println!("* {}", stringify!($t));
      $(println!("* {}", stringify!($u));)*

      exit(0);
    }
  };
}

/// Register tasks with CLI entrypoint.
/// The first entry is the default task,
/// When no tasks are named in CLI arguments.
#[macro_export]
macro_rules! wubba_lubba_dub_dub {
  ($d : expr ; $($t : expr),*) => {
    use std::env::args;
    use std::process::exit;

    let arguments : Vec<String> = args()
      .collect();

    let task_names : Vec<&str> = arguments
      .iter()
      .skip(1)
      .map(String::as_str)
      .collect();

    if task_names.len() == 0 {
      $d();
    } else {
      for task_name in task_names {
        match task_name {
          "-l" => tinyrick::list_tasks!($d $(, $t)*),
          "--list" => tinyrick::list_tasks!($d $(, $t)*),
          stringify!($d) => $d(),
          $(stringify!($t) => $t(),)*
          _ => panic!("Unknown task {}", task_name)
        }
      }
    }
  };
}