#include <GL/glew.h>
#include <GL/glut.h>

/* Using the standard output for fprintf */
#include <iostream>
#include <functional>
#include <memory>

#include "Shader.hpp"
#include "Program.hpp"

#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iterator>
#include <time.h>



GLint attribute_coord3d, attribute_v_color;
GLuint vbo_triangle, vbo_triangle_colors;
std::shared_ptr<cs5400::Program> program;
const int NUM_ITERATIONS = 5;
const int NUM_TRIANGLES = pow(4.0,NUM_ITERATIONS);
int modelDrawn=0;

struct vec3
{
    float x;
    float y;
    float z;

    vec3(float x1, float y1, float z1): x(x1), y(y1), z(z1)
    {}
    vec3():x(0),y(0),z(0)
    {}

    vec3& operator+=(const vec3& other)
    {
        x+=other.x;
        y+=other.y;
        z+=other.z;
    }
    vec3 operator/=(const float)
    {

    }
    vec3 operator+(const vec3& other) const
    {
        return vec3(x+other.x, y+other.y, z+other.z);
    }
    vec3 operator/(const float &denom) const
    {
        return vec3(x/denom, y/denom, z/denom);
    }
    vec3 operator*(const float mult)
    {
        return vec3(x*mult, y*mult, z*mult);
    }
    bool operator<( const vec3 & n ) const
    {
        if(x != n.x)
            return x < n.x;
        else if(y != n.y)
            return y < n.y;
        else if(z != n.z)
            return z < n.z;
        return length() < n.length();
    }
    bool operator==( const vec3 & n ) const
    {
        return x==n.x&&y==n.y&&z==n.z;
    }
    float length() const
    {
        return sqrt(pow(x,2)+pow(y,2)+pow(z,2));
    }
    void Print() const
    {
        std::cout<<"("<<x<<","<<y<<","<<z<<")"<<std::endl;
    }
};

//container for gasket verts
std::vector<vec3> triangle_vertices;
std::vector<vec3> triangle_colors_vec;


float getRandom(float max, float min)
{
    return((float(rand()) / float(RAND_MAX)) * (max - (min))) + (min);
}

float getVectorDistance(vec3 a, vec3 b)
{
    return sqrt(pow((a.x-b.x),2) + pow((a.y-b.y),2) + pow((a.z-b.z),2));
}

vec3 randVector();

struct Triangle
{
    vec3 a;
    vec3 b;
    vec3 c;

    Triangle(vec3 a1, vec3 b1, vec3 c1):a(a1),b(b1),c(c1)
    {}
};

vec3 getMidpoint(const vec3& a, const vec3& b)
{
    const float SCALE = 0.1;

    static std::map<std::pair<vec3,vec3>,vec3> memo;


    auto foundResult = memo.find(std::make_pair(a,b));
    if (foundResult!=memo.end())
    {
        return foundResult->second;
    }

    auto result = (a+b)/2;
    auto variance = 0.1 * getVectorDistance(a,b);
    auto randX = getRandom(result.x + variance, result.x - variance);
    auto randY = getRandom(result.y + variance, result.y - variance);
    auto randZ = getRandom(result.z + variance, result.z - variance);

    result = vec3(randX,randY,randZ);
    memo.insert(std::make_pair(std::make_pair(a,b),result));
    memo.insert(std::make_pair(std::make_pair(b,a),result));
    return result;

}

void makeGasket(Triangle t, int count)
{
    if(count > 0)
    {
        auto d = getMidpoint(t.a,t.b);
        auto e = getMidpoint(t.b,t.c);
        auto f = getMidpoint(t.a,t.c);


        makeGasket(Triangle(t.a,d,f), count - 1);
        makeGasket(Triangle(d,t.b,e), count - 1);
        makeGasket(Triangle(f,d,e), count - 1);
        makeGasket(Triangle(f,e,t.c), count - 1);
    }
    else
    {
        triangle_vertices.push_back(t.a);
        triangle_vertices.push_back(t.b);
        triangle_vertices.push_back(t.c);

    }

}


void createColors()
{
    for(int i=0;i<triangle_vertices.size();i++)
    {
        float random = getRandom(0.5,1.0);
        static std::map<vec3,float> randColor;
        auto foundResult = randColor.find(triangle_vertices[i]);
        if (foundResult!=randColor.end())
        {
            random = foundResult->second;
        }
        else
            randColor.insert(std::make_pair(triangle_vertices[i],random));

        triangle_colors_vec.push_back(vec3(random,random,random));
    }

}


vec3 triangle_verts[15000];
vec3 triangle_colors[15000];

void onDisplay()
{
    srand(time(NULL));
  /* Clear the background as white */
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);
  glCullFace(GL_FRONT);
  glEnable(GL_CULL_FACE);
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  /* Tell OpenGL which program to use*/
  glUseProgram(program->getHandle());

  if(modelDrawn == 0)
  {
        modelDrawn = 1;
        vec3 verts[]=
        {
            vec3(0.0,  1.0, 0.0),
            vec3(0.943,  -0.333, 0.0),
            vec3(-0.471, -0.333, 0.816),
            vec3(-0.471, -0.333, -0.816)

        };

        Triangle initialTri = Triangle(
          verts[0],
          verts[2],
          verts[1]
          );
        Triangle initialTri2 = Triangle(
          verts[0],
          verts[1],
          verts[3]

          );
        Triangle initialTri3 = Triangle(
          verts[0],
          verts[3],
          verts[2]

          );
        Triangle initialTri4 = Triangle(
          verts[1],
          verts[2],
          verts[3]
          );

        makeGasket(initialTri, NUM_ITERATIONS);
        makeGasket(initialTri2, NUM_ITERATIONS);
        makeGasket(initialTri3, NUM_ITERATIONS);
        makeGasket(initialTri4, NUM_ITERATIONS);

        std::copy(triangle_vertices.begin(),triangle_vertices.end(), triangle_verts);

        createColors();


        std::copy(triangle_colors_vec.begin(),triangle_colors_vec.end(), triangle_colors);

  }

    /* Setup vertex data */




    glGenBuffers(1, &vbo_triangle);
    glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle);

    glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_verts), triangle_verts, GL_STATIC_DRAW);
    glEnableVertexAttribArray(attribute_coord3d);




  /* Describe our vertices array to OpenGL (it can't guess its format automatically) */
  glVertexAttribPointer(
    attribute_coord3d, // attribute
    3,                 // number of elements per vertex, here (x,y,z)
    GL_FLOAT,          // the type of each element
    GL_FALSE,          // take our values as-is
    0,                 // no extra data between each position
    0 // vec3er to the C array
  );

  /* Push each element in buffer_vertices to the vertex shader */



  glGenBuffers(1, &vbo_triangle_colors);
  glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle_colors);
  glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_colors), triangle_colors, GL_STATIC_DRAW);


  char* attribute_name = "v_color";
  auto attribute_v_color = glGetAttribLocation(program->getHandle(), attribute_name);
  if (attribute_v_color == -1)
    fprintf(stderr, "Could not bind attribute %s\n", attribute_name);



  glEnableVertexAttribArray(attribute_v_color);
  glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle_colors);
  glVertexAttribPointer(
    attribute_v_color, // attribute
    3,                 // number of elements per vertex, here (r,g,b)
    GL_FLOAT,          // the type of each element
    GL_FALSE,          // take our values as-is
    0,                 // no extra data between each position
    0                  // offset of first element
  );

  glDrawArrays(GL_TRIANGLES, 0, NUM_TRIANGLES*3*4);
  glDisableVertexAttribArray(attribute_v_color);
  glDisableVertexAttribArray(attribute_coord3d);



  /* Display the result */
  glutSwapBuffers();
}

void rotate( int value )
{

    //
    float angle = 0.0175; // 1 degree
    //float angle = glutGet(GLUT_ELAPSED_TIME) / 1000.0 * 0.001;

    float rotation_matrix[] =
    {
        cosf(angle),0,sinf(angle),
        0,1,0,
        -1.0*sinf(angle),0,cosf(angle),

    };
    float rotation_matrix_x[] =
    {
        1,0,0,
        0,cosf(angle),-1.0*sinf(angle),
        0,sinf(angle),cosf(angle),

    };
    float rotation_matrix_z[] =
    {
        cosf(angle),-1.0*sin(angle),0,
        sinf(angle),cosf(angle),0,
        0,0,1,


    };



    vec3 tempVec;
    for(int i=0;i< triangle_vertices.size();i++)
    {
        tempVec.x = rotation_matrix[0] * triangle_verts[i].x + rotation_matrix[1] * triangle_verts[i].y + rotation_matrix[2] * triangle_verts[i].z;
        tempVec.y = rotation_matrix[3] * triangle_verts[i].x + rotation_matrix[4] * triangle_verts[i].y + rotation_matrix[5] * triangle_verts[i].z;
        tempVec.z = rotation_matrix[6] * triangle_verts[i].x + rotation_matrix[7] * triangle_verts[i].y + rotation_matrix[8] * triangle_verts[i].z;
        triangle_verts[i] = tempVec;
    }
    glutTimerFunc(10, rotate,1);
    glutPostRedisplay();
}



int main(int argc, char* argv[])
{
  /* Glut-related initialising functions */
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
  glutInitWindowSize(640, 480);
  glutCreateWindow("Hello Triangle!");



  /* Extension wrangler initialising */
  GLenum glew_status = glewInit();
  if (glew_status != GLEW_OK)
  {
    fprintf(stderr, "Error: %s\n", glewGetErrorString(glew_status));
    return EXIT_FAILURE;
  }

  /* When all init functions runs without errors,
  the program can initialise the resources */
  try
  {
    program = cs5400::make_program
      (
    cs5400::make_vertexShader("vertex.glsl")
      ,cs5400::make_fragmentShader("fragment.glsl")
      );
    glutDisplayFunc(onDisplay);
    //glutIdleFunc( idle );

    glutTimerFunc(10, rotate,1);
    glutMainLoop();
  }
  catch(std::exception& e)
  {
    std::cerr << e.what();
  }
  return EXIT_SUCCESS;
}