// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// IndexDataManager.cpp: Defines the IndexDataManager, a class that
// runs the Buffer translation process for index buffers.

#include "IndexDataManager.h"

#include "Buffer.h"
#include "common/debug.h"

#include <string.h>
#include <algorithm>

namespace
{
	enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };
}

namespace es2
{

IndexDataManager::IndexDataManager()
{
	mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);

	if(!mStreamingBuffer)
	{
		ERR("Failed to allocate the streaming index buffer.");
	}
}

IndexDataManager::~IndexDataManager()
{
	delete mStreamingBuffer;
}

void copyIndices(GLenum type, const void *input, GLsizei count, void *output)
{
	if(type == GL_UNSIGNED_BYTE)
	{
		memcpy(output, input, count * sizeof(GLubyte));
	}
	else if(type == GL_UNSIGNED_INT)
	{
		memcpy(output, input, count * sizeof(GLuint));
	}
	else if(type == GL_UNSIGNED_SHORT)
	{
		memcpy(output, input, count * sizeof(GLushort));
	}
	else UNREACHABLE(type);
}

inline GLsizei getNumIndices(const std::vector<GLsizei>& restartIndices, size_t i, GLsizei count)
{
	return restartIndices.empty() ? count :
	       ((i == 0) ? restartIndices[0] : ((i == restartIndices.size()) ? (count - restartIndices[i - 1] - 1) : (restartIndices[i] - restartIndices[i - 1] - 1)));
}

void copyIndices(GLenum mode, GLenum type, const std::vector<GLsizei>& restartIndices, const void *input, GLsizei count, void* output)
{
	size_t bytesPerIndex = 0;
	const unsigned char* inPtr = static_cast<const unsigned char*>(input);
	unsigned char* outPtr = static_cast<unsigned char*>(output);
	switch(type)
	{
	case GL_UNSIGNED_BYTE:
		bytesPerIndex = sizeof(GLubyte);
		break;
	case GL_UNSIGNED_INT:
		bytesPerIndex = sizeof(GLuint);
		break;
	case GL_UNSIGNED_SHORT:
		bytesPerIndex = sizeof(GLushort);
		break;
	default:
		UNREACHABLE(type);
	}

	size_t numRestarts = restartIndices.size();
	switch(mode)
	{
	case GL_TRIANGLES:
	case GL_LINES:
	case GL_POINTS:
	{
		GLsizei verticesPerPrimitive = (mode == GL_TRIANGLES) ? 3 : ((mode == GL_LINES) ? 2 : 1);
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			GLsizei numIndices = getNumIndices(restartIndices, i, count);
			size_t numBytes = (numIndices / verticesPerPrimitive) * verticesPerPrimitive * bytesPerIndex;
			if(numBytes > 0)
			{
				memcpy(outPtr, inPtr, numBytes);
				outPtr += numBytes;
			}
			inPtr += (numIndices + 1) * bytesPerIndex;
		}
	}
		break;
	case GL_TRIANGLE_FAN:
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			GLsizei numIndices = getNumIndices(restartIndices, i, count);
			GLsizei numTriangles = (numIndices - 2);
			for(GLsizei tri = 0; tri < numTriangles; ++tri)
			{
				memcpy(outPtr, inPtr, bytesPerIndex);
				outPtr += bytesPerIndex;
				memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex + bytesPerIndex);
				outPtr += bytesPerIndex + bytesPerIndex;
			}
			inPtr += (numIndices + 1) * bytesPerIndex;
		}
		break;
	case GL_TRIANGLE_STRIP:
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			GLsizei numIndices = getNumIndices(restartIndices, i, count);
			GLsizei numTriangles = (numIndices - 2);
			for(GLsizei tri = 0; tri < numTriangles; ++tri)
			{
				if(tri & 1) // Reverse odd triangles
				{
					memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex);
					outPtr += bytesPerIndex;
					memcpy(outPtr, inPtr + ((tri + 0) * bytesPerIndex), bytesPerIndex);
					outPtr += bytesPerIndex;
					memcpy(outPtr, inPtr + ((tri + 2) * bytesPerIndex), bytesPerIndex);
					outPtr += bytesPerIndex;
				}
				else
				{
					size_t numBytes = 3 * bytesPerIndex;
					memcpy(outPtr, inPtr + (tri * bytesPerIndex), numBytes);
					outPtr += numBytes;
				}
			}
			inPtr += (numIndices + 1) * bytesPerIndex;
		}
		break;
	case GL_LINE_LOOP:
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			GLsizei numIndices = getNumIndices(restartIndices, i, count);
			if(numIndices >= 2)
			{
				GLsizei numLines = numIndices;
				memcpy(outPtr, inPtr + (numIndices - 1) * bytesPerIndex, bytesPerIndex); // Last vertex
				outPtr += bytesPerIndex;
				memcpy(outPtr, inPtr, bytesPerIndex); // First vertex
				outPtr += bytesPerIndex;
				size_t bytesPerLine = 2 * bytesPerIndex;
				for(GLsizei tri = 0; tri < (numLines - 1); ++tri)
				{
					memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
					outPtr += bytesPerLine;
				}
			}
			inPtr += (numIndices + 1) * bytesPerIndex;
		}
		break;
	case GL_LINE_STRIP:
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			GLsizei numIndices = getNumIndices(restartIndices, i, count);
			GLsizei numLines = numIndices - 1;
			size_t bytesPerLine = 2 * bytesPerIndex;
			for(GLsizei tri = 0; tri < numLines; ++tri)
			{
				memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
				outPtr += bytesPerLine;
			}
			inPtr += (numIndices + 1) * bytesPerIndex;
		}
		break;
	default:
		UNREACHABLE(mode);
		break;
	}
}

template<class IndexType>
void computeRange(const IndexType *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex, std::vector<GLsizei>* restartIndices)
{
	*maxIndex = 0;
	*minIndex = MAX_ELEMENTS_INDICES;

	for(GLsizei i = 0; i < count; i++)
	{
		if(restartIndices && indices[i] == IndexType(-1))
		{
			restartIndices->push_back(i);
			continue;
		}
		if(*minIndex > indices[i]) *minIndex = indices[i];
		if(*maxIndex < indices[i]) *maxIndex = indices[i];
	}
}

void computeRange(GLenum type, const void *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex, std::vector<GLsizei>* restartIndices)
{
	if(type == GL_UNSIGNED_BYTE)
	{
		computeRange(static_cast<const GLubyte*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else if(type == GL_UNSIGNED_INT)
	{
		computeRange(static_cast<const GLuint*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else if(type == GL_UNSIGNED_SHORT)
	{
		computeRange(static_cast<const GLushort*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else UNREACHABLE(type);
}

int recomputePrimitiveCount(GLenum mode, GLsizei count, const std::vector<GLsizei>& restartIndices, unsigned int* primitiveCount)
{
	size_t numRestarts = restartIndices.size();
	*primitiveCount = 0;

	unsigned int countOffset = 0;
	unsigned int vertexPerPrimitive = 0;

	switch(mode)
	{
	case GL_TRIANGLES: // 3 vertex per primitive
		++vertexPerPrimitive;
	case GL_LINES: //  2 vertex per primitive
		vertexPerPrimitive += 2;
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			unsigned int nbIndices = getNumIndices(restartIndices, i, count);
			*primitiveCount += nbIndices / vertexPerPrimitive;
		}
		return vertexPerPrimitive;
	case GL_TRIANGLE_FAN:
	case GL_TRIANGLE_STRIP: // (N - 2) polygons, 3 vertex per primitive
		++vertexPerPrimitive;
		--countOffset;
	case GL_LINE_STRIP: // (N - 1) polygons, 2 vertex per primitive
		--countOffset;
	case GL_LINE_LOOP: // N polygons, 2 vertex per primitive
		vertexPerPrimitive += 2;
		for(size_t i = 0; i <= numRestarts; ++i)
		{
			unsigned int nbIndices = getNumIndices(restartIndices, i, count);
			*primitiveCount += (nbIndices >= vertexPerPrimitive) ? (nbIndices + countOffset) : 0;
		}
		return vertexPerPrimitive;
	case GL_POINTS:
		*primitiveCount = static_cast<unsigned int>(count - restartIndices.size());
		return 1;
	default:
		UNREACHABLE(mode);
		return -1;
	}
}

GLenum IndexDataManager::prepareIndexData(GLenum mode, GLenum type, GLuint start, GLuint end, GLsizei count, Buffer *buffer, const void *indices, TranslatedIndexData *translated, bool primitiveRestart)
{
	if(!mStreamingBuffer)
	{
		return GL_OUT_OF_MEMORY;
	}

	intptr_t offset = reinterpret_cast<intptr_t>(indices);

	if(buffer != NULL)
	{
		if(typeSize(type) * count + offset > static_cast<std::size_t>(buffer->size()))
		{
			return GL_INVALID_OPERATION;
		}

		indices = static_cast<const GLubyte*>(buffer->data()) + offset;
	}

	std::vector<GLsizei>* restartIndices = primitiveRestart ? new std::vector<GLsizei>() : nullptr;
	computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex, restartIndices);

	StreamingIndexBuffer *streamingBuffer = mStreamingBuffer;

	sw::Resource *staticBuffer = buffer ? buffer->getResource() : NULL;

	if(restartIndices)
	{
		int vertexPerPrimitive = recomputePrimitiveCount(mode, count, *restartIndices, &translated->primitiveCount);
		if(vertexPerPrimitive == -1)
		{
			delete restartIndices;
			return GL_INVALID_ENUM;
		}

		size_t streamOffset = 0;
		int convertCount = translated->primitiveCount * vertexPerPrimitive;

		streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
		void *output = streamingBuffer->map(typeSize(type) * convertCount, &streamOffset);

		if(output == NULL)
		{
			delete restartIndices;
			ERR("Failed to map index buffer.");
			return GL_OUT_OF_MEMORY;
		}

		copyIndices(mode, type, *restartIndices, staticBuffer ? buffer->data() : indices, count, output);
		streamingBuffer->unmap();

		translated->indexBuffer = streamingBuffer->getResource();
		translated->indexOffset = static_cast<unsigned int>(streamOffset);
		delete restartIndices;
	}
	else if(staticBuffer)
	{
		translated->indexBuffer = staticBuffer;
		translated->indexOffset = static_cast<unsigned int>(offset);
	}
	else
	{
		size_t streamOffset = 0;
		int convertCount = count;

		streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
		void *output = streamingBuffer->map(typeSize(type) * convertCount, &streamOffset);

		if(output == NULL)
		{
			ERR("Failed to map index buffer.");
			return GL_OUT_OF_MEMORY;
		}

		copyIndices(type, indices, convertCount, output);
		streamingBuffer->unmap();

		translated->indexBuffer = streamingBuffer->getResource();
		translated->indexOffset = static_cast<unsigned int>(streamOffset);
	}

	if(translated->minIndex < start || translated->maxIndex > end)
	{
		ERR("glDrawRangeElements: out of range access. Range provided: [%d -> %d]. Range used: [%d -> %d].", start, end, translated->minIndex, translated->maxIndex);
	}

	return GL_NO_ERROR;
}

std::size_t IndexDataManager::typeSize(GLenum type)
{
	switch(type)
	{
	case GL_UNSIGNED_INT:   return sizeof(GLuint);
	case GL_UNSIGNED_SHORT: return sizeof(GLushort);
	case GL_UNSIGNED_BYTE:  return sizeof(GLubyte);
	default: UNREACHABLE(type); return sizeof(GLushort);
	}
}

StreamingIndexBuffer::StreamingIndexBuffer(size_t initialSize) : mIndexBuffer(NULL), mBufferSize(initialSize)
{
	if(initialSize > 0)
	{
		mIndexBuffer = new sw::Resource(initialSize + 16);

		if(!mIndexBuffer)
		{
			ERR("Out of memory allocating an index buffer of size %u.", initialSize);
		}
	}

	mWritePosition = 0;
}

StreamingIndexBuffer::~StreamingIndexBuffer()
{
	if(mIndexBuffer)
	{
		mIndexBuffer->destruct();
	}
}

void *StreamingIndexBuffer::map(size_t requiredSpace, size_t *offset)
{
	void *mapPtr = NULL;

	if(mIndexBuffer)
	{
		mapPtr = (char*)mIndexBuffer->lock(sw::PUBLIC) + mWritePosition;

		if(!mapPtr)
		{
			ERR(" Lock failed");
			return NULL;
		}

		*offset = mWritePosition;
		mWritePosition += requiredSpace;
	}

	return mapPtr;
}

void StreamingIndexBuffer::unmap()
{
	if(mIndexBuffer)
	{
		mIndexBuffer->unlock();
	}
}

void StreamingIndexBuffer::reserveSpace(size_t requiredSpace, GLenum type)
{
	if(requiredSpace > mBufferSize)
	{
		if(mIndexBuffer)
		{
			mIndexBuffer->destruct();
			mIndexBuffer = 0;
		}

		mBufferSize = std::max(requiredSpace, 2 * mBufferSize);

		mIndexBuffer = new sw::Resource(mBufferSize + 16);

		if(!mIndexBuffer)
		{
			ERR("Out of memory allocating an index buffer of size %u.", mBufferSize);
		}

		mWritePosition = 0;
	}
	else if(mWritePosition + requiredSpace > mBufferSize)   // Recycle
	{
		if(mIndexBuffer)
		{
			mIndexBuffer->destruct();
			mIndexBuffer = new sw::Resource(mBufferSize + 16);
		}

		mWritePosition = 0;
	}
}

sw::Resource *StreamingIndexBuffer::getResource() const
{
	return mIndexBuffer;
}

}