#include "expr.h"

#include <src/value.h>

void test_expr_ref_type(void) {
    ystr_t str = ystr_new("abc");
    yref_t ref0, ref = yref_new_c("abc");

    assert(YREF_SYM == yref_type(&ref));
    yref_destroy(&ref);

    ref = yref_new_str(&str);
    assert(YREF_SYM == yref_type(&ref));
    yref_destroy(&ref);

    ystr_t str2 = ystr_new("abc");
    ref = yref_new_id(yvalue_resolve_or_create_symbol(&str2));
    assert(YREF_ID == yref_type(&ref));
    ystr_destroy(&str2);
    ref0 = ref;

    ref = yref_new();
    assert(YREF_ID == yref_type(&ref));
    assert(ref.ref.id == ref0.ref.id+1);
}

void test_expr_set(void) {
    yexpr_t expr = yexpr_new();

    // Test atoms.
    yexpr_set_atom_name(&expr, "myatom");
    assert(0 == strcmp("myatom", yatom_name(expr.value.atom)));
    yexpr_set_atom(&expr, yatom_get_or_add("myatom2"));
    assert(0 == strcmp("myatom2", yatom_name(expr.value.atom)));
    yexpr_debug(&expr);
    fputs("\n", stderr);
    yexpr_destroy(&expr);
    expr = yexpr_new();

    // Test number.
    yexpr_set_number(&expr, 12345);
    assert(12345 == expr.value.n);
    yexpr_debug(&expr);
    fputs("\n", stderr);
    yexpr_destroy(&expr);
    expr = yexpr_new();

    // Test string.
    yexpr_set_str(&expr, ystr_new("hello"));
    assert(0 == ystr_cmp_str(&expr.value.str, "hello"));
    yexpr_debug(&expr);
    fputs("\n", stderr);
    yexpr_destroy(&expr);
    expr = yexpr_new();

    // Test refs, symbolic and numeric.
    yexpr_set_ref(&expr, yref_new_c("my-ref"));
    yexpr_debug(&expr);
    fputs("\n", stderr);
    yvalue_resolve_or_create_ref(&expr.value.ref);
    assert(YREF_ID == yref_type(&expr.value.ref));
    yexpr_debug(&expr);
    fputs("\n", stderr);
    yexpr_destroy(&expr);
    expr = yexpr_new();

    // Test list.
    yexpr_t src[3] = {yexpr_new(), yexpr_new(), yexpr_new()};
    yexpr_set_number(&src[0], 123);
    yexpr_set_number(&src[1], 124);
    yexpr_set_number(&src[2], 125);
    yvec_t vec = YVEC_NEW(src, 3, yexpr_t);
    yexpr_set_list(&expr, vec);
    assert(124 == (YVEC_AT(&expr.value.list, 1, yexpr_t))->value.n);

    // Test append (first value to end).
    yexpr_append_value(&expr, src[0]);
    yexpr_append_value(&expr, src[2]);
    assert(123 == (YVEC_AT(&expr.value.list, 3, yexpr_t))->value.n);
    assert(125 == (YVEC_AT(&expr.value.list, 4, yexpr_t))->value.n);

    yexpr_destroy(&expr);
    expr = yexpr_new();

    // Test init_or_extend.
    yexpr_set_number(&expr, 12345);

    yexpr_t src2[3] = {yexpr_new(), yexpr_new(), yexpr_new()};
    yexpr_set_atom_name(&src2[0], "atom1");
    yexpr_set_atom_name(&src2[1], "atom2");
    yexpr_set_atom_name(&src2[2], "atom3");
    yexpr_init_or_extend(&expr, src2[0]);
    yexpr_init_or_extend(&expr, src2[2]);
    // Expr now contains list of exprs: 12345, atom1, atom3.
    yvec_t list = expr.value.list;
    assert(12345 == YVEC_AT(&list, 0, yexpr_t)->value.n);
    yatom_t got = YVEC_AT(&list, 1, yexpr_t)->value.atom;
    assert(yatom_get_or_add("atom1") == got);
    got = YVEC_AT(&list, 2, yexpr_t)->value.atom;
    assert(yatom_get_or_add("atom3") == got);

    yexpr_debug(&expr);
    fputs("\n", stderr);

    yexpr_destroy(&expr);
}

int main(int argc, char** argv) {
    test_expr_ref_type();
    test_expr_set();
    return 0;
}