use std::str::FromStr;
use std::fmt;

#[derive(PartialEq, Debug, Clone, Copy)]
pub enum Op {
    Add,
    Sub,
    Mul,
    Div,
    Modulo,
    Equals,
    Greater,
    GrEqTo,
    Less,
    LsEqTo,
}

impl fmt::Display for Op {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Op::Add => write!(f, "+"),
            &Op::Sub => write!(f, "-"),
            &Op::Mul => write!(f, "*"),
            &Op::Div => write!(f, "/"),
            &Op::Modulo => write!(f, "%"),
            &Op::Equals => write!(f, "="),
            &Op::Greater => write!(f, ">"),
            &Op::GrEqTo => write!(f, ">="),
            &Op::Less => write!(f, "<"),
            &Op::LsEqTo => write!(f, "<="),
        }
    }
}

impl FromStr for Op {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "+" => Ok(Op::Add),
            "-" => Ok(Op::Sub),
            "*" => Ok(Op::Mul),
            "/" => Ok(Op::Div),
            "%" => Ok(Op::Modulo),
            "=" => Ok(Op::Equals),
            ">" => Ok(Op::Greater),
            ">=" => Ok(Op::GrEqTo),
            "<" => Ok(Op::Less),
            "<=" => Ok(Op::LsEqTo),
            x => Err(format!("{} is not an operator", x))
        }
    }
}

pub type FloatType = f64;

#[derive(PartialEq, Debug, Clone)]
pub enum Number {
    Int(isize),
    Float(FloatType)
}

#[derive(PartialEq, Debug, Clone)]
pub enum Type {
    Bool(bool),
    Number(Number),
    Str(String),
    Symbol(String),
    Operator(Op),
}

impl fmt::Display for Type {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Type::Bool(b) => write!(f, "{}", b),
            Type::Number(Number::Int(n)) => write!(f, "{}", n),
            Type::Number(Number::Float(n)) => write!(f, "{}", n),
            Type::Str(s) => write!(f, "{}", s),
            Type::Symbol(s) => write!(f, "{}", s),
            Type::Operator(op) => write!(f, "{}", op)
        }
    }
}