#include "builder.hpp"
#include "io_device.hpp"
#include "vm.hpp"
#include <SDL2/SDL_main.h>
#include <array>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <print>
#include <string>
#include <thread>
#include <utility>

using namespace std::chrono_literals;

using namespace vc5;
using R = Reg;

int main()
{
    auto device = IoDevice::create().value();

    constexpr R r0 = R::R0;
    constexpr R r1 = R::R1;
    constexpr R r2 = R::R2;
    constexpr R r3 = R::R3;
    constexpr R r4 = R::R4;
    constexpr R r5 = R::R5;
    constexpr R rbp = R::Rbp;
    constexpr R rsp = R::Rsp;
    constexpr R rfl = R::Rfl;
    constexpr R rip = R::Rip;

    auto program = std::array<uint8_t, 65536>();

    auto l = Builder(program.data());

    l.mov_imm(rsp, 0x1000);
    l.mov_reg(rbp, rsp);

    l.mov_imm(r0, 0x2000);
    l.store_word_imm(0x700, r0);
    l.lvcd_imm(0x700);

    l.mov_imm(r0, 0x1ffc);
    l.store_word_imm(0x702, r0);
    l.mov_imm(r0, 0x1ffe);
    l.store_word_imm(0x704, r0);
    auto to_set_key_press_int = l.ip();
    l.mov_imm(r0, 0);
    l.store_word_imm(0x706, r0);
    l.lkbd_imm(0x702);

    l.mov_imm(r0, 0);
    l.store_word_imm(0x600, r0);

    auto main_loop = l.ip();
    l.hlt();
    l.jmp_imm(main_loop);

    auto key_press_int = l.ip();
    l.load_word_imm(r0, 0x1ffc);
    l.and_imm(r0, r0, 1);
    auto to_set_key_press_int_leave = l.ip();
    l.jnz_imm(r0, 0);

    l.load_word_imm(r0, 0x600);
    l.add_imm(r0, r0, 0x2000);
    // l.load_word_imm(r1, 0x1ffe);
    // l.add_imm(r1, r1, 61);
    l.mov_imm(r1, 'A');
    l.nop();
    l.nop();
    l.store_byte_reg(r0, 0, r1);
    l.nop();
    l.nop();

    l.load_word_imm(r0, 0x600);
    l.add_imm(r0, r0, 1);
    l.store_word_imm(0x600, r0);

    auto key_press_int_leave = l.ip();
    l.reti();

    l.set_ip(to_set_key_press_int + 2);
    l.push(key_press_int);
    l.set_ip(to_set_key_press_int_leave + 2);
    l.push(key_press_int_leave);

    auto vm = VM(*device);
    vm.load(0, program.data(), program.size());

    device->set_title("vc5");

    vm.run();

    std::println("--- regs ---");
    std::println("r0\t{}", vm.reg(r0));
    std::println("r1\t{}", vm.reg(r1));
    std::println("r2\t{}", vm.reg(r2));
    std::println("r3\t{}", vm.reg(r3));
    std::println("r4\t{}", vm.reg(r4));
    std::println("r5\t{}", vm.reg(r5));
    std::println("rbp\t{}", vm.reg(rbp));
    std::println("rsp\t{}", vm.reg(rsp));
    std::println("rfl\t{}", vm.reg(rfl));
    std::println("rip\t{}", vm.reg(rip));
    std::println("--- mem ---");
    for (uint16_t i = 0; i < 32; i += 2) {
        std::println("{: 4x}\t{}", i, vm.word(i));
    }
}

extern "C" const char* __asan_default_options(void)
{
    return "detect_leaks=0";
}