use std::rc::Rc;
use std::convert::From;

use source_map::{SourceMap};
use builtin::{BinOp, PrefixOp};

pub struct Node<T> {
  n: T,
  meta: Meta
}

impl<T> Node<T> {
  fn node(&self) -> &T {
    &self.n
  }
}

struct Meta {
}

#[derive(Debug, PartialEq)]
pub struct AST(pub Vec<Statement>);

#[derive(Debug, PartialEq, Clone)]
pub enum Statement {
  ExpressionStatement(Expression),
  Declaration(Declaration),
}

pub type Block = Vec<Statement>;
pub type ParamName = Rc<String>;
pub type InterfaceName = Rc<String>; //should be a singleton I think??
pub type FormalParam = (ParamName, Option<TypeIdentifier>);

#[derive(Debug, PartialEq, Clone)]
pub enum Declaration {
  FuncSig(Signature),
  FuncDecl(Signature, Block),
  TypeDecl {
    name: TypeSingletonName,
    body: TypeBody,
    mutable: bool
  },
  TypeAlias(Rc<String>, Rc<String>), //should have TypeSingletonName in it, or maybe just String, not sure
  Binding {
    name: Rc<String>,
    constant: bool,
    expr: Expression,
  },
  Impl {
    type_name: TypeIdentifier,
    interface_name: Option<InterfaceName>,
    block: Vec<Declaration>,
  },
  Interface {
    name: Rc<String>,
    signatures: Vec<Signature>
  }
}

#[derive(Debug, PartialEq, Clone)]
pub struct Signature {
  pub name: Rc<String>,
  pub operator: bool,
  pub params: Vec<FormalParam>,
  pub type_anno: Option<TypeIdentifier>,
}

#[derive(Debug, PartialEq, Clone)]
pub struct TypeBody(pub Vec<Variant>);

#[derive(Debug, PartialEq, Clone)]
pub enum Variant {
  UnitStruct(Rc<String>),
  TupleStruct(Rc<String>, Vec<TypeIdentifier>),
  Record(Rc<String>, Vec<(Rc<String>, TypeIdentifier)>),
}

#[derive(Debug, PartialEq, Clone)]
pub struct Expression(pub ExpressionType, pub Option<TypeIdentifier>);

impl From<Expression> for SourceMap<Expression> {
  fn from(node: Expression) -> Self {
    SourceMap { node, data: None }
  }
}

#[derive(Debug, PartialEq, Clone)]
pub enum TypeIdentifier {
  Tuple(Vec<TypeIdentifier>),
  Singleton(TypeSingletonName)
}

#[derive(Debug, PartialEq, Clone)]
pub struct TypeSingletonName {
  pub name: Rc<String>,
  pub params: Vec<TypeIdentifier>,
}

#[derive(Debug, PartialEq, Clone)]
pub enum ExpressionType {
  NatLiteral(u64),
  FloatLiteral(f64),
  StringLiteral(Rc<String>),
  BoolLiteral(bool),
  BinExp(BinOp, Box<Expression>, Box<Expression>),
  PrefixExp(PrefixOp, Box<Expression>),
  TupleLiteral(Vec<Expression>),
  Value(Rc<String>),
  NamedStruct {
    name: Rc<String>,
    fields: Vec<(Rc<String>, Expression)>,
  },
  Call {
    f: Box<Expression>,
    arguments: Vec<Expression>,
  },
  Index {
    indexee: Box<Expression>,
    indexers: Vec<Expression>,
  },
  IfExpression {
    discriminator: Box<Discriminator>,
    body: Box<IfExpressionBody>,
  },
  WhileExpression {
    condition: Option<Box<Expression>>,
    body: Block,
  },
  ForExpression {
    enumerators: Vec<Enumerator>,
    body: Box<ForBody>,
  },
  Lambda {
    params: Vec<FormalParam>,
    type_anno: Option<TypeIdentifier>,
    body: Block,
  },
  ListLiteral(Vec<Expression>),
}

impl From<ExpressionType> for SourceMap<ExpressionType> {
  fn from(node: ExpressionType) -> Self {
    SourceMap { node, data: None }
  }
}

#[derive(Debug, PartialEq, Clone)]
pub enum Discriminator {
  Simple(Expression),
  BinOp(Expression, BinOp)
}

#[derive(Debug, PartialEq, Clone)]
pub enum IfExpressionBody {
  SimpleConditional(Block, Option<Block>),
  SimplePatternMatch(Pattern, Block, Option<Block>),
  GuardList(Vec<GuardArm>)
}

#[derive(Debug, PartialEq, Clone)]
pub struct GuardArm {
  pub guard: Guard,
  pub body: Block,
}

#[derive(Debug, PartialEq, Clone)]
pub enum Guard {
  Pat(Pattern),
  HalfExpr(HalfExpr)
}

#[derive(Debug, PartialEq, Clone)]
pub struct HalfExpr {
  pub op: Option<BinOp>,
  pub expr: ExpressionType,
}

#[derive(Debug, PartialEq, Clone)]
pub enum Pattern {
  Ignored,
  TuplePattern(Vec<Pattern>),
  Literal(PatternLiteral),
  TupleStruct(Rc<String>, Vec<Pattern>),
  Record(Rc<String>, Vec<(Rc<String>, Pattern)>),
}

#[derive(Debug, PartialEq, Clone)]
pub enum PatternLiteral {
  NumPattern {
    neg: bool,
    num: ExpressionType,
  },
  StringPattern(Rc<String>),
  BoolPattern(bool),
  VarPattern(Rc<String>)
}

#[derive(Debug, PartialEq, Clone)]
pub struct Enumerator {
  pub id: Rc<String>,
  pub generator: Expression,
}

#[derive(Debug, PartialEq, Clone)]
pub enum ForBody {
  MonadicReturn(Expression),
  StatementBlock(Block),
}