use std::ops::Deref;

#[derive(Debug)]
pub struct WithLocation<T> {
    pub value: T,
    pub start: usize,
    pub end: usize,
}

impl<T> WithLocation<T> {
    pub fn new(value: T, start: usize, end: usize) -> WithLocation<T> {
        WithLocation {
            value: value,
            start: start,
            end: end,
        }
    }

    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> WithLocation<U> {
        WithLocation {
            value: f(self.value),
            start: self.start,
            end: self.end,
        }
    }

    pub fn join_map<U, V, F>(self, other: WithLocation<U>, f: F) -> WithLocation<V>
        where F: FnOnce(WithLocation<T>, WithLocation<U>) -> V
    {
        let start = self.start;
        let end = other.end;
        WithLocation {
            value: f(self, other),
            start: start,
            end: end,
        }
    }
}

impl<T> Deref for WithLocation<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

#[derive(Debug)]
pub struct Program(pub Box<WithLocation<Expression>>);

#[derive(Debug)]
pub enum UnaryOp {
    Pos,
    Neg,
    Not,
}

#[derive(Debug)]
pub enum BinOp {
    Add,
    Sub,
    Mul,
    Div,
    FloorDiv,
    Eq,
    Neq,
    Gt,
    Lt,
    Ge,
    Le,
    And,
    Or,
}

#[derive(Debug)]
pub enum Expression {
    Let(Vec<WithLocation<Declaration>>, Box<WithLocation<Expression>>),
    UnaryOp(UnaryOp, Box<WithLocation<Expression>>),
    BinOp(BinOp, Box<WithLocation<Expression>>, Box<WithLocation<Expression>>),
    Number(u64),
    String(String),
    Name(String),
    Nil,
}

#[derive(Debug)]
pub struct RecordField {
    name: WithLocation<String>,
    ty: WithLocation<String>,
}

impl RecordField {
    pub fn new(name: WithLocation<String>, ty: WithLocation<String>) -> RecordField {
        RecordField { name, ty }
    }
}

#[derive(Debug)]
pub enum Ty {
    Name(String),
    Array(Box<Ty>),
    Record(Vec<WithLocation<RecordField>>),
}

#[derive(Debug)]
pub struct Declaration {
    pub name: WithLocation<String>,
    pub declaration: DeclarationBody,
}

#[derive(Debug)]
pub enum DeclarationBody {
    Var {
        ty: Option<WithLocation<Ty>>,
        value: Box<WithLocation<Expression>>,
    },
    Ty {
        ty: WithLocation<Ty>,
    },
    Fun {
        ty: Option<WithLocation<Ty>>,
        params: Vec<WithLocation<RecordField>>,
        body: Box<WithLocation<Expression>>,
    },
}

impl Declaration {
    pub fn new_var(name: WithLocation<String>, type_: Option<WithLocation<Ty>>,
                   value: Box<WithLocation<Expression>>) -> Declaration {
        Declaration {
            name: name,
            declaration: DeclarationBody::Var {
                ty: type_,
                value: value,
            }
        }
    }

    pub fn new_ty(name: WithLocation<String>, type_: WithLocation<Ty>) -> Declaration {
        Declaration {
            name: name,
            declaration: DeclarationBody::Ty {
                ty: type_,
            }
        }
    }

    pub fn new_fun(name: WithLocation<String>,
                   params: Vec<WithLocation<RecordField>>,
                   type_: Option<WithLocation<Ty>>,
                   body: Box<WithLocation<Expression>>) -> Declaration {
        Declaration {
            name: name,
            declaration: DeclarationBody::Fun {
                ty: type_,
                params: params,
                body: body,
            }
        }
    }
}