#include "renderer_polygon_3d.hpp"

#include <iostream>

#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/euler_angles.hpp>

namespace endofthejedi {
    void RendererPolygon3d::setup()
    {
        std::cout<<"setup polygon 3d" << std::endl;

        //m_missileModel = new PolygonModel("../data/mesh/quad_screen_coords.stl");

        addModel("../data/mesh/small_atomic_bomb.stl", &m_missileModel);
        //addModel("../data/mesh/planet_128.stl",        &m_planetModel);
        addModel("../data/mesh/planet_12.stl",         &m_planetModel);
        addModel("../data/mesh/ship.stl",              &m_shipModel);

        size_t n = 10;

        m_particles = new ParticleBatch(n, 0.01);

        for (size_t i=0; i<n; i++) {
            m_particles->setParticle(
                    i,
                    glm::vec2(i/(float) n, 0.0),
                    glm::vec2(1.0, 1.0),
                    0.0,
                    0.0);
        }

        m_particles->upload();

        std::string vss_simple =
            "#version 120\n"
            "varying vec3 vertex;\n"
            "void main()\n"
            "{\n"
            "  gl_Position = gl_Vertex;\n"
            "  vertex = gl_Position.xyz;\n"
            "}\n"
            ;

        std::string fss_simple =
            "#version 120\n"
            "varying vec3 vertex;\n"
            "void main()\n"
            "{\n"
            "  gl_FragColor = vec4(0.5+0.5*vertex.xyz, 1.0);\n"
            "}\n"
            ;

        std::string vss_game_objects =
            "#version 120\n"
            "varying vec3 vertex;\n"
            "uniform mat4 model;\n"
            "void main()\n"
            "{\n"
            //"  vec3 p = position + scale*gl_Vertex.xyz;\n"
            "  vec3 p = (model*gl_Vertex).xyz;\n"
            "  gl_Position = vec4(p, 1.0);\n"
            "  vertex = p.xyz;\n"
            "}\n"
            ;

        std::string fss_game_objects =
            "#version 120\n"
            "varying vec3 vertex;\n"
            "uniform vec3 color;\n"
            "void main()\n"
            "{\n"
            //"  gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
            //"  gl_FragColor = vec4(0.5+0.5*vertex.xyz, 1.0);\n"
            "  gl_FragColor = vec4(color, 1.0);\n"
            "}\n"
            ;

        m_shader.init();

#if 0
        (void) vss_game_objects;
        (void) fss_game_objects;
        m_shader.load(vss_simple.c_str(), GL_VERTEX_SHADER);
        m_shader.load(fss_simple.c_str(), GL_FRAGMENT_SHADER);
#else
        (void) vss_simple;
        (void) fss_simple;
        m_shader.load(vss_game_objects.c_str(), GL_VERTEX_SHADER);
        m_shader.load(fss_game_objects.c_str(), GL_FRAGMENT_SHADER);
#endif
    }

    void RendererPolygon3d::render(const game::State *state)
    {
        glClearColor(0.0, 0.0, 0.0, 1.0);

        m_state = state;

        m_shader.bind();

        // TODO :Z?

        renderPlanets();
        renderShips();
        renderMissiles();

        //renderParticles();

        //glColor3f(1.0, 0.0, 0.0);
        //glBegin(GL_QUADS);
        //glVertex2f(-1.0f, -1.0f);
        //glVertex2f(1.0f, -1.0f);
        //glVertex2f(1.0f, 1.0f);
        //glVertex2f(-1.0f, 1.0f);
        //glEnd();
    }

    void RendererPolygon3d::renderParticles()
    {
        //m_particles->bind();
        m_particles->render();
    }

    void RendererPolygon3d::renderPlanets()
    {
        m_planetModel->bind();

        for (const game::Planet *planet : m_state->planets) {
            glm::mat4 model = computeModelMatrix(planet);
            glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));

            glm::vec3 c = glm::vec3(0.7, 0.2, 0.1);
            glUniform3f(m_shader.location("color"),    c.x, c.y, c.z);

            m_planetModel->render();
        }
    }

    void RendererPolygon3d::renderMissiles()
    {
        m_missileModel->bind();

        for (const game::Player *player : m_state->players) {
            for (const game::Missile *missile : player->missiles) {
                glm::vec3 c = glm::vec3(1.0, 1.0, 0.3);
                glUniform3f(m_shader.location("color"),    c.x, c.y, c.z);

                glm::mat4 model = computeModelMatrix(missile);
                glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));

                m_missileModel->render();
            }
        }
    }

    void RendererPolygon3d::renderShips()
    {
        m_shipModel->bind();

        for (const game::Ship *ship : m_state->ships) {
            glm::mat4 model = computeModelMatrix(ship);
            glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));

            glm::vec3 c = glm::vec3(0.1, 1.0, 0.2);
            glUniform3f(m_shader.location("color"),    c.x, c.y, c.z);

            m_shipModel->render();
        }
    }

    void RendererPolygon3d::addModel(const std::string &filename, PolygonModel **dest)
    {
        //std::cout<<"adding a model: " << filename << std::endl;

        *dest = new PolygonModel(filename);
        if (!(*dest)->import()) {
            std::cout<<"error: failed to load needed model!!!" << std::endl << std::endl;
            exit(-1);
        }

        (*dest)->uploadToOpenGl();

        m_models.push_back(*dest);
    }

    glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Planet *planet)
    {
        return computeModelMatrix(planet->position, planet->radius);
    }

    glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Missile *missile)
    {
        glm::vec2 vn = glm::normalize(missile->velocity);
        float a = std::atan2(vn.y, vn.x);

        // TODO: which visual size has the rocket? in game its just a point with
        // no size because all others have size.
        return computeModelMatrix(missile->position, 0.02f, a);
    }

    glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Ship *ship)
    {
        // TODO: rotate them before shooting, that looks better
        return computeModelMatrix(ship->position, m_state->shipRadius());
    }

    glm::mat4 RendererPolygon3d::computeModelMatrix(const glm::vec2 &pos, float scale, float angle)
    {
        // init as identity matrix
        glm::mat4 model;

        model = glm::translate(model, glm::vec3(pos, 0.0));

        if (scale != 1.0) {
            model = glm::scale(model, glm::vec3(scale));
        }

        if (angle != 0.0) {
            model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));
        }

        return model;
    }
}