import unittest

from disas import decode_instruction_complete as di


def make_instruction(ins):
    ins <<= 6
    ins |= 0x8000
    return ins


def dbglog(message: str):
    print("\n", end="")
    print(message, end="")


class DisasUnitTest(unittest.TestCase):
    # from nandgame
    # opcode | u | op | op0 | zx | sw
    # D+A    | 1 | 0  | 0   | 0  | 0
    def test_add(self):
        ins = 0b10000
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "add")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "A")

    # D-A    | 1 | 1  | 0   | 0  | 0
    def test_sub1(self):
        ins = 0b11000
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "sub")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "A")

    # A-D    | 1 | 1  | 0   | 0  | 1
    def test_sub2(self):
        ins = 0b11001
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "sub")
        self.assertEqual(X, "A")
        self.assertEqual(Y, "D")

    # D+1    | 1 | 0  | 1   | 0  | 0
    def test_incD(self):
        ins = 0b10100
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "inc")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "")

    # A+1    | 1 | 0  | 1   | 0  | 1
    def test_incA(self):
        ins = 0b10101
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "inc")
        self.assertEqual(X, "A")
        self.assertEqual(Y, "")

    # D-1    | 1 | 1  | 1   | 0  | 0
    def test_decD(self):
        ins = 0b11100
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "dec")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "")

    # A-1    | 1 | 1  | 1   | 0  | 1
    def test_decA(self):
        ins = 0b11101
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "dec")
        self.assertEqual(X, "A")
        self.assertEqual(Y, "")

    # -D     | 1 | 1  | 0   | 1  | 1
    def test_minusD(self):
        ins = 0b11011
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "sub")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "D")

    # -A     | 1 | 1  | 0   | 1  | 0
    def test_minusA(self):
        ins = 0b11010
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "sub")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "A")

    # -1     | 1 | 1  | 1   | 1  | 0
    def test_minusOne(self):
        ins = 0b11110
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "dec")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "")

    # 1      | 1 | 0  | 1   | 1  | 0
    def test_plusOne(self):
        ins = 0b10110
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "inc")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "")

    # D      | 1 | 0  | 0   | 1  | 1
    def test_D(self):
        ins = 0b10011
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "add")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "D")

    # A      | 1 | 0  | 0   | 1  | 0
    def test_A(self):
        ins = 0b10010
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "add")
        self.assertEqual(X, "0")
        self.assertEqual(Y, "A")

    # D&A    | 0 | 0  | 0   | 0  | 0
    def test_DandA(self):
        ins = 0b00000
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "and")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "A")

    # D|A    | 0 | 0  | 1   | 0  | 0
    def test_DorA(self):
        ins = 0b00100
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "or")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "A")

    # ~D     | 0 | 1  | 1   | 0  | 0
    def test_negD(self):
        ins = 0b01100
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "neg")
        self.assertEqual(X, "D")
        self.assertEqual(Y, "")

    # ~A     | 0 | 1  | 1   | 0  | 1
    def test_negD(self):
        ins = 0b01101
        ins = make_instruction(ins)
        (mnemonic, _, X, Y, _) = di(ins)
        dbglog(f"    {mnemonic} {X}, {Y}")
        self.assertEqual(mnemonic, "neg")
        self.assertEqual(X, "A")
        self.assertEqual(Y, "")


if __name__ == "__main__":
    unittest.main()