use core::fmt;

use internment::Intern;

use crate::utils::span::{Span, Spanned};

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Token {
    span: Span,
    kind: TokenKind,
}

impl Spanned for Token {
    #[inline(always)]
    fn span(&self) -> Span {
        self.span
    }
}

impl Token {
    pub fn new(span: Span, kind: TokenKind) -> Self {
        Self { span, kind }
    }
    #[inline(always)]
    pub fn kind(&self) -> TokenKind {
        self.kind
    }
}


#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Keyword {
    If,
    Else,
    Then,
    As,    
    Let,    
    Struct,    
    Enum,    
    Do,
    End,
    Match,
    With,
    Or,
    And,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Literal {
    ///Default int literal, may change in the parser based on the type of the variable
    Int(i64),
    
    ///Default float literal, may change in the parser based on the type of the variable
    Float(f64),

    Bool(bool),
    //At this point, types don't exist in the parser, it's just Identifier
    Identifier(Intern<String>),

    StringLiteral(Intern<String>),
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum TokenKind {
    /// A literal see [Literal] for more information
    Literal(Literal),

    /// A keyword see [Keyword] for more information
    Keyword(Keyword),

    //One character tokens

    /// ";"
    SemiColon,
    /// ","
    Comma,
    /// "."
    Dot,
    /// "("
    LParen,
    /// ")"
    RParen,
    /// "{"
    LBrace,
    /// "}"
    RBrace,
    /// "["
    LBracket,
    /// "]"
    RBracket,
    /// "@"
    At,
    /// "#"
    HashTag,
    /// "~"
    Tilde,
    /// "?"
    Question,
    /// ":"
    Colon,
    /// "$"
    Dollar,
    /// "="
    Eq,
    /// "!"
    Bang,
    /// "<"
    LAngle,
    /// ">"
    RAngle,
    /// "-"
    Minus,
    /// "&"
    Ampersand,
    /// "|"
    Pipe,
    /// "+"
    Plus,
    /// "*"
    Star,
    /// "/"
    Slash,
    /// "^"
    Caret,
    /// "%"
    Percent,
    /// "_"
    Underscore,
    /// "\"
    Backslash,

    //Two character tokens
    /// "=>"
    FatArrow,
    /// "<-"
    LArrow,
    /// "->"
    RArrow,
    /// "::"
    DoubleColon,
    /// ".."
    DoubleDot,
    /// "!="
    NEq,
    /// "<="
    LtEq,
    /// ">="
    GtEq,
    /// "=="
    DoubleEq,

    //Others
    /// Represents an unknown character (not supported by the current Lexer)
    UnknownChar(char),

    /// Start Of File
    SOI,
    /// End Of File
    EOI,
}

impl fmt::Display for Keyword {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use Keyword::*;
        match self {
            If => write!(f, "if"),
            Else => write!(f, "else"),
            Then => write!(f, "then"),
            As => write!(f, "as"),
            Let => write!(f, "let"),
            Struct => write!(f, "struct"),
            Enum => write!(f, "enum"),
            Do => write!(f, "do"),
            End => write!(f, "end"),
            Match => write!(f, "match"),
            With => write!(f, "with"),
            Or => write!(f, "or"),
            And => write!(f, "and"),
        }
    }
}

impl fmt::Display for Literal {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use Literal::*;
        match self {
            Int(i) => write!(f, "{}", i),
            Float(i) => write!(f, "{}", i),
            Bool(i) => write!(f, "{}", i),
            Identifier(i) => write!(f, "{}", i),
            StringLiteral(i) => write!(f, "{}", i),
        }
    }
}

impl fmt::Display for TokenKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use TokenKind::*;
        match self {
            Keyword(k) => write!(f, "Keyword: {}", k),
            Literal(l) => write!(f, "Literal: {}", l),
            UnknownChar(c) => write!(f, "UnknownChar: {}", c),
            _ => write!(f, "{:?}", self),
        }
    }
}