use crate::*;


#[derive(Clone)]
pub struct Expression {
    pub source: SourceSpan,
    pub tokens: Vec<ExpressionToken>,
}

#[derive(Clone)]
pub struct ExpressionToken {
    pub source: SourceSpan,
    pub variant: ExpressionTokenVariant,
}

#[derive(Clone)]
pub enum ExpressionTokenVariant {
    Invocation(String),
    Literal(isize),
    Operator(Operator),
    Error(ExpressionParseError),
}

#[derive(Clone, Copy, Debug)]
pub enum Operator {
    Equal,
    NotEqual,
    LessThan,
    GreaterThan,
    Add,
    Subtract,
    LeftShift,
    RightShift,
    And,
    Or,
    Xor,
    Not,
}

#[derive(Clone)]
pub enum ExpressionParseError {
    InvalidHexadecimalLiteral(String),
}

impl std::fmt::Debug for Expression {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        for (i, token) in self.tokens.iter().enumerate() {
            let string = match &token.variant {
                ExpressionTokenVariant::Invocation(name) => name,
                ExpressionTokenVariant::Literal(value) => &value.to_string(),
                ExpressionTokenVariant::Operator(operator) => match operator {
                    Operator::Equal       => "=",
                    Operator::NotEqual    => "!=",
                    Operator::LessThan    => "<",
                    Operator::GreaterThan => ">",
                    Operator::Add         => "+",
                    Operator::Subtract    => "-",
                    Operator::LeftShift   => "<<",
                    Operator::RightShift  => ">>",
                    Operator::And         => "&",
                    Operator::Or          => "|",
                    Operator::Xor         => "^",
                    Operator::Not         => "~",
                }
                ExpressionTokenVariant::Error(_) => "<error>",
            };
            match i {
                0 => write!(f, "{string}")?,
                _ => write!(f, " {string}")?,
            }
        }
        return Ok(());
    }
}