#include "z80debug.h"
#include <SDL2/SDL.h>
#include "z80.h"
#include "z80dis.h"

namespace z80debug
{
    #define CHR_W 6
    #define CHR_H 13

    #define COLOR_BLACK     0
    #define COLOR_DARK_BLUE 1
    #define COLOR_GREEN     2
    #define COLOR_TEAL      3
    #define COLOR_BROWN     4
    #define COLOR_PURPLE    5
    #define COLOR_ORANGE    6
    #define COLOR_GRAY      7
    #define COLOR_DARK      8
    #define COLOR_BLUE      9
    #define COLOR_LIME      10
    #define COLOR_CYAN      11
    #define COLOR_RED       12
    #define COLOR_MAGENTA   13
    #define COLOR_YELLOW    14
    #define COLOR_WHITE     15

    uint8_t colors[16][3] = {
        {0,0,0},
        {0,0,128},
        {0,128,0},
        {0,128,128},
        {128,0,0},
        {128,0,128},
        {255,128,0},
        {128,128,128},
        {30,30,30},
        {0,0,255},
        {0,255,0},
        {0,255,255},
        {255,0,0},
        {255,0,255},
        {255,255,0},
        {255,255,255},
    };
   
    uint8_t offset_x = 0;
    uint8_t offset_y = 0;

    SDL_Window *win = nullptr;
    SDL_Renderer *ren = nullptr;
    SDL_Texture *tex = nullptr;

    uint16_t mem_viewer_pos = 0;

    char temp[256];
    const char *tohex(int value, int numdigits)
    {
        if (numdigits==2) sprintf(temp, "%02X", value);
        else if (numdigits==4) sprintf(temp, "%04X", value);
        return temp;
    }

    void show()
    {
        if (win) return;
        win = SDL_CreateWindow("Z80 Debugger", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 71*CHR_W, 28*CHR_H, SDL_WINDOW_SHOWN);
        ren = SDL_CreateRenderer(win, -1, 0);
        tex = SDL_CreateTextureFromSurface(ren, SDL_LoadBMP("font.bmp"));
        SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);

        z80debug::refresh();
    }

    void box(int x, int y, int w, int h, uint8_t color)
    {
        SDL_Rect rect {((offset_x+x)*CHR_W)+3, ((offset_y+y)*CHR_H)+6, w*CHR_W-6, h*CHR_H-13};
        SDL_SetRenderDrawColor(ren, colors[color][0], colors[color][1], colors[color][2], 255);
        SDL_RenderDrawRect(ren, &rect);
    }

    void printrect(int x, int y, int w, int h, uint8_t color)
    {
        SDL_Rect rect {(offset_x+x)*CHR_W, (offset_y+y)*CHR_H, w*CHR_W, h*CHR_H};
        SDL_SetRenderDrawColor(ren, colors[color][0], colors[color][1], colors[color][2], 255);
        SDL_RenderFillRect(ren, &rect);
    }

    void printchar(int x, int y, char chr, uint8_t color=255)
    {
        if (color != 255) SDL_SetRenderDrawColor(ren, colors[color][0], colors[color][1], colors[color][2], 255);
        if (chr==32) return;
        if (chr<32 || chr>127) chr = '.';
        SDL_Rect src {((chr-32)&0xf)*CHR_W, ((chr-32)>>4)*CHR_H, CHR_W, CHR_H};
        SDL_Rect dst {(offset_x+x)*CHR_W, (offset_y+y)*CHR_H, CHR_W, CHR_H};
        SDL_RenderCopy(ren, tex, &src, &dst);
    }

    void printtxt(int x, int y, const char *text, uint8_t color)
    {
        SDL_SetTextureColorMod(tex, colors[color][0], colors[color][1], colors[color][2]);
        for (int i=0; i<strlen(text);++i) if (text[i]!=32) printchar(x+i, y, text[i]);
    }

    uint16_t find_previous_opcode(uint16_t pc)
    {
        pc-=4;
        if (z80dis::getOpcodeSize(&z80::getMem()[pc]) != 4) {
            pc++;
            if (z80dis::getOpcodeSize(&z80::getMem()[pc]) != 3) {
                pc++;
                if (z80dis::getOpcodeSize(&z80::getMem()[pc]) != 2) {
                    pc++;
                }
            }
        }
        return pc;
    }

    void refresh()
    {
        SDL_SetRenderDrawColor(ren, 30, 30, 30, 255);
        SDL_RenderClear(ren);

        offset_x = offset_y = 0;

        box(0,0,46,20,COLOR_WHITE);
        printrect(2,0, 12,1, COLOR_DARK);
        printtxt(3,0, "ASSEMBLER:", COLOR_WHITE);
        
        offset_x=1; offset_y=1;
        /*printtxt(1,0, "19C4:", COLOR_CYAN);
        printtxt(7,0, "10 EE", COLOR_GRAY);
        printtxt(19,0, "DJNZ 0x19B4", COLOR_WHITE);
        printrect(0,1, 44,1, COLOR_BLUE);
        printtxt(1,1, "19C6:", COLOR_YELLOW);
        printtxt(7,1, "01 3C 00", COLOR_YELLOW);
        printtxt(19,1, "LD BC,0x003C", COLOR_YELLOW);*/

        printrect(0,8, 44,1, COLOR_BLUE);
        uint16_t pc = z80::getPC();
        uint8_t *memory = z80::getMem();
        printtxt(1,8,tohex(pc,4), COLOR_YELLOW);
        printtxt(7,8, z80dis::getOpcode(&memory[pc]), COLOR_YELLOW);
        printtxt(19,8, z80dis::getAsm(&memory[pc]), COLOR_YELLOW);

        uint16_t pos = pc;
        for (int i=9;i<18;++i) {
            pos += z80dis::getOpcodeSize(&memory[pos]);
            printtxt(1,i,tohex(pos,4), COLOR_CYAN);
            printtxt(7,i, z80dis::getOpcode(&memory[pos]), COLOR_GRAY);
            printtxt(19,i, z80dis::getAsm(&memory[pos]), COLOR_WHITE);
        }

        pos = pc;
        for (int i=7;i>=0;--i) {
            pos = find_previous_opcode(pos);
            printtxt(1,i,tohex(pos,4), COLOR_CYAN);
            printtxt(7,i, z80dis::getOpcode(&memory[pos]), COLOR_GRAY);
            printtxt(19,i, z80dis::getAsm(&memory[pos]), COLOR_WHITE);
        }
        //for (int i=0;i<20;++i) printtxt(1,i,tohex(pc,4), COLOR_CYAN);

        offset_x = offset_y = 0;
        box(46,0,25,8,COLOR_WHITE);
        printrect(48,0, 12,1, COLOR_DARK);
        printtxt(49,0, "REGISTERS:", COLOR_WHITE);

        offset_x=47;
        offset_y=1;
        printtxt(0,0, "AF      AF'     IX     ", COLOR_WHITE);
        printtxt(0,1, "BC      BC'     IY     ", COLOR_WHITE);
        printtxt(0,2, "DE      DE'     SP     ", COLOR_WHITE);
        printtxt(0,3, "HL      HL'     PC     ", COLOR_WHITE);
        printtxt(0,5, "(BC)    (DE)    (HL)   ", COLOR_WHITE);

        printtxt(3,0, tohex(z80::getAF(), 4), COLOR_GRAY);
        printtxt(11,0, tohex(z80::getAF(true), 4), COLOR_GRAY);
        printtxt(19,0, tohex(z80::getIX(), 4), COLOR_GRAY);
        printtxt(3,1, tohex(z80::getBC(), 4), COLOR_GRAY);
        printtxt(11,1, tohex(z80::getBC(true), 4), COLOR_GRAY);
        printtxt(19,1, tohex(z80::getIY(), 4), COLOR_GRAY);
        printtxt(3,2, tohex(z80::getDE(), 4), COLOR_GRAY);
        printtxt(11,2, tohex(z80::getDE(true), 4), COLOR_GRAY);
        printtxt(19,2, tohex(z80::getSP(), 4), COLOR_GRAY);
        printtxt(3,3, tohex(z80::getHL(), 4), COLOR_GRAY);
        printtxt(11,3, tohex(z80::getHL(true), 4), COLOR_GRAY);
        printtxt(19,3, tohex(z80::getPC(), 4), COLOR_GRAY);
        
        printtxt(5,5, tohex(memory[z80::getBC()], 2), COLOR_GRAY);
        printtxt(13,5, tohex(memory[z80::getDE()], 2), COLOR_GRAY);
        printtxt(21,5, tohex(memory[z80::getHL()], 2), COLOR_GRAY);

        offset_x=offset_y=0;
        box(0,20,71,8,COLOR_WHITE);
        printrect(2,20, 9,1, COLOR_DARK);
        printtxt(3,20, "MEMORY:", COLOR_WHITE);

        offset_x=1; offset_y=21;

        uint16_t mem_viewer_cursor = mem_viewer_pos;
        for (int i=0; i<6; ++i) {
            printtxt(0,i, tohex(mem_viewer_cursor, 4), COLOR_CYAN);
            for (int j=0; j<16; ++j) {
                printtxt(5+j*3, i, tohex(memory[mem_viewer_cursor++],2), COLOR_WHITE);
                printchar(53+j, i, memory[mem_viewer_cursor++], COLOR_GRAY);
            }
            //printtxt(5,0, "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00", COLOR_WHITE);
            //printtxt(53,0, "0123456789AB\tDEF", COLOR_GRAY);
        }

        SDL_RenderPresent(ren);
    }
}