import unittest
from modelverse_kernel.main import ModelverseKernel
from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref

class TestRead(unittest.TestCase):
    def setUp(self):
        self.mvs = MvSWrapper()
        self.root = self.mvs.execute("RR", [])[0]
        self.mvk = ModelverseKernel(self.root)

        self.task_root = self.mvs.execute("CN", [])[0]
        self.task_frame = self.mvs.execute("CN", [])[0]
        self.symbols = self.mvs.execute("CN", [])[0]
        self.evalstack = self.mvs.execute("CN", [])[0]
        self.returnvalue = self.mvs.execute("CN", [])[0]
        self.phase = self.mvs.execute("CNV", ["init"])[0]

        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])

        execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
        self.primitives = read_primitive_interfaces(self.root, self.mvs)

    def test_read_root(self):
        self.helper_primitives_no_params("read_root")
        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(v, self.root)

    def test_read_nr_out_none(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_1_params("read_nr_out", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(self.mvs.execute("RV", [v])[0], 0)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_nr_out_one(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        self.helper_primitives_1_params("read_nr_out", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(self.mvs.execute("RV", [v])[0], 1)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_nr_out_multi(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        self.helper_primitives_1_params("read_nr_out", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(self.mvs.execute("RV", [v])[0], 4)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_nr_in_none(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        self.helper_primitives_1_params("read_nr_in", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
        self.assertEquals(self.mvs.execute("RV", [v])[0], 3)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_nr_in_one(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_1_params("read_nr_in", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
        self.assertEquals(self.mvs.execute("RV", [v])[0], 4)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_nr_in_multi(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_1_params("read_nr_in", v)

        v = get_returnvalue_ref(self.root, self.mvs)
        # There are still input links from the execution itself, such as entries in symbol table, parameter lists, ...
        self.assertEquals(self.mvs.execute("RV", [v])[0], 7)
        self.assertEquals(self.mvs.execute("RE", [v])[0], [None, None])
        self.assertEquals(len(self.mvs.execute("RO", [v])[0]), 0)
        # There is an incoming link, as this is due to the returnvalue link
        self.assertEquals(len(self.mvs.execute("RI", [v])[0]), 1)

    def test_read_out_one(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [v, a])[0]
        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [0])[0])

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(v, e)

    def test_read_out_multi(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e1 = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e2 = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e3 = self.mvs.execute("CE", [v, a])[0]
        a = self.mvs.execute("CN", [])[0]
        e4 = self.mvs.execute("CE", [v, a])[0]
        self.helper_primitives_2_params("read_out", v, self.mvs.execute("CNV", [2])[0])

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(v, e3)

    def test_read_in_one(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [0])[0])

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(v, e)

    def test_read_in_multi(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e1 = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e2 = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e3 = self.mvs.execute("CE", [a, v])[0]
        a = self.mvs.execute("CN", [])[0]
        e4 = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_2_params("read_in", v, self.mvs.execute("CNV", [2])[0])

        v = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(v, e3)

    def test_read_edge_src(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_1_params("read_edge_src", e)

        r = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(r, a)

    def test_read_edge_dst(self):
        v = self.mvs.execute("CN", [])[0]
        a = self.mvs.execute("CN", [])[0]
        e = self.mvs.execute("CE", [a, v])[0]
        self.helper_primitives_1_params("read_edge_dst", e)

        r = get_returnvalue_ref(self.root, self.mvs)
        self.assertEquals(r, v)

    def helper_primitives_2_params(self, operation, a, b):
        self.actual_arg_a = self.mvs.execute("CN", [])[0]
        self.actual_arg_b = self.mvs.execute("CN", [])[0]

        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_second = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.value_a = self.mvs.execute("CNV", ["a"])[0]
        self.value_b = self.mvs.execute("CNV", ["b"])[0]
        self.value_c = self.mvs.execute("CNV", ["c"])[0]
        self.value_first = a
        self.value_second = b

        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.mvs.execute("CD", [self.inst, "func", self.const_func])
        self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
        self.mvs.execute("CD", [self.inst, "next", self.const_c])
        self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
        self.mvs.execute("CD", [self.actual_arg_a, "next_param", self.actual_arg_b])
        self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_b])
        self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_first])
        self.mvs.execute("CD", [self.actual_arg_b, "value", self.const_second])
        self.mvs.execute("CD", [self.actual_arg_a, "name", self.value_a])
        self.mvs.execute("CD", [self.actual_arg_b, "name", self.value_b])
        self.mvs.execute("CD", [self.const_a, "node", self.value_a])
        self.mvs.execute("CD", [self.const_b, "node", self.value_b])
        self.mvs.execute("CD", [self.const_c, "node", self.value_c])
        self.mvs.execute("CD", [self.const_first, "node", self.value_first])
        self.mvs.execute("CD", [self.const_second, "node", self.value_second])

        ### Execute rules
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_a)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        self.assertEquals(get_returnvalue_ref(self.root, self.mvs), self.value_first)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_b)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        self.assertEquals(get_returnvalue_ref(self.root, self.mvs), self.value_second)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "call")
        execute_until_finished(self.mvk, self.mvs)

        # Body points to empty instruction, as it is a primitive
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        # This will have triggered the primitive, so now we are back where we left off
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")

    def helper_primitives_1_params(self, operation, a):
        self.actual_arg_a = self.mvs.execute("CN", [])[0]

        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.value_a = self.mvs.execute("CNV", ["a"])[0]
        self.value_b = self.mvs.execute("CNV", ["b"])[0]
        self.value_c = self.mvs.execute("CNV", ["c"])[0]
        self.value_first = a

        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.mvs.execute("CD", [self.inst, "func", self.const_func])
        self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
        self.mvs.execute("CD", [self.inst, "next", self.const_c])
        self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
        self.mvs.execute("CD", [self.inst, "last_param", self.actual_arg_a])
        self.mvs.execute("CD", [self.actual_arg_a, "value", self.const_first])
        self.mvs.execute("CD", [self.actual_arg_a, "name", self.value_a])
        self.mvs.execute("CD", [self.const_a, "node", self.value_a])
        self.mvs.execute("CD", [self.const_b, "node", self.value_b])
        self.mvs.execute("CD", [self.const_c, "node", self.value_c])
        self.mvs.execute("CD", [self.const_first, "node", self.value_first])

        ### Execute rules
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase_ref(self.root, self.mvs), self.actual_arg_a)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        self.assertEquals(get_returnvalue_ref(self.root, self.mvs), self.value_first)
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "call")
        execute_until_finished(self.mvk, self.mvs)

        # Body points to empty instruction, as it is a primitive
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        # This will have triggered the primitive, so now we are back where we left off
        # Just check whether or not the correct value is in the returnvalue to be used
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")

    def helper_primitives_no_params(self, operation, expected=None):
        self.inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
        self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.const_first = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.value_a = self.mvs.execute("CNV", ["a"])[0]
        self.value_b = self.mvs.execute("CNV", ["b"])[0]
        self.value_c = self.mvs.execute("CNV", ["c"])[0]

        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
        self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
        self.mvs.execute("CD", [self.inst, "func", self.const_func])
        self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
        self.mvs.execute("CD", [self.inst, "next", self.const_c])
        self.mvs.execute("CD", [self.const_a, "node", self.value_a])
        self.mvs.execute("CD", [self.const_b, "node", self.value_b])
        self.mvs.execute("CD", [self.const_c, "node", self.value_c])

        ### Execute rules
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "constant")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
        execute_until_finished(self.mvk, self.mvs)

        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "call")
        execute_until_finished(self.mvk, self.mvs)

        # Body points to empty instruction, as it is a primitive
        self.assertEquals(get_phase(self.root, self.mvs), "init")
        execute_until_finished(self.mvk, self.mvs)

        # This will have triggered the primitive, so now we are back where we left off
        # Just check whether or not the correct value is in the returnvalue to be used
        self.assertEquals(get_inst(self.root, self.mvs), "call")
        self.assertEquals(get_phase(self.root, self.mvs), "finish")
