#include "game.h"
#include "math/vector3f.h"
#include "math/vector2f.h"
#include "math/matrix4x4.h"
#include "input.h"
#include "util/util.h"
#include "util/util_time.h"
#include "light.h"
#include "renderer/renderer.h"

/*
    TODO:   Shadows
            Texture Atlases

            improve math package
            repair gui on renderer.c
*/

void LoadResources(game_t* game);
void Draw(game_t* game);
void ProcessInput(game_t* game);
void CleanUp(game_t* game);

int main(int args, char* argv[])
{
    SDL_Init(SDL_INIT_EVERYTHING);

    game_t game;
    game.gameState = RUNNING;
    game.window = Window_Create("Test", WINDOW_WIDTH, WINDOW_HEIGHT);

    if(glewInit() != GLEW_OK)
        Util_FatalError("Glew could no be started!");

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    SDL_GL_SetSwapInterval(0);
    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );

    game.shaderProgram.ID = Shader_CompileShaders("resources/shaders/shader.vert",
                                                  "resources/shaders/shader.frag");

    game.terrainProgram.ID = Shader_CompileShaders("resources/shaders/terrainShader.vert",
                                                   "resources/shaders/terrainShader.frag");
    glUseProgram(game.shaderProgram.ID);

    Camera_Init(&game.camera);

    LoadResources(&game);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    Time_Init();
    Time_SetMaxFramesPerSecond(6000);
    while(game.gameState != EXIT)
    {
        Time_Begin();
        ProcessInput(&game);
        Player_Update(&game.player, game.terrain);
        Draw(&game);

        float FPS = Time_End();

        if( !( Time_GetCountedFrames() % (int)FPS ) ) {
            fprintf(stderr, "FPS: %.4f\n", FPS);
        }
    }

    Window_Destroy(game.window);
    CleanUp(&game);
    SDL_Quit();
    return 0;
}

void CleanUp(game_t* game)
{
    Shape_Free(game->entsShape);
    Texture_Destroy(game->entsTexture);
    Terrain_Destroy(game->terrain);

    Shader_Destroy(game->shaderProgram.ID);
    Shader_Destroy(game->terrainProgram.ID);
    Render_Quit();
}

void LoadResources(game_t* game)
{
    Render_Init();
    Uint32 start = SDL_GetTicks();

    game->entsShape = Shape_MakeCube();
    game->entsTexture = Texture_Create("resources/textures/gato.png");

    Player_Init(&game->player);
    game->player.entity.texture = game->entsTexture;
    game->player.entity.shape = game->entsShape;

    {
        vec3_t position = { 0.0f, 3.0f, 0.0f };
        float rotation[3] = { 0.0f, 45.0f, 45.0f };
        game->ents[0].position = position;
        game->ents[0].rotX = rotation[0];
        game->ents[0].rotY = rotation[1];
        game->ents[0].rotZ = rotation[2];
        game->ents[0].shape = game->entsShape;
        game->ents[0].texture = game->entsTexture;
    }

    {
        vec3_t position = { -400.0f, 0.0f, -400.0f };
        texture_t *blendmap = Texture_Create("resources/textures/blendmap.png");
        TerrainTexturePack pack =
        {
            {
                Texture_Create("resources/textures/soil1.png"),
                Texture_Create("resources/textures/soil2.png"),
                Texture_Create("resources/textures/soil4.png"),
                Texture_Create("resources/textures/soil3.png"),
            }
        };
        game->terrain = Terrain_Create(800, 800, "resources/textures/heightmap.png", blendmap, &pack);
        game->terrain->position = position;
    }

    /* Shader Layouts */

    game->shaderProgram.Texture = Shader_GetUniformLocation(game->shaderProgram.ID, "Texture");
    game->shaderProgram.modelToWorld = Shader_GetUniformLocation(game->shaderProgram.ID, "Matrix_modelToWorld");
    game->shaderProgram.totalTransform = Shader_GetUniformLocation(game->shaderProgram.ID, "Matrix_totalTransform");
    game->shaderProgram.lightPosition = Shader_GetUniformLocation(game->shaderProgram.ID, "lightPosition");
    game->shaderProgram.lightColor = Shader_GetUniformLocation(game->shaderProgram.ID, "lightColor");
    game->shaderProgram.lightAttenuation = Shader_GetUniformLocation(game->shaderProgram.ID, "attenuation");

    game->terrainProgram.modelToWorld = Shader_GetUniformLocation(game->terrainProgram.ID, "Matrix_modelToWorld");
    game->terrainProgram.totalTransform = Shader_GetUniformLocation(game->terrainProgram.ID, "Matrix_totalTransform");
    game->terrainProgram.lightPosition = Shader_GetUniformLocation(game->terrainProgram.ID, "lightPosition");
    game->terrainProgram.lightColor = Shader_GetUniformLocation(game->terrainProgram.ID, "lightColor");
    game->terrainProgram.lightAttenuation = Shader_GetUniformLocation(game->terrainProgram.ID, "attenuation");

    game->terrainProgram.Texture_Background = Shader_GetUniformLocation(game->terrainProgram.ID, "Texture_Background");
    game->terrainProgram.Texture_BlendMap = Shader_GetUniformLocation(game->terrainProgram.ID, "Texture_BlendMap");
    game->terrainProgram.Texture_R = Shader_GetUniformLocation(game->terrainProgram.ID, "Texture_R");
    game->terrainProgram.Texture_G = Shader_GetUniformLocation(game->terrainProgram.ID, "Texture_G");
    game->terrainProgram.Texture_B = Shader_GetUniformLocation(game->terrainProgram.ID, "Texture_B");

    fprintf(stderr, "Loading time: %u (ms)\n", SDL_GetTicks() - start);
}

void Draw(game_t* game)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /*We upload all the light vectors*/
    static light_t diffuseLight[4] =
    {
        { {0.0f, 20.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}, {1.0f, 0.01f, 0.002f} },
        { {10.0f, 20.0f, 0.0f}, {1.0f, 0.0f, 0.0f, 1.0f}, {1.0f, 0.01f, 0.002f} },
        { {20.0f, 20.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 1.0f}, {1.0f, 0.01f, 0.002f} },
        { {30.0f, 20.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 1.0f}, {1.0f, 0.01f, 0.002f} },
    };

    Shader_SetUniformVec3(game->shaderProgram.ID, "World_eyePosition", (float*)&game->camera.position);
    Render_LoadLights(&game->shaderProgram, diffuseLight, 4);

    mat4_t viewMatrix, projectionMatrix, projectedViewMatrix;

    viewMatrix = Camera_GetModelToViewMatrix(&game->camera);
    projectionMatrix = mat4_perspective(60.0f, WINDOW_ASPECT_RATIO, 0.1f, 300.0f);
    projectedViewMatrix = mat4_mul(&projectionMatrix, &viewMatrix);

    Render_DrawEntity(&game->shaderProgram, &projectedViewMatrix, &game->player.entity);
    Render_DrawEntity(&game->shaderProgram, &projectedViewMatrix, &game->ents[0]);

    glUseProgram(game->terrainProgram.ID);

    Shader_SetUniformVec3(game->terrainProgram.ID, "World_eyePosition", (float*)&game->camera.position);
    Render_LoadLights(&game->terrainProgram, diffuseLight, 4);

    Render_DrawTerrain(&game->terrainProgram, &projectedViewMatrix, game->terrain);

    glUseProgram(game->shaderProgram.ID);

    Window_Update(game->window);
}

void ProcessInput(game_t* game)
{
    vec2_t mousePosition;
    SDL_Event e;
    while(SDL_PollEvent(&e))
    {
        switch(e.type)
        {
        case SDL_QUIT:
            game->gameState = EXIT;
            break;

        case SDL_MOUSEMOTION:
            mousePosition = vec2_create(e.motion.x, e.motion.y);
            Camera_MouseUpdate(&game->camera, &mousePosition);
            break;

        case SDL_KEYDOWN:
            Input_PressKey(e.key.keysym.scancode);
            break;

        case SDL_KEYUP:
            Input_ReleaseKey(e.key.keysym.scancode);
            break;
        }

        if(Input_isKeyPressed(SDL_SCANCODE_UP))
            Camera_Move_Foward(&game->camera);

        if(Input_isKeyPressed(SDL_SCANCODE_DOWN))
            Camera_Move_Backward(&game->camera);

        if(Input_isKeyPressed(SDL_SCANCODE_LEFT))
            Camera_Move_Left(&game->camera);

        if(Input_isKeyPressed(SDL_SCANCODE_RIGHT))
            Camera_Move_Right(&game->camera);

        if(Input_isKeyPressed(SDL_SCANCODE_ESCAPE))
            game->gameState = EXIT;
    }
}