use std::rc::Rc;

use crate::derivative::Derivative;

mod walker;
mod visitor;
mod visitor_test;
mod operators;
pub use operators::*;

/// An abstract identifier for an AST node
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct ItemId {
  idx: u32,
}

impl ItemId {
  fn new(n: u32) -> ItemId {
    ItemId { idx: n }
  }
}

pub struct ItemIdStore {
  last_idx: u32
}

impl ItemIdStore {
  pub fn new() -> ItemIdStore {
    ItemIdStore { last_idx: 0 }
  }
  /// Always returns an ItemId with internal value zero
  #[cfg(test)]
  pub fn new_id() -> ItemId {
    ItemId { idx: 0 }
  }

  /// This limits the size of the AST to 2^32 tree elements
  pub fn fresh(&mut self) -> ItemId {
    let idx = self.last_idx;
    self.last_idx += 1;
    ItemId::new(idx)
  }
}

#[derive(Derivative, Debug)]
#[derivative(PartialEq)]
pub struct AST {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub statements: Vec<Statement>
}

#[derive(Derivative, Debug, Clone)]
#[derivative(PartialEq)]
pub struct Statement {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub kind: StatementKind,
}

#[derive(Debug, PartialEq, Clone)]
pub enum StatementKind {
  Expression(Expression),
  Declaration(Declaration),
  Import(ImportSpecifier),
}

pub type Block = Vec<Statement>;
pub type ParamName = Rc<String>;

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct QualifiedName {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub components: Vec<Rc<String>>,
}

#[derive(Debug, PartialEq, Clone)]
pub struct FormalParam {
  pub name: ParamName,
  pub default: Option<Expression>,
  pub anno: Option<TypeIdentifier>
}

#[derive(Debug, PartialEq, Clone)]
pub enum Declaration {
  FuncSig(Signature),
  FuncDecl(Signature, Block),
  TypeDecl {
    name: TypeSingletonName,
    body: TypeBody,
    mutable: bool
  },
  //TODO this needs to be more sophisticated
  TypeAlias {
    alias: Rc<String>,
    original: Rc<String>,
  },
  Binding {
    name: Rc<String>,
    constant: bool,
    type_anno: Option<TypeIdentifier>,
    expr: Expression,
  },
  Impl {
    type_name: TypeIdentifier,
    interface_name: Option<TypeSingletonName>,
    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 {
    name: Rc<String>,
    members: Vec<(Rc<String>, TypeIdentifier)>,
  }
}

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct Expression {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub kind: ExpressionKind,
  pub type_anno: Option<TypeIdentifier>
}

impl Expression {
  pub fn new(id: ItemId, kind: ExpressionKind) -> Expression {
    Expression { id, kind, type_anno: None }
  }

  pub fn with_anno(id: ItemId, kind: ExpressionKind, type_anno: TypeIdentifier) -> Expression {
    Expression { id, kind, type_anno: Some(type_anno) }
  }
}

#[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 ExpressionKind {
  NatLiteral(u64),
  FloatLiteral(f64),
  StringLiteral(Rc<String>),
  BoolLiteral(bool),
  BinExp(BinOp, Box<Expression>, Box<Expression>),
  PrefixExp(PrefixOp, Box<Expression>),
  TupleLiteral(Vec<Expression>),
  Value(QualifiedName),
  NamedStruct {
    name: QualifiedName,
    fields: Vec<(Rc<String>, Expression)>,
  },
  Call {
    f: Box<Expression>,
    arguments: Vec<InvocationArgument>,
  },
  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>),
}

#[derive(Debug, PartialEq, Clone)]
pub enum InvocationArgument {
  Positional(Expression),
  Keyword {
    name: Rc<String>,
    expr: Expression,
  },
  Ignored
}

#[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: ExpressionKind,
}

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

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

#[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),
}

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct ImportSpecifier {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub path_components: Vec<Rc<String>>,
  pub imported_names: ImportedNames
}

#[derive(Debug, PartialEq, Clone)]
pub enum ImportedNames {
  All,
  LastOfPath,
  List(Vec<Rc<String>>)
}