use tusk_lexer::Lexer;
use tusk_lexer::Token;
use tusk_lexer::TokenType;

#[test]
fn test_it_can_be_created() {
    Lexer::new("");
}

#[test]
fn test_it_can_produce_valid_keyword_tokens() {
    assert_tokens_match(
        "<?php true false null function fn if else while do for foreach as class abstract extends implements clone try catch const public protected private final static trait switch continue break case yield yield from callable default declare echo elseif empty exit die global goto include include_once require require_once isset and namespace new or print return throw",
        vec![
            TokenType::OpenTag,
            TokenType::True,
            TokenType::False,
            TokenType::Null,
            TokenType::Function,
            TokenType::ShortFunction,
            TokenType::If,
            TokenType::Else,
            TokenType::While,
            TokenType::Do,
            TokenType::For,
            TokenType::Foreach,
            TokenType::As,
            TokenType::Class,
            TokenType::Abstract,
            TokenType::Extends,
            TokenType::Implements,
            TokenType::Clone,
            TokenType::Try,
            TokenType::Catch,
            TokenType::Const,
            TokenType::Public,
            TokenType::Protected,
            TokenType::Private,
            TokenType::Final,
            TokenType::Static,
            TokenType::Trait,
            TokenType::Switch,
            TokenType::Continue,
            TokenType::Break,
            TokenType::Case,
            TokenType::Yield,
            TokenType::Yield,
            TokenType::From,
            TokenType::Callable,
            TokenType::Default,
            TokenType::Declare,
            TokenType::Echo,
            TokenType::ElseIf,
            TokenType::Empty,
            TokenType::Exit,
            TokenType::Die,
            TokenType::Global,
            TokenType::Goto,
            TokenType::Include,
            TokenType::IncludeOnce,
            TokenType::Require,
            TokenType::RequireOnce,
            TokenType::Isset,
            TokenType::And,
            TokenType::Namespace,
            TokenType::New,
            TokenType::Or,
            TokenType::Print,
            TokenType::Return,
            TokenType::Throw,
        ]
    );
}

#[test]
fn test_it_can_produce_valid_numeric_tokens() {
    assert_tokens_match("12345 9876.543", vec![
        TokenType::Integer,
        TokenType::Float,
    ]);
}

#[test]
fn test_it_can_produce_valid_string_tokens() {
    assert_tokens_match("\"here we go\" 'here we go'", vec![
        TokenType::String,
        TokenType::String,
    ]);
}

#[test]
fn test_it_can_produce_valid_variable_tokens() {
    assert_tokens_match("$hello $helloWorld $hello_world", vec![
        TokenType::Variable,
        TokenType::Variable,
        TokenType::Variable,
    ]);
}

#[test]
fn test_it_can_produce_valid_identifier_tokens() {
    assert_tokens_match("hello_world HelloWorld helloWorld _myClassName", vec![
        TokenType::Identifier,
        TokenType::Identifier,
        TokenType::Identifier,
        TokenType::Identifier,
    ]);
}

#[test]
fn test_it_can_produce_valid_operator_tokens() {
    assert_tokens_match("+ - * / % ** && || & | ++ -- = == != <> !== === > < >= <= += -= *= /= %= **= -> => ?->", vec![
        TokenType::Plus,
        TokenType::Minus,
        TokenType::Asterisk,
        TokenType::Slash,
        TokenType::Percent,
        TokenType::Power,
        TokenType::And,
        TokenType::Or,
        TokenType::BitwiseAnd,
        TokenType::BitwiseOr,
        TokenType::Increment,
        TokenType::Decrement,
        TokenType::Equals,
        TokenType::EqualsEquals,
        TokenType::NotEquals,
        TokenType::NotEquals,
        TokenType::NotEqualsEquals,
        TokenType::EqualsEqualsEquals,
        TokenType::GreaterThan,
        TokenType::LessThan,
        TokenType::GreaterThanEquals,
        TokenType::LessThanEquals,
        TokenType::PlusEquals,
        TokenType::MinusEquals,
        TokenType::AsteriskEquals,
        TokenType::SlashEquals,
        TokenType::PercentEquals,
        TokenType::PowerEquals,
        TokenType::Arrow,
        TokenType::DoubleArrow,
        TokenType::NullsafeArrow,
    ]);
}

#[test]
fn test_it_can_produce_valid_punctuation_tokens() {
    assert_tokens_match(", ; :", vec![
        TokenType::Comma,
        TokenType::SemiColon,
        TokenType::Colon,
    ]);
}

#[test]
fn test_peek_does_move_real_internal_pointer() {
    let mut lexer = Lexer::new("$variable identifier");

    assert_eq!(lexer.next().unwrap().kind, TokenType::Variable);
    assert_eq!(lexer.peek().unwrap().kind, TokenType::Identifier);
    assert_eq!(lexer.next().unwrap().kind, TokenType::Identifier);
}

#[test]
fn test_it_can_produce_valid_comment_tokens() {
    assert_tokens_match("/* block comment */", vec![
        TokenType::BlockComment,
    ]);

    assert_tokens_match("// single line comment", vec![
        TokenType::SingleLineComment
    ]);

    assert_tokens_match("# alternative single line comment", vec![
        TokenType::SingleLineComment,
    ]);

    assert_tokens_match("/** @var Example $param */", vec![
        TokenType::DocBlockComment,
    ]);
}

#[test]
fn test_it_can_produce_valid_nullable_identifier_tokens() {
    assert_tokens_match("?test ?Testing", vec![
        TokenType::NullableIdentifier,
        TokenType::NullableIdentifier,
    ])
}

#[test]
fn test_it_can_produce_valid_backslash_tokens() {
    assert_tokens_match("\\", vec![
        TokenType::Backslash,
    ])
}

fn assert_tokens_match(source: &str, mut tokens: Vec<TokenType>) {
    let mut lexer = Lexer::new(source);

    while let Some(token) = lexer.next() {
        assert_eq!(token.kind, tokens.remove(0));
    }
}