#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_shaders.flat = std::make_shared<FlatShader>();

    GLint cursor_bounds[] = {0, 0,
        m_font.get_advance(), 0,
        m_font.get_advance(), m_font.get_line_height(),
        0, m_font.get_line_height()};
    m_cursor_array = glcxx::Array::create();
    m_cursor_array->bind();
    m_cursor_buffer = glcxx::Buffer::create(GL_ARRAY_BUFFER, GL_STATIC_DRAW,
            cursor_bounds, sizeof(cursor_bounds));
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_INT, GL_FALSE, 0, 0);

    m_buffer = buffer;
    m_cursor = m_buffer->piece_table->add_cursor();
    m_start_piece = m_buffer->piece_table->start_piece->next;
    m_cursor_row = 0;
    m_scroll_offset = 5;

    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_H:
        cursor_move(CURSOR_LEFT);
        break;
    case SDL_SCANCODE_J:
        cursor_move(CURSOR_DOWN);
        break;
    case SDL_SCANCODE_K:
        cursor_move(CURSOR_UP);
        break;
    case SDL_SCANCODE_L:
        cursor_move(CURSOR_RIGHT);
        break;
    }
}

void Window::cursor_move(int which)
{
    bool success = false;
    int current_row_offset = m_cursor->column / m_columns;
    int row_offset = 0;

    switch (which)
    {
    case CURSOR_LEFT:
        success = m_cursor->go_left(1);
        break;
    case CURSOR_RIGHT:
        success = m_cursor->go_right(1);
        break;
    case CURSOR_UP:
        success = m_cursor->go_up(1, m_cursor->column);
        break;
    case CURSOR_DOWN:
        success = m_cursor->go_down(1, m_cursor->column);
        break;
    }
    if (success)
    {
        switch (which)
        {
        case CURSOR_LEFT:
        case CURSOR_RIGHT:
            row_offset = m_cursor->column / m_columns - current_row_offset;
            break;
        case CURSOR_UP:
            {
                PieceTable::Cursor c = *m_cursor;
                c.go_end_of_line();
                row_offset = m_cursor->column / m_columns - c.column / m_columns - 1 - current_row_offset;
            }
            break;
        case CURSOR_DOWN:
            {
                PieceTable::Cursor c = *m_cursor;
                c.go_up(1, 0u);
                c.go_end_of_line();
                row_offset = c.column / m_columns - current_row_offset + 1 + m_cursor->column / m_columns;
            }
            break;
        }
        update_cursor_row(m_cursor_row + row_offset);
        redraw();
    }
}

void Window::update_cursor_row(int cursor_row)
{
    m_cursor_row = std::max(m_scroll_offset, std::min(m_rows - m_scroll_offset - 1, cursor_row));
}

std::pair<int, PieceTable::Cursor> Window::calculate_start_position()
{
    m_cursor_row = std::min(m_cursor_row, m_rows - 1);
    int row = m_cursor_row - m_cursor->column / m_columns;
    PieceTable::Cursor cursor = *m_cursor;
    cursor.go_start_of_line();
    while (row > 0)
    {
        if (cursor.go_up(1, 0u))
        {
            PieceTable::Cursor c = cursor;
            c.go_end_of_line();
            row -= c.column / m_columns + 1;
        }
        else
        {
            m_cursor_row -= row;
            row = 0;
        }
    }
    return std::pair<int, PieceTable::Cursor>(row, cursor);
}

void Window::draw_text()
{
    auto start_position = calculate_start_position();
    int row = start_position.first;
    PieceTable::Cursor cursor = start_position.second;

    for (;;)
    {
        int row_offset = cursor.column / m_columns;
        int screen_row = row + row_offset;
        if (screen_row >= m_rows)
            break;
        int screen_column = cursor.column % m_columns;
        if (cursor == *m_cursor)
            draw_cursor(screen_column, screen_row);
        if (screen_row >= 0)
        {
            uint32_t character = *cursor;
            if (character != 0xFFFFFFFFu)
                draw_character(screen_column, screen_row, character);
        }
        if (!cursor.go_right(1))
        {
            if (!cursor.go_down(1, 0))
                break;
            row = screen_row + 1;
        }
    }
}

void Window::draw_character(int screen_column, int screen_row, uint32_t character)
{
    m_shaders.text->use();
    int advance = m_font.get_advance();
    int line_height = m_font.get_line_height();
    int x = screen_column * advance;
    int y = m_height - (screen_row + 1) * line_height;
    auto g = m_font.get_glyph(character);
    m_shaders.text->set_position(x, y + m_font.get_baseline_offset());
    g->render();
}

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_shaders.flat->use();
    m_shaders.flat->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);

    draw_text();

    SDL_GL_SwapWindow(m_window);
}

void Window::draw_cursor(int screen_column, int screen_row)
{
    int advance = m_font.get_advance();
    int line_height = m_font.get_line_height();
    int x = screen_column * advance;
    int y = m_height - (screen_row + 1) * line_height;
    m_cursor_array->bind();
    m_shaders.flat->use();
    m_shaders.flat->set_color(1.0, 0.2, 1.0, 1.0);
    m_shaders.flat->set_position(x, y);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}