#include "z80.h"

namespace z80
{
    static uint8_t *memory = nullptr;
    static uint32_t t_states = 0;

    #define fC 0b00000001
    #define fN 0b00000010
    #define fP 0b00000100
    #define fV 0b00000100
    #define fX 0b00001000
    #define fH 0b00010000
    #define fY 0b00100000
    #define fZ 0b01000000
    #define fS 0b10000000

    #define cNO -1
    #define cNZ 0
    #define cZ  1
    #define cNC 2
    #define cC  3
    #define cPO 4
    #define cPE 5
    #define cP  6
    #define cM  7

    uint8_t regs[28];

    uint8_t *_rF = &regs[0];
    uint8_t *_rA = &regs[1];
    uint8_t *_rC = &regs[2];
    uint8_t *_rB = &regs[3];
    uint8_t *_rE = &regs[4];
    uint8_t *_rD = &regs[5];
    uint8_t *_rL = &regs[6];
    uint8_t *_rH = &regs[7];

    uint16_t *_rAF = (uint16_t*)&regs[0];
    uint16_t *_rBC = (uint16_t*)&regs[2];
    uint16_t *_rDE = (uint16_t*)&regs[4];
    uint16_t *_rHL = (uint16_t*)&regs[6];

    uint8_t *_rF2 = &regs[8];
    uint8_t *_rA2 = &regs[9];
    uint8_t *_rC2 = &regs[10];
    uint8_t *_rB2 = &regs[11];
    uint8_t *_rE2 = &regs[12];
    uint8_t *_rD2 = &regs[13];
    uint8_t *_rL2 = &regs[14];
    uint8_t *_rH2 = &regs[15];

    uint16_t *_rAF2 = (uint16_t*)&regs[8];
    uint16_t *_rBC2 = (uint16_t*)&regs[10];
    uint16_t *_rDE2 = (uint16_t*)&regs[12];
    uint16_t *_rHL2 = (uint16_t*)&regs[14];

    uint16_t *_rIX = (uint16_t*)&regs[16];
    uint16_t *_rIY = (uint16_t*)&regs[18];
    uint16_t *_rSP = (uint16_t*)&regs[20];

    uint8_t *_rI = &regs[22];
    uint8_t *_rR = &regs[23];

    uint16_t *_rPC = (uint16_t*)&regs[24];

    uint16_t *_rWZ = (uint16_t*)&regs[26];
    uint8_t  *_rZ = (uint8_t*)&regs[26];
    uint8_t  *_rW = (uint8_t*)&regs[27];

    #define rA (*_rA)
    #define rF (*_rF)
    #define rB (*_rB)
    #define rC (*_rC)
    #define rD (*_rD)
    #define rE (*_rE)
    #define rH (*_rH)
    #define rL (*_rL)
    #define rW (*_rW)
    #define rZ (*_rZ)

    #define rAF (*_rAF)
    #define rBC (*_rBC)
    #define rDE (*_rDE)
    #define rHL (*_rHL)
    #define rWZ (*_rWZ)

    #define rA2 (*_rA2)
    #define rF2 (*_rF2)
    #define rB2 (*_rB2)
    #define rC2 (*_rC2)
    #define rD2 (*_rD2)
    #define rE2 (*_rE2)
    #define rH2 (*_rH2)
    #define rL2 (*_rL2)

    #define rAF2 (*_rAF2)
    #define rBC2 (*_rBC2)
    #define rDE2 (*_rDE2)
    #define rHL2 (*_rHL2)

    #define rIX (*_rIX)
    #define rIY (*_rIY)
    #define rSP (*_rSP)

    #define rI (*_rI)
    #define rR (*_rR)

    #define rPC (*_rPC)

    #define SWAP(a,b) {auto temp=a;a=b;b=temp;}

    uint16_t LD16()
    {
        return memory[rPC++] + memory[rPC++] << 8;
    }

    uint16_t LD8()
    {
        return memory[rPC++];
    }

    void INC16(uint16_t *reg)
    {
        reg++;
    }

    void DEC16(uint16_t *reg)
    {
        reg--;
    }

    void INC8(uint8_t *reg)
    {
        reg++;
    }

    void DEC8(uint8_t *reg)
    {
        reg--;
    }

    void RLCA()
    {
        // [TODO]
    }

    void RRCA()
    {
        // [TODO]
    }

    void RLA()
    {
        // [TODO]
    }

    void RRA()
    {
        // [TODO]
    }

    void DAA()
    {
        // [TODO]
    }

    void CPL()
    {
        // [TODO]
    }

    void ADD16(uint16_t* a, uint16_t b)
    {
        *a = *a + b;
    }

    void DJNZ()
    {
        // [TODO]
    }

    void JR(uint8_t cond, int8_t disp)
    {
        // [TODO]
    }

    void reset(uint8_t* mem)
    {
        memory = mem;
        rPC = 0;
        t_states = 0;
    }

    void step()
    {
        const uint8_t opcode = memory[rPC++];
        t_states+=4;
        uint16_t tmp;

        switch (opcode)
        {
            case 0x00: /* NOP */                        break;
            case 0x01: rBC = LD16();                    break;
            case 0x02: memory[rBC] = rA;                break;
            case 0x03: INC16(_rBC);                     break;
            case 0x04: INC8(_rB);                       break;
            case 0x05: DEC8(_rB);                       break;
            case 0x06: rB = LD8();                      break;
            case 0x07: RLCA();                          break;
            case 0x08: SWAP(rAF, rAF2);                 break;
            case 0x09: ADD16(_rHL, rBC);                break;
            case 0x0A: rA = memory[rBC];                break;
            case 0x0B: DEC16(_rBC);                     break;
            case 0x0C: INC8(_rC);                       break;
            case 0x0D: DEC8(_rC);                       break;
            case 0x0E: rC = LD8();                      break;
            case 0x0F: RRCA();                          break;

            case 0x10: DJNZ();                          break;
            case 0x11: rDE = LD16();                    break;
            case 0x12: memory[rDE] = rA;                break;
            case 0x13: INC16(_rDE);                     break;
            case 0x14: INC8(_rD);                       break;
            case 0x15: DEC8(_rD);                       break;
            case 0x16: rD = LD8();                      break;
            case 0x17: RLA();                           break;
            case 0x18: JR(cNO, int8_t(rD));             break;
            case 0x19: ADD16(_rHL, rDE);                break;
            case 0x1A: rA = memory[rDE];                break;
            case 0x1B: DEC16(_rDE);                     break;
            case 0x1C: INC8(_rE);                       break;
            case 0x1D: DEC8(_rE);                       break;
            case 0x1E: rE = LD8();                      break;
            case 0x1F: RRA();                           break;

            case 0x20: JR(cNZ, int8_t(rD));             break;
            case 0x21: rHL = LD16();                    break;
            case 0x22: tmp=LD16(); memory[tmp] = rL; memory[tmp+1] = rH; break;
            case 0x23: INC16(_rHL);                     break;
            case 0x24: INC8(_rH);                       break;
            case 0x25: DEC8(_rH);                       break;
            case 0x26: rH = LD8();                      break;
            case 0x27: DAA();                           break;
            case 0x28: JR(cZ, int8_t(rD));              break;
            case 0x29: ADD16(_rHL, rHL);                break;
            case 0x2A: tmp=LD16(); rL = memory[tmp]; rH = memory[tmp+1]; break;
            case 0x2B: DEC16(_rHL);                     break;
            case 0x2C: INC8(_rL);                       break;
            case 0x2D: DEC8(_rL);                       break;
            case 0x2E: rL = LD8();                      break;
            case 0x2F: CPL();                           break;

        }
    }
}