#[derive(Debug, Clone, Copy, PartialEq)]
pub enum StringType {
    Single,
    Double,
    DoubleBracket,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Token<'s> {
    /// Keywords
    Break,
    Goto,
    Do,
    End,
    While,
    Repeat,
    Until,
    If,
    Then,
    ElseIf,
    Else,
    For,
    In,
    Function,
    Local,
    Return,
    True,
    False,
    Nil,
    /// Symbols
    Semicolon,
    Eq,
    Comma,
    ColonColon,
    Dot,
    Colon,
    OpenBracket,
    CloseBracket,
    DotDotDot,
    OpenParen,
    CloseParen,
    OpenBrace,
    CloseBrace,
    /// Operators
    Plus,
    Minus,
    Star,
    Slash,
    SlashSlash,
    Hat,
    Percent,
    Amp,
    Tilde,
    Pipe,
    LtLt,
    GtGt,
    DotDot,
    Lt,
    Le,
    Gt,
    Ge,
    EqEq,
    TildeEq,
    And,
    Or,
    Hash,
    Not,
    /// Containers
    Number(&'s str),
    String(&'s str, StringType),
    Identifier(&'s str),

    // HTML extensions
    Bang,
    OpenClosingTag,
    LuaStart,
    LuaEnd,
    Eof,
    HtmlTextChar(char),
    Unknown(char),
    Whitespace,
}

impl std::fmt::Display for Token<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Token::Break => write!(f, "break"),
            Token::Goto => write!(f, "goto"),
            Token::Do => write!(f, "do"),
            Token::End => write!(f, "end"),
            Token::While => write!(f, "while"),
            Token::Repeat => write!(f, "repeat"),
            Token::Until => write!(f, "until"),
            Token::If => write!(f, "if"),
            Token::Then => write!(f, "then"),
            Token::ElseIf => write!(f, "elseif"),
            Token::Else => write!(f, "else"),
            Token::For => write!(f, "for"),
            Token::In => write!(f, "in"),
            Token::Function => write!(f, "function"),
            Token::Local => write!(f, "local"),
            Token::Return => write!(f, "return"),
            Token::True => write!(f, "true"),
            Token::False => write!(f, "false"),
            Token::Nil => write!(f, "nil"),
            Token::Semicolon => write!(f, ";"),
            Token::Eq => write!(f, "="),
            Token::Comma => write!(f, ","),
            Token::ColonColon => write!(f, "::"),
            Token::Dot => write!(f, "."),
            Token::Colon => write!(f, ":"),
            Token::OpenBracket => write!(f, "["),
            Token::CloseBracket => write!(f, "]"),
            Token::DotDotDot => write!(f, "..."),
            Token::OpenParen => write!(f, "("),
            Token::CloseParen => write!(f, ")"),
            Token::OpenBrace => write!(f, "{{"),
            Token::CloseBrace => write!(f, "}}"),
            Token::Plus => write!(f, "+"),
            Token::Minus => write!(f, "-"),
            Token::Star => write!(f, "*"),
            Token::Slash => write!(f, "/"),
            Token::SlashSlash => write!(f, "//"),
            Token::Hat => write!(f, "^"),
            Token::Percent => write!(f, "%"),
            Token::Amp => write!(f, "&"),
            Token::Tilde => write!(f, "~"),
            Token::Pipe => write!(f, "|"),
            Token::LtLt => write!(f, "<<"),
            Token::GtGt => write!(f, ">>"),
            Token::DotDot => write!(f, ".."),
            Token::Lt => write!(f, "<"),
            Token::Le => write!(f, "<="),
            Token::Gt => write!(f, ">"),
            Token::Ge => write!(f, ">="),
            Token::EqEq => write!(f, "=="),
            Token::TildeEq => write!(f, "~="),
            Token::And => write!(f, "and"),
            Token::Or => write!(f, "or"),
            Token::Hash => write!(f, "#"),
            Token::Not => write!(f, "not"),
            Token::Number(n) => write!(f, "{}", n),
            Token::String(s, st) => match st {
                StringType::Single => write!(f, "'{}'", s),
                StringType::Double => write!(f, "\"{}\"", s),
                StringType::DoubleBracket => write!(f, "[[{}]]", s),
            },
            Token::Identifier(s) => write!(f, "{}", s),
            Token::OpenClosingTag => write!(f, "</"),
            Token::LuaStart => write!(f, "{{$"),
            Token::LuaEnd => write!(f, "$}}"),

            Token::Bang => write!(f, "!"),
            Token::Eof => write!(f, "EOF"),
            Token::HtmlTextChar(c) => write!(f, "{}", c),
            Token::Unknown(c) => write!(f, "{}", c),
            Token::Whitespace => write!(f, " "),
        }
    }
}