//
//  Cube.cpp
//  interface
//
//  Created by Philip on 12/31/12.
//  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
//

#include "VoxelSystem.h"
#include <AgentList.h>

const int MAX_VOXELS_PER_SYSTEM = 500000;

const int VERTICES_PER_VOXEL = 8;
const int VERTEX_POINTS_PER_VOXEL = 3 * VERTICES_PER_VOXEL;
const int COLOR_VALUES_PER_VOXEL = 3 * VERTICES_PER_VOXEL;
const int INDICES_PER_VOXEL = 3 * 12;

const float CUBE_WIDTH = 0.025f;

float identityVertices[] = { -1, -1, 1,
                            1, -1, 1,
                            1, -1, -1,
                            -1, -1, -1,
                            1, 1, 1,
                            -1, 1, 1,
                            -1, 1, -1,
                            1, 1, -1 };

GLubyte identityIndices[] = { 0,1,2, 0,2,3,
                              0,4,1, 0,4,5,
                              0,3,6, 0,5,6,
                              1,2,4, 2,4,7,
                              2,3,6, 2,6,7,
                              4,5,6, 4,6,7 };

VoxelSystem::VoxelSystem() {
    voxelsRendered = 0;
}

VoxelSystem::~VoxelSystem() {    
    delete[] verticesArray;
    delete[] colorsArray;
}

void VoxelSystem::parseData(void *data, int size) {
    // ignore the first char, it's a V to tell us that this is voxel data
    char *voxelDataPtr = (char *) data + 1;

    GLfloat *position = new GLfloat[3];
    GLubyte *color = new GLubyte[3];

    // get pointers to position of last append of data
    GLfloat *parseVerticesPtr = lastAddPointer;
    GLubyte *parseColorsPtr = colorsArray + (lastAddPointer - verticesArray);
    
    int voxelsInData = 0;    
    
    // pull voxels out of the received data and put them into our internal memory structure
    while ((voxelDataPtr - (char *) data) < size) {
        
        memcpy(position, voxelDataPtr, 3 * sizeof(float));
        voxelDataPtr += 3 * sizeof(float);
        memcpy(color, voxelDataPtr, 3);
        voxelDataPtr += 3;
        
        for (int v = 0; v < VERTEX_POINTS_PER_VOXEL; v++) {
            parseVerticesPtr[v] = position[v % 3] + (identityVertices[v] * CUBE_WIDTH);
        }
        
        parseVerticesPtr += VERTEX_POINTS_PER_VOXEL;
        
        for (int c = 0; c < COLOR_VALUES_PER_VOXEL; c++) {
            parseColorsPtr[c] = color[c % 3];
        }
        
        parseColorsPtr += COLOR_VALUES_PER_VOXEL;
      
        
        voxelsInData++;
    }
    
    // increase the lastAddPointer to the new spot, increase the number of rendered voxels
    lastAddPointer = parseVerticesPtr;
    voxelsRendered += voxelsInData;
}

VoxelSystem* VoxelSystem::clone() const {
    // this still needs to be implemented, will need to be used if VoxelSystem is attached to agent
    return NULL;
}

void VoxelSystem::init() {
    // prep the data structures for incoming voxel data
    lastDrawPointer = lastAddPointer = verticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
    colorsArray = new GLubyte[COLOR_VALUES_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
    
    GLuint *indicesArray = new GLuint[INDICES_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
    
    // populate the indicesArray
    // this will not change given new voxels, so we can set it all up now
    for (int n = 0; n < MAX_VOXELS_PER_SYSTEM; n++) {
        // fill the indices array
        int voxelIndexOffset = n * INDICES_PER_VOXEL;
        GLuint *currentIndicesPos = indicesArray + voxelIndexOffset;
        int startIndex = (n * VERTICES_PER_VOXEL);
        
        for (int i = 0; i < INDICES_PER_VOXEL; i++) {
            // add indices for this side of the cube
            currentIndicesPos[i] = startIndex + identityIndices[i];
        }
    }
    
    // VBO for the verticesArray
    glGenBuffers(1, &vboVerticesID);
    glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
    glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
    
    // VBO for colorsArray
    glGenBuffers(1, &vboColorsID);
    glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
    glBufferData(GL_ARRAY_BUFFER, COLOR_VALUES_PER_VOXEL * sizeof(GLubyte) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
    
    // VBO for the indicesArray
    glGenBuffers(1, &vboIndicesID);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDICES_PER_VOXEL * sizeof(GLuint) * MAX_VOXELS_PER_SYSTEM, indicesArray, GL_STATIC_DRAW);
    
    // delete the indices array that is no longer needed
    delete[] indicesArray;
}

void VoxelSystem::render() {
    // check if there are new voxels to draw
    int vertexValuesToDraw = lastAddPointer - lastDrawPointer;
    
    if (vertexValuesToDraw > 0) {
        // calculate the offset into each VBO, in vertex point values
        int vertexBufferOffset = lastDrawPointer - verticesArray;
        
        // bind the vertices VBO, copy in new data
        glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
        glBufferSubData(GL_ARRAY_BUFFER, vertexBufferOffset * sizeof(GLfloat), vertexValuesToDraw * sizeof(GLfloat), lastDrawPointer);
        
        // bind the colors VBO, copy in new data
        glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
        glBufferSubData(GL_ARRAY_BUFFER, vertexBufferOffset * sizeof(GLubyte), vertexValuesToDraw * sizeof(GLubyte), (colorsArray + (lastDrawPointer - verticesArray)));
        
        // increment the lastDrawPointer to the lastAddPointer value used for this draw
        lastDrawPointer += vertexValuesToDraw;
    }

    // tell OpenGL where to find vertex and color information
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    
    glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
    glVertexPointer(3, GL_FLOAT, 0, 0);
    
    glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
    glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
   
    // draw the number of voxels we have
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
    glDrawElements(GL_TRIANGLES, 36 * voxelsRendered, GL_UNSIGNED_INT, 0);
    
    // deactivate vertex and color arrays after drawing
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
    
    // bind with 0 to switch back to normal operation
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

void VoxelSystem::simulate(float deltaTime) {
    
}