#include "linalg.h"
#include "texture_map.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_blendmode.h>
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_keycode.h>
#include <SDL2/SDL_pixels.h>
#include <SDL2/SDL_rect.h>
#include <SDL2/SDL_render.h>
#include <SDL2/SDL_timer.h>
#include <SDL2/SDL_video.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wchar.h>

const f3 verts[] = {
    // clang-format off
    { 0, 0, 0 }, //  0 front top     left
    { 1, 0, 0 }, //  1 front top     right
    { 0, 1, 0 }, //  2 front bottom  left
    { 1, 1, 0 }, //  3 front bottom  right
    { 0, 0, 1 }, //  4 back  top     left
    { 1, 0, 1 }, //  5 back  top     right
    { 0, 1, 1 }, //  6 back  bottom  left
    { 1, 1, 1 }, //  7 back  bottom  right
    // clang-format on
};

const size_t shapes[][3] = {
    // back
    { 0, 1, 2 },
    { 3, 2, 1 },
    // bottom
    { 4, 5, 0 },
    { 1, 0, 5 },
    // left
    { 4, 0, 6 },
    { 2, 6, 0 },
    // front
    { 5, 4, 7 },
    { 6, 7, 4 },
    // top
    { 7, 6, 3 },
    { 2, 3, 6 },
    // right
    { 1, 5, 3 },
    { 7, 3, 5 },
};

constexpr size_t verts_size = sizeof(verts) / sizeof(verts[0]);
constexpr size_t shapes_size = sizeof(shapes) / sizeof(shapes[0]);

constexpr int screen_width = 1024;
constexpr int screen_height = 1024;

constexpr size_t colors_size = 32;
uint32_t colors[colors_size] = { 0 };

constexpr size_t textures_size = 1;
uint32_t textures[textures_size][64];

const f2 verts_uv_map[verts_size] = {
    // clang-format off
    { 0, 0 },
    { 1, 0 },
    { 0, 1 },
    { 1, 1 },
    { 0, 0 },
    { 1, 0 },
    { 0, 1 },
    { 1, 1 },
    // clang-format on
};

const size_t shapes_textures_map[shapes_size] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};

#ifndef M_PI
#define M_PI (3.141529653578)
#endif

double pi(double v)
{
    return v * M_PI;
}

#define MAX(L, R) ((L) >= (R) ? (L) : (R))
#define MIN(L, R) ((L) < (R) ? (L) : (R))

void set_px(uint32_t* pixels, int x, int y, uint32_t color)
{
    if ((uint32_t)x >= (size_t)screen_width
        || (uint32_t)y >= (size_t)screen_height)
        return;

    pixels[y * screen_width + x] = color;
}

void draw_line_impl(
    uint32_t* pixels, int x0, int y0, int x1, int y1, uint32_t color,
    bool steep)
{
    if (abs(x0 - x1) < abs(y0 - y1)) {
        draw_line_impl(pixels, y0, x0, y1, x1, color, true);
        return;
    }
    if (x0 > x1) {
        draw_line_impl(pixels, x1, y1, x0, y0, color, steep);
        return;
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    int derror2 = abs(dy) * 2;
    int error2 = 0;
    int y = y0;
    for (int x = x0; x <= x1; ++x) {
        if (steep) {
            set_px(pixels, y, x, color);
        } else {
            set_px(pixels, x, y, color);
        }
        error2 += derror2;
        if (error2 > dx) {
            y += y1 > y0 ? 1 : -1;
            error2 -= dx * 2;
        }
    }
}

void draw_line(uint32_t* pixels, i2 p0, i2 p1, uint32_t color)
{
    draw_line_impl(pixels, p0.x, p0.y, p1.x, p1.y, color, false);
}

void draw_triangle_lines(uint32_t* pixels, i2x3 tri, uint32_t color)
{
    draw_line(pixels, tri.p0, tri.p1, color);
    draw_line(pixels, tri.p1, tri.p2, color);
    draw_line(pixels, tri.p2, tri.p0, color);
}

double signed_triangle_area(int x0, int y0, int x1, int y1, int x2, int y2)
{
    return 0.5
        * ((y1 - y0) * (x1 + x0) + (y2 - y1) * (x2 + x1)
           + (y0 - y2) * (x0 + x2));
}

void draw_triangle_filled(uint32_t* pixels, i2x3 tri, uint32_t color)
{
    int x0 = tri.p0.x;
    int y0 = tri.p0.y;
    int x1 = tri.p1.x;
    int y1 = tri.p1.y;
    int x2 = tri.p2.x;
    int y2 = tri.p2.y;

    int rect_x0 = MIN(MIN(x0, x1), x2);
    int rect_y0 = MIN(MIN(y0, y1), y2);

    int rect_x1 = MAX(MAX(x0, x1), x2);
    int rect_y1 = MAX(MAX(y0, y1), y2);

    int rect_w = rect_x1 - rect_x0;
    int rect_h = rect_y1 - rect_y0;

    if (rect_w == 0 || rect_h == 0)
        return;

    double area = signed_triangle_area(x0, y0, x1, y1, x2, y2);

    for (int y = rect_y0; y <= rect_y1; ++y) {
        for (int x = rect_x0; x <= rect_x1; ++x) {
            double a0 = signed_triangle_area(x, y, x1, y1, x2, y2) / area;
            double a1 = signed_triangle_area(x, y, x2, y2, x0, y0) / area;
            double a2 = signed_triangle_area(x, y, x0, y0, x1, y1) / area;

            if (a0 < 0 || a1 < 0 || a2 < 0)
                continue;

            set_px(pixels, x, y, color);
        }
    }
}

f3 rotate_x(f3 v, double angle)
{
    f3x3 rotation_mx = {
        // clang-format off
        1,          0,           0,
        0, cos(angle), -sin(angle),
        0, sin(angle),  cos(angle),
        // clang-format on
    };
    return mul_f3_f3x3(v, rotation_mx);
}

f3 rotate_y(f3 v, double angle)
{
    f3x3 rotation_mx = {
        // clang-format off
         cos(angle), 0, sin(angle),
                  0, 1,          0,
        -sin(angle), 0, cos(angle),
        // clang-format on
    };
    return mul_f3_f3x3(v, rotation_mx);
}

f3 rotate_z(f3 v, double angle)
{
    f3x3 rotation_mx = {
        // clang-format off
        cos(angle), -sin(angle), 0,
        sin(angle),  cos(angle), 0,
                 0,           0, 1,
        // clang-format on
    };
    return mul_f3_f3x3(v, rotation_mx);
}

f3 translate(f3 v, double x, double y, double z)
{
    return add_f3(v, (f3) { x, y, z });
}

f2 f3_project(f3 v, double focal_length)
{
    focal_length *= -1;
    return (f2) {
        (v.x * focal_length) / (v.z + focal_length),
        (-v.y * focal_length) / (v.z + focal_length),
    };
}

i2 f2_to_screen_i2(f2 v)
{
    return (i2) {
        (int)(v.x * (screen_width / 4.0) + screen_width / 2.0),
        (int)(v.y * (screen_width / 4.0) + screen_width / 2.0),
    };
}

f2 f2_to_screen(f2 v)
{
    return (f2) {
        v.x * (screen_width / 4.0) + screen_width / 2.0,
        v.y * (screen_width / 4.0) + screen_width / 2.0,
    };
}

void draw_shape(uint32_t* pixels, i2x3 verts, uint32_t color)
{
    double cross_z = (verts.p1.x - verts.p0.x) * (verts.p2.y - verts.p0.y)
        - (verts.p1.y - verts.p0.y) * (verts.p2.x - verts.p0.x);
    if (cross_z <= 0)
        return;

    draw_triangle_filled(pixels, verts, color);
    // draw_triangle_lines(pixels, verts, 0xff000000);
}

double f2x3_signed_area(f2x3 s)
{
    return 0.5
        * ((s.p1.y - s.p0.y) * (s.p1.x + s.p0.x)
           + (s.p2.y - s.p1.y) * (s.p2.x + s.p1.x)
           + (s.p0.y - s.p2.y) * (s.p0.x + s.p2.x));
}

void draw_shape_with_texture(uint32_t* pixels, size_t shape_idx, f2x3 s)
{
    double cross_z = (s.p1.x - s.p0.x) * (s.p2.y - s.p0.y)
        - (s.p1.y - s.p0.y) * (s.p2.x - s.p0.x);
    if (cross_z <= 0)
        return;

    double rect_x0 = MIN(MIN(s.p0.x, s.p1.x), s.p2.x);
    double rect_y0 = MIN(MIN(s.p0.y, s.p1.y), s.p2.y);

    double rect_x1 = MAX(MAX(s.p0.x, s.p1.x), s.p2.x);
    double rect_y1 = MAX(MAX(s.p0.y, s.p1.y), s.p2.y);

    double rect_w = rect_x1 - rect_x0;
    double rect_h = rect_y1 - rect_y0;

    if (rect_w == 0 || rect_h == 0)
        return;

    double area = f2x3_signed_area(s);

    for (int y = (int)rect_y0; y <= rect_y1; ++y) {
        for (int x = (int)rect_x0; x <= rect_x1; ++x) {
            f2 p = { x, y };
            double a0 = f2x3_signed_area((f2x3) { p, s.p1, s.p2 }) / area;
            double a1 = f2x3_signed_area((f2x3) { p, s.p2, s.p0 }) / area;
            double a2 = f2x3_signed_area((f2x3) { p, s.p0, s.p1 }) / area;

            if (a0 < 0 || a1 < 0 || a2 < 0)
                continue;

            f2 uv = { x / rect_x1, y / rect_y1 };

            // uint32_t color
            //     = (uint32_t)(0xff * uv.x) << 0 | (uint32_t)(0xff * uv.y) <<
            //     8;
            // uint32_t color = colors[shape_idx];
            uint32_t color
                = textures[0][MIN((size_t)(uv.y * 8 * 8 + uv.x * 8), 63)];

            set_px(pixels, x, y, 0xff000000 | color);
        }
    }
}

void render(uint32_t* pixels, uint64_t total_ms)
{
    double time_frac = total_ms % 4000 / 4000.0;

    i2 screen_verts_i2[verts_size];
    f2 screen_verts[verts_size];
    for (size_t i = 0; i < verts_size; ++i) {
        f3 v = verts[i];

        v = translate(v, -0.5, -0.5, -0.5);

        // v = rotate_y(v, pi(2) * time_frac);

        v = rotate_x(v, M_PI * 2 * time_frac);
        v = rotate_y(v, M_PI * 2 * time_frac);
        v = rotate_z(v, M_PI * 2 * time_frac);

        v = translate(v, -1, -1, 0);
        v = translate(v, 10 * time_frac, 10 * time_frac, -20 * time_frac);

        screen_verts_i2[i] = f2_to_screen_i2(f3_project(v, 4.0));
        screen_verts[i] = f2_to_screen(f3_project(v, 4.0));
    }

    for (size_t shape_idx = 0; shape_idx < shapes_size; ++shape_idx) {

        i2x3 shape_verts_i2;
        f2x3 shape_verts;
        for (size_t vert_idx = 0; vert_idx < 3; ++vert_idx) {
            ((i2*)&shape_verts_i2)[vert_idx]
                = screen_verts_i2[shapes[shape_idx][vert_idx]];
            ((f2*)&shape_verts)[vert_idx]
                = screen_verts[shapes[shape_idx][vert_idx]];
        }

#ifdef DRAW_TEXTURE
        draw_shape_with_texture(pixels, shape_idx, shape_verts);
#elifdef DRAW_LINES
        draw_triangle_lines(pixels, shape_verts_i2, 0xffffffff);
#else
        draw_shape(pixels, shape_verts_i2, colors[shape_idx]);
#endif
    }
}

int main(void)
{
    srand((unsigned int)time(nullptr));

    TextureMap* texture_map = texture_map_new("texture_map.tga");

    for (size_t i = 0; i < textures_size; ++i) {
        texture_map_read_texture(texture_map, textures[i], (int)i);
    }

    texture_map_free(texture_map);

    for (size_t i = 0; i < colors_size; ++i) {
        uint32_t color = (uint32_t)((double)rand() / RAND_MAX * 0xffffff);
        colors[i] = 0xffu << 24 | color;
    }

    SDL_Init(SDL_INIT_VIDEO);

    SDL_Window* window;
    SDL_Renderer* renderer;

    SDL_CreateWindowAndRenderer(
        screen_width, screen_height, 0, &window, &renderer);

    SDL_Texture* buffer = SDL_CreateTexture(
        renderer,
        SDL_PIXELFORMAT_RGBA32,
        SDL_TEXTUREACCESS_STREAMING,
        screen_width,
        screen_height);

    SDL_SetTextureBlendMode(buffer, SDL_BLENDMODE_BLEND);

    uint64_t before = SDL_GetTicks64();

    while (true) {
        uint64_t now = SDL_GetTicks64();
        uint64_t delta = now - before;
        (void)delta;

        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_QUIT:
                    goto exit_game;
                case SDL_KEYDOWN: {
                    switch (event.key.keysym.sym) {
                        case SDLK_ESCAPE:
                            goto exit_game;
                    }
                }
            }
        }

        SDL_RenderClear(renderer);

        uint32_t* pixels;
        int row_size;
        SDL_LockTexture(
            buffer,
            &(SDL_Rect) { 0, 0, screen_width, screen_height },
            (void**)&pixels,
            &row_size);
        row_size /= (int)sizeof(uint32_t);

        memset(
            pixels,
            0,
            sizeof(int) * (size_t)screen_width * (size_t)screen_height);

        render(pixels, now);

        SDL_UnlockTexture(buffer);

        SDL_RenderCopy(renderer, buffer, nullptr, nullptr);
        SDL_RenderPresent(renderer);
        SDL_Delay(16);

        before = now;
    }

exit_game:;
    printf("exitting...\n");

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
}