#include "Graphics.hh"
#include "GameState.hh"
#include <cmath>
#include <sstream>

Graphics::Graphics (Engine &engine, GameState &state, PixelCoordinate resolution, bool fullscreen) :
    CL_DisplayWindow(GRAPHICS_WINDOW_TITLE, resolution.x, resolution.y, fullscreen),
    engine(engine), 
    state(state), 
    resolution(resolution),
    update_timer(GRAPHICS_UPDATE_INTERVAL_MS),
    input(get_ic()->get_keyboard()),
    simple_font("Font2", engine.getResourceManager()) 
{

    // connect timer signal
    slots.connect(update_timer.sig_tick(), this, &Graphics::on_update);

    // enable
    update_timer.start();
}

const std::vector<CL_DisplayMode> & Graphics::getDisplayModes (void) {
    return CL_DisplayMode::get_display_modes();
}

const CL_DisplayMode Graphics::getBestMode (void) {
    const std::vector<CL_DisplayMode> &modes = Graphics::getDisplayModes();

    const CL_DisplayMode *best_mode = NULL;
    
    for (std::vector<CL_DisplayMode>::const_iterator it = modes.begin(); it != modes.end(); it++)
        if (best_mode == NULL || (
                it->get_resolution().width * it->get_resolution().height > 
                best_mode->get_resolution().width * best_mode->get_resolution().height    
        ))
            best_mode = &*it;
    
    if (best_mode == NULL)
        throw Error("No available video modes!");
    
    return *best_mode;
}

void Graphics::check_input (void) {
    LocalPlayer *player;
    PlayerInput input_mask;
    TimeMS input_dt;
    
    // update gui flags
    handle_input(input.readGuiInput());

    // stop here if we don't have a local player
    if ((player = state.getLocalPlayer()) == NULL)
        return;
    
    // build input_mask
    input.readPlayerInput(input_mask, input_dt);
    
    // apply input if there was any
    if (input_mask)
        player->handleInput(input_mask, input_dt);
}
    
void Graphics::handle_input (GuiInput flags) {
    // update flags
    this->flags = flags;

    // quit?
    if (flags & GUI_INPUT_QUIT) {
        engine.stop();

        return;
    }

    // dump player debug info on stderr
    if ((flags & GUI_INPUT_DEBUG_PLAYER) && state.getLocalPlayer())
        state.getLocalPlayer()->printDebugInfo();
    
    // toggle fullscreen?
    if (flags & GUI_INPUT_TOGGLE_FULLSCREEN) {
        if (is_fullscreen())
            set_windowed();
        else
            set_fullscreen();
    }
}

static PixelDimension value_between (PixelDimension low, PixelDimension value, PixelDimension high) {
    if (high < low)
        return (high + low) / 2;

    else if (value < low)
        return low;

    else if (value > high)
        return high;

    else
        return value;
}

void Graphics::do_redraw (void) {
    CL_GraphicContext *gc = get_gc();
    LocalPlayer *player;

    // calculate camera
    PixelCoordinate camera(0, 0);
    
    // ...to track our local player
    if ((player = state.getLocalPlayer()) != NULL) {
        // try and center the screen on the player
        PixelCoordinate target = player->getCoordinate() - PixelCoordinate(resolution.x / 2, (resolution.y - 100) / 2);

        // ...but keep the world in view
        PixelCoordinate max = state.world.getDimensions() - resolution + PixelCoordinate(0, 100);
        
        // ...by limiting the value to 0...max
        camera = PixelCoordinate(
            value_between(0, target.x, max.x),
            value_between(0, target.y, max.y)
        );
    }
    
    // Black background
    gc->clear(CL_Color::black);

    // Draw the game
    state.draw(this, camera, flags & GUI_INPUT_DISPLAY_WEAPON);

    if (player != NULL) {
        // draw player info box
        draw_player_info(gc, player);
    }

    // Flip window buffer, sync
    flip(1);
}

void Graphics::on_update (TimeMS tick_length) {
    (void) tick_length;

    // check keyboard input
    check_input();

    // redraw display
    do_redraw();
}

void Graphics::draw_player_info(CL_GraphicContext *gc, Player *p) {
    int box_top = resolution.y - 100;
    int box_left = 0;
    int box_right = resolution.x;
    int box_bottom = resolution.y;
    int bar_length = 3; // *100

    // draw status info at bottom of display
    gc->fill_rect(
        CL_Rect(
            box_left,
            box_top,
            box_right,
            box_bottom
        ),
        CL_Gradient(
            CL_Color(0, 0, 0),
            CL_Color(50, 50, 50),
            CL_Color(50, 50, 50, 150),
            CL_Color(100, 100, 100, 200)
        )
    );
    
    // Health
    gc->draw_rect(
        CL_Rect(
            box_left + 9,
            box_top + 9,
            box_left + 11 + 100 * bar_length,
            box_top + 31
        ),
        CL_Color(150, 150, 150)
    );

    gc->fill_rect(
        CL_Rect(
            box_left + 10,
            box_top + 10,
            box_left + 10 + (int) (p->getHealthPercent() * bar_length),
            box_top + 30
        ),
        CL_Gradient(
            CL_Color(200, 0, 0),
            CL_Color(200 - (int)(p->getHealthPercent() * 2), (int)(p->getHealthPercent() * 2), 0),
            CL_Color(200, 0, 0),
            CL_Color(200 - (int)(p->getHealthPercent() * 2), (int)(p->getHealthPercent() * 2), 0)
        )
    );

    // stats - kills
    std::stringstream sskills;
    sskills << "Kills:  " << p->getKills();
    getSimpleFont().draw(
        box_left + 20 + 100 * bar_length,
        box_top + 10,
        sskills.str(),
        get_gc()
    );
    
    // stats - deaths
    std::stringstream ssdeaths;
    ssdeaths << "Deaths:  " << p->getDeaths();
    getSimpleFont().draw(
        box_left + 20 + 100 * bar_length,
        box_top + 30,
        ssdeaths.str(),
        get_gc()
    );
    
    // stats - ratio
    std::stringstream ssratio;
    ssratio << "Ratio:  " << (p->getKills()+1) / (p->getDeaths()+1);
    getSimpleFont().draw(
        box_left + 20 + 100 * bar_length,
        box_top + 50,
        ssratio.str(),
        get_gc()
    );
    

    // Weapon clip / reloading
    gc->draw_rect(
        CL_Rect(
            box_left + 9,
            box_top + 69,
            box_left + 11 + 100 * bar_length,
            box_top + 91
        ),
        CL_Color(150, 150, 150)
    );

    gc->fill_rect(
        CL_Rect(
            box_left + 10,
            box_top + 70,
            box_left + 10 + (100 - (int) (p->getCurrentWeapon()->getReloadTimer() * 100 / p->getCurrentWeapon()->getReloadTime())) * bar_length,
            box_top + 90
        ),
        CL_Gradient(
            CL_Color(100, 100, 0),
            CL_Color(100, 100, 0),
            CL_Color(100, 100, 0),
            CL_Color(100, 100, 100)
        )
    );
   
    // current weapon name
    getSimpleFont().draw(
        box_left + 20 + 100 * bar_length,
        box_top + 70,
        p->getCurrentWeapon()->getName(),
        get_gc()
    );
}