use std::rc::Rc;

use crate::span::Spanned;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LetVar {
    pub name: Spanned<Rc<str>>,
    pub expr: Spanned<Expr>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Atom {
    Int(i64),
    Str(Rc<str>),
    Sym(Rc<str>),
    Bool(bool),
    Nil,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Expr {
    Fn {
        name: Spanned<Rc<str>>,
        args: Vec<Spanned<Rc<str>>>,
        body: Vec<Spanned<Expr>>,
    },
    Const {
        vars: Vec<Spanned<LetVar>>,
    },
    Let {
        vars: Vec<Spanned<LetVar>>,
        body: Vec<Spanned<Expr>>,
    },
    If {
        condition: Spanned<Box<Expr>>,
        then_expr: Spanned<Box<Expr>>,
        else_expr: Option<Spanned<Box<Expr>>>,
    },
    For {
        loop_var: Spanned<Rc<str>>,
        from: Spanned<Box<Expr>>,
        to: Spanned<Box<Expr>>,
        body: Vec<Spanned<Expr>>,
    },
    Set {
        target_var: Spanned<Rc<str>>,
        expr: Spanned<Box<Expr>>,
    },
    Do {
        body: Vec<Spanned<Expr>>,
    },
    Call {
        fn_name: Spanned<Rc<str>>,
        args: Vec<Spanned<Expr>>,
    },
    Atom(Atom),
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Ast(Vec<Spanned<Expr>>);

impl Ast {
    pub fn new(ast: Vec<Spanned<Expr>>) -> Self {
        Self(ast)
    }

    pub fn inner(&self) -> &[Spanned<Expr>] {
        &self.0
    }

    pub fn into_inner(self) -> Vec<Spanned<Expr>> {
        self.0
    }
}