#[derive(Clone, Copy)]
pub enum Operator {
    Equal,
    NotEqual,
    LessThan,
    GreaterThan,
    LessThanEqual,
    GreaterThanEqual,
    Add,
    Subtract,
    Multiply,
    Divide,
    Modulo,
    Exponent,
    LeftShift,
    RightShift,
    BitAnd,
    BitOr,
    BitXor,
    BitNot,
    Length,
}

impl Operator {
    pub fn from_str(string: &str) -> Option<Self> {
        match string {
            "="     => Some(Operator::Equal),
            "=="    => Some(Operator::Equal),
            "<eq>"  => Some(Operator::Equal),
            "!="    => Some(Operator::NotEqual),
            "<neq>" => Some(Operator::NotEqual),
            "<"     => Some(Operator::LessThan),
            "<lth>" => Some(Operator::LessThan),
            ">"     => Some(Operator::GreaterThan),
            "<gth>" => Some(Operator::GreaterThan),
            "<="    => Some(Operator::LessThanEqual),
            "<leq>" => Some(Operator::LessThanEqual),
            ">="    => Some(Operator::GreaterThanEqual),
            "<geq>" => Some(Operator::GreaterThanEqual),
            "+"     => Some(Operator::Add),
            "<add>" => Some(Operator::Add),
            "-"     => Some(Operator::Subtract),
            "<sub>" => Some(Operator::Subtract),
            "*"     => Some(Operator::Multiply),
            "<mul>" => Some(Operator::Multiply),
            "/"     => Some(Operator::Divide),
            "<div>" => Some(Operator::Divide),
            "<mod>" => Some(Operator::Modulo),
            "**"    => Some(Operator::Exponent),
            "<exp>" => Some(Operator::Exponent),
            "<<"    => Some(Operator::LeftShift),
            "<shl>" => Some(Operator::LeftShift),
            ">>"    => Some(Operator::RightShift),
            "<shr>" => Some(Operator::RightShift),
            "<and>" => Some(Operator::BitAnd),
            "<or>"  => Some(Operator::BitOr),
            "<xor>" => Some(Operator::BitXor),
            "<not>" => Some(Operator::BitNot),
            "<len>" => Some(Operator::Length),
            _      => None,
        }
    }
}

impl std::fmt::Display for Operator {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        let string = match self {
            Operator::Equal            => "<eq>",
            Operator::NotEqual         => "<neq>",
            Operator::LessThan         => "<lth>",
            Operator::GreaterThan      => "<gth>",
            Operator::LessThanEqual    => "<leq>",
            Operator::GreaterThanEqual => "<geq>",
            Operator::Add              => "<add>",
            Operator::Subtract         => "<sub>",
            Operator::Multiply         => "<mul>",
            Operator::Divide           => "<div>",
            Operator::Modulo           => "<mod>",
            Operator::Exponent         => "<exp>",
            Operator::LeftShift        => "<shl>",
            Operator::RightShift       => "<shr>",
            Operator::BitAnd           => "<and>",
            Operator::BitOr            => "<or>",
            Operator::BitXor           => "<xor>",
            Operator::BitNot           => "<not>",
            Operator::Length           => "<len>",
        };
        write!(f, "{string}")
    }
}