#include "sdlterm.h"

#include <algorithm>

void ColorMap::index_to_rgb(int index, SDL_Color &color) const

{

    color.r = _map[index][0];

    color.g = _map[index][1];

    color.b = _map[index][2];

}

SDL_Surface *GlyphCache::lookup_glyph(Uint64 id)

{

    auto iter = _glyph_map.find(id);

    if (iter == _glyph_map.end())

    {

        return NULL;

    }

    return iter->second;

}

void GlyphCache::put_glyph(Uint64 id, SDL_Surface *srf)

{

    _glyph_map[id] = srf;

}

void GlyphCache::flush()

{

    for (auto iter = _glyph_map.begin(); iter != _glyph_map.end(); iter++)

    {

        SDL_FreeSurface(iter->second);

    }

    _glyph_map.clear();

}

GlyphRenderer::GlyphRenderer()

 : _font_regular(NULL), _font_bold(NULL), _cell_width(0), _cell_height(0), _cache(), _colormap()

{

    if (TTF_Init() == -1)

    {

        throw SDLTermError(std::string("TTF_Init: ") + TTF_GetError());

    }

}

GlyphRenderer::~GlyphRenderer()

{

    _cache.flush();

    close_font();

    TTF_Quit();

}

void GlyphRenderer::open_font(const char *fname_regular, const char *fname_bold, int ptsize)

{

    close_font();

    // open regular font

    _font_regular = TTF_OpenFont(fname_regular, ptsize);

    if (!_font_regular)

    {

        throw SDLTermError(std::string("TTF_OpenFont: ") + TTF_GetError());

    }

    // open bold font

    _font_bold = TTF_OpenFont(fname_bold, ptsize);

    if (!_font_bold)

    {

        throw SDLTermError(std::string("TTF_OpenFont: ") + TTF_GetError());

    }

    // update metrics for regular font

    int advance;

    if (TTF_GlyphMetrics(_font_regular, 'M', NULL, NULL, NULL, NULL, &advance) == -1)

    {

        throw SDLTermError(std::string("TTF_GlyphMetrics: ") + TTF_GetError());

    }

    _cell_width = advance;

    _cell_height = TTF_FontHeight(_font_regular);

    // read metrics for bold font

    if (TTF_GlyphMetrics(_font_bold, 'M', NULL, NULL, NULL, NULL, &advance) == -1)

    {

        throw SDLTermError(std::string("TTF_GlyphMetrics: ") + TTF_GetError());

    }

    if (advance > _cell_width)

    {

        _cell_width = advance;

    }

    int height = TTF_FontHeight(_font_bold);

    if (height > _cell_height)

    {

        _cell_height = height;

    }

}

void GlyphRenderer::close_font()

{

    if (_font_regular)

    {

        TTF_CloseFont(_font_regular);

        _font_regular = NULL;

    }

    if (_font_bold)

    {

        TTF_CloseFont(_font_bold);

        _font_bold = NULL;

    }

}

SDL_Surface *GlyphRenderer::render_cell(Uint32 ch, Uint32 attr, bool blink_state)

{

    SDL_Surface *cell_surface;

    TTF_Font *font;

    SDL_Color fgcolor, bgcolor;

    // blink affects cache lookup, must be processed first

    if ((attr & Style::BLINK) && !blink_state)

    {

        ch = ' ';

    }

    // try cache

    Uint64 id = (Uint64)ch | (Uint64)attr << 32;

    cell_surface = _cache.lookup_glyph(id);

    if (cell_surface)

    {

        return cell_surface;

    }

    // load attributes

    _colormap.index_to_rgb((attr & 0x000000FF), fgcolor);

    _colormap.index_to_rgb((attr & 0x0000FF00) >> 8, bgcolor);

    font = (attr & Style::BOLD) ? _font_bold : _font_regular;

    if (attr & Style::STANDOUT)

    {

        std::swap(fgcolor, bgcolor);

    }

    // create surface for whole cell and fill it with bg color

    cell_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,

            _cell_width, _cell_height, 32, 0, 0, 0, 0);

    SDL_Rect dst_rect;

    dst_rect.x = 0;

    dst_rect.y = 0;

    dst_rect.w = _cell_width;

    dst_rect.h = _cell_height;

    Uint32 bgcolor_mapped = SDL_MapRGB(cell_surface->format, bgcolor.r, bgcolor.g, bgcolor.b);

    SDL_FillRect(cell_surface, &dst_rect, bgcolor_mapped);

    // render glyph, blit it onto cell surface

    if (ch)

    {

        // when glyph is not provided by BOLD font but is provided by REGULAR font, use that (better than nothing)

        if ((attr & Style::BOLD) && !TTF_GlyphIsProvided(font, ch) && TTF_GlyphIsProvided(_font_regular, ch))

        {

            // use bold style of regular font instead of bold font

            TTF_SetFontStyle(_font_regular, TTF_STYLE_BOLD);

            _render_glyph(cell_surface, _font_regular, ch, fgcolor, bgcolor);

            TTF_SetFontStyle(_font_regular, TTF_STYLE_NORMAL);

        }

        else

        {

            // normal case

            _render_glyph(cell_surface, font, ch, fgcolor, bgcolor);

        }

        if (attr & Style::UNDERLINE)

        {

            // draw underline

            SDL_LockSurface(cell_surface);

            int y = 1 + TTF_FontAscent(font);

            Uint32 fgcolor_mapped = SDL_MapRGB(cell_surface->format, fgcolor.r, fgcolor.g, fgcolor.b);

            Uint32 *p = (Uint32 *)((Uint8 *)cell_surface->pixels + y * cell_surface->pitch);

            for (int x = 0; x < _cell_width; x++)

                *p++ = fgcolor_mapped;

            SDL_UnlockSurface(cell_surface);

        }

    }

    // convert to display format

    SDL_Surface *tmp_surface = cell_surface;

    cell_surface = SDL_DisplayFormat(tmp_surface);

    SDL_FreeSurface(tmp_surface);

    // put to cache

    _cache.put_glyph(id, cell_surface);

    return cell_surface;

}

void GlyphRenderer::_render_glyph(SDL_Surface *cell_surface, TTF_Font *font, Uint32 ch,

        SDL_Color fgcolor, SDL_Color bgcolor)

{

    int minx, maxy;

    SDL_Rect dst_rect;

    SDL_Surface *glyph_surface = TTF_RenderGlyph_Shaded(font, ch, fgcolor, bgcolor);

    TTF_GlyphMetrics(font, ch, &minx, NULL, NULL, &maxy, NULL);

    dst_rect.x = minx;

    dst_rect.y = TTF_FontAscent(font) - maxy;

    SDL_BlitSurface(glyph_surface, NULL, cell_surface, &dst_rect);

    SDL_FreeSurface(glyph_surface);

}

void TerminalScreen::select_font(const char *fname_regular, const char *fname_bold, int ptsize)

{

    _render.open_font(fname_regular, fname_bold, ptsize);

    _reset_cells();

}

void TerminalScreen::resize(int pxwidth, int pxheight)

{

    _screen_surface = SDL_SetVideoMode(pxwidth, pxheight, 0, SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE);

    if (_screen_surface == NULL)

    {

        throw SDLTermError(std::string("SDL_SetVideoMode: ") + SDL_GetError());

    }

    _pixel_width = pxwidth;

    _pixel_height = pxheight;

    _reset_cells();

}

void TerminalScreen::erase()

{

    std::fill(_cells_front.begin(), _cells_front.end(), TerminalCell());

}

void TerminalScreen::putch(int x, int y, Uint32 ch, Uint32 attr)

{

    TerminalCell &cell = _cells_front[y * _width + x];

    cell.ch = ch;

    cell.attr = attr;

}

void TerminalScreen::toggle_cursor(int x, int y)

{

    TerminalCell &cell = _cells_front[y * _width + x];

    cell.attr ^= Style::STANDOUT;

}

void TerminalScreen::commit()

{

    auto front_iter = _cells_front.begin();

    auto back_iter = _cells_back.begin();

    SDL_Surface *cell_surface;

    SDL_Rect dst_rect;

    for (int y = 0; y < _height; y++)

    {

        for (int x = 0; x < _width; x++)

        {

            if (*front_iter != *back_iter)

            {

                dst_rect.x = x * _cell_width;

                dst_rect.y = y * _cell_height;

                cell_surface = _render.render_cell(front_iter->ch, front_iter->attr, _blink_state);

                SDL_BlitSurface(cell_surface, NULL, _screen_surface, &dst_rect);

                *back_iter = *front_iter;

            }

            front_iter++;

            back_iter++;

        }

    }

    SDL_UpdateRect(_screen_surface, 0, 0, 0, 0);

}

void TerminalScreen::redraw()

{

    // clear back buffer, current screen is considered blank

    std::fill(_cells_back.begin(), _cells_back.end(), TerminalCell());

}

void TerminalScreen::_reset_cells()

{

    _cell_width = _render.get_cell_width();

    _cell_height = _render.get_cell_height();

    if (!_cell_width || !_cell_height)

        return;

    _width = _pixel_width / _cell_width;

    _height = _pixel_height / _cell_height;

    if (!_width || !_height)

        return;

    int num_cells = _width * _height;

    _cells_front.resize(num_cells, TerminalCell());

    _cells_back.resize(num_cells);

    redraw();

}

void TerminalScreen::_draw_blink()

{

    // Use back buffer which contains commited changes.

    // This is called from timer while application may draw into front_buffer.

    auto back_iter = _cells_back.begin();

    SDL_Surface *cell_surface;

    SDL_Rect dst_rect;

    for (int y = 0; y < _height; y++)

    {

        for (int x = 0; x < _width; x++)

        {

            // draw only blinking characters

            if (back_iter->attr & Style::BLINK)

            {

                dst_rect.x = x * _cell_width;

                dst_rect.y = y * _cell_height;

                cell_surface = _render.render_cell(back_iter->ch, back_iter->attr, _blink_state);

                SDL_BlitSurface(cell_surface, NULL, _screen_surface, &dst_rect);

            }

            back_iter++;

        }

    }

    SDL_UpdateRect(_screen_surface, 0, 0, 0, 0);

}

Terminal::Terminal()

 : _screen(), _attr(7), _cursor_x(0), _cursor_y(0), _cursor_visible(false),

   _mousemove_last_x(-1), _mousemove_last_y(-1)

{

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) == -1)

    {

        throw SDLTermError(std::string("SDL_Init: ") + SDL_GetError());

    }

    SDL_EnableUNICODE(1);

    SDL_EnableKeyRepeat(250, SDL_DEFAULT_REPEAT_INTERVAL);

    SDL_WM_SetCaption("terminal", NULL);

    SDL_AddTimer(500, _blink_toggle_callback, NULL);

}

Terminal::~Terminal()

{

    SDL_Quit();

}

void Terminal::commit()

{

    if (_cursor_visible)

    {

        _screen.toggle_cursor(_cursor_x, _cursor_y);

        _screen.commit();

        _screen.toggle_cursor(_cursor_x, _cursor_y);

    }

    else

    {

        _screen.commit();

    }

}

bool Terminal::wait_event(Event &event, Uint32 timeout)

{

    // use timer to simulate SDL_WaitEventTimeout, which is not available in SDL 1.2

    SDL_TimerID timer_id = NULL;

    if (timeout)

    {

        timer_id = SDL_AddTimer(timeout, _wait_event_callback, NULL);

    }

    // loop until we have something to return

    SDL_Event sdl_event;

    bool event_ready = false;

    while (SDL_WaitEvent(&sdl_event) && !event_ready)

    {

        switch (sdl_event.type)

        {

            case SDL_USEREVENT:

                // timeout

                if (sdl_event.user.code == 1)

                {

                    SDL_RemoveTimer(timer_id);

                    return false;

                }

                // toggle blink

                if (sdl_event.user.code == 2)

                {

                    _screen.toggle_blink();

                }

                break; // continue loop

            case SDL_QUIT:

                event.type = Event::QUIT;

                event_ready = true;

                break;

            case SDL_VIDEORESIZE:

                event.type = Event::RESIZE;

                _screen.resize(sdl_event.resize.w, sdl_event.resize.h);

                event_ready = true;

                break;

            case SDL_VIDEOEXPOSE:

                _screen.redraw();

                break;

            case SDL_KEYDOWN:

            {

                //switch(event.key.keysym.sym)

                event.type = Event::KEYPRESS;

                const char *keyname = _translate_keyname(sdl_event.key.keysym.sym);

                // return only keyname or unicode, never both

                if (keyname)

                {

                    strncpy(event.key.keyname, keyname, 10);

                    event.key.unicode = 0;

                }

                else

                {

                    event.key.keyname[0] = 0;

                    event.key.unicode = sdl_event.key.keysym.unicode;

                    if (!event.key.unicode)

                        break; // continue loop (unknown key)

                }

                event_ready = true;

                break;

            }

            case SDL_MOUSEBUTTONDOWN:

            case SDL_MOUSEBUTTONUP:

                event.type = (sdl_event.type == SDL_MOUSEBUTTONDOWN) ? Event::MOUSEDOWN : Event::MOUSEUP;

                event.mouse.x = sdl_event.button.x / _screen.get_cell_width();

                event.mouse.y = sdl_event.button.y / _screen.get_cell_height();

                event.mouse.button = sdl_event.button.button;

                if (sdl_event.button.button == SDL_BUTTON_WHEELUP || sdl_event.button.button == SDL_BUTTON_WHEELDOWN)

                {

                    if (sdl_event.type == SDL_MOUSEBUTTONUP)

                        break; // do not report button-up events for mouse wheel

                    event.type = Event::MOUSEWHEEL;

                }

                _mousemove_last_x = -1;

                event_ready = true;

                break;

            case SDL_MOUSEMOTION:

                if (sdl_event.motion.state == 0)

                    break; // continue loop, do not report move events when no button is pressed

                event.type = Event::MOUSEMOVE;

                event.mouse.x = sdl_event.motion.x / _screen.get_cell_width();

                event.mouse.y = sdl_event.motion.y / _screen.get_cell_height();

                if (_mousemove_last_x != event.mouse.x ||

                    _mousemove_last_y != event.mouse.y)

                {

                    _mousemove_last_x = event.mouse.x;

                    _mousemove_last_y = event.mouse.y;

                    event_ready = true;

                    break;

                }

                break; // continue loop when mouse position did not change

            default:

                break; // continue loop

        }

    }

    // remove timer when other event came before timeout

    if (timeout)

    {

        SDL_RemoveTimer(timer_id);

    }

    // ok or error?

    if (event_ready)

    {

        return true;

    }

    else

    {

        throw SDLTermError(std::string("SDL_WaitEvent: ") + SDL_GetError());

    }

}