#define _DEFAULT_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <stdarg.h>

#include <endian.h>

#include "bits.c"
#include "fnt.c"
#include "log.c"


#define C8_RESET_VECTOR     0x200
#define C8_CYCLES_PER_FRAME 1000


typedef struct
{
    u16 pc;
    u8  sp;

    u16 i;
    u16 keys;

    u64 cycles;

            /* timers: */
    u8  dt; /* - delay */
    u8  st; /* - sound */

    bool running;

    union
    {
        struct
        {
            u8  v[16];
            u64 disp[32];
            u8  font[sizeof(fnt)];
            u16 stack[16];

        } sys;
        u8 ram[4*KB];
    } mem;

} chip8;

#define V       mem.sys.v
#define STACK   mem.sys.stack
#define DISPLAY mem.sys.disp
#define FONT    mem.sys.font
#define RAM     mem.ram

#include "instr.c"

void c8_reset(chip8* c8)
{
    assert(c8);
    assert(sizeof(c8->mem) > sizeof(fnt));
    assert(sizeof(c8->mem) >= 4*KB);

    memcpy(c8->FONT, fnt, sizeof(fnt));

    c8->pc = C8_RESET_VECTOR;
    c8->running = true;
}

void c8_dump_state(chip8* c8, bool stack)
{
    int i = 0;

    for(i = 0; i < (int)sizeof(c8->V); i += 4)
    {
        printf("      V%x: %02X (%-3d) ",  i+0, c8->V[i+0], c8->V[i+0]);
        printf("V%x: %02X (%-3d) ",  i+1, c8->V[i+1], c8->V[i+1]);
        printf("V%x: %02X (%-3d) ",  i+2, c8->V[i+2], c8->V[i+2]);
        printf("V%x: %02X (%-3d)\n", i+3, c8->V[i+3], c8->V[i+3]);
    }

    printf("      I:%04X SP: %02X DT: %02X ST: %02X\n", c8->i, c8->sp, c8->dt, c8->st);

    if(stack)
    {
        printf("stack:\n");
        for(i = 0; i < (int)sizeof(c8->STACK); i += 2)
        {
            printf("      %-2d: %04X ",  i+0, c8->STACK[i+0]);
            printf("%-2d: %04X\n", i+1, c8->STACK[i+1]);
        }
    }
}

int main(int argc, char** argv)
{
    u64   sz = 0;
    FILE*  f = NULL;
    chip8 c8 = {0};

    srand(time(NULL));

    c8_reset(&c8);

    if(argc > 1)
    {
        u64 got = 0;

        f = fopen(argv[1], "r");
        if(!f) return 1;

        fseek(f, 0, SEEK_END);
        sz = (u64)ftell(f);
        rewind(f);

        if(sz >= (sizeof(c8.RAM) - 512)) return 2;

        got = fread(c8.RAM + C8_RESET_VECTOR, 1, sz, f);
        if(got != sz) return 3;

        fclose(f);
    }
    else
    {
        c8.RAM[C8_RESET_VECTOR + iota] = 0x60;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x04;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x61;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x03;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x72;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x01;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x80;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x14;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x30;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x10;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x12;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x04;

        sz = iota;
    }

    printf("Disasm:\n");
    {
        u64 i;
        char buf[512] = {0};

        for(i = 0; i < sz; i += 2)
        {
            u16 pc = C8_RESET_VECTOR + i;
            c8_disasm(c8.RAM, pc, buf);
            printf("%04X:   %s\n", pc, buf);
        }
    }

    printf("\nExec:\n");
    while(c8.running)
    {
        char buf[512] = {0};

        if(c8.pc >= sizeof(c8.mem))
        {
            report(ERR, "PC Overflow!\n");
            c8.running = false;
        }

        if(c8.pc & 0x0001)
        {
            report(ERR, "PC is not aligned!\n");
            c8.running = false;
        }

        c8_disasm(c8.RAM, c8.pc, buf);
        printf("%04X:   %s\n", c8.pc, buf);

        c8_exec(c8.RAM, c8.pc, &c8);
        c8_dump_state(&c8, false);

        c8.cycles++;
        if((c8.cycles % C8_CYCLES_PER_FRAME) == 0)
        {
            if(c8.dt) c8.dt--;
            if(c8.st) c8.st--;
        }

        c8.pc += 2;
    }

    return 0;
}