#include "shorthand.h"
#include "bd-font.c"

//
// Memory sections.
//

// Defines for the different memory sections in the GBA.
#define MEM_SROM  0x00000000
#define MEM_EW    0x02000000
#define MEM_IW    0x03000000
#define MEM_IO    0x04000000
#define MEM_PAL   0x05000000
#define MEM_VRAM  0x06000000
#define MEM_OAM   0x07000000
#define MEM_PAK   0x08000000
#define MEM_CART  0x0E000000

//
// Display modes.
//

// Display registers.
#define DISP_CONTROL *((vu32*)(MEM_IO + 0x0000))
#define DISP_STATUS  *((vu32*)(MEM_IO + 0x0004))
#define DISP_VCOUNT  *((vu32*)(MEM_IO + 0x0006))

// Bits for display control.
#define DISP_CONTROL_PAGE (1 << 4)

// Display modes.
#define DISP_MODE_0 0x0000
#define DISP_MODE_1 0x0001
#define DISP_MODE_2 0x0002
#define DISP_MODE_3 0x0003
#define DISP_MODE_4 0x0004
#define DISP_MODE_5 0x0005

// Layers.
#define DISP_BG_0 0x0100
#define DISP_BG_1 0x0200
#define DISP_BG_2 0x0400
#define DISP_BG_3 0x0800
#define DISP_OBJ  0x1000

// Screen settings.
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 160

// The GBA in mode 3 expects rbg15 colors in the VRAM, where each component
// (RGB) have a 0--31 range. For example, pure red would be rgb15(31, 0, 0).
typedef u16 Color;

// We can treat the screen as a HxW matrix. With the following macro we can
// write a pixel to the screen at the (x, y) position using:
//
//     FRAMEBUFFER[y][x] = color;
//
typedef Color Scanline[SCREEN_WIDTH];
#define FRAMEBUFFER ((Scanline*)MEM_VRAM)
#define SCREEN_BUFFER ((vu16*) MEM_VRAM)
#define PAL_BUFFER ((vu16*) MEM_PAL)

//
// Colors.
//

static inline Color
rgb15(u32 red, u32 green, u32 blue ) {
    return (blue << 10) | (green << 5) | red;
}

#define COLOR_RED   rgb15(31, 0, 12)
#define COLOR_BLUE  rgb15(2, 15, 30)
#define COLOR_CYAN  rgb15(0, 30, 30)
#define COLOR_GREY  rgb15(4, 4, 4)
#define COLOR_BLACK rgb15(0, 0, 0)
#define COLOR_WHITE rgb15(28, 28, 28)

// Using bd-font, an 8x8 bitmap font.
static void
put_char(int x, int y, Color clr, u8 chr) {
    for (size_t i = 0; i < 8; ++i) {
        for (size_t j = 0; j < 8; ++j) {
            if ((font[chr][i] >> (7 - j)) & 0x1) {
                FRAMEBUFFER[y + i][x + j] = clr;
            }
        }
    }
}

static void
put_text(int x, int y, Color clr, char *msg) {
    int count = 0;
    while (*msg) {
        put_char(x + count, y, clr, *msg++);
        count += 8;
    }
}

// Draws a line with the given color between (x0,y0) and (x1,y1) using the
// Bresenham's line drawing algorithm using exclusively integer arithmetic.
static void
draw_line(int x0, int y0, int x1, int y1, Color clr) {
    // Pointer to the initial position of the screen buffer where we will start
    // writing our data.
    vu16 *destination = (u16*)(SCREEN_BUFFER + y0 * SCREEN_WIDTH + x0);

    // Adjust the step direction and calculate deltas.
    int x_step;
    int y_step;
    int dx;
    int dy;
    if (x0 > x1) {
        x_step = -1;
        dx = x0 - x1;
    } else {
        x_step = 1;
        dx = x1 - x0;
    }
    if (y0 > y1) {
        y_step = -SCREEN_WIDTH;
        dy = y0 - y1;
    } else {
        y_step = +SCREEN_WIDTH;
        dy = y1 - y0;
    }

    if(dy == 0) {
        // Horizontal line.
        for(int i = 0; i <= dx; i++) {
            destination[i * x_step] = clr;
        }
    } else if(dx == 0) {
        // Vertical line.
        for(int i = 0; i <= dy; i++) {
            destination[i * y_step] = clr;
        }
    } else if (dx >= dy){
        // Positive slope.
        int diff = 2 * dy - dx;
        for (int i = 0; i <= dx; ++i) {
            *destination = clr;
            if (diff >= 0) {
                destination += y_step;
                diff -= 2 * dx;
            }
            destination += x_step;
            diff += 2 * dy;
        }
    } else {
        // Negative slope.
        int diff = 2 * dx - dy;
        for (int i = 0; i <= dy; ++i) {
            *destination = clr;
            if (diff >= 0) {
                destination += x_step;
                diff -= 2 * dy;
            }
            destination += y_step;
            diff += 2 * dx;
        }
    }
}

static inline void
draw_rect(int x0, int y0, int x1, int y1, Color clr) {
    if (x0 > x1) {
        int tmp = x0;
        x0 = x1;
        x1 = tmp;
    }
    if (y0 > y1) {
        int tmp = y0;
        y0 = y1;
        y1 = tmp;
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    for (int i = 0; i <= dx; ++i) {
        int x = x0 + i;
        FRAMEBUFFER[y0][x] = clr;
        FRAMEBUFFER[y1][x] = clr;
    }
    for (int j = 0; j <= dy; ++j) {
        int y = y0 + j;
        FRAMEBUFFER[y][x0] = clr;
        FRAMEBUFFER[y][x1] = clr;
    }
}

static inline void
draw_fill_rect(int x0, int y0, int x1, int y1, Color clr) {
    if (x0 > x1) {
        int tmp = x0;
        x0 = x1;
        x1 = tmp;
    }
    if (y0 > y1) {
        int tmp = y0;
        y0 = y1;
        y1 = tmp;
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    for (int i = 0; i <= dx; ++i) {
        for (int j = 0; j <= dy; ++j) {
            int x = x0 + i;
            int y = y0 + j;
            FRAMEBUFFER[y][x] = clr;
        }
    }
}

static inline void
wait_vsync() {
    while(DISP_VCOUNT >= 160);
    while(DISP_VCOUNT < 160);
}

//
// Main functions.
//

// In Mode4 the buffer is of 8 bytes per pixel instead of 16. We can't write the
// color directly, instead the color is stored in the palette memory at
// `MEM_PAL`. Note that in this mode MEM_PAL[0] is the background color. This
// plotter takes an index to a color stored in MEM_PAL[col_index]. Because the
// GBA needs to meet memory alignment requirements, we can't write a u8 into
// memory, instead we need to read a u16 word, mask and or the corresponding
// bits and wave the updated u16.
static void
put_pixel_m4(int x, int y, u8 col_index, vu16 *buffer) {
    int buffer_index = (y * SCREEN_WIDTH + x) / 2;
    vu16 *destination = &buffer[buffer_index];
    // Odd pixels will go to the top 8 bits of the destination. Even pixels to
    // the lower 8 bits.
    int odd = x & 0x1;
    if(odd) {
        *destination= (*destination & 0xFF) | (col_index << 8);
    } else {
        *destination= (*destination & ~0xFF) |  col_index;
    }
}

static void
draw_fill_rect_m4(int x0, int y0, int x1, int y1, u8 col_index, vu16 *buffer) {
    int ix, iy;
    for(iy = y0; iy < y1; iy++) {
        for(ix = x0; ix < x1; ix++) {
            put_pixel_m4(ix, iy, col_index, buffer);
        }
    }
}

static inline void
flip_page() {
    DISP_CONTROL ^= DISP_CONTROL_PAGE;
}

#define SCREEN_PAGE_1 ((vu16*) MEM_VRAM)
#define SCREEN_PAGE_2 ((vu16*) (MEM_VRAM + 0xa000))

//
// Profiling.
//

#define TIMER_DATA_0  *((vu16*) (0x04000100 + 0x04 * 0))
#define TIMER_DATA_1  *((vu16*) (0x04000100 + 0x04 * 1))
#define TIMER_DATA_2  *((vu16*) (0x04000100 + 0x04 * 2))
#define TIMER_DATA_3  *((vu16*) (0x04000100 + 0x04 * 3))
#define TIMER_CTRL_0  *((vu16*) (0x04000102 + 0x04 * 0))
#define TIMER_CTRL_1  *((vu16*) (0x04000102 + 0x04 * 1))
#define TIMER_CTRL_2  *((vu16*) (0x04000102 + 0x04 * 2))
#define TIMER_CTRL_3  *((vu16*) (0x04000102 + 0x04 * 3))

// Timer control bits.
#define TIMER_CTRL_FREQ_0   0
#define TIMER_CTRL_FREQ_1   1
#define TIMER_CTRL_FREQ_2   2
#define TIMER_CTRL_FREQ_3   3
#define TIMER_CTRL_CASCADE (1 << 2)
#define TIMER_CTRL_IRQ     (1 << 6)
#define TIMER_CTRL_ENABLE  (1 << 7)

// We use timers 2 and 3 to count the number of cycles since the profile_start
// functions is called. Don't use if the code we are trying to profile make use
// of these timers.
static inline
void profile_start() {
    TIMER_DATA_2 = 0;
    TIMER_DATA_3 = 0;
    TIMER_CTRL_2 = 0;
    TIMER_CTRL_3 = 0;
    TIMER_CTRL_3 = TIMER_CTRL_ENABLE | TIMER_CTRL_CASCADE;
    TIMER_CTRL_2 = TIMER_CTRL_ENABLE;
}

static inline
u32 profile_stop() {
   TIMER_CTRL_2 = 0;
   return (TIMER_DATA_3 << 16) | TIMER_DATA_2;
}

int main(void) {
    DISP_CONTROL = DISP_MODE_3 | DISP_BG_2;

    draw_fill_rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_GREY);

    int side = 60;
    int line = 35;
    int height = side * 0.5;
    int x = SCREEN_WIDTH / 2 - height / 2;
    int y = SCREEN_HEIGHT / 2;

    // Draw red triangle.
    draw_line(x + height - 1, y - side / 2, x, y - 1, COLOR_RED);
    draw_line(x + height - 1, y + side / 2, x, y + 1, COLOR_RED);
    draw_line(x + height - 1, y - side / 2 + 1, x, y, COLOR_RED);
    draw_line(x + height - 1, y + side / 2 - 1, x, y, COLOR_RED);

    // Draw white triangle.
    draw_line(x, y - side / 2, x, y + side / 2, COLOR_WHITE);
    draw_line(x + 1, y - side / 2, x + height, y - 1, COLOR_WHITE);
    draw_line(x + 1, y + side / 2, x + height, y + 1, COLOR_WHITE);

    // Draw white line at triangle tip.
    draw_line(x + height, y - side / 2, x + height, y + side / 2, COLOR_WHITE);
    draw_line(x + height + 1, y - side / 2, x + height + 1, y + side / 2, COLOR_WHITE);

    // Double triangle line.
    draw_line(x - 1, y - side / 2, x - 1, y + side / 2, COLOR_WHITE);
    draw_line(x + 1, y - side / 2 + 1, x + height, y, COLOR_WHITE);
    draw_line(x + 1, y + side / 2 - 1, x + height, y, COLOR_WHITE);

    // Draw white lines.
    draw_line(x - line, y, x, y, COLOR_WHITE);
    draw_line(x + height, y, x + height + line, y, COLOR_WHITE);
    draw_line(x - line, y + 1, x, y + 1, COLOR_WHITE);
    draw_line(x + height, y + 1, x + height + line, y + 1, COLOR_WHITE);

    put_text(SCREEN_WIDTH / 2 - 8 * 10 / 2, 125, COLOR_RED, "0xbadd10de");

    int frame_counter = 0;
    while(true) {
        wait_vsync();
        if (frame_counter++ > 30) {
            frame_counter = 0;
            flip_page();
        }
    };

    return 0;
}