#include "camera.h"
#include "engine.h"
#include "loader.h"
#include "matrix.h"
#include "transform.h"
#include "util.h"
#include <cstdio>


// GLOBALS
static Mesh mesh;
static Camera camera;


// PRIVATE PROTOTYPES
static void CheckInputs(uint32_t input);


// PUBLIC FUNCTIONS
int Engine_Init(Engine_Buffer &buffer, char *filename)
{
    int result = LoadMesh(filename, mesh);

    if (result < 0)
    {
        return -1;
    }

    mesh.position.z = 250;

    camera.SetFOV(90.0f, buffer.width, buffer.height);

    return 0;
}

void Engine_Render(Engine_Buffer &buffer, uint32_t input)
{
    CheckInputs(input);

    Matrix tTranslate = Transform_Translate(
            mesh.position.x, mesh.position.y, mesh.position.z);

    Matrix tRotate = Transform_Rotate(
            mesh.rotation[0], mesh.rotation[1], mesh.rotation[2]);

    Matrix tScale = Transform_Scale(
            mesh.scale);

    Matrix tView = Transform_View(
            camera.position, camera.rotation);

    Matrix tPersp = Transform_Perspective(
            camera.xZoom, camera.yZoom, camera.nearClip, camera.farClip);

    for (size_t v = 0; v < mesh.verts.size(); ++v)
    {
        mesh.vertsTransformed[v] =
            mesh.verts[v] * tScale * tRotate * tTranslate * tView * tPersp;

        mesh.vertsTransformed[v] =
            mesh.vertsTransformed[v] / mesh.vertsTransformed[v].w;
    }

    Matrix tScreen = Transform_Screen(camera.xScale, camera.yScale);

    for (size_t v = 0; v < mesh.verts.size(); ++v)
    {
        mesh.vertsTransformed[v] = mesh.vertsTransformed[v] * tScreen;
    }

    for(size_t f = 0; f < mesh.faces.size(); ++f)
    {
        unsigned int v0 = mesh.faces[f].vertIndex[0];
        unsigned int v1 = mesh.faces[f].vertIndex[1];
        unsigned int v2 = mesh.faces[f].vertIndex[2];
    }
}

void Engine_Shutdown(void)
{
}


// PRIVATE FUNCTIONS
static void CheckInputs(uint32_t input)
{
    if (CHECK_BIT(input, TRANSLATE_X_POS))
    {
        mesh.position.x += 10;
    }
    else if (CHECK_BIT(input, TRANSLATE_X_NEG))
    {
        mesh.position.x -= 10;
    }

    if (CHECK_BIT(input, TRANSLATE_Z_POS))
    {
        mesh.position.z += 10;
    }
    else if (CHECK_BIT(input, TRANSLATE_Z_NEG))
    {
        mesh.position.z -= 10;
    }

    if (CHECK_BIT(input, TRANSLATE_Y_POS))
    {
        mesh.position.y += 10;
    }
    else if (CHECK_BIT(input, TRANSLATE_Y_NEG))
    {
        mesh.position.y -= 10;
    }

    if (CHECK_BIT(input, ROTATE_X_POS))
    {
        mesh.rotation[0] += .10;
    }
    else if (CHECK_BIT(input, ROTATE_X_NEG))
    {
        mesh.rotation[0] -= .10;
    }

    if (CHECK_BIT(input, ROTATE_Z_POS))
    {
        mesh.rotation[1] += .10;
    }
    else if (CHECK_BIT(input, ROTATE_Z_NEG))
    {
        mesh.rotation[1] -= .10;
    }

    if (CHECK_BIT(input, ROTATE_Y_POS))
    {
        mesh.rotation[2] += .10;
    }
    else if (CHECK_BIT(input, ROTATE_Y_NEG))
    {
        mesh.rotation[2] -= .10;
    }

    if (CHECK_BIT(input, SCALE_UP))
    {
        mesh.scale += 0.1f;
    }
    else if (CHECK_BIT(input, SCALE_DOWN))
    {
        mesh.scale -= 0.1f;
    }
}