/* Libraries we use */
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <iostream>
#include "wfobj/WFObj.h"
#include "loadTexture/loadTexture.h"
#include "glslUtil/glslUtil.h"
using namespace std;

/* Some definitions */
#define WIDTH 800
#define HEIGHT 800
#define TITLE "Josh's Wavefront Object Viewer"

enum Locations {
    LOC_POSITION,
    LOC_NORMAL,
    LOC_TEXTURE
};

class Viewer
{
public:
    Viewer(const char * filename);
    void run();

private:
    void initgl();
    void display();
    void setProjection();

    WFObj m_obj;
    GLuint m_list;
    float m_rotationMatrix[16];
    int m_startx, m_starty;
    bool m_dragging;
    float m_dist;
    GLuint m_program;
    GLint m_ambient_loc, m_diffuse_loc, m_specular_loc, m_shininess_loc;
};

static GLuint load_texture(const char *fname)
{
    GLuint id = loadTexture(fname);
    if (id != 0)
    {
        glBindTexture(GL_TEXTURE_2D, id);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    }
    return id;
}

/* The program's main entry point */
int main(int argc, char * argv[])
{
    if (argc < 2)
    {
        cerr << "Usage: " << argv[0] << " <filename>" << endl;
        return -1;
    }

    if (SDL_Init(SDL_INIT_VIDEO))
    {
        printf("Failed to initialize SDL!\n");
        return -2;
    }

    atexit(SDL_Quit);

    SDL_Surface * screen;
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    if (!(screen = SDL_SetVideoMode(WIDTH, HEIGHT, 32, SDL_OPENGL)))
    {
        printf("Failed to set video mode!\n");
        SDL_Quit();
        return -3;
    }
    SDL_WM_SetCaption(TITLE, TITLE);

    Viewer v(argv[1]);
    v.run();

    return 0;
}

Viewer::Viewer(const char * filename)
{
    m_dist = 5.0;
    m_dragging = false;
    if (!m_obj.load(filename, NULL, load_texture))
    {
        cerr << "Error loading " << filename << endl;
        exit(1);
    }

    const static guAttribBinding bindings[] = {
        {LOC_POSITION, "pos"},
        {LOC_NORMAL, "normal"},
        {0, NULL}
    };
    m_program = guMakeProgramFromFiles("v_shader.glsl", "f_shader.glsl",
            bindings);
    if (m_program == 0)
    {
        exit(1);
    }

    guUniformLocation uniforms[] = {
        {&m_ambient_loc, "ambient"},
        {&m_diffuse_loc, "diffuse"},
        {&m_specular_loc, "specular"},
        {&m_shininess_loc, "shininess"},
        {NULL, NULL}
    };
    guGetUniformLocations(m_program, uniforms);
    if (m_ambient_loc < 0 || m_diffuse_loc < 0 || m_specular_loc < 0
            || m_shininess_loc < 0)
    {
        exit(1);
    }

    glUseProgram(m_program);
    glUniform4f(m_ambient_loc, 0.2, 0.2, 0.2, 1.0);
    glUniform4f(m_diffuse_loc, 1.0, 1.0, 1.0, 1.0);
    glUniform4f(m_specular_loc, 1.0, 1.0, 1.0, 1.0);
    glUniform1f(m_shininess_loc, 85.0);

    /* Print out the object's size */
    const float * aabb = m_obj.getAABB();
    cout << "Object width:  " << (aabb[3]-aabb[0]) << endl;
    cout << "Object depth:  " << (aabb[4]-aabb[1]) << endl;
    cout << "Object height: " << (aabb[5]-aabb[2]) << endl;
}

void Viewer::initgl()
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glViewport(0, 0, WIDTH, HEIGHT);
    setProjection();
    glLoadIdentity();
    glGetFloatv(GL_MODELVIEW_MATRIX, m_rotationMatrix);
}

void Viewer::setProjection()
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (GLfloat)WIDTH/(GLfloat)WIDTH, 0.01, 10000.0);
//  gluLookAt(0, m_dist, 0, 0, 0, 0, 0, 0, 1);
    glMatrixMode(GL_MODELVIEW);
}

void Viewer::display()
{
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    glLoadIdentity();
    gluLookAt(0, -m_dist, 0, 0, 0, 0, 0, 0, 1);
    glMultMatrixf(m_rotationMatrix);

    m_obj.bindBuffers();
    glUseProgram(m_program);
    glEnableVertexAttribArray(LOC_POSITION);
    glEnableVertexAttribArray(LOC_NORMAL);
    int stride = m_obj.getStride();
    glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE,
            stride, (GLvoid *) m_obj.getVertexOffset());
    glVertexAttribPointer(LOC_NORMAL, 3, GL_FLOAT, GL_FALSE,
            stride, (GLvoid *) m_obj.getNormalOffset());
    if (m_obj.doTextures())
    {
        glVertexAttribPointer(LOC_TEXTURE, 3, GL_FLOAT, GL_FALSE,
                stride, (GLvoid *) m_obj.getTextureCoordOffset());
    }
    for (map<string, WFObj::Material>::iterator it =
            m_obj.getMaterials().begin();
            it != m_obj.getMaterials().end();
            it++)
    {
        WFObj::Material & m = it->second;
        if (m.flags & WFObj::Material::SHININESS_BIT)
            glUniform1f(m_shininess_loc, m.shininess);
        if (m.flags & WFObj::Material::AMBIENT_BIT)
            glUniform4fv(m_ambient_loc, 1, &m.ambient[0]);
        if (m.flags & WFObj::Material::DIFFUSE_BIT)
            glUniform4fv(m_diffuse_loc, 1, &m.diffuse[0]);
        if (m.flags & WFObj::Material::SPECULAR_BIT)
            glUniform4fv(m_specular_loc, 1, &m.specular[0]);
        if (m.flags & WFObj::Material::TEXTURE_BIT)
        {
            cerr << "error: textured materials not implemented yet" << endl;
        }
        glDrawElements(GL_TRIANGLES, m.num_vertices,
                GL_UNSIGNED_SHORT,
                (GLvoid *) (sizeof(GLushort) * m.first_vertex));
    }
    SDL_GL_SwapBuffers();
}

void Viewer::run()
{
    initgl();
    display();
    SDL_Event event;
    while (SDL_WaitEvent(&event))
    {
        if (event.type == SDL_QUIT)
            break;
        else if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_ESCAPE)
                break;
            if (event.key.keysym.sym == SDLK_q)
                break;
        }
        else if (event.type == SDL_MOUSEBUTTONDOWN)
        {
            if (event.button.button == SDL_BUTTON_LEFT)
            {
                if (event.button.state == SDL_PRESSED)
                {
                    m_dragging = true;
                    m_startx = event.button.x;
                    m_starty = event.button.y;
                }
            }
            else if (event.button.button == 4)
            {
                m_dist *= 0.85;
                if (m_dist < 1.0f)
                    m_dist = 1.0f;
                setProjection();
                display();
            }
            else if (event.button.button == 5)
            {
                m_dist *= 1.2;
                setProjection();
                display();
            }
        }
        else if (event.type == SDL_MOUSEBUTTONUP)
        {
            if (event.button.button == SDL_BUTTON_LEFT)
            {
                m_dragging = false;
            }
        }
        else if (event.type == SDL_MOUSEMOTION)
        {
            if (m_dragging)
            {
                glLoadIdentity();
                glRotatef(event.motion.y - m_starty, 1, 0, 0);
                glRotatef(event.motion.x - m_startx, 0, 0, 1);
                glMultMatrixf(m_rotationMatrix);
                glGetFloatv(GL_MODELVIEW_MATRIX, m_rotationMatrix);
                m_startx = event.motion.x;
                m_starty = event.motion.y;
                display();
            }
        }
    }
}