use crate::syn::{op::*, span::*};
use derivative::Derivative;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Stmt {
    Assign(AssignStmt),
    Expr(Expr),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AssignStmt {
    pub lhs: Expr,
    pub rhs: Expr,
    pub span: Span,
}

impl Spanned for AssignStmt {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Expr {
    Bin(Box<BinExpr>),
    Un(Box<UnExpr>),
    FunCall(Box<FunCallExpr>),
    Index(Box<IndexExpr>),
    Fun(Box<FunExpr>),
    Base(BaseExpr),
}

impl Spanned for Expr {
    fn span(&self) -> Span {
        match self {
            Expr::Bin(b) => b.span(),
            Expr::Un(u) => u.span(),
            Expr::FunCall(f) => f.span(),
            Expr::Index(i) => i.span(),
            Expr::Fun(f) => f.span(),
            Expr::Base(b) => b.span(),
        }
    }
}

impl From<UnExpr> for Expr {
    fn from(un: UnExpr) -> Self {
        Expr::Un(Box::new(un))
    }
}

impl From<BinExpr> for Expr {
    fn from(bin: BinExpr) -> Self {
        Expr::Bin(Box::new(bin))
    }
}

impl From<BaseExpr> for Expr {
    fn from(base: BaseExpr) -> Self {
        Expr::Base(base)
    }
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct BinExpr {
    pub lhs: Expr,
    pub op: BinOp,
    pub rhs: Expr,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for BinExpr {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct UnExpr {
    pub op: UnOp,
    pub expr: Expr,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for UnExpr {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct FunCallExpr {
    pub expr: Expr,
    pub args: Vec<Expr>,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for FunCallExpr {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct IndexExpr {
    pub expr: Expr,
    pub index: Expr,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for IndexExpr {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct FunExpr {
    pub params: Vec<String>,
    pub expr: Expr,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for FunExpr {
    fn span(&self) -> Span {
        self.span
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BaseExprKind {
    Ident,
    Num,
    Str,
    Sym,
    List(Vec<Expr>),
    Object(Vec<(Expr, Expr)>),
    Tuple(Vec<Expr>),
    Block(Vec<Stmt>),
}

#[derive(Derivative, Clone, PartialEq, Eq)]
#[derivative(Debug)]
pub struct BaseExpr {
    pub kind: BaseExprKind,
    #[derivative(Debug = "ignore")]
    pub span: Span,
}

impl Spanned for BaseExpr {
    fn span(&self) -> Span {
        self.span
    }
}