#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct instruction {
    size_t offset;
    unsigned int opcode;
    unsigned int mode;
    unsigned int rdest;
    unsigned int rsrc;
    uint16_t imm;
} instruction;

static instruction instructions[16384];
size_t num_instructions = 0;

static const char *op_names[] = {
    "MOVE", "OR", "XOR", "AND", "NOT", "ADD", "SUB", "MUL", "SHL", "SHR",
    "INC", "DEC", "PUSH", "POP", "CMP", "JNZ", "JZ",
};

static void create_instructions(const uint8_t *code, size_t length)
{
    for (size_t i = 0; i < length; i += 2) {
        unsigned int opt = code[i + 1];

        instruction insn = {
            .offset = i,
            .opcode = code[i],
            .mode = opt & 15,
            .rdest = (opt >> 4) & 3,
            .rsrc = (opt >> 6) & 3,
            .imm = 0xbaadU,
        };

        if (insn.opcode >= sizeof(op_names) / sizeof(op_names[0])) {
            fprintf(stderr, "Wrong opcode %u at %.8zx\n", insn.opcode, insn.offset);
            exit(1);
        }

        if (insn.mode >= 4) {
            fprintf(stderr, "Wrong mode %u at %.8zx\n", insn.mode, insn.offset);
            exit(1);
        }

        if (insn.mode == 0 || insn.mode == 2) {
            i += 2;
            insn.imm = code[i] | code[i + 1] << 8;
        }
        instructions[num_instructions++] = insn;
    }
}

static void read_code(const char *filename)
{
    static uint8_t code[65536];

    FILE *fp = fopen(filename, "rb");
    if (!fp) {
        perror(filename);
        exit(1);
    }

    size_t length = fread(code, 1, sizeof(code), fp);
    fclose(fp);

    create_instructions(code, length);
}

static void write_response(const char *filename, const uint16_t *regs)
{
    FILE *fp = fopen(filename, "wb");
    if (!fp) {
        perror(filename);
        exit(1);
    }
    fprintf(fp, "%.4x %.4x %.4x %.4x\n", regs[0], regs[1], regs[2], regs[3]);
    fclose(fp);
}

int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "usage: %s <input file> <output file>", argv[0]);
        return -1;
    }

    read_code(argv[1]);

    size_t ip = 0;
    uint16_t regs[4] = { 0 };
    uint16_t stack[256];
    size_t stackptr = 0;
    bool zf = false;

    while (ip < num_instructions) {
        instruction *insn = &instructions[ip];
        uint16_t *dest = NULL;
        uint16_t *src = NULL;
        uint16_t imm = insn->imm;

        printf("%.4zx: %s\t", ip, op_names[insn->opcode]);

        switch (insn->mode) {
            case 0: // IMM.
                dest = &imm;
                printf("%.4x    ", insn->imm);
                break;
            case 1: // REG.
                dest = &regs[insn->rdest];
                printf("r%u      ", insn->rdest);
                break;
            case 2: // REG, IMM.
                dest = &regs[insn->rdest];
                src = &imm;
                printf("r%u, %.4x", insn->rdest, insn->imm);
                break;
            case 3: // REG, REG.
                dest = &regs[insn->rdest];
                src = &regs[insn->rsrc];
                printf("r%u, r%u  ", insn->rdest, insn->rsrc);
                break;
        }

        printf(" ; ");
        ++ip;

        switch (insn->opcode) {
            case 0: // MOVE.
                *dest = *src;
                break;
            case 1: // OR.
                *dest = *dest | *src;
                break;
            case 2: // XOR.
                *dest = *dest ^ *src;
                break;
            case 3: // AND.
                *dest = *dest & *src;
                break;
            case 4: // NOT.
                *dest = ~*dest;
                break;
            case 5: // ADD.
                *dest += *src;
                break;
            case 6: // SUB.
                *dest -= *src;
                break;
            case 7: // MUL.
                *dest = *dest * *src;
                break;
            case 8: // SHL.
                *dest <<= *src;
                break;
            case 9: // SHR.
                *dest >>= *src;
                break;
            case 10: // INC.
                *dest += 1;
                break;
            case 11: // DEC.
                *dest -= 1;
                break;
            case 12: // PUSH.
                if (stackptr >= sizeof(stack) / sizeof(stack[0])) {
                    fprintf(stderr, "Stack overflow\n");
                    return 2;
                }
                stack[stackptr++] = *dest;
                break;
            case 13: // POP
                if (stackptr == 0) {
                    fprintf(stderr, "Stack underflow\n");
                    return 2;
                }
                *dest = stack[--stackptr];
                break;
            case 14: // CMP.
                zf = (*dest - *src) == 0;
                break;
            case 15: // JNZ.
                if (!zf) {
                    ip = *dest;
                }
                break;
            case 16: // JZ.
                if (zf) {
                    ip = *dest;
                }
                break;
        }

        // Set ZF for arithmetical and logical instructions (except CMP).
        if (insn->opcode >= 1 && insn->opcode <= 11) {
            zf = *dest == 0;
        }

        printf(" r0 = %.4x, r1 = %.4x, r2 = %.4x, r3 = %.4x, zf = %u\n",
            regs[0], regs[1], regs[2], regs[3], zf);
    }

    write_response(argv[2], regs);
    return 0;
}
