#include <stdio.h>
#include <stdlib.h>

#include "../include/GL/glew.h"

#include "../include/buffers.h"
#include "../include/global.h"

using namespace VMI;



VertexIL *VMI::saveVertexBuffer(Change *c, Vertex_ *verts, Color *cols) {
    int i, j, t, n = 0, m;
    VertexIL *dest;
    
    dest = (VertexIL *)malloc((c->numDel + c->numMod + 1) * 3 * sizeof(VertexIL));
    
    // Save vertex coordinates and color for deleted triangles
    for (j=0; j<c->numDel; j++) { 
        
        t = c->deleted[j].id;
        
        m = 3 * t;
        
		for (i=0; i<3; i++) {
			dest[n].x = verts[m + i].x;
			dest[n].y = verts[m + i].y;
			dest[n].z = verts[m + i].z;
			dest[n].a = cols[m + i].a;
			dest[n].b = cols[m + i].b;
			dest[n].r = cols[m + i].r;
			dest[n].g = cols[m + i].g;
			n++;
		}
    }
    // Save vertex coordinates for modified triangles
    for (j=0; j<c->numMod; j++) { 
        
        t = c->modified[j].id;
        
        m = 3 * t;
        
		for (i=0; i<3; i++) {
			dest[n].x = verts[m + i].x;
			dest[n].y = verts[m + i].y;
			dest[n].z = verts[m + i].z;
			n++;
		}
    }
    
    return dest;
}

VertexIL *VMI::saveVertexBufferGPU(Change *c) {
    Vertex_ *verts;
	Color *cols;
    VertexIL *dest;
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    // Map the buffer object
	verts = (Vertex_ *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_ONLY);
	
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    // Map the buffer object
	cols = (Color *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_ONLY);
	
	// Update GPU buffers
	dest = saveVertexBuffer(c, verts, cols);
	
	// Unmap buffers
    glBindBuffer(GL_ARRAY_BUFFER_ARB, vertex_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }
    glBindBuffer(GL_ARRAY_BUFFER_ARB, color_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }

    return dest;
}

void VMI::loadVertexBuffer(VertexIL *src, Change *c, Vertex_ *verts, Color *cols) {
    int i, j, t, n = 0, m;

    // Load vertex coordinates and color for deleted triangles
    for (j=0; j<c->numDel; j++) { 
        
        t = c->deleted[j].id;
        
        m = 3 * t;
		
		for (i=0; i<3; i++) {
			verts[m + i].x = src[n].x;
			verts[m + i].y = src[n].y;
			verts[m + i].z = src[n].z;
			cols[m + i].a = src[n].a;
			cols[m + i].b = src[n].b;
			cols[m + i].r = src[n].r;
			cols[m + i].g = src[n].g;
			n++;
		}
    }
    // Load vertex coordinates for modified triangles
    for (j=0; j<c->numMod; j++) { 
        
        t = c->modified[j].id;
        
        m = 3 * t;
		
		for (i=0; i<3; i++) {
			verts[m + i].x = src[n].x;
			verts[m + i].y = src[n].y;
			verts[m + i].z = src[n].z;
			n++;
		}
    }
}

void VMI::loadVertexBufferGPU(VertexIL *src, Change *c) {
	Vertex_ *verts;
	Color *cols;
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    // Map the buffer object
	verts = (Vertex_ *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY);
	
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    // Map the buffer object
	cols = (Color *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY);
	
	// Update GPU buffers
	loadVertexBuffer(src, c, verts, cols);
	
	// Unmap buffers
    glBindBuffer(GL_ARRAY_BUFFER_ARB, vertex_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }
    glBindBuffer(GL_ARRAY_BUFFER_ARB, color_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }
}

void VMI::setupVertexArray(Mesh *mesh, Color *colors)
{
    int i, j, v, n = 0;
    GLubyte r, g, b, a;

    if (buf_vertices != NULL) free(buf_vertices);
    if (buf_colors != NULL) free(buf_colors);

    buf_vertices = (Vertex_ *)malloc(mesh->numTriangles * 3 * sizeof(Vertex_));
    buf_colors = (Color *)malloc(mesh->numTriangles * 3 * sizeof(Color));

    if (buf_vertices == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    if (buf_colors == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    for (i=0; i<mesh->numTriangles; i++) {
		if (mesh->triangles[i].enable == TRUE) {

			r = colors[i].r;
			g = colors[i].g;
			b = colors[i].b;
			a = colors[i].a;
			
			for (j=0; j<3; j++) {
				
				v = mesh->triangles[i].indices[j];
				
				buf_colors[n].r = r;
				buf_colors[n].g = g;
				buf_colors[n].b = b;
				buf_colors[n].a = a;
				buf_vertices[n].x = mesh->vertices[v].x;
				buf_vertices[n].y = mesh->vertices[v].y;
				buf_vertices[n].z = mesh->vertices[v].z;
				n++;
			}
		} else {
			for (j=0; j<3; j++) {
				
				buf_colors[n].r = 0;
				buf_colors[n].g = 0;
				buf_colors[n].b = 0;
				buf_colors[n].a = 0;
				buf_vertices[n].x = 0;
				buf_vertices[n].y = 0;
				buf_vertices[n].z = 0;
				n++;
			}
		}
    }
#ifdef VERTEX_ARRAY
    // Enable the buf_vertices vector
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, buf_colors);
    glVertexPointer(3, GL_FLOAT, 0, buf_vertices);
#endif
}

void VMI::setupVertexBufferObjects(Mesh *mesh, Color *colors) {
    
    setupVertexArray(mesh, colors);
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->numTriangles * 3 * sizeof(Vertex_), buf_vertices, GL_STATIC_DRAW_ARB); //upload data

    glVertexPointer(3, GL_FLOAT, 0,0);
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->numTriangles * 3 * sizeof(Color), buf_colors, GL_STATIC_DRAW_ARB); //upload data
    
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);

    // Enable the vertex array functionality:
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);

	free(buf_vertices);
	buf_vertices = NULL;

    free(buf_colors);
	buf_colors =NULL;
}

void VMI::updateVertexArray(Mesh *mesh, Change *c, Vertex_ *verts, Color * cols)
{
    int i, j, v, t, n;

    // The deleted triangles are now in background color
    for (i=0; i<c->numDel; i++) {
        t = c->deleted[i].id;
		
        n = t * 3;
		
		for (j=0; j<3; j++) {
			cols[n + j].r = 0;
			cols[n + j].g = 0;
			cols[n + j].b = 0;
			cols[n + j].a = 0;
			
			verts[n + j].x = 0;
			verts[n + j].y = 0;
			verts[n + j].z = 0;
		}
    }

    // Update vertex coordinates for modified triangles
    for (i=0; i<c->numMod; i++) {
        t = c->modified[i].id;

        n = t * 3;

		for (j=0; j<3; j++) {
			
			v= mesh->triangles[t].indices[j];
			
			verts[n + j].x = mesh->vertices[v].x;
			verts[n + j].y = mesh->vertices[v].y;
			verts[n + j].z = mesh->vertices[v].z;
		}
    }
}

void VMI::updateVertexBufferObjects(Mesh *mesh, Change *c) {
	Vertex_ *verts;
	Color *cols;
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    // Map the buffer object
	verts = (Vertex_ *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY);

    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    // Map the buffer object
	cols = (Color *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY);

	// Update GPU buffers
    updateVertexArray(mesh, c, verts, cols);

    // Unmap buffers
    glBindBuffer(GL_ARRAY_BUFFER_ARB, vertex_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }
    glBindBuffer(GL_ARRAY_BUFFER_ARB, color_buf);
    if (!glUnmapBufferARB(GL_ARRAY_BUFFER_ARB)) {
        // Handle error case
    }
}

VertexIL *VMI::setupInterleave(Mesh *mesh, Color *colors)
{
    int i, j, v, n = 0;
    GLubyte r, g, b, a;
    VertexIL *interleave = NULL;
    
    interleave = (VertexIL *)malloc(mesh->currentNumTriangles * 3 * sizeof(VertexIL));
    
    if (interleave == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }
    
    for (i=0; i<mesh->numTriangles; i++) {
        
        if (mesh->triangles[i].enable == TRUE) {
			
			r = colors[i].r;
            g = colors[i].g;
            b = colors[i].b;
            a = colors[i].a;
			
			for (j=0; j<3; j++) {
				
				v= mesh->triangles[i].indices[j];
				
				interleave[n].tx = 0.0f;
				interleave[n].ty = 0.0f;
				interleave[n].r = r;
				interleave[n].g = g;
				interleave[n].b = b;
				interleave[n].a = a;
				interleave[n].x = mesh->vertices[v].x;
				interleave[n].y = mesh->vertices[v].y;
				interleave[n].z = mesh->vertices[v].z;
				n++;
			}
        }
    }

    return interleave;
}

void VMI::printInterleave(VertexIL *interleave, int num)
{
    int i;

    printf("\n");
    for (i=0; i<num * 3; i++) {
        printf("Interleave%d (%d, %d, %d ,%d, %f, %f ,%f)\n", i,
            interleave[i].r, interleave[i].g, interleave[i].b, interleave[i].a,
            interleave[i].x , interleave[i].y, interleave[i].z);
    }
}

void VMI::updateAllColorInterleave(VertexIL *interleave, int num, Color *colors)
{
    int i, j, n = 0;
    GLubyte r, g, b, a;
	
    for (i=1; i<=num; i++) { // Triangles start at 1
		
        r = colors[i].r;
        g = colors[i].g;
        b = colors[i].b;
        a = colors[i].a;
		
		for (j=0; j<3; j++) {
			interleave[n].r = r;
			interleave[n].g = g;
			interleave[n].b = b;
			interleave[n].a = a;
			n++;
		}
    }
}

void VMI::updateColorInterleave(VertexIL *interleave, int num, Color *colors, int begin, int end)
{
    int i, n;
    GLubyte r, g, b, a;

    if (end > num) return;

    for (i=begin; i<end; i++) {
        
        n = i * 3;

        r = colors[i].r;
        g = colors[i].g;
        b = colors[i].b;
        a = colors[i].a;

        interleave[n].r = r;
        interleave[n].g = g;
        interleave[n].b = b;
        interleave[n].a = a;

        n++;
        interleave[n].r = r;
        interleave[n].g = g;
        interleave[n].b = b;
        interleave[n].a = a;

        n++;
        interleave[n].r = r;
        interleave[n].g = g;
        interleave[n].b = b;
        interleave[n].a = a;
    }
}

void VMI::fillColorInterleave(VertexIL *interleave, int num, int begin, int end, GLubyte color)
{
    int i, n;

    if (end > num) return;

    for (i=begin; i<end; i++) {
        
        n = i * 3;
        interleave[n].r = color;
        interleave[n].g = color;
        interleave[n].b = color;
        interleave[n].a = color;

        n++;
        interleave[n].r = color;
        interleave[n].g = color;
        interleave[n].b = color;
        interleave[n].a = color;

        n++;
        interleave[n].r = color;
        interleave[n].g = color;
        interleave[n].b = color;
        interleave[n].a = color;
    }
}