module src/cpu

import bytearray
import queue
import src/ram
import src/renderer

import io/time
/*
The CPU for the Chip8 emulator.
CPU Cycle and Effects:
1. Fetch Opcode
2. Decode Opcode
3. Execute Opcode
4. Update Timers
5. Update Display
6. Wait for next cycle
*/

extern io def getNow(): Int = 
  js "Date.now()"
  chez "(current-milliseconds)"
  llvm """
    %time = call i64 @time(ptr null)
    %ms = mul i64 %time, 1000
    ret i64 %ms
  """
  vm "effekt::getNow()"

interface CPU {
  def initCPU(rom: ByteArray): Unit
  def cycleCPU(): Unit

}
def convertKey(key: String): Int = key match {
    case "1" => 1
    case "2" => 2
    case "3" => 3
    case "4" => 12
    case "q" => 4
    case "w" => 5
    case "e" => 6
    case "r" => 13
    case "a" => 7
    case "s" => 8
    case "d" => 9
    case "f" => 14
    case "z" => 10
    case "x" => 0
    case "c" => 11
    case "v" => 15
    case _ => -1
} 

def makeCPU() {r: Renderer} = {
  // Initialize the RAM
  var ram in global = makeRam()
  
  // Initialize the CPU registers
  var v: ByteArray in global = allocate(16) // 16 8-bit registers
  var i: Int in global = 0 // 16-bit register treat as 12-bit !!!

  var delay: Byte in global = 0.toByte() // Delay timer
  var sound: Byte in global = 0.toByte() // Sound timer
  var pc: Int in global = 512 // Program counter
  var sp: Byte in global = 0.toByte() // Stack pointer
  // After checking the implementation of queue in Effekt, I realized that it also works as a stack, so I will use it as a stack
  var stack in global = emptyQueue[Int](32) // Stack with 16 levels. Each level is 16-bit that is 2 bytes, so 32 bytes

  var last_key_update_time in global = getNow()
  var last_instruction_run_time in global = getNow()
  var last_display_update_time in global = getNow()
  var last_timer_update in global = getNow()

  new CPU {
    def initCPU(rom: ByteArray) = {
      ram.init(rom)
      r.clear()
    }
    def cycleCPU() = {
      val currentTime = getNow()
      var key: Int = -1 // Key pressed
      if (currentTime - last_key_update_time >= 1) { 
        val key_ = r.getKeyPressed().getOrElse { "P" }
        if (key_ != "P") {
          key = convertKey(key_)
        }
        last_key_update_time = currentTime
      }

      if (currentTime - last_instruction_run_time >= 2) { // ~500Hz
        val h = ram.getAddr(pc)
        val l = ram.getAddr(pc + 1)
        val inst = bitwiseOr(bitwiseShl(h.toInt(), 8), l.toInt())

        // Decode
        val opcode = bitwiseShr(bitwiseAnd(inst, 61440), 12)
        val nnn = bitwiseAnd(inst, 4095)
        val nn = bitwiseAnd(inst, 255)
        val n = bitwiseAnd(inst, 15)
        val x = bitwiseAnd(bitwiseShr(inst, 8), 15)
        val y = bitwiseAnd(bitwiseShr(inst, 4), 15)

        // Execute
        opcode match {
          case 0 => {
            nn match {
              // Clear the screen
              case 224 => {
                r.clear()
                pc = pc + 2
              }
              // Return from a subroutine
              case 238 => {
                // pc = stack[Int].popFront[Int]().value[Int]()
                pc = stack.popFront().getOrElse { 0 }
              }
            } else {
              // 0nnn - SYS addr - Jump to a machine code routine at nnn
              pc = nnn
            }
          }
          // Jump to address NNN
          case 1 => {
            pc = nnn
          }
          // Call subroutine at NNN
          case 2 => {
            stack.pushFront(pc + 2)
            pc = nnn
          }
          // Skip next instruction if VX == NN
          case 3 => {
            if (v.unsafeGet(x).toInt() == nn) {
              pc = pc + 2
            }
            pc = pc + 2
          }
          // Skip next instruction if VX != NN
          case 4 => {
            if (v.unsafeGet(x).toInt() != nn) {
              pc = pc + 2
            }
            pc = pc + 2
          }
          // Skip next instruction if VX == VY
          case 5 => {
            if (v.unsafeGet(x).toInt() == v.unsafeGet(y).toInt()) {
              pc = pc + 2
            }
            pc = pc + 2
          }
          // Set VX = NN
          case 6 => {
            v.unsafeSet(x, nn.toByte())
            pc = pc + 2
          }
          // Set VX = VX + NN
          case 7 => {
            v.unsafeSet(x, (v.unsafeGet(x).toInt() + nn).toByte())
            pc = pc + 2
          }
          case 8 => {
            n match {
              // Set VX = VY
              case 0 => {
                v.unsafeSet(x, v.unsafeGet(y))
              }
              // Set VX = VX OR VY
              case 1 => {
                v.unsafeSet(x, bitwiseOr(v.unsafeGet(x).toInt(), v.unsafeGet(y).toInt()).toByte())
              }
              // Set VX = VX AND VY
              case 2 => {
                v.unsafeSet(x, bitwiseAnd(v.unsafeGet(x).toInt(), v.unsafeGet(y).toInt()).toByte())
              }
              // Set VX = VX XOR VY
              case 3 => {
                v.unsafeSet(x, bitwiseXor(v.unsafeGet(x).toInt(), v.unsafeGet(y).toInt()).toByte())
              }
              // Set VX = VX + VY, set VF = carry
              case 4 => {
                val sum = v.unsafeGet(x).toInt() + v.unsafeGet(y).toInt()
                v.unsafeSet(x, sum.toByte())
                v.unsafeSet(15, (if (sum > 255) 1 else 0).toByte())
                
              }
              // Set VX = VX - VY, set VF = NOT borrow
              case 5 => {
                val vx = v.unsafeGet(x).toInt()
                val vy = v.unsafeGet(y).toInt()
                val sub = vx - vy

                v.unsafeSet(x, sub.toByte())
                v.unsafeSet(15, (if (vx > vy) 1 else 0).toByte())
              }
              // Set VX = VX SHR 1 and VF = LSB of VX
              case 6 => {
                val vx = v.unsafeGet(x).toInt()
                val lsb = bitwiseAnd(vx, 1)
                val vx_ = bitwiseShr(vx, 1)
                v.unsafeSet(x, vx_.toByte())
                v.unsafeSet(15, lsb.toByte())
              }
              // Set VX = VY - VX, set VF = NOT borrow
              case 7 => {
                val vx = v.unsafeGet(x).toInt()
                val vy = v.unsafeGet(y).toInt()
                val sub = vy - vx
                
                v.unsafeSet(x, sub.toByte())
                v.unsafeSet(15, (if (vy > vx) 1 else 0).toByte())
              }
              // Set VX = VX SHL 1 and VF = MSB of VX
              case 14 => {
                val vx = v.unsafeGet(x).toInt()
                val msb = bitwiseAnd(vx, 128)
                val vx_ = vx * 2
                val vf = bitwiseShr(msb, 7)
                v.unsafeSet(x, vx_.toByte())
                v.unsafeSet(15, vf.toByte())
              }
            } else {
              r.log("Unknown Instruction: " ++ show(inst))
            }
            pc = pc + 2
          }
          // Skip next instruction if VX != VY
          case 9 => {
            if (v.unsafeGet(x).toInt() != v.unsafeGet(y).toInt()) {
              pc = pc + 2
            }
            pc = pc + 2
          }
          // Set I = NNN
          case 10 => {
            i = nnn
            pc = pc + 2
          }
          // Jump to location NNN + V0
          case 11 => {
            pc = nnn + v.unsafeGet(0).toInt()
          }

          // Set VX = random byte AND NN
          case 12 => {
            val randInt: Int = floor(random() * 255.0)
            v.unsafeSet(x, bitwiseAnd(randInt, nn).toByte())
            pc = pc + 2
          }
          // Display n-byte sprite starting at memory location I at (VX, VY), set VF = collision
          case 13 => {
            val vx = v.unsafeGet(x).toInt()
            val vy = v.unsafeGet(y).toInt()
            var collision = false
            var yline = 0
            
            while (yline < n) {
              val pixel = ram.getAddr(i + yline)
              var xline = 0
              
              while (xline < 8) {
                // Get if the current sprite pixel is set (1)
                val spritePixel = bitwiseAnd(bitwiseShr(pixel.toInt(), 7 - xline), 1) == 1
                
                if (spritePixel) {
                  val x = mod(vx + xline, 64)
                  val y = mod(vy + yline, 32)
                  
                  // Get current screen pixel
                  val screenPixel = r.get(x, y)
                  
                  // XOR operation
                  if (screenPixel == spritePixel) {
                    // If both pixels are on, turn it off and set collision
                    r.draw(x, y, "black")
                    collision = true
                  } else if (screenPixel != spritePixel) {
                    // If screen pixel is off and sprite pixel is on, turn it on
                    r.draw(x, y, "white") 
                  }
                }
                xline = xline + 1
              }
              yline = yline + 1
            }
            
            v.unsafeSet(15, (if (collision) 1 else 0).toByte())
            pc = pc + 2
          }
          case 14 => {
            nn match {
              // Skip next instruction if key with the value of VX is not pressed
              case 161 => {
                val vx = v.unsafeGet(x).toInt()
                if (key != v.unsafeGet(x).toInt()) {
                  pc = pc + 4
                } else {
                  pc = pc + 2
                }
              }
              // Skip next instruction if key with the value of VX is pressed
              case 158 => {
                val vx = v.unsafeGet(x).toInt()
                if (key != -1 && key == v.unsafeGet(x).toInt()) {
                  pc = pc + 4
                } else {
                  pc = pc + 2
                }
              }
            } else {
              r.log("Unknown Instruction: " ++ show(inst))
            }
          }
          case 15 => {
            nn match {
              // Set VX = delay timer value
              case 7 => {
                v.unsafeSet(x, delay)
                pc = pc + 2
              }
              // Wait for a key press, store the value of the key in VX
              case 10 => {
                if (key >= 0) {
                  v.unsafeSet(x, key.toByte())
                  pc = pc + 2
                }
              }
              // SET delay timer = VX
              case 21 => {
                delay = v.unsafeGet(x)
                pc = pc + 2
              }
              // Set sound timer = VX
              case 24 => {
                sound = v.unsafeGet(x)
                pc = pc + 2
              }
              // SET I = I + VX
              case 30 => {
                i = i + v.unsafeGet(x).toInt()
                pc = pc + 2
              }
              // Set I = location of sprite for digit VX
              case 41 => {
                i = v.unsafeGet(x).toInt() * 5
                pc = pc + 2
              }
              // Store BCD representation of VX in memory locations I, I+1, and I+2
              case 51 => {
                val vx = v.unsafeGet(x).toInt()
                ram.setAddr(i, (vx / 100).toByte())
                ram.setAddr(i + 1, mod((vx / 10), 10).toByte())
                ram.setAddr(i + 2, mod(vx, 10).toByte())
                pc = pc + 2
              }
              // Store registers V0 through VX in memory starting at location I
              case 85 => {
                var index = 0
                while (index <= x) {
                  ram.setAddr(i + index, v.unsafeGet(index))
                  index = index + 1
                }
                // i = i + x + 1
                pc = pc + 2
              }
              // Read registers V0 through VX from memory starting at location I
              case 101 => {
                var index = 0
                while (index <= x) {
                  v.unsafeSet(index, ram.getAddr(i + index))
                  index = index + 1
                }
                // i = i + x + 1
                pc = pc + 2
              }
            } else {
              r.log("Unknown Instruction: " ++ show(inst))
            }
          }
        } else {
          r.log("Unknown Instruction: " ++ show(inst))
        }
        last_instruction_run_time = getNow()

        // Update timers if needed
        if (currentTime - last_timer_update >= 16) { // 60Hz timer updates
          // Update timers
          if (delay.toInt() > 0) {
            delay = (delay.toInt() - 1).toByte()
          }
          if (sound.toInt() > 0) {
            sound = (sound.toInt() - 1).toByte()
            r.beep()
          } else {
            r.stopBeep()
          }
          
          last_timer_update = currentTime
        }
      }
    }
  }
}