#include "memory_stream.h"
#include "read.h"
#include "unity.h"

#include <string.h>

#define CAR(expr) (expr->pair.car)
#define CDR(expr) (expr->pair.cdr)
#define CADR(expr) CAR(CDR(expr))
#define CDDR(expr) CDR(CDR(expr))
#define CADDR(expr) CAR(CDDR(expr))
#define CDDDR(expr) CDR(CDDR(expr))
#define CAADDR(expr) CAR(CADDR(expr))
#define CDADDR(expr) CDR(CADDR(expr))
#define CADADDR(expr) CAR(CDADDR(expr))
#define CDDADDR(expr) CDR(CDADDR(expr))
#define CADDADDR(expr) CAR(CDDADDR(expr))
#define CDDDADDR(expr) CDR(CDDADDR(expr))

static am_t am;

void setUp(void)
{
	am_init(&am);
}

void tearDown(void)
{
}

static void test_nested_expression(void)
{
	const char *input = "(+ 1 (* 2 3))";
	memory_stream_t stream;
	memory_stream_init(&stream, (const uint8_t *)input, strlen(input));

	read(&am, (stream_t *)&stream);

	TEST_ASSERT_NOT_NULL(am.expr);
	TEST_ASSERT_FALSE(am.expr->is_atom);

	TEST_ASSERT_NOT_NULL(CAR(am.expr));
	TEST_ASSERT_TRUE(CAR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAR(am.expr)->atom.type);
	TEST_ASSERT_EQUAL(1, CAR(am.expr)->atom.symbol.len);
	TEST_ASSERT_EQUAL_MEMORY("+", CAR(am.expr)->atom.symbol.buf, 1);

	TEST_ASSERT_NOT_NULL(CDR(am.expr));
	TEST_ASSERT_FALSE(CDR(am.expr)->is_atom);

	TEST_ASSERT_NOT_NULL(CADR(am.expr));
	TEST_ASSERT_TRUE(CADR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADR(am.expr)->atom.type);
	TEST_ASSERT_EQUAL(1, CADR(am.expr)->atom.integer);

	TEST_ASSERT_NOT_NULL(CDDR(am.expr));
	TEST_ASSERT_FALSE(CDDR(am.expr)->is_atom);

	TEST_ASSERT_NOT_NULL(CADDR(am.expr));
	TEST_ASSERT_FALSE(CADDR(am.expr)->is_atom);

	TEST_ASSERT_NOT_NULL(CAADDR(am.expr));
	TEST_ASSERT_TRUE(CAADDR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAADDR(am.expr)->atom.type);
	TEST_ASSERT_EQUAL(1, CAADDR(am.expr)->atom.symbol.len);
	TEST_ASSERT_EQUAL_MEMORY("*", CAADDR(am.expr)->atom.symbol.buf, 1);

	TEST_ASSERT_NOT_NULL(CDADDR(am.expr));
	TEST_ASSERT_FALSE(CDADDR(am.expr)->is_atom);

	TEST_ASSERT_NOT_NULL(CADADDR(am.expr));
	TEST_ASSERT_TRUE(CADADDR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADADDR(am.expr)->atom.type);
	TEST_ASSERT_EQUAL(2, CADADDR(am.expr)->atom.integer);

	TEST_ASSERT_NOT_NULL(CDDADDR(am.expr));
	TEST_ASSERT_FALSE(CDDADDR(am.expr)->is_atom);

	TEST_ASSERT_NOT_NULL(CADDADDR(am.expr));
	TEST_ASSERT_TRUE(CADDADDR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADDADDR(am.expr)->atom.type);
	TEST_ASSERT_EQUAL(3, CADDADDR(am.expr)->atom.integer);

	TEST_ASSERT_NOT_NULL(CDDDADDR(am.expr));
	TEST_ASSERT_TRUE(CDDDADDR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDDDADDR(am.expr)->atom.type);

	TEST_ASSERT_NOT_NULL(CDDDR(am.expr));
	TEST_ASSERT_TRUE(CDDDR(am.expr)->is_atom);
	TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDDDR(am.expr)->atom.type);
}

int main(void)
{
	UNITY_BEGIN();
	RUN_TEST(test_nested_expression);
	return UNITY_END();
}