package mayton;

import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

import static java.lang.Integer.valueOf;
import static mayton.JLisp.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class JLispTest {

    @Test
    public void testAtom(){
        // (atom (1))
        assertTrue(atom(new node(valueOf(1), null)));
        // (atom ())
        assertTrue(atom(new node(new node(), null)));
    }

    @Test
    public void testNil(){
        assertTrue(nil(new node(null, null)));
    }

    node nil;
    Object atom;
    Object atom2;
    Object atom3;
    Object atom4;
    node list1;
    node list2;
    node list3;

    node tree1;
    node tree2;

    node listWithNil;

    node moreComplexTree;

    @Before
    public void before(){
        // Atom
        nil = null;
        atom = valueOf(1);
        atom2 = "Hello";
        atom3 = Double.valueOf(3.14);
        atom4 = Boolean.FALSE;

        // List
        list1 = new node(valueOf(1));
        list2 = new node(valueOf(1),new node(valueOf(2),null));
        list3 = new node(valueOf(1),new node(valueOf(2),new node(valueOf(3),null)));

        listWithNil = new node(null, new node(2, new node("Three", null)));

        // Tree ((NIL))
        tree1 = new node(
                    new node(null,null),
                    null
        );
        // Tree (((NIL)))
        tree2 = new node(
                    new node(
                            new node(),
                            null),
                    null
        );

        // More Complex Tree
        // (person (name "Ivan")
        moreComplexTree = new node();

    }

    @Test
    public void stringFormatAtom() throws IOException {
        assertEquals("NIL",    JLispHelper.node2String(null));
        assertEquals("1",      JLispHelper.node2String(valueOf(1)));
        assertEquals("Hello",  JLispHelper.node2String(atom2));
        assertEquals("3.14",   JLispHelper.node2String(atom3));
        assertEquals("false",  JLispHelper.node2String(atom4));
        assertEquals("Hello \"Monkey\"",  JLispHelper.node2String("Hello \"Monkey\""));
    }


    @Test
    public void stringFormatList() throws IOException {
        assertEquals("(1)",        JLispHelper.node2String(list1));
        assertEquals("(1 2)",      JLispHelper.node2String(list2));
        assertEquals("(1 2 3)",    JLispHelper.node2String(list3));
        // Mixed list
        assertEquals("(NIL 2 \"Three\")", JLispHelper.node2String(listWithNil));

        assertEquals("(3.14 false)", JLispHelper.node2String(
                        new node(Double.valueOf(3.14), new node(Boolean.FALSE, null)))
        );
        // Nested list
        assertEquals("(NIL)",    JLispHelper.node2String(new node(null, null)));
        assertEquals("((NIL))",  JLispHelper.node2String(tree1));
        assertEquals("(((NIL)))", JLispHelper.node2String(tree2));
    }

    @Test
    public void testCons() throws IOException {
        node consList = cons(valueOf(0),list3);
        assertEquals("(0 1 2 3)", JLispHelper.node2String(consList));
    }

    /**
     * Test car
     *
     * <pre>
     *   > (car '(1 2 3))
     *   1
     *   > (car '((1) 2 3))
     *   (1)
     * </pre>
     * @throws IOException
     */
    @Test
    public void testCar() throws IOException {
        assertEquals("1",    JLispHelper.node2String(car(list3)));
    }

    /**
     * Test cdr
     * <pre>
     *     > (cdr '(1 2 3)
     *     (2 3)
     *     > (cdr (cdr '(1 2 3))
     *     (3)
     * </pre>
     * @throws IOException
     */
    @Test
    public void testCdr() throws IOException {
        assertEquals("(2 3)",    JLispHelper.node2String(cdr(list3)));
        assertEquals("(3)",    JLispHelper.node2String(cdr(cdr(list3))));
    }

}