#include <SDL.h>
#include <stdio.h>
#include "glcxx.hpp"
#include "GL3/gl3w.h"
#include <iostream>
#include "TextShader.h"
#include "RectShader.h"

using namespace std;

std::shared_ptr<TextShader> text_shader;
std::shared_ptr<RectShader> rect_shader;
std::shared_ptr<glcxx::Array> rect_array;
std::shared_ptr<glcxx::Buffer> rect_buffer;

#define WIDTH   800
#define HEIGHT  800

bool init(void)
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_CULL_FACE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glViewport(0, 0, WIDTH, HEIGHT);
    try
    {
        text_shader = std::make_shared<TextShader>();
        text_shader->use();
        text_shader->set_texture(0);
        text_shader->set_viewport_size(WIDTH, HEIGHT);

        rect_shader = std::make_shared<RectShader>();
        rect_shader->use();
        rect_shader->set_viewport_size(WIDTH, HEIGHT);
        rect_shader->set_position(0, 0);
        rect_shader->set_size(WIDTH, HEIGHT);
        GLfloat rect_buffer_data[] = {
            0.0, 0.0,   0.0, 0.0, 1.0, 1.0,
            1.0, 0.0,   1.0, 1.0, 1.0, 1.0,
            1.0, 1.0,   0.0, 1.0, 0.0, 1.0,
            0.0, 1.0,   1.0, 0.0, 0.0, 1.0,
        };
        rect_array = glcxx::Array::create();
        rect_array->bind();
        rect_buffer = glcxx::Buffer::create(GL_ARRAY_BUFFER, GL_STATIC_DRAW,
                rect_buffer_data, sizeof(rect_buffer_data));
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), 0);
        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void *)(2 * sizeof(GLfloat)));
    }
    catch (glcxx::Error & e)
    {
        cerr << "glcxx error: " << e.what() << endl;
        return false;
    }
    return true;
}

void display(SDL_Window * window)
{
    glClear(GL_COLOR_BUFFER_BIT);

    rect_array->bind();
    rect_shader->use();
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

    SDL_GL_SwapWindow(window);
}

static SDL_Event UpdateEvent;

static Uint32 UpdateCallback(Uint32 interval, void * param)
{
    SDL_PushEvent(&UpdateEvent);
    return interval;
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        fprintf(stderr, "Usage: %s <font-file>\n", argv[0]);
        return 1;
    }

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER))
    {
        fprintf(stderr, "Failed to initialize SDL!\n");
        return 1;
    }

    atexit(SDL_Quit);

    SDL_Window * window = SDL_CreateWindow(argv[0],
                                           SDL_WINDOWPOS_UNDEFINED,
                                           SDL_WINDOWPOS_UNDEFINED,
                                           WIDTH,
                                           HEIGHT,
                                           SDL_WINDOW_OPENGL);
    if (!window)
    {
        fprintf(stderr, "Failed to create window!\n");
        SDL_Quit();
        return 2;
    }

    (void)SDL_GL_CreateContext(window);

    if (gl3wInit())
    {
        fprintf(stderr, "Failed to initialize GL3W");
        return 2;
    }
    if (!gl3wIsSupported(3, 0))
    {
        fprintf(stderr, "OpenGL 3.0 is not supported!");
        return 2;
    }

    if (!init())
    {
        return 2;
    }

    UpdateEvent.type = SDL_USEREVENT;
    UpdateEvent.user.code = 0;
    SDL_AddTimer(25, UpdateCallback, NULL);
    display(window);
    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;
            if (event.key.keysym.sym == SDLK_RETURN)
                display(window);
        }
        else if (event.type == SDL_USEREVENT)
        {
            display(window);
        }
    }
}