#include "Draw.h"

namespace NB{

DrawError::DrawError(
    const std::string& msg,
    const std::string& file,
    int line) : std::runtime_error(NB::formatDebugString(msg, file, line)) {}

uint8_t VerticesFromPrimitives(GLenum type, unsigned int num_prims) {
    switch(type) {
    case GL_POINTS:
        return num_prims;
    case GL_LINES:
        return num_prims*2;
        break;
    case GL_LINE_STRIP:
        return num_prims+1;
        break;
    case GL_LINE_LOOP:
        return num_prims;
        break;
    case GL_TRIANGLES:
        return num_prims*3;
        break;
    case GL_TRIANGLE_STRIP:
    case GL_TRIANGLE_FAN:
        return num_prims+2;
        break;
    case GL_QUADS:
        return 4*num_prims;
        break;
    case GL_QUAD_STRIP:
        return 2*num_prims+2;
        break;
    default:
        return num_prims;
        break;
    }
}

uint8_t PrimitivesFromVertices(GLenum type, unsigned int num_verts) {
    switch(type) {
    case GL_POINTS:
        return num_verts;
    case GL_LINES:
        return num_verts/2;
        break;
    case GL_LINE_STRIP:
        return num_verts-1;
        break;
    case GL_LINE_LOOP:
        return num_verts;
        break;
    case GL_TRIANGLES:
        return num_verts/3;
        break;
    case GL_TRIANGLE_STRIP:
    case GL_TRIANGLE_FAN:
        return num_verts-2;
        break;
    case GL_QUADS:
        return num_verts/4;
        break;
    case GL_QUAD_STRIP:
        return num_verts/2 - 1;
        break;
    default:
        return num_verts;
        break;
    }
}


//DrawBuffer class
DrawBuffer::DrawBuffer(const Shader& shader, VertexAttributeList vas, GLenum prim_type)
: _shader(shader), _vert_data(), _elmt_data(), 
_gl_primitive_type(prim_type), _VAO() {
    _VAO.addVBO(&_vert_data);
    _VAO.changeEBO(&_elmt_data);
    try {
        throw _VAO.checkValid(vas);
    } catch (VAOError vaoe) {
        if (vaoe.error) {
            _VAO.addVertexAttributes(DrawBuffer::defaultVAO(vas));
        } else {
            _VAO.addVertexAttributes(vas);
        }
    }
}

VertexAttributeList DrawBuffer::defaultVAO(VertexAttributeList vert_attrs) {
    GLuint vert_id = _vert_data.id();
    unsigned int vert_size = 0;
    for (const VertexAttribute& va : vert_attrs) {
        vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
    }
    unsigned int curr_byte = 0;
    for (VertexAttribute& va : vert_attrs) {
        va.ptr.buffer = vert_id;
        va.ptr.stride = vert_size;
        va.ptr.offset = curr_byte;
        va.ptr.divisor = 0;
        curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
    }
    return vert_attrs;
}

VertexAttributeList DrawBuffer::changeVertLayout(unsigned int i, VertexAttributePointer vap) {
    GLuint vert_id = _vert_data.id();
    vap.buffer = (vap.buffer) ? vap.buffer : vert_id;
    VertexAttributeList vas = _VAO.getLayout();
    unsigned int idx = 0;
    for (const VertexAttribute& va : vas) {
        if (va.ptr.buffer == vert_id) {
            if (idx == i) {
                return _VAO.changeLayout(i, vap);
            }
            idx++;
        }
    }
    THROW_DRAW_ERROR("Could not find vertex attribute with index " + std::to_string(i));
}

unsigned int DrawBuffer::vertSize() const { return _VAO.vertSize(_vert_data.id()); }

void DrawBuffer::draw() const {
    _shader.use();
    _VAO.bind();
    glDrawElements(_gl_primitive_type, _elmt_data.capacity(), GL_UNSIGNED_INT, 0);
    _VAO.unbind();
}

const Shader DrawBuffer::shader() const {
    return _shader;
}

bool DrawBuffer::keepLocalElement() const { return _elmt_data.keepLocal(); }

bool DrawBuffer::keepLocalVertex() const { return _vert_data.keepLocal(); }

unsigned int DrawBuffer::elementBufferID() const { return _elmt_data.id(); }

unsigned int DrawBuffer::vertexBufferID() const { return _vert_data.id(); }

bool DrawBuffer::keepLocalElement(bool keep) { return _elmt_data.keepLocal(keep); }

bool DrawBuffer::keepLocalVertex(bool keep) { return _vert_data.keepLocal(keep); }

const Shader DrawBuffer::shader(const Shader& new_shader) {
    _shader = new_shader;
    return _shader;
}

void DrawBuffer::generateEBO(unsigned int num_prims) {
    generateEBO(std::vector<unsigned int>(VerticesFromPrimitives(_gl_primitive_type, num_prims)));
}

void DrawBuffer::generateEBO(const std::vector<unsigned int>& elements) {
    _num_prims = PrimitivesFromVertices(_gl_primitive_type, elements.size());
    _elmt_data.keepLocal(false);
    _elmt_data.setData(elements);
}

void DrawBuffer::generateVBO(unsigned int num_verts) {
    generateVBO(RawVec(num_verts * vertSize()));
}

void DrawBuffer::generateVBO(const RawVec& vert_data) {
    // Check for uninitialized Vertex Pointers. If so, will fallback to default VAO setup.
    // Otherwise, set VAO to provided Vertex Atributes.
    int vert_size = vertSize();
    if (vert_data.size() % vert_size != 0) {
        THROW_DRAW_ERROR("Initializing data does not match vertex size of " + std::to_string(vert_size) + ".");
    }
    _num_verts = vert_data.size() / vert_size;
    // TODO: Make it not static draw all the time

    _VAO.bind();
    _vert_data.keepLocal(false);
    _vert_data.setData(vert_data);
    _VAO.unbind();
}

void DrawBuffer::loadEBO(const std::vector<unsigned int>& elements, unsigned int offset) {
    _VAO.bind();
    if (!_elmt_data.isInitialized()) {
        std::vector<unsigned int> init_elmts(elements);
        init_elmts.insert(init_elmts.cbegin(), offset, 0);
        generateEBO(init_elmts);
    } else {
        _elmt_data.setSubData(elements, offset);
    }
    _VAO.unbind();
}

void DrawBuffer::loadVBO(const RawVec& data, unsigned int offset) {
    _VAO.bind();
    if (!_vert_data.isInitialized()) {
        RawVec load_data(offset);
        load_data.insert(load_data.end(), data.begin(), data.end());
        generateVBO(load_data);
    } else {
        try{
            _vert_data.setSubData(data, offset);
        } catch(BufferError& e) {
            THROW_DRAW_ERROR("NB::BufferError in loadVBO:\n\t" + std::string(e.what()));
        }
    }
    _VAO.unbind();
}

//DrawInstanceBufferClass
DrawInstanceBuffer::DrawInstanceBuffer(
    const Shader& shad,
    VertexAttributeList vert_vas,
    VertexAttributeList inst_vas,
    GLenum prim_type
): DrawBuffer(shad, vert_vas, prim_type), _inst_data() {
    _VAO.addVBO(&_inst_data);
    try {
        throw _VAO.checkValid(inst_vas);
    } catch (VAOError vaoe) {
        if (vaoe.error) {
            _VAO.addVertexAttributes(defaultVAO(inst_vas));
        } else {
            _VAO.addVertexAttributes(inst_vas);
        }
    }
}

unsigned int DrawInstanceBuffer::instSize() const { return _VAO.vertSize(_inst_data.id()); }

void DrawInstanceBuffer::generateIBO(unsigned int num_inst) {
    generateIBO(RawVec(instSize() * num_inst));
}

void DrawInstanceBuffer::generateIBO(const RawVec& inst_data) {
    int inst_size = instSize();
    if (inst_data.size() % inst_size != 0) {
        THROW_DRAW_ERROR("Initializing data does not match instance size of " + std::to_string(inst_size) + ".");
    }
    _num_inst = inst_data.size() / inst_size;
    
    _VAO.bind();
    _inst_data.keepLocal(false);
    _inst_data.setData(inst_data);
    _VAO.unbind();
}

void DrawInstanceBuffer::loadIBO(const RawVec& data, unsigned int offset) {
    _VAO.bind();
    if (!_inst_data.isInitialized()) {
        RawVec load_data(offset);
        load_data.insert(load_data.end(), data.begin(), data.end());
        generateIBO(load_data);
    } else {
        try{
            _inst_data.setSubData(data, offset);
        } catch(BufferError& e) {
            THROW_DRAW_ERROR("NB::BufferError in loadIBO:\n\t" + std::string(e.what()));
        }
    }
    _VAO.unbind();
}

VertexAttributeList DrawInstanceBuffer::defaultVAO(VertexAttributeList inst_attrs) {
    GLuint inst_id = _inst_data.id();
    unsigned int vert_size = 0;
    for (const VertexAttribute& va : inst_attrs) {
        vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
    }
    unsigned int curr_byte = 0;
    for (VertexAttribute& va : inst_attrs) {
        va.ptr.buffer = inst_id;
        va.ptr.stride = vert_size;
        va.ptr.offset = curr_byte;
        va.ptr.divisor = 0;
        curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
    }
    return inst_attrs;
}

VertexAttributeList DrawInstanceBuffer::changeInstanceLayout(unsigned int i, VertexAttributePointer vap) {
    GLuint inst_id = _inst_data.id();
    vap.buffer = (vap.buffer) ? vap.buffer : inst_id;
    VertexAttributeList vas = _VAO.getLayout();
    unsigned int vas_size = vas.size();
    unsigned int inst_idx = 0;
    unsigned int idx = 0;
    for (const VertexAttribute& va : vas) {
        if (va.ptr.buffer == inst_id) {
            if (inst_idx == i) {
                return _VAO.changeLayout(idx, vap);
            }
            inst_idx++;
        }
        idx++;
    }
    THROW_DRAW_ERROR("Could not find instance attribute with index " + std::to_string(i));
}

void DrawInstanceBuffer::draw() const {
    _shader.use();
    _VAO.bind();
    glDrawElementsInstanced(_gl_primitive_type, _elmt_data.capacity(), GL_UNSIGNED_INT, 0, _num_inst);
    _VAO.unbind();
}

}