#include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <cglm/cglm.h>
#include <cglm/struct.h>

#include "graphics.h"
#include "window.h"
#include "common.h"

#define SW 640
#define SH 480

window_t window;
graphics_t graphics;

int _create_surface(VkInstance instance, VkSurfaceKHR *surface);
int update_ubo(void *uniform_buffer);

struct ubo {
    mat4 model;
    mat4 view;
    mat4 proj;
}; 

vertex_t vertices[] = {
    {{-0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}},
    {{0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}},
    {{0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}},
    {{-0.5f, 0.5f}, {1.0f, 1.0f, 1.0f}}
};

u32 indices[] = {
    0, 1, 2, 2, 3, 0
};

int main(void)
{
    int ret = 1;

    if(SDL_Init(0)) {
        err("SDL_Init: failed");
        goto f1;
    }

    // populate window info
    struct window_info win_info = {0};
    win_info.title = "Test App";
    // win_info.flags = SDL_WINDOW_RESIZABLE;
    win_info.w = SW;
    win_info.h = SH;
    
    // create window
    window = window_create(&win_info);
    if(!window) {
        err("window_create: failed");
        goto f2;
    }
    
    // get extensions
    unsigned int ext_count = 0;
    window_extension_info(window, &ext_count, NULL);
    
    char **extensions = xcalloc(ext_count, sizeof(char *));
    window_extension_info(window, &ext_count, (const char **)extensions);
    
    // populate the device info
    struct graphics_info grph_info = {0};
    grph_info.name = "Test App";
    grph_info.version = MAKE_VERSION(1, 0, 0);

    grph_info.ext_count = ext_count;
    grph_info.extensions = (const char * const *)extensions;
    
    grph_info.vertices = vertices;
    grph_info.nvertices = ARR_SIZE(vertices);
    grph_info.indices = indices;
    grph_info.nindices = ARR_SIZE(indices);

    grph_info.ubo_size = sizeof(struct ubo);
    grph_info.update_ubo = update_ubo;

    grph_info.surface_func = _create_surface;
    
    // create the device
    graphics = graphics_create(&grph_info);
    if(!graphics) {
        err("device_create: failed");
        if(extensions) free(extensions);
        goto f3;
    }

    if(extensions) free(extensions);
    
    int running = 1;
    while(running) {
        SDL_Event windowEvent;
        while(SDL_PollEvent(&windowEvent))
            if(windowEvent.type == SDL_QUIT) {
                running = 0;
                break;
            }

        graphics_draw_frame(graphics);
    }
    
    ret = 0;
    
    graphics_destroy(graphics);
f3: window_destroy(window);
f2: SDL_Quit();
f1: return ret;
}

int update_ubo(void *uniform_buffer)
{
    struct ubo *ubo = (struct ubo *)uniform_buffer;

    static float time = 1.0f;
    time += 0.01f;

    memcpy(ubo->model, glms_mat4_identity().raw, sizeof(ubo->model));
    glm_rotate(&ubo->model, time * glm_rad(90.0f),
               (vec3){0.0f, 0.0f, 1.0f});

    glm_lookat((vec3){1.0f, 1.0f, 2.0f}, (vec3){0.0f, 0.0f, 0.0f}, (vec3){0.0f, 0.0f, 1.0f}, ubo->view);
 
    glm_perspective(glm_rad(45.0f), (float)SW/(float)SH, 0.1f, 10.0f, ubo->proj);

    ubo->proj[1][1] *= -1;
    return 0;
}

int _create_surface(VkInstance instance, VkSurfaceKHR *surface)
{
    return window_create_surface(window, instance, surface);
}