fn resolve_numbers(symbols: &mut SymbolTable, args: &[Expr], name: &str) -> Result<Vec<Fraction>> {

    args.iter()

        .map(|arg| {

            let resolved = eval_value(symbols, arg)?;

            match resolved {

                Expr::Number(n) => Ok(n),

                other => Err(Error::Compile(format!(

                    "{name} expects number arguments, got {}",

                    format_expr(&other)

                ))),

        })

        .collect()

}

fn bool_result(value: bool) -> Expr {

    if value { Expr::Bool(true) } else { Expr::Nil }

}

pub(super) fn call(symbols: &mut SymbolTable, name: &str, args: &[Expr]) -> Result<Expr> {

    match name {

        "+" => add(symbols, args),

        "-" => sub(symbols, args),

        "*" => mul(symbols, args),

        "/" => div(symbols, args),

        "MOD" => modulo(symbols, args),

        "=" => num_cmp(symbols, args, "=", |a, b| a == b),

        "/=" => num_neq(symbols, args),

        "<" => num_cmp(symbols, args, "<", |a, b| a < b),

        ">" => num_cmp(symbols, args, ">", |a, b| a > b),

        "<=" => num_cmp(symbols, args, "<=", |a, b| a <= b),

        ">=" => num_cmp(symbols, args, ">=", |a, b| a >= b),

        "EQL" => eql(symbols, args),

        "EQUAL" => equal(symbols, args),

        "DEBUG" => debug_call(symbols, args),

        "LIST" => list(symbols, args),

        "CONS" => cons(symbols, args),

        "CAR" => car(symbols, args),

        "CDR" => cdr(symbols, args),

        "MAP" => map_fn(symbols, args),

        "MAKE-STRUCT-INSTANCE" => make_struct_instance(symbols, args),

        "STRUCT-FIELD" => struct_field(symbols, args),

        "STRUCT-P" => struct_p(symbols, args),

        "STRUCT-SET-FIELD" => struct_set_field(symbols, args),

        "UPCASE-STRING" => upcase_string(symbols, args),

        "GET-INPUT-ENTITIES" => get_input_entities(symbols, args),

}

fn debug_call(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    let parts: Vec<String> = args

        .iter()

        .map(|a| eval_value(symbols, a).map(|r| format_expr(&r)))

        .collect::<Result<_>>()?;

    let msg = parts.join(" ");

    tracing::debug!("[script] {msg}");

    Ok(Expr::Nil)

}

pub(super) fn compile_debug_effect(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let resolved: std::result::Result<Vec<_>, _> =

        args.iter().map(|a| eval_value(symbols, a)).collect();

    let msg = resolved?

        .iter()

        .map(format_expr)

        .collect::<Vec<_>>()

        .join(" ");

    let data_idx = ctx.add_data(msg.as_bytes());

    let len = msg.len() as u32;

    emit.memory_init(data_idx, SCRATCH_OFFSET, len);

    emit.i32_const(0);

    emit.i32_const(SCRATCH_OFFSET as i32);

    emit.i32_const(len as i32);

    emit.call(ctx.func("log"));

    Ok(())

}

pub(super) fn compile_debug(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let resolved: std::result::Result<Vec<_>, _> =

        args.iter().map(|a| eval_value(symbols, a)).collect();

    let msg = resolved?

        .iter()

        .map(format_expr)

        .collect::<Vec<_>>()

        .join(" ");

    let data_idx = ctx.add_data(msg.as_bytes());

    let len = msg.len() as u32;

    emit.memory_init(data_idx, SCRATCH_OFFSET, len);

    emit.i32_const(0); // level = debug

    emit.i32_const(SCRATCH_OFFSET as i32);

    emit.i32_const(len as i32);

    emit.call(ctx.func("log"));

    compile_nil(emit);

    Ok(())

}

fn add(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    let nums = resolve_numbers(symbols, args, "+")?;

    let sum = nums

        .into_iter()

        .fold(Fraction::from_integer(0), |a, b| a + b);

    Ok(Expr::Number(sum))

}

fn sub(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.is_empty() {

    }

    let nums = resolve_numbers(symbols, args, "-")?;

    let result = if nums.len() == 1 {

        nums[1..].iter().fold(nums[0], |a, b| a - b)

    Ok(Expr::Number(result))

}

fn mul(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    let nums = resolve_numbers(symbols, args, "*")?;

    let product = nums

        .into_iter()

        .fold(Fraction::from_integer(1), |a, b| a * b);

    Ok(Expr::Number(product))

}

fn num_cmp(

    symbols: &mut SymbolTable,

    args: &[Expr],

    name: &str,

    cmp: fn(&Fraction, &Fraction) -> bool,

) -> Result<Expr> {

    if args.is_empty() {

    }

    let nums = resolve_numbers(symbols, args, name)?;

    let result = nums.windows(2).all(|w| cmp(&w[0], &w[1]));

    Ok(bool_result(result))

}

fn eql(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 2 {

    }

    let a = eval_value(symbols, &args[0])?;

    let b = eval_value(symbols, &args[1])?;

    Ok(bool_result(a == b))

}

fn equal(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 2 {

    }

    let a = eval_value(symbols, &args[0])?;

    let b = eval_value(symbols, &args[1])?;

    Ok(bool_result(a == b))

}

fn list(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    let resolved: Vec<Expr> = args

        .iter()

        .map(|a| eval_value(symbols, a))

        .collect::<Result<_>>()?;

    Ok(Expr::Quote(Box::new(Expr::List(resolved))))

}

pub(super) fn compile(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    name: &str,

    args: &[Expr],

) -> Result<()> {

    match name {

        "+" => compile_add(emit, symbols, args),

        "-" => compile_sub(emit, symbols, args),

        "*" => compile_mul(emit, symbols, args),

        "/" => compile_div(emit, symbols, args),

        "MOD" => compile_mod(emit, symbols, args),

        "=" => compile_num_cmp(emit, symbols, args, "=", |a, b| a == b),

        "/=" => compile_num_neq(emit, symbols, args),

        "<" => compile_num_cmp(emit, symbols, args, "<", |a, b| a < b),

        ">" => compile_num_cmp(emit, symbols, args, ">", |a, b| a > b),

        "<=" => compile_num_cmp(emit, symbols, args, "<=", |a, b| a <= b),

        ">=" => compile_num_cmp(emit, symbols, args, ">=", |a, b| a >= b),

        "EQL" => compile_eql(emit, symbols, args),

        "EQUAL" => compile_equal(emit, symbols, args),

        "DEBUG" => compile_debug(ctx, emit, symbols, args),

        "LIST" => compile_list(ctx, emit, symbols, args),

        "CONS" => compile_cons(ctx, emit, symbols, args),

        "CAR" => compile_car(ctx, emit, symbols, args),

        "CDR" => compile_cdr(ctx, emit, symbols, args),

        "MAP" => compile_map(ctx, emit, symbols, args),

        "MAKE-STRUCT-INSTANCE" => compile_make_struct_instance(ctx, emit, symbols, args),

}

fn emit_bool(emit: &mut FunctionEmitter, value: bool) {

    if value {

        compile_bool(emit, true);

    } else {

        compile_nil(emit);

    }

}

fn compile_add(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    let nums = resolve_numbers(symbols, args, "+")?;

    let sum = nums

        .into_iter()

        .fold(Fraction::from_integer(0), |a, b| a + b);

    compile_number(emit, *sum.numer(), *sum.denom());

    Ok(())

}

fn compile_sub(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    if args.is_empty() {

        return Err(Error::Compile("- requires at least 1 argument".to_string()));

    }

    let nums = resolve_numbers(symbols, args, "-")?;

    let result = if nums.len() == 1 {

        -nums[0]

        nums[1..].iter().fold(nums[0], |a, b| a - b)

    compile_number(emit, *result.numer(), *result.denom());

    Ok(())

}

fn compile_mul(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    let nums = resolve_numbers(symbols, args, "*")?;

    let product = nums

        .into_iter()

        .fold(Fraction::from_integer(1), |a, b| a * b);

    compile_number(emit, *product.numer(), *product.denom());

    Ok(())

}

fn compile_div(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    if args.is_empty() {

        return Err(Error::Compile("/ requires at least 1 argument".to_string()));

    }

    let nums = resolve_numbers(symbols, args, "/")?;

    let result = if nums.len() == 1 {

        if *nums[0].numer() == 0 {

            return Err(Error::Compile("division by zero".to_string()));

        }

        nums[0].recip()

        let mut acc = nums[0];

        for &n in &nums[1..] {

            if *n.numer() == 0 {

                return Err(Error::Compile("division by zero".to_string()));

            }

            acc /= n;

        acc

    compile_number(emit, *result.numer(), *result.denom());

    Ok(())

}

fn compile_mod(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    if args.len() != 2 {

        return Err(Error::Arity {

            name: "MOD".to_string(),

            expected: 2,

            actual: args.len(),

        });

    }

    let nums = resolve_numbers(symbols, args, "MOD")?;

    if *nums[1].numer() == 0 {

    }

    let quotient = (nums[0] / nums[1]).floor();

    let result = nums[0] - nums[1] * quotient;

    compile_number(emit, *result.numer(), *result.denom());

    Ok(())

}

fn compile_num_cmp(

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

    name: &str,

    cmp: fn(&Fraction, &Fraction) -> bool,

) -> Result<()> {

    if args.is_empty() {

    }

    let nums = resolve_numbers(symbols, args, name)?;

    let result = nums.windows(2).all(|w| cmp(&w[0], &w[1]));

    emit_bool(emit, result);

    Ok(())

}

fn compile_num_neq(

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    if args.is_empty() {

    }

    let nums = resolve_numbers(symbols, args, "/=")?;

    let result = (0..nums.len()).all(|i| (i + 1..nums.len()).all(|j| nums[i] != nums[j]));

    emit_bool(emit, result);

    Ok(())

}

fn compile_eql(emit: &mut FunctionEmitter, symbols: &mut SymbolTable, args: &[Expr]) -> Result<()> {

    if args.len() != 2 {

        return Err(Error::Arity {

            name: "EQL".to_string(),

            expected: 2,

            actual: args.len(),

        });

    }

    let a = eval_value(symbols, &args[0])?;

    let b = eval_value(symbols, &args[1])?;

    emit_bool(emit, a == b);

    Ok(())

}

fn compile_equal(

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    if args.len() != 2 {

        return Err(Error::Arity {

            name: "EQUAL".to_string(),

            expected: 2,

            actual: args.len(),

        });

    }

    let a = eval_value(symbols, &args[0])?;

    let b = eval_value(symbols, &args[1])?;

    emit_bool(emit, a == b);

    Ok(())

}

fn compile_list(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let result = list(symbols, args)?;

    compile_expr(ctx, emit, symbols, &result)

}

fn compile_cons(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let result = cons(symbols, args)?;

    compile_expr(ctx, emit, symbols, &result)

}

fn cons(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 2 {

        return Err(Error::Arity {

            name: "CONS".to_string(),

            expected: 2,

            actual: args.len(),

        });

    }

    let car = eval_value(symbols, &args[0])?;

    let cdr = eval_value(symbols, &args[1])?;

    match cdr {

        Expr::Quote(inner) => match *inner {

            Expr::List(mut elems) => {

                elems.insert(0, car);

                Ok(Expr::Quote(Box::new(Expr::List(elems))))

        Expr::Nil => Ok(Expr::Quote(Box::new(Expr::List(vec![car])))),

}

fn car(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 1 {

        return Err(Error::Arity {

            name: "CAR".to_string(),

            expected: 1,

            actual: args.len(),

        });

    }

    let arg = eval_value(symbols, &args[0])?;

    match arg {

        Expr::Nil => Ok(Expr::Nil),

        Expr::RuntimeValue(crate::runtime::Value::Struct { name, .. }) => Ok(Expr::Symbol(name)),

        Expr::Quote(inner) => match *inner {

            Expr::List(elems) => {

                if elems.is_empty() {

                    Ok(Expr::Nil)

                    Ok(elems[0].clone())

        other => Err(Error::Compile(format!(

            "CAR expects a list, got {}",

            format_expr(&other)

        ))),

}

fn cdr(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 1 {

        return Err(Error::Arity {

            name: "CDR".to_string(),

            expected: 1,

            actual: args.len(),

        });

    }

    let arg = eval_value(symbols, &args[0])?;

        Expr::Nil => Ok(Expr::Nil),

        Expr::Quote(inner) => match *inner {

            Expr::List(elems) => {

                if elems.is_empty() {

                    Ok(Expr::Nil)

                } else if elems.len() == 1 {

                    let tail = elems[1..].to_vec();

                    Ok(Expr::Quote(Box::new(Expr::List(tail))))

        other => Err(Error::Compile(format!(

            "CDR expects a list, got {}",

            format_expr(&other)

        ))),

}

fn map_fn(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() < 2 {

        return Err(Error::Arity {

            name: "MAP".to_string(),

            expected: 2,

            actual: args.len(),

        });

    }

    let function_arg = &args[0];

    let list_args = &args[1..];

    let lists: Vec<Vec<Expr>> = list_args

        .iter()

        .map(|arg| {

            let resolved = eval_value(symbols, arg)?;

            extract_list_elements(&resolved)

        })

        .collect::<Result<_>>()?;

    let min_len = lists.iter().map(std::vec::Vec::len).min().unwrap_or(0);

    let mut results = Vec::new();

    fn as_literal_arg(expr: &Expr) -> Expr {

        match expr {

                Expr::Quote(Box::new(expr.clone()))

            _ => expr.clone(),

    }

    for i in 0..min_len {

        let mut call_args = vec![function_arg.clone()];

        for list in &lists {

            call_args.push(as_literal_arg(&list[i]));

        }

        let result = super::expr::call(symbols, &call_args)?;

        let resolved_result = eval_value(symbols, &result)?;

        results.push(resolved_result);

    Ok(Expr::Quote(Box::new(Expr::List(results))))

}

fn extract_list_elements(expr: &Expr) -> Result<Vec<Expr>> {

    match expr {

        Expr::Quote(inner) => match inner.as_ref() {

            Expr::List(elems) => Ok(elems.clone()),

        other => Err(Error::Compile(format!(

            "MAP expects list arguments, got {}",

            format_expr(other)

        ))),

}

fn make_struct_instance(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 3 {

    }

    let name_expr = eval_value(symbols, &args[0])?;

    let fields_expr = eval_value(symbols, &args[1])?;

    let values_expr = eval_value(symbols, &args[2])?;

    let name = match name_expr {

        Expr::Quote(inner) => match inner.as_ref() {

            Expr::String(s) => s.clone(),

    let field_names = match fields_expr {

        Expr::Quote(inner) => match inner.as_ref() {

            Expr::List(elems) => elems

                .iter()

                .map(|e| match e {

                    Expr::String(s) => Ok(s.clone()),

                })

                .collect::<Result<Vec<_>>>()?,

    let field_values = match values_expr {

        Expr::Quote(inner) => match inner.as_ref() {

            Expr::List(elems) => elems

                .iter()

                .map(|e| match e {

                    Expr::Nil => Ok(crate::runtime::Value::Nil),

                    Expr::Number(n) => Ok(crate::runtime::Value::Number(*n)),

                    Expr::String(s) => Ok(crate::runtime::Value::String(s.clone())),

                })

                .collect::<Result<Vec<_>>>()?,

    if field_values.len() == field_names.len() {

        let struct_value = Value::Struct {

            name: name.clone(),

            fields: field_values,

        };

        Ok(Expr::RuntimeValue(struct_value))

}

fn struct_field(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 2 {

    }

    let instance_expr = eval_value(symbols, &args[0])?;

    let field_expr = eval_value(symbols, &args[1])?;

    let field_name = match field_expr {

        Expr::Quote(inner) => match inner.as_ref() {

            Expr::Symbol(s) => s.clone(),

    match instance_expr {

        Expr::RuntimeValue(val) => {

            match val {

                Value::Struct { name, fields } => {

                    let Some(field_names) = symbols.struct_fields(&name) else {

                    let Some(index) = field_names.iter().position(|f| f == &field_name) else {

                        return Ok(Expr::Nil);

                    let value = fields.get(index).cloned().unwrap_or(Value::Nil);

                    match value {

                        Value::String(s) => Ok(Expr::String(s)),

}

fn struct_p(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.is_empty() || args.len() > 2 {

    }

    let object_expr = eval_value(symbols, &args[0])?;

    let type_name = if args.len() == 2 {

        None

    match object_expr {

        Expr::RuntimeValue(val) => {

            match val {

                Value::Struct { name, fields: _ } => {

                    if let Some(type_name) = type_name {

                        Ok(Expr::Bool(true))

}

fn struct_set_field(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 3 {

    }

    let instance_expr = eval_value(symbols, &args[0])?;

    let field_expr = eval_value(symbols, &args[1])?;

    let new_value_expr = eval_value(symbols, &args[2])?;

    let field_name = match field_expr {

        Expr::Quote(inner) => match inner.as_ref() {

            other => {

                return Err(Error::Compile(format!(

                    "STRUCT-SET-FIELD: expected string or symbol for field name, got quoted {}",

                    format_expr(other)

                )));

}

fn compile_make_struct_instance(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    if args.len() != 3 {

    }

    let result = make_struct_instance(symbols, args)?;

    compile_expr(ctx, emit, symbols, &result)

}

fn get_input_entities(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if !args.is_empty() {

    }

    let transaction_entity = Value::Struct {

        name: "TRANSACTION".to_string(),

        fields: vec![

            Value::String("2024-01-15".to_string()), // post-date (from test)

            Value::String("2024-01-15".to_string()), // enter-date (from test)

            Value::Number(crate::ast::Fraction::from_integer(2)), // split-count

            Value::Number(crate::ast::Fraction::from_integer(1)), // tag-count

            Value::Bool(false),                      // is-multi-currency

        ],

    };

    let split1_entity = Value::Struct {

        name: "SPLIT".to_string(),

        fields: vec![

            Value::String("account1".to_string()), // account-id (simplified from test)

            Value::String("USD".to_string()),      // commodity-id

            Value::Number(crate::ast::Fraction::new(-5000, 100)), // value-num/denom

            Value::Number(crate::ast::Fraction::from_integer(100)),

            Value::Number(crate::ast::Fraction::from_integer(0)), // reconcile-state

            Value::Nil,                                           // reconcile-date

        ],

    };

    let split2_entity = Value::Struct {

        name: "SPLIT".to_string(),

        fields: vec![

            Value::String("account2".to_string()), // account-id

            Value::String("USD".to_string()),      // commodity-id

            Value::Number(crate::ast::Fraction::new(5000, 100)), // value-num/denom

            Value::Number(crate::ast::Fraction::from_integer(100)),

            Value::Number(crate::ast::Fraction::from_integer(0)), // reconcile-state

            Value::Nil,                                           // reconcile-date

        ],

    };

    let tag_entity = Value::Struct {

        name: "TAG".to_string(),

        fields: vec![

            Value::String("note".to_string()),             // name

            Value::String("test-transaction".to_string()), // value (from test data!)

        ],

    };

    let entities = vec![

        Expr::RuntimeValue(transaction_entity),

        Expr::RuntimeValue(split1_entity),

        Expr::RuntimeValue(split2_entity),

        Expr::RuntimeValue(tag_entity),

    Ok(Expr::Quote(Box::new(Expr::List(entities))))

}