//! AST builder DSL

use super::*;

pub use super::BinOp;

/* TODO
macro_rules! ast {
    ({$stmt:tt}) => {
        todo!()
    };
    ({$stmt:tt, $($stmts),+}) => {
        ast!
    }
}
*/

// ==============================================
// [`Program`] and statements.

/// Creates a [`Program`] from a list of [`Statement`]s.
///
/// ```
/// use sljs::ast::build::*;
///
/// let program = script(|ctx| Ok(vec![
///     // Statement list
/// ])).expect("Program");
/// ```
pub fn script<F>(action: F) -> ParseResult<Program>
where
    F: FnMut(&mut LexicalContext) -> ParseResult<Vec<Statement>>,
{
    LexicalContext::new_program(|ctx| ctx.enter_block(action))
}

/// Creates a [`BlockStatement`] from a closure that builds a vector of [`Statement`]s.
///
/// ```
/// use sljs::ast::{Program, build::*};
///
/// let b = Program::try_from(block(|ctx| Ok(vec![
///     // Statements
/// ]))).expect("Program");
/// ```
pub fn block<F>(closure: F) -> BlockBuilder<F>
where
    F: FnOnce(&mut LexicalContext) -> ParseResult<Vec<Statement>>,
{
    BlockBuilder { closure }
}

/// make a [`ReturnStatement`](`expr`)
pub fn return_(expr: Expression) -> Statement {
    Statement::from(ReturnStatement(Some(expr)))
}

// ==============================================
// Expressions

/// make a [`Literal`] (`JSON::Null`) (JS: `null`).
pub fn null() -> Expression {
    Expression::from(Literal::NULL)
}

/// make a [`Literal`] from `value`
///
///  - `lit(2)` is `2` in JavaScript
///  - `lit(true)` is `true` in JavaScript
///  - ...
///
/// DO NOT USE this for arrays and objects, use [`array()`] and [`object()`] instead!
pub fn lit<V>(value: V) -> Expression
where
    Literal: From<V>,
{
    Expression::from(Literal::from(value))
}

/// make an [`ArrayExpression`] (`vec![v1, v2, ...]`) (JS: `[v1, v2, ...]`)
pub fn array<E>(exprs: Vec<E>) -> Expression
where
    Expression: From<E>,
{
    let exprs = exprs.into_iter().map(Expression::from).collect();
    let expr = Expr::Array(ArrayExpression(exprs));
    Expression { expr, loc: None }
}

/// make an empty [`ArrayExpression`], JS: `[]`
pub fn empty_array() -> Expression {
    array::<Expression>(vec![])
}

/// make a [`ObjectExpression`] (`vec![(k1, v1), ...]`) (JS: `{k1: v1, ...}`)
pub fn object<K>(pairs: Vec<(K, Expression)>) -> Expression
where
    ObjectKey: From<K>,
{
    let pairs = (pairs.into_iter())
        .map(|(k, v)| (ObjectKey::from(k), v))
        .collect();
    Expression::from(ObjectExpression(pairs))
}

/// make an empty [`ObjectExpression`] (JS: `{}`)
pub fn empty_object() -> Expression {
    object::<Identifier>(vec![])
}

/// make a [`UnaryExpression`]([`UnOp::Plus`], `expr`)
pub fn plus<E>(expr: E) -> Expression
where
    Expression: From<E>,
{
    let expr = Expression::from(expr);
    let expr = Expr::Unary(Box::new(UnaryExpression(UnOp::Plus, expr)));
    Expression { expr, loc: None }
}

/// make a [`BinaryExpression`](`left`, `op`, `right`)
pub fn binary<E1, E2>(op: BinOp, left: E1, right: E2) -> Expression
where
    Expression: From<E1> + From<E2>,
{
    let left = Expression::from(left);
    let right = Expression::from(right);
    Expression::from(BinaryExpression(left, op, right))
}

/// make a [`BinaryExpression`] (`left`, [`BinOp::Plus`], `right`)
pub fn add<E1, E2>(left: E1, right: E2) -> Expression
where
    Expression: From<E1> + From<E2>,
{
    binary(BinOp::Plus, Expression::from(left), Expression::from(right))
}

/// make a [`BinaryExpression`] (`left`, [`BinOp::Minus`], `right`)
pub fn sub<E1, E2>(left: E1, right: E2) -> Expression
where
    Expression: From<E1> + From<E2>,
{
    binary::<E1, E2>(BinOp::Minus, left, right)
}

/// make a [`BinaryExpression`] (`left`, [`BinOp::Star`], `right`)
pub fn mul<E1, E2>(left: E1, right: E2) -> Expression
where
    Expression: From<E1> + From<E2>,
{
    binary::<E1, E2>(BinOp::Star, left, right)
}

/// make a [`BinaryExpression`] (`left`, [`BinOp::EqEq`], `right`)
pub fn eqeq<E1, E2>(left: E1, right: E2) -> Expression
where
    Expression: From<E1> + From<E2>,
{
    binary(BinOp::EqEq, left, right)
}

/// make a non-computed (i.e. `object.attr`) [`MemberExpression`](`object`, `attr`)
pub fn memb<E, I>(object: E, attr: I) -> Expression
where
    Expression: From<E>,
    Identifier: From<I>,
{
    let object = Expression::from(object);
    let attr = Identifier::from(attr);
    let attr = Expression {
        expr: Expr::Identifier(attr),
        loc: None,
    };
    MemberExpression(object, attr, false).into()
}

/// make a computed  [`MemberExpression`](`object`, `attr`) (JS: `object[attr]`)
pub fn index<E>(object: E, attr: Expression) -> Expression
where
    Expression: From<E>,
{
    let object = Expression::from(object);
    MemberExpression(object, attr, true).into()
}

/// make a [`CallExpression`] with `callee` and `arguments` (JS: `callee(arguments...)`)
pub fn call<E>(callee: E, arguments: Vec<Expression>) -> Expression
where
    Expression: From<E>,
{
    let callee = Expression::from(callee);
    CallExpression(callee, arguments).into()
}

// ==============================================
// AST DSL helpers

/// An AST DSL helper to enable `Program::try_from(with(|ctx| Ok(...)))` via [`with`]
pub struct Builder<T, F: FnOnce(&mut LexicalContext) -> ParseResult<T>> {
    closure: F,
}

impl<T, F> TryFrom<Builder<T, F>> for Program
where
    Statement: From<T>,
    F: FnOnce(&mut LexicalContext) -> ParseResult<T>,
{
    type Error = ParseError;

    fn try_from(builder: Builder<T, F>) -> Result<Self, ParseError> {
        LexicalContext::new_program(|ctx| {
            ctx.block(|ctx| {
                let expr = (builder.closure)(ctx)?;
                Ok(vec![Statement::from(expr)])
            })
        })
    }
}

/// An AST DSL helper to enable `Program::try_from(block(|ctx| Ok(...)))` via [`block`]
pub type BlockBuilder<F> = Builder<Vec<Statement>, F>;

impl<F> TryFrom<BlockBuilder<F>> for Program
where
    F: FnOnce(&mut LexicalContext) -> ParseResult<Vec<Statement>>,
{
    type Error = ParseError;

    fn try_from(builder: BlockBuilder<F>) -> Result<Self, ParseError> {
        LexicalContext::new_program(|ctx| ctx.block(|ctx| (builder.closure)(ctx)))
    }
}

/// A helper to surround an closure in `assert_parse!` macro calls.
pub fn with<T, F>(closure: F) -> Builder<T, F>
where
    F: FnOnce(&mut LexicalContext) -> ParseResult<T>,
{
    Builder { closure }
}

/// make an [`Identifier`] from `name` (JS: `name`)
pub fn id(name: &str) -> Expression {
    Expression::from(Identifier::from(name))
}