/* ----------------------------------------------------------------------------
 * spritebatch.cpp
 *
 * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
 * See file LICENSE for more details
 * ----------------------------------------------------------------------------
 */

#include "spritebatch.hpp"

#include <algorithm>
#include <stdexcept>

namespace yage
{

const int SpriteBatch::NUM_VERTICES;

Glyph::Glyph(GLuint texture, float depth, const Vertex &top_left, const Vertex &top_right, const Vertex &bottom_right, const Vertex &bottom_left) :
	texture_(texture),
	depth_(depth),
	top_left_(top_left),
	top_right_(top_right),
	bottom_right_(bottom_right),
	bottom_left_(bottom_left)
{}

RenderBatch::RenderBatch(GLint offset, GLsizei num_vertices, GLuint texture) :
	num_vertices_(num_vertices),
	offset_(offset),    
	texture_(texture)
{}

SpriteBatch::SpriteBatch()
{}

SpriteBatch::~SpriteBatch()
{
	if(vao_!=0)
		glDeleteVertexArrays(1, &vao_);

	if(vbo_!=0)
		glDeleteVertexArrays(1, &vbo_);
}

void SpriteBatch::init()
{
	createVertexArray();
}

void SpriteBatch::begin()
{
	glyphs_.clear();
	glyph_ptrs_.clear();
	render_batches_.clear();
}

void SpriteBatch::end()
{
	sortGlyphs();
	createRenderBatches();
}

void SpriteBatch::draw(const glm::vec4 &destination_rect, const glm::vec4 &uv_rect, GLuint texture, const Color &color, float depth)
{
	Vertex top_left, top_right, bottom_right, bottom_left;
    
	top_left.color=color;
	top_left.setPosition(destination_rect.x, destination_rect.y+destination_rect.w);
	top_left.setUv(uv_rect.x, uv_rect.y+uv_rect.w);

	top_right.color=color;
	top_right.setPosition(destination_rect.x+destination_rect.z, destination_rect.y+destination_rect.w);
	top_right.setUv(uv_rect.x+uv_rect.z, uv_rect.y+uv_rect.w);

	bottom_right.color=color;
	bottom_right.setPosition(destination_rect.x+destination_rect.z, destination_rect.y);
	bottom_right.setUv(uv_rect.x+uv_rect.z, uv_rect.y);

	bottom_left.color=color;
	bottom_left.setPosition(destination_rect.x, destination_rect.y);
	bottom_left.setUv(uv_rect.x, uv_rect.y);
    
	// deal with fragmenting by creating vector of pointers
	glyphs_.emplace_back(texture, depth, top_left, top_right, bottom_right, bottom_left);
	glyph_ptrs_.push_back(&glyphs_.back());
}

void SpriteBatch::render()
{
	glBindVertexArray(vao_);
	for(auto &&batch : render_batches_)
	{
		glBindTexture(GL_TEXTURE_2D, batch.texture());
		glDrawArrays(GL_TRIANGLES, batch.offset(), batch.num_vertices());
	}
	glBindVertexArray(0);
}

void SpriteBatch::createVertexArray()
{
	if(vao_==0)
	{
		glGenVertexArrays(1, &vao_);
		if(vao_==0)
			throw std::runtime_error("glGenVertexArrays failed");
	}
	// bind vertex array object
	glBindVertexArray(vao_);
    
	if(vbo_==0)
	{
		glGenBuffers(1, &vbo_);
		if(vbo_==0)
			throw std::runtime_error("glGenBuffers failed");
	}
	// bind vertex buffer object
	glBindBuffer(GL_ARRAY_BUFFER, vbo_);

	// enable vertex attribute arrays
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glEnableVertexAttribArray(2);

	// set the vertex attribute pointers
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, position));
	glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), (void *)offsetof(Vertex, color));
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, uv));
	glDrawArrays(GL_TRIANGLES, 0, 6);

	// unbind vertex array object
	glBindVertexArray(0);
}

void SpriteBatch::createRenderBatches()
{
	std::vector<Vertex> vertices;
	if(glyph_ptrs_.empty())
		return;
    
	render_batches_.reserve(glyph_ptrs_.size()*NUM_VERTICES);

	for(int i=0; i<(int)glyph_ptrs_.size(); ++i)
	{
		if(i==0 || (i>0 && (glyph_ptrs_[i]->texture()!=glyph_ptrs_[i-1]->texture())))
			render_batches_.emplace_back(i*NUM_VERTICES, NUM_VERTICES, glyph_ptrs_[i]->texture());
		else
			render_batches_.back().num_vertices_+=NUM_VERTICES;

		vertices.push_back(glyph_ptrs_[i]->bottom_left());
		vertices.push_back(glyph_ptrs_[i]->top_left());
		vertices.push_back(glyph_ptrs_[i]->top_right());
		vertices.push_back(glyph_ptrs_[i]->bottom_left());
		vertices.push_back(glyph_ptrs_[i]->bottom_right());
		vertices.push_back(glyph_ptrs_[i]->top_right());

		// bind vbo
		glBindBuffer(GL_ARRAY_BUFFER, vbo_);
		// orphan the buffer
		glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), nullptr, GL_DYNAMIC_DRAW);
		// upload the data
		glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.size()*sizeof(Vertex), vertices.data());
		// unbind buffer
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	}
}

void SpriteBatch::sortGlyphs()
{
	// sort using introsort or quicksort
	std::sort(glyph_ptrs_.begin(), glyph_ptrs_.end(), [] (Glyph *a, Glyph *b)->bool {
			if(a->depth()==b->depth())
				return a->texture()<b->texture();
			return a->depth()<b->depth();
		});
}

} // yage