use std::io::Result as IoResult;
use std::cmp::PartialEq;

#[derive(Debug)]
pub struct Name {
  pub first_name: String,
  pub last_name: String,
}

#[derive(Debug)]
pub struct Email {
  pub email: String,
}

#[derive(Debug)]
pub struct Text {
  pub title: String,
  pub description: String,
}

#[derive(Debug)]
pub struct Address {
  pub address: String,
}

impl PartialEq for Name {
  fn eq(&self, other: &Self) -> bool {
    (self.first_name == other.first_name) && (self.last_name == other.last_name)
  }
}

impl Name {
  pub fn fullname(self) -> String {
    format!("{} {}", self.first_name, self.last_name)
  }

  pub fn reverse(self) -> IoResult<String> {
    let mut result = String::new();

    for name in self.fullname().chars().rev() {
      result.push(name)
    }

    Ok(result)
  }
}

impl PartialEq for Email {
  fn eq(&self, other: &Self) -> bool {
    self.email == other.email
  }
}

impl PartialEq for Text {
  fn eq(&self, other: &Self) -> bool {
    (self.title == other.title) && (self.description == other.description)
  }
}

impl PartialEq for Address {
  fn eq(&self, other: &Self) -> bool {
    self.address == other.address
  }
}

pub mod name;
pub mod email;
pub mod text;
pub mod address;

pub fn create_names(first_name: &'static str, last_name: &'static str, loop_by: i32) -> IoResult<Vec<Name>> {
  Ok(name::create_names(first_name, last_name, loop_by).unwrap())
}

pub fn create_name(first_name: &'static str, last_name: &'static str) -> IoResult<Name> {
  Ok(name::create_name(first_name, last_name).unwrap())
}

pub fn create_emails(email: &'static str, loop_by: i32) -> IoResult<Vec<Email>> {
  Ok(email::create_emails(email, loop_by).unwrap())
} 

pub fn create_email(email: &'static str) -> IoResult<Email> {
  Ok(email::create_email(email).unwrap())
}

pub fn create_text(title: &'static str, description: &'static str, loop_by: i32) -> IoResult<Vec<Text>> {
  Ok(text::create_text(title, description, loop_by).unwrap())
}

pub fn create_address(address: &'static str, loop_by: i32) -> IoResult<Vec<Address>> {
  Ok(address::create_address(address, loop_by).unwrap())
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_create_names() {
    let first_name: &'static str = "Adiatma";
    let last_name: &'static str = "Kamarudin";
    let actual = create_names(first_name, last_name, 2).unwrap();
    let expected = [
      Name{
        first_name: first_name.to_string(),
        last_name: last_name.to_string(),
      },
      Name{
        first_name: first_name.to_string(),
        last_name: last_name.to_string(),
      },
    ];

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_create_name() {
    let first_name: &'static str = "Adiatma";
    let last_name: &'static str = "Kamarudin";
    let actual = create_name(first_name, last_name).unwrap();
    let expected = Name{
      first_name: first_name.to_string(),
      last_name: last_name.to_string()
    };

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_fullname() {
    let first_name: &'static str = "Adiatma";
    let last_name: &'static str = "Kamarudin";
    let actual = create_name(first_name, last_name).unwrap().fullname();
    let expected = "Adiatma Kamarudin";

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_reverse_name() {
    let first_name: &'static str = "A";
    let last_name: &'static str = "b";
    let actual = create_name(first_name, last_name).unwrap().reverse().unwrap();
    let expected = "b A";

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_create_emails() {
    let email: &'static str = "adiatma@gmail.com";
    let actual = create_emails(email, 2).unwrap();
    let expected = [
      Email{
        email: email.to_string(),
      },
      Email{
        email: email.to_string(),
      },
    ];

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_create_email() {
    let email: &'static str = "adiatma@gmail.com";
    let actual = create_email(email).unwrap();
    let expected = Email{ email: email.to_string() };

    assert_eq!(actual, expected)
  }

  #[test]
  fn text_create_text() {
    let title: &'static str = "Hello";
    let description: &'static str = "World";
    let actual = create_text(title, description, 2).unwrap();
    let expected = [
      Text{
        title: title.to_string(),
        description: description.to_string()
      },
      Text{
        title: title.to_string(),
        description: description.to_string()
      },
    ];

    assert_eq!(actual, expected)
  }

  #[test]
  fn test_create_address() {
    let address: &'static str = "Street Foo";
    let actual = create_address(address, 2).unwrap();
    let expected = [Address{ address: address.to_string() }, Address{ address: address.to_string() }];

    assert_eq!(actual, expected)
  }
}