use std::error::Error;
use std::fmt;
use std::io::Error as IoError;

use command_runner::CommandRunner;
use symbols::Symbol;

#[derive(Debug, PartialEq)]
pub enum UserAdderError<E: Error> {
  AlreadyExists,
  UnknownError,
  ImplError(E)
}

impl<E: Error> Error for UserAdderError<E> {
  fn description(&self) -> &str {
    match self {
      &UserAdderError::AlreadyExists => "User already exists",
      &UserAdderError::UnknownError => "Unknown error",
      &UserAdderError::ImplError(_) => "User adding error"
    }
  }
  fn cause(&self) -> Option<&Error> {
    match self {
      &UserAdderError::ImplError(ref e) => Some(e),
      _ => None
    }
  }
}

impl<E: Error> fmt::Display for UserAdderError<E> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self.cause() {
      Some(e) => write!(f, "{} (cause: {})", self.description(), e),
      None => write!(f, "{}", self.description())
    }
  }
}

pub trait UserAdder {
  type SubE: Error;
  fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<Self::SubE>>;
}

#[derive(Debug, PartialEq)]
pub enum UserError<E: Error> {
  GenericError,
  ExecError(E)
}

impl<E: Error> Error for UserError<E> {
  fn description(&self) -> &str {
    match self {
      &UserError::GenericError => "Could not find out if user exists",
      &UserError::ExecError(_) => "Error executing symbol"
    }
  }
  fn cause(&self) -> Option<&Error> {
    match self {
      &UserError::ExecError(ref e) => Some(e),
      _ => None
    }
  }
}

impl<E: Error> fmt::Display for UserError<E> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self.cause() {
      Some(e) => write!(f, "{} (cause: {})", self.description(), e),
      None => write!(f, "{}", self.description())
    }
  }
}

pub struct User<'a, E, A> where E: Error + Sized, A: 'a + UserAdder<SubE=E> {
  user_name: &'a str,
  command_runner: &'a CommandRunner,
  user_adder: &'a A
}

impl<'a, E: Error + Sized, A: 'a + UserAdder<SubE=E>> User<'a, E, A> {
  pub fn new(user_name: &'a str, command_runner: &'a CommandRunner, user_adder: &'a A) -> User<'a, E, A> {
    User {
      user_name: user_name,
      command_runner: command_runner,
      user_adder: user_adder
    }
  }
}

impl<'a, E: Error, A: UserAdder<SubE=E>> fmt::Display for User<'a, E, A> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "User {}", self.user_name)
  }
}

impl<'a, E: Error, A: UserAdder<SubE=E>> Symbol for User<'a, E, A> {
  type Error = UserError<UserAdderError<E>>;
  fn target_reached(&self) -> Result<bool, Self::Error> {
    let output = self.command_runner.run_with_args("getent", &["passwd", self.user_name]);
    match output {
      Ok(output) => match output.status.code() {
        Some(2) => Ok(false),
        Some(0) => Ok(true),
        _ => Err(UserError::GenericError)
      },
      Err(_) => Err(UserError::GenericError)
    }
  }

  fn execute(&self) -> Result<(), Self::Error> {
    self.user_adder.add_user(self.user_name).map_err(|e| UserError::ExecError(e))
  }
}

pub struct SystemUserAdder<'a> {
  command_runner: &'a CommandRunner
}

impl<'a> SystemUserAdder<'a> {
  pub fn new(command_runner: &'a CommandRunner) -> SystemUserAdder<'a> {
    SystemUserAdder { command_runner: command_runner }
  }
}

impl<'a> UserAdder for SystemUserAdder<'a> {
  type SubE = IoError;
  fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<IoError>> {
    let output = self.command_runner.run_with_args("adduser", &["--system", "--disabled-login", "--disabled-password", user_name]);
    match output {
      Ok(output) => match output.status.code() {
        Some(0) => Ok(()),
        Some(1) => Err(UserAdderError::AlreadyExists),
        Some(_) => Err(UserAdderError::UnknownError),
        None => Err(UserAdderError::UnknownError),
      },
      Err(e) => Err(UserAdderError::ImplError(e))
    }
  }
}

#[cfg(test)]
mod test {
  use std::error::Error;
  use std::fmt;

  use command_runner::StdCommandRunner;
  use symbols::Symbol;
  use symbols::user::User;
  use symbols::user::UserAdder;
  use symbols::user::UserAdderError;

  #[derive(Debug, PartialEq)]
  struct DummyError;
  impl Error for DummyError {
    fn description(&self) -> &str {
      "DummyError"
    }
  }

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

  struct DummyUserAdder;

  impl UserAdder for DummyUserAdder {
    type SubE = DummyError;
    fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<Self::SubE>> {
      Ok(())
    }
  }

  #[test]
  fn test_target_reached_nonexisting() {
    let symbol = User { user_name: "nonexisting", command_runner: &StdCommandRunner, user_adder: &DummyUserAdder };
    assert_eq!(symbol.target_reached(), Ok(false));
  }

  #[test]
  fn test_target_reached_root() {
    let symbol = User { user_name: "root", command_runner: &StdCommandRunner, user_adder: &DummyUserAdder };
    assert_eq!(symbol.target_reached(), Ok(true));
  }
}