// Бележка: името на проекта трябва да се казва "solution". Ако не се казва така, променете го на
// тези два реда:
extern crate solution;
use solution::*;

macro_rules! assert_substring {
    ($expected:expr, $actual:expr) => {
        assert!($actual.contains($expected), "Expected {:?} to contain {:?}", $actual, $expected);
    }
}

macro_rules! assert_match {
    ($pattern:pat, $actual:expr) => {
        if let $pattern = $actual {
            assert!(true);
        } else {
            assert!(false, "Expected {} to match {:?}", stringify!($pattern), $actual);
        }
    }
}

#[test]
fn test_game_basic() {
    let mut g = Game::new("foobar", 2).unwrap();

    assert!(!g.is_over());

    assert_eq!(2, g.attempts_remaining);
    assert_eq!(0, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());

    assert_substring!("_ _ _ _ _ _", format!("{}", g));

    assert!(g.guess_letter('o').unwrap());
    assert_eq!(1, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("_ o o _ _ _", format!("{}", g));

    assert!(g.guess_word("foobar").unwrap());
    assert_eq!(1, g.attempted_letters.len());
    assert_eq!(1, g.attempted_words.len());
    assert_substring!("foobar", format!("{}", g));
    assert_substring!("won", format!("{}", g));

    assert!(g.is_over());
}

#[test]
fn test_game_advanced() {
    let mut g = Game::new("tranquilizer", 3).unwrap();

    assert!(!g.is_over());

    assert_eq!(3, g.attempts_remaining);
    assert_eq!(0, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());

    assert_substring!("_ _ _ _ _ _ _ _ _ _ _ _", format!("{}", g));

    assert!(g.guess_letter('i').unwrap());
    assert_eq!(1, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("_ _ _ _ _ _ i _ i _ _ _", format!("{}", g));

    assert!(g.guess_letter('t').unwrap());
    assert_eq!(2, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("t _ _ _ _ _ i _ i _ _ _", format!("{}", g));

    assert!(g.guess_word("tranquilizer").unwrap());
    assert_eq!(2, g.attempted_letters.len());
    assert_eq!(1, g.attempted_words.len());
    assert_substring!("tranquilizer", format!("{}", g));
    assert_substring!("won", format!("{}", g));

    assert!(g.is_over());
}

#[test]
fn test_game_with_errors() {
    let mut g = Game::new("pencil", 3).unwrap();

    assert!(!g.is_over());

    assert_eq!(3, g.attempts_remaining);
    assert_eq!(0, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());

    assert_substring!("_ _ _ _ _ _", format!("{}", g));

    assert!(g.guess_letter('i').unwrap());
    assert_eq!(3, g.attempts_remaining);
    assert_eq!(1, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("_ _ _ _ i _", format!("{}", g));

    assert!(!g.guess_letter('w').unwrap());
    assert_eq!(2, g.attempts_remaining);
    assert_eq!(2, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("_ _ _ _ i _", format!("{}", g));

    assert!(g.guess_letter('p').unwrap());
    assert_eq!(2, g.attempts_remaining);
    assert_eq!(3, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("p _ _ _ i _", format!("{}", g));

    assert!(!g.guess_word("pannic").unwrap());
    assert_eq!(1, g.attempts_remaining);
    assert_eq!(3, g.attempted_letters.len());
    assert_eq!(1, g.attempted_words.len());
    assert_substring!("p _ _ _ i _", format!("{}", g));

    assert!(!g.guess_letter('u').unwrap());
    assert_eq!(0, g.attempts_remaining);
    assert_eq!(4, g.attempted_letters.len());
    assert_eq!(1, g.attempted_words.len());
    assert_substring!("pencil", format!("{}", g));
    assert_substring!("lost", format!("{}", g));

    assert!(g.is_over());
}

#[test]
fn test_game_cyrillic() {
    let mut g = Game::new("крокодил", 2).unwrap();

    assert!(!g.is_over());

    assert_eq!(2, g.attempts_remaining);
    assert_eq!(0, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());

    assert_substring!("_ _ _ _ _ _ _ _", format!("{}", g));

    assert!(g.guess_letter('о').unwrap());
    assert_eq!(1, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("_ _ о _ о _ _ _", format!("{}", g));

    assert!(g.guess_letter('к').unwrap());
    assert_eq!(2, g.attempted_letters.len());
    assert_eq!(0, g.attempted_words.len());
    assert_substring!("к _ о к о _ _ _", format!("{}", g));

    assert!(g.guess_word("крокодил").unwrap());
    assert_eq!(2, g.attempted_letters.len());
    assert_eq!(1, g.attempted_words.len());
    assert_substring!("крокодил", format!("{}", g));
    assert_substring!("won", format!("{}", g));

    assert!(g.is_over());
}

#[test]
fn test_commands_basic() {
    assert_match!(Ok(Command::Help), "help".parse::<Command>());
    assert_match!(Ok(Command::Help), "he".parse::<Command>());
    assert_match!(Ok(Command::Info), "info".parse::<Command>());
    assert_match!(Ok(Command::Info), "inf".parse::<Command>());
    assert_match!(Ok(Command::Quit), "quit".parse::<Command>());
    assert_match!(Ok(Command::Quit), "q".parse::<Command>());
    assert_match!(Ok(Command::TryLetter(_)), "try letter x".parse::<Command>());
    assert_match!(Ok(Command::TryLetter(_)), "t l x".parse::<Command>());
    assert_match!(Ok(Command::TryWord(_)), "try word xyzzy".parse::<Command>());
    assert_match!(Ok(Command::TryWord(_)), "tr wo xyzzy".parse::<Command>());
}

#[test]
fn test_errors_basic() {
    assert_match!(
        GameError::ParseError(_),
        GameError::ParseError(String::from("error!"))
    );
    assert_match!(
        GameError::BadGuess(_),
        GameError::BadGuess(String::from("error!"))
    );
    assert_match!(
        GameError::InvalidSolution(_),
        GameError::InvalidSolution(String::from("error!"))
    );
    assert_match!(GameError::GameOver, GameError::GameOver);
}