use super::frame;
use super::ir;
use super::temp;

#[derive(Debug)]
pub enum Expression {
    Exp(ir::Expression),
    Void(ir::Statement),
}

pub struct Translate<F> {
    pub temp: temp::Temp,
    level_counter: usize,
    _frametype: ::std::marker::PhantomData<F>,
}

pub enum Level<'a, F>
    where F: 'a + frame::Frame {
    Top,
    Level {
        parent: &'a Level<'a, F>,
        frame: F,
        unique_id: usize,
    },
}

impl<F: frame::Frame> Translate<F> {
    pub fn new() -> Translate<F> {
        Translate {
            temp: temp::Temp::new(),
            level_counter: 0,
            _frametype: ::std::marker::PhantomData,
        }
    }

    pub fn make_level<'a>(
        &mut self,
        parent: &'a Level<F>,
        formals: Vec<frame::Escape>) -> Level<'a, F> {
        let id = self.level_counter;
        self.level_counter += 1;
        Level::Level {
            parent: parent,
            frame: F::new(self.temp.next_label(), formals),
            unique_id: id,
        }
    }

    pub fn make_num(&mut self, num: u64) -> Expression {
        Expression::Exp(ir::Expression::Const(num))
    }

    pub fn make_binop(&mut self, op: ir::BinOp,
                      left: Expression, right: Expression) -> Expression {
        match (left, right) {
            (Expression::Exp(left), Expression::Exp(right)) =>
                Expression::Exp(ir::Expression::BinOp(op, Box::new(left), Box::new(right))),
            // TODO: return Result
            _ => panic!("Can't make binop from Void"),
        }
    }
}