#include "gl3w.h"
#include "GL.h"
#include "GLBuffer.h"
#include "GLProgram.h"
#include "ruby.h"
#include "Window.h"
#include <SDL.h>

#define WIDTH   500
#define HEIGHT  500

typedef struct
{
    SDL_Window * sdl_window;
} Window;

static VALUE ruby_class;
static VALUE window_instance;

static void Init_SDL()
{
    static bool initialized = false;

    if (initialized)
        return;

    if (SDL_Init(SDL_INIT_VIDEO))
    {
        rb_raise(rb_eRuntimeError, "Failed to initialize SDL");
    }

    atexit(SDL_Quit);

    initialized = true;
}

static void Window_free(void * ptr)
{
    Window * window = (Window *)ptr;

    if (window->sdl_window)
        SDL_DestroyWindow(window->sdl_window);

    delete window;
}

static void resize()
{
    int width;
    int height;
    Window * window;
    Data_Get_Struct(window_instance, Window, window);
    SDL_GetWindowSize(window->sdl_window, &width, &height);
    GL_Resize(width, height);
    rb_funcall(window_instance,
               rb_intern("resize"),
               4,
               INT2FIX(0),
               INT2FIX(0),
               INT2FIX(width),
               INT2FIX(height));
}

static VALUE Window_new(VALUE klass)
{
    static bool one_created = false;

    if (one_created)
    {
        rb_raise(rb_eRuntimeError, "Only one Window for now");
    }

    Init_SDL();

    SDL_Window * sdl_window =
        SDL_CreateWindow("jes",
                         SDL_WINDOWPOS_UNDEFINED,
                         SDL_WINDOWPOS_UNDEFINED,
                         WIDTH,
                         HEIGHT,
                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if (sdl_window == NULL)
    {
        rb_raise(rb_eRuntimeError, "Failed to create SDL window");
    }

    Window * window = new Window();
    window->sdl_window = sdl_window;

    (void)SDL_GL_CreateContext(window->sdl_window);

    GL_Load();

    one_created = true;

    VALUE rv = Data_Wrap_Struct(ruby_class, NULL, Window_free, window);
    rb_obj_call_init(rv, 0, NULL);

    /* TODO: remove window_instance and map SDL_Window * to Window Ruby object
     * to support multiple windows. */
    window_instance = rv;
    resize();

    return rv;
}

static void draw()
{
    rb_funcall(window_instance, rb_intern("draw"), 0);
}

static VALUE Window_event_loop(VALUE klass)
{
    SDL_Event event;

    while (SDL_WaitEvent(&event))
    {
        if (event.type == SDL_QUIT)
            break;
        else if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_ESCAPE)
                break;
        }
        else if (event.type == SDL_WINDOWEVENT)
        {
            switch (event.window.event)
            {
            case SDL_WINDOWEVENT_EXPOSED:
                draw();
                break;
            case SDL_WINDOWEVENT_RESIZED:
                resize();
                draw();
                break;
            }
        }
    }

    return Qnil;
}

static VALUE Window_render_begin(VALUE self)
{
    rb_call_super(0, NULL);

    glClearColor (0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

    return Qnil;
}

static VALUE Window_render_end(VALUE self)
{
    Window * window;
    Data_Get_Struct(window_instance, Window, window);
    SDL_GL_SwapWindow(window->sdl_window);

    return Qnil;
}

void Window_Init(void)
{
    ruby_class = rb_define_class("Window", rb_cObject);
    rb_define_singleton_method(ruby_class, "new",
                               (VALUE(*)(...))Window_new, 0);
    rb_define_singleton_method(ruby_class, "event_loop",
                               (VALUE(*)(...))Window_event_loop, 0);
    rb_define_method(ruby_class, "render_begin",
                     (VALUE(*)(...))Window_render_begin, 0);
    rb_define_method(ruby_class, "render_end",
                     (VALUE(*)(...))Window_render_end, 0);
}
