#include "gl3w.h"
#include "Window.h"
#include "Runtime.h"

#define INITIAL_WIDTH   500
#define INITIAL_HEIGHT  500
#define FONT_SIZE 16

struct
{
    SDL_TimerID timer_id;
    Uint16 mod;
    bool pressed;
} Key_Statuses[SDL_NUM_SCANCODES];

/**
 * Initialize SDL.
 *
 * @retval true SDL was loaded successfully.
 * @retval false Loading SDL failed.
 */
static bool Initialize_SDL()
{
    static bool initialized = false;

    if (initialized)
    {
        return true;
    }

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
    {
        return false;
    }

    atexit(SDL_Quit);

    initialized = true;
    return true;
}

/**
 * Initialize OpenGL.
 *
 * @retval true OpenGL was loaded successfully.
 * @retval false Loading OpenGL failed.
 */
static bool Initialize_OpenGL()
{
    if (gl3wInit() != 0)
    {
        /* Failed to gl3wInit() */
        return false;
    }

    if (!gl3wIsSupported(3, 0))
    {
        /* OpenGL 3.0 is not supported */
        return false;
    }

    glActiveTexture(GL_TEXTURE0);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    return true;
}

/**
 * Create a Window.
 *
 * @retval true The Window was created successfully.
 * @retval false There was an error while creating the Window.
 */
bool Window::create(std::shared_ptr<Buffer> buffer)
{
    if (!Initialize_SDL())
    {
        return false;
    }

    m_window = SDL_CreateWindow(
            APPNAME,
            SDL_WINDOWPOS_UNDEFINED,
            SDL_WINDOWPOS_UNDEFINED,
            INITIAL_WIDTH,
            INITIAL_HEIGHT,
            SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if (m_window == NULL)
    {
        return false;
    }

    (void)SDL_GL_CreateContext(m_window);

    if (!Initialize_OpenGL())
    {
        return false;
    }

    m_exit_requested = false;

    /* TODO: user configurable font, size */
    std::string font_path = Runtime::find(Runtime::FONT, "DejaVuSansMono");
    if (font_path == "")
    {
        return false;
    }

    if (!m_font.load(font_path.c_str(), FONT_SIZE))
    {
        return false;
    }

    m_shaders.text = std::make_shared<TextShader>();
    m_shaders.text->use();
    m_shaders.text->set_texture(0);
    m_shaders.text->set_color(1.0, 1.0, 1.0, 1.0);

    m_buffer = buffer;
    m_start_piece = m_buffer->piece_table->start_piece->next;

    resize();

    return true;
}

/**
 * Run the Window event loop.
 *
 * TODO: make this a static method to support multiple GUI windows.
 */
void Window::run_event_loop()
{
    SDL_Event event;

    while ((!m_exit_requested) && SDL_WaitEvent(&event))
    {
        handle_event(event);
    }
}

Uint32 Key_Repeat(Uint32 interval, void * param)
{
    if (Key_Statuses[(uintptr_t)param].pressed)
    {
        SDL_Event event;

        event.user.code = 0;
        event.user.data1 = param;
        event.user.data2 = (void *)(uintptr_t)Key_Statuses[(uintptr_t)param].mod;
        event.type = SDL_USEREVENT;

        SDL_PushEvent(&event);

        return 25u;
    }
    else
    {
        return 0u;
    }
}

/**
 * Handle a SDL event.
 */
void Window::handle_event(SDL_Event & event)
{
    switch (event.type)
    {
    case SDL_QUIT:
        m_exit_requested = true;
        break;

    case SDL_KEYDOWN:
        if (event.key.repeat == 0)
        {
            Key_Statuses[event.key.keysym.scancode].pressed = true;
            Key_Statuses[event.key.keysym.scancode].timer_id = SDL_AddTimer(200, Key_Repeat, (void *)event.key.keysym.scancode);
            Key_Statuses[event.key.keysym.scancode].mod = event.key.keysym.mod;
            handle_key(event.key.keysym.scancode, event.key.keysym.mod);
        }
        break;

    case SDL_KEYUP:
        Key_Statuses[event.key.keysym.scancode].pressed = false;
        if (Key_Statuses[event.key.keysym.scancode].timer_id != 0)
        {
            SDL_RemoveTimer(Key_Statuses[event.key.keysym.scancode].timer_id);
            Key_Statuses[event.key.keysym.scancode].timer_id = 0;
        }
        break;

    case SDL_WINDOWEVENT:
        switch (event.window.event)
        {
        case SDL_WINDOWEVENT_EXPOSED:
            redraw();
            break;
        case SDL_WINDOWEVENT_RESIZED:
            resize();
            redraw();
            break;
        }
        break;

    case SDL_USEREVENT:
        handle_key((uint32_t)(uintptr_t)event.user.data1,
                (uint32_t)(uintptr_t)event.user.data2);
        break;
    }
}

void Window::handle_key(uint32_t scancode, uint32_t mod)
{
    switch (scancode)
    {
    case SDL_SCANCODE_ESCAPE:
        m_exit_requested = true;
        break;
    case SDL_SCANCODE_J:
        scroll_down();
        break;
    case SDL_SCANCODE_K:
        scroll_up();
        break;
    }
}

void Window::scroll_down()
{
    if ((m_start_piece != m_buffer->piece_table->end_piece) &&
        (m_start_piece->next != m_buffer->piece_table->end_piece))
    {
        m_start_piece = m_start_piece->next;
        redraw();
    }
}

void Window::scroll_up()
{
    if ((m_start_piece != m_buffer->piece_table->start_piece) &&
        (m_start_piece->prev != m_buffer->piece_table->start_piece))
    {
        m_start_piece = m_start_piece->prev;
        redraw();
    }
}

void Window::resize()
{
    SDL_GetWindowSize(m_window, &m_width, &m_height);
    glViewport(0, 0, m_width, m_height);
    m_shaders.text->use();
    m_shaders.text->set_viewport_size(m_width, m_height);
    m_columns = m_width / m_font.get_advance();
    if (m_columns < 1)
        m_columns = 1;
    m_rows = (m_height + m_font.get_line_height() - 1) / m_font.get_line_height();
}

void Window::redraw()
{
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

    m_shaders.text->use();

    int advance = m_font.get_advance();
    int line_height = m_font.get_line_height();
    int x = 0;
    int y = m_height - line_height;
    for (PieceTable::Piece * piece = m_start_piece;
         piece != m_buffer->piece_table->end_piece;
         piece = piece->next)
    {
        for (int i = 0, len = piece->length; i < len; i++)
        {
            uint8_t c = piece->start[i];
            auto g = m_font.get_glyph(c);
            m_shaders.text->set_position(x, y);
            g->render();
            if ((i + 1) % m_columns == 0)
            {
                y -= line_height;
                x = 0;
            }
            else
            {
                x += advance;
            }
        }
        if (piece->eol())
        {
            y -= line_height;
            x = 0;
        }
        if (y + line_height < 0)
        {
            break;
        }
    }

    SDL_GL_SwapWindow(m_window);
}