#made by zombie
#02/01/21

#0-255 is internal registers and flags and etc
# program execcution starts at 256
#stack starts at 65535 FILO

#0  IP      #Instruction Pointer
#1	EAX
#2	EBX
#3	ECX
#4	EDX
#5	ESI
#6	EDI
#7	ESP     #stack pointer
#8	EBP
#9  FLAG    #Read-Only contains the flags


#list of opcodes
#0 interrupt
#1 reset
#2 debug info (nop)
#3 mov
#4 push (onto stack)
#5 pop  (off of stack into address)


import math
import numpy as np
import opcodes as ops
np.set_printoptions(threshold=np.inf)



class Zomcpu:
    def __init__(self, memorysize=None, debug=None):
        print('Processor Init')
        self._memorysize = memorysize
        self._memory = np.zeros(memorysize)
        self._debug = debug
        
    def reset(self):
        print('Processor Resetting')
        self._memory = np.zeros(self._memorysize) #clear memory
        
        self._memory[7] = self._memorysize - 1 #set stackpointer
        self._memory[0] = 256 #set instructiojn pointer
        
    def exec(self):
        Halted = False
        while not Halted: #change this to if not halt
            #fetch
            opcode = self._memory[int(self._memory[0])]
            address = self._memory[int(self._memory[0] + 1)]
            value = self._memory[int(self._memory[0] + 2)]
            
            if self._debug:
                print(f'Opcode: {opcode}\nAddress: {address}\nValue: {value}\nIP: {self._memory[0]}')
            
            if opcode == ops.NOP:
                pass
            
            elif opcode == ops.HLT:
                Halted = True
                print('Processor Halted')

            elif opcode == ops.RST: #reset
                self.reset()
            
            elif opcode == ops.DBG: #debug enable
                self._debug = value
                
            elif opcode == ops.LDI: #mov but actually load immediate
                self.write_memory(address, value)
                
            elif opcode == ops.PUSH: #push
                self.write_memory(self._memory[7], value) #put value onto stack
                self.write_memory(7, self._memory[7] - 1) #dec stackpointer
                
            elif opcode == ops.POP: #pop
                self.write_memory(address, self.read_memory_address(self._memory[7] + 1)) #read the last value and put it into address (not the empty space)
                self.write_memory(7, self._memory[7] + 1) #inc stackpointer
                
            self._memory[0] += 3 #increment instruction pointer
            
    
    def set_memory(self, memory):
        self._memory = memory
    def write_memory(self, address, value):
        self._memory[int(address)] = value
    def read_memory(self):
        return self._memory
    def read_memory_address(self, address):
        return self._memory[int(address)]
        
if __name__ == "__main__":
    cpu = Zomcpu(65536, True)
    cpu.reset()
    
    #hard coded opcodes
    cpu.write_memory(256, ops.LDI)    #mov
    cpu.write_memory(257, 27)   #address 27
    cpu.write_memory(258, 105)  #105 into ^
    cpu.write_memory(259, ops.PUSH)    #push
    cpu.write_memory(260, 0)    #unused in this op  
    cpu.write_memory(261, 27)   #the value at address 27 onto the stack
    cpu.write_memory(262, ops.POP)    #pop
    cpu.write_memory(263, 100)  #into 100
    cpu.write_memory(264, 0)    #unused in this op
    cpu.write_memory(265, 1)    #halt
                     
    
    

    cpu.exec()
    print(cpu.read_memory_address(100))
    print(cpu.read_memory_address(264))
    print(cpu.read_memory_address(7))

    #c = Console(cpu.read_memory()) ima finish this later
    #c.draw()