numericKeys = [ "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F" ]

def toHex(n):
    return "%0.2X" % n

class Monitor:
    def __init__(self, cpu):
        self.cpu = cpu
        self.monitorMode = 'addressEntry' # or dataEntry
        self.monitorAddressInput = TwoDigitHexInput()
        self.monitorDataInput = TwoDigitHexInput()

        # In data entry mode, when a full byte is keyed in,
        # the next keypress advances to the next address and continues entering data there.
        # This variable tracks whether it's time to do that or not.
        self.advanceDataEntryNextPress = False
        
    def handleKeys(self):
        keypad_event = keymatrix.events.get()
        keyPressed = True if (keypad_event and keypad_event.released ) else False
        key = keymap[keypad_event.key_number] if keyPressed else False
        numericKeyPressed = True if (keyPressed and (key in numericKeys)) else False


        if self.cpu.running:
          if key == "runhalt":
              print("HALT PRESSED")
              self.cpu.running = False
              time.sleep(0.5) # lazy debounce
              # km.events.clear() # don't track keypresses from during the run

          if numericKeyPressed:
            self.cpu.memory[26] = int(key, 16)

        elif not self.cpu.running:
            if key == "runhalt":
                self.cpu.running = True
                print("\nSTARTING")
                time.sleep(0.5) # lazy debounce

            if key == "addr":
                self.monitorMode = 'addressEntry'
                print("\nENTERING", self.monitorMode, "MODE")
                self.monitorAddressInput.currentDigit = 0
                time.sleep(0.5) # lazy debounce
            if key == "data":
                self.monitorMode = 'dataEntry'
                print("\nENTERING", self.monitorMode, "MODE")
                self.monitorDataInput.clear()
                self.advanceDataEntryNextPress = False
                time.sleep(0.5) # lazy debounce

            if key == "step":
                print("\nSINGLE STEP FROM MONITOR ADDR")
                # self.IP = self.monitorAddressInput.value
                self.cpu.step()
                time.sleep(0.5) # lazy debounce

            if numericKeyPressed:
                if self.monitorMode == 'addressEntry':
                    self.monitorAddressInput.input(int(key, 16))
                    self.cpu.IP = self.monitorAddressInput.value
                    print("MA", self.cpu.IP)

                if self.monitorMode == 'dataEntry':
                    if self.advanceDataEntryNextPress:
                        print("ADVANCING")
                        self.cpu.IP = (self.cpu.IP + 1) % 256
                        # self.monitorDataInput.clear() # reset .currentDigit
                        self.monitorDataInput.set(self.cpu.memory[self.cpu.IP])
                        self.advanceDataEntryNextPress = False
                    self.monitorDataInput.input(int(key, 16))
                    self.cpu.memory[self.cpu.IP] = self.monitorDataInput.value
                    print("MD", self.monitorDataInput.value)
                    if self.monitorDataInput.currentDigit == 0: # that was the second keypress, so next keypress is for the next address
                        self.advanceDataEntryNextPress = True
                        
                print("Acc", self.cpu.acc, "IP", self.cpu.IP, "Data", self.cpu.memory[self.cpu.IP], "\n")
            
            
    def displayScreen(self):
        for x in range(8):
            for y in range(8):
                matrix[x, y] = self.cpu.memory[x + (8*y)]



    def run(self):
        #self.cpu.start()
        t = time.time()
        while (time.time() - t) < 120: # TODO: add a time delta or sth maybe so this doesn't just burn cycles
            self.handleKeys()
            display_1.print(toHex(self.cpu.IP) + toHex(self.cpu.memory[self.cpu.IP]))
            # display_1.print(toHex(self.monitorAddressInput.value) + toHex(self.cpu.memory[self.cpu.IP]))
            # display_2.print(toHex(self.cpu.IP) + toHex(self.cpu.acc))
            display_2.print(toHex(self.cpu.acc))
            self.displayScreen()
            if self.cpu.running:
                self.cpu.step()
            # time.sleep(0.5) # TODO ?
        print("timeout")
        print(self.cpu.memory)


cpu = CPU()
monitor = Monitor(cpu)

# preamble = '00 ' * 64
# prog = preamble + '02 01   13 f0   12 f0   04 02   03 f0   12 f0   05 41   08 00   06 40   00 00' # STRIPES
# offset = 64
# prog = preamble + '02 01  13 f0  12 f0  04 02  03 f0  05 08  09 00  04 09  03 f0  07 41  06' + toHex(offset) + '00 00'
#prog = '00'
# program_bytes = bytearray.fromhex(prog.replace(" ", ""))

# Add jmp at addr 254:
#program_with_jump = program_bytes + bytearray(254 - len(program_bytes)) + bytearray.fromhex('0600') # jump to addr 00
# program_with_jump = program_bytes + bytearray(254 - len(program_bytes)) + bytearray.fromhex('0640') # jump to addr 0x40 (dec 64)

with open('test-multiply2.bin', 'rb') as file:
    program_bytes = bytearray(file.read())

cpu.load_memory(program_bytes)

monitor.run()