package main

import (
	"flag"
	"fmt"
	"io/ioutil"
)

type chip8 struct {
	opcode uint16
	memory [4096]byte

	// register
	v [16]byte

	index uint16
	pc    uint16

	gfx [64 * 32]byte

	delayTimer byte
	soundTimer byte

	stack [16]uint16
	sp    int

	key [16]byte

	drawFlag bool
}

// Initialize registers and memory once
func (c *chip8) initialize() {
	c.pc = 0x200
	c.opcode = 0
	c.index = 0
	c.sp = 0
}

func (c *chip8) emulateCycle() {
	// Fetch Opcode
	c.opcode = uint16(c.memory[c.pc])<<8 | uint16(c.memory[c.pc+1])

	// Decode Opcode
	// https://en.wikipedia.org/wiki/CHIP-8#Opcode_table
	// http://www.multigesture.net/wp-content/uploads/mirror/goldroad/chip8_instruction_set.shtml
	switch c.opcode & 0xF000 {
	case 0x0000:
		switch c.opcode & 0x000F {
		case 0x0000: // 0x00E0
			// clear screen
			// TODO
			c.pc += 2
			break
		case 0x000E: // 0x00EE
			// TODO
			break
		default:
			fmt.Printf("Unknown opcode [0x0000]: 0x%X\n", c.opcode)
		}
	case 0x2000:
		c.stack[c.sp] = c.pc
		c.sp++
		c.pc = c.opcode & 0x0FFF
		break
	case 0x6000:
		pos := (c.opcode & 0x0F00) >> 8
		c.v[pos] = byte(c.opcode)
		c.pc += 2
		break
	case 0x7000:
		c.v[c.opcode&0x0F00>>8] += byte(c.opcode)
		c.pc += 2
		break
	case 0x8000:
		switch c.opcode & 0x000F {
		case 0x0004: // 0x8XY4
			if c.v[(c.opcode&0x00F0)>>4] > (0xFF - c.v[c.opcode&0x0F00]) {
				c.v[0xF] = 1
			} else {
				c.v[0xF] = 0
			}
			c.v[(c.opcode&0x0F00)>>8] += c.v[(c.opcode&0x00F0)>>4]
			c.pc += 2
			break
		default:
			fmt.Printf("Unknown opcode [0x8000]: 0x%X\n", c.opcode)
		}
	case 0xA000:
		// set index to NNN position
		c.index = c.opcode & 0x0FFF
		c.pc += 2
		break
	case 0xD000:
		x := uint16(c.v[(c.opcode&0x0F00)>>8])
		y := uint16(c.v[(c.opcode&0x00F0)>>4])
		height := c.opcode & 0x000F

		var pixel byte
		c.v[0xF] = 0
		for yline := uint16(0); yline < height; yline++ {
			pixel = c.memory[c.index+yline]
			for xline := uint16(0); xline < 8; xline++ {
				if (pixel & (0x80 >> xline)) != 0 {
					if c.gfx[(x+xline+((y+yline)*64))] == 1 {
						c.v[0xF] = 1
					}
					c.gfx[x+xline+((y+yline)*64)] ^= 1
				}
			}

		}
		c.drawFlag = true
		c.pc += 2
		break
	case 0xE000:
		switch c.opcode & 0x00FF {
		case 0x009E:
			if c.key[c.v[(c.opcode&0x0F00)>>8]] != 0 {
				c.pc += 4
			} else {
				c.pc += 2
			}
			break
		}
		break
	case 0xF000:
		x := (c.opcode & 0x0F00) >> 8
		fmt.Printf("F: 0x%X\n", c.opcode)
		switch c.opcode & 0x00FF {
		case 0x0029:
			// TODO
			// c.index = uint16(c.v[x]) *
			c.pc += 2
			break
		case 0x0033:
			c.memory[c.index] = c.v[x] / 100
			c.memory[c.index+1] = (c.v[x] / 10) % 10
			c.memory[c.index+2] = (c.v[x] / 100) % 10
			c.pc += 2
			break
		case 0x0065:
			for i := uint16(0); i < x+1; i++ {
				c.v[i] = c.memory[c.index+i]
			}
			c.pc += 2
			break
		}
		break
	default:
		fmt.Printf("Unknown opcode: 0x%X\n", c.opcode)
	}

	// Update timers
	if c.delayTimer > 0 {
		c.delayTimer--
	}
	if c.soundTimer > 0 {
		if c.soundTimer == 1 {
			fmt.Printf("Beep!\n")
		}
		c.soundTimer--
	}
}

func (c *chip8) loadGame(filepath string) error {
	buffer, err := ioutil.ReadFile(filepath)
	if err != nil {
		return err
	}

	for i := 0; i < len(buffer); i++ {
		// 0x200 == 512
		c.memory[512+i] = buffer[i]
	}
	return nil
}

var fontSet = [80]byte{
	0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
	0x20, 0x60, 0x20, 0x20, 0x70, // 1
	0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2
	0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3
	0x90, 0x90, 0xF0, 0x10, 0x10, // 4
	0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5
	0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6
	0xF0, 0x10, 0x20, 0x40, 0x40, // 7
	0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8
	0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9
	0xF0, 0x90, 0xF0, 0x90, 0x90, // A
	0xE0, 0x90, 0xE0, 0x90, 0xE0, // B
	0xF0, 0x80, 0x80, 0x80, 0xF0, // C
	0xE0, 0x90, 0x90, 0x90, 0xE0, // D
	0xF0, 0x80, 0xF0, 0x80, 0xF0, // E
	0xF0, 0x80, 0xF0, 0x80, 0x80, // F
}

func (c *chip8) drawGraphics() {

}

func (c *chip8) setKeys() {

}

func main() {
	filepath := flag.String("file", "file-path", "file path of the input file")

	flag.Parse()

	// setupGraphics()
	// setupInput()

	var c chip8
	c.initialize()
	err := c.loadGame(*filepath)
	if err != nil {
		panic(err)
	}

	for {
		c.emulateCycle()
		if c.drawFlag {
			c.drawGraphics()
			c.setKeys()
		}
	}
}