#include "BBCSubEntity.h"

namespace BBC {

SubEntity::SubEntity(): references(0) // initialize references to 0
{
	mHasTangents = false;
	mHasVertexColours = false;
	mHasNormals = true;
	mHasTextureCoords = true;
}

SubEntity::~SubEntity() 
{
	mUniqueVertexList.clear();
	mIndices.clear();
	mTextureCoordSetsDimensions.clear();

}

void SubEntity::setPosition(unsigned int index, Ogre::Vector3 value)
{
	mUniqueVertexList[index].position = value;
}

Ogre::Vector3 SubEntity::getPosition(unsigned int index)
{
	return mUniqueVertexList[index].position;
}

void SubEntity::setNormal(unsigned int index, Ogre::Vector3 value)
{
	mUniqueVertexList[index].normal = value;
}

Ogre::Vector3 SubEntity::getNormal(unsigned int index)
{
	return mUniqueVertexList[index].normal;
}

void SubEntity::setTexCoord(unsigned int index, unsigned int set, Ogre::Vector3 value)
{
	mUniqueVertexList[index].uv[set] = value;
}

Ogre::Vector3 SubEntity::getTexCoord(unsigned int index, unsigned int set, unsigned int value)
{
	return mUniqueVertexList[index].uv[set];
}

void SubEntity::addFaceVerticesIDs(Ogre::Vector3 value)
{
	mIndices.push_back(value);
}

void SubEntity::removeFaceVerticesIDs(unsigned int value)
{
	mIndices.erase(mIndices.begin()+value);
}

Ogre::Vector3 SubEntity::getFaceVerticesIDs(unsigned int value)
{
	return mIndices[value];
}

void SubEntity::enableTangents(bool value)
{
	mHasTangents = value;
}

bool SubEntity::hasTangents()
{
	return mHasTangents;
}

void SubEntity::enableNormals(bool value)
{
	mHasNormals = value;
}

bool SubEntity::hasNormals()
{
	return mHasNormals;
}

void SubEntity::enableTextureCoords(bool value)
{
	mHasTextureCoords = value;
}

void SubEntity::addTextureCoordSet(unsigned int numTexCoords)
{
	mTextureCoordSetsDimensions.push_back(numTexCoords);
	enableTextureCoords(true);
}

void SubEntity::removeTextureCoordSet()
{
	if (mTextureCoordSetsDimensions.size() > 0)
	{
		mTextureCoordSetsDimensions.erase(mTextureCoordSetsDimensions.begin());
	}

	if (mTextureCoordSetsDimensions.size() == 0)
	{
		enableTextureCoords(false);
	}
}

unsigned int SubEntity::getNumTexCoordSets()
{
	return static_cast<unsigned int>(mTextureCoordSetsDimensions.size());
}

unsigned int SubEntity::getNumTexCoords()
{
	return static_cast<unsigned int>(mUniqueVertexList.size());
}

unsigned int SubEntity::getTexCoordDimensions(unsigned int set)
{
	return mTextureCoordSetsDimensions[set];
}

void SubEntity::enableVertexColours(bool value)
{
	mHasVertexColours = value;
}

bool SubEntity::hasVertexColours()
{
	return mHasVertexColours;
}

void SubEntity::setVertexColour(unsigned int index, Ogre::RGBA value)
{
	mUniqueVertexList[index].colour = value;
}

Ogre::RGBA SubEntity::getVertexColour(unsigned int index)
{
	return mUniqueVertexList[index].colour;
}

unsigned int SubEntity::getNumFaces()
{
	return static_cast<unsigned int>(mIndices.size());
}

unsigned int SubEntity::getNumVertices()
{
	return static_cast<unsigned int>(mUniqueVertexList.size());
}

Ogre::String SubEntity::getName()
{
	return mName;
}

void SubEntity::setName(Ogre::String value)
{
	mName = value;
}

Ogre::String SubEntity::getMaterialName()
{
	return mMaterialName;
}

void SubEntity::setMaterialName(Ogre::String value)
{
	mMaterialName = value;
}


UniqueVertexList* SubEntity::getUniqueVertices()
{
	return &mUniqueVertexList;
}

void SubEntity::addUniqueVertex(UniqueVertex uniqueVertex)
{
	mUniqueVertexList.push_back(uniqueVertex);
}

void SubEntity::removeUniqueVertex(unsigned int index)
{
	mUniqueVertexList.erase(mUniqueVertexList.begin() + index);
}

UniqueVertex SubEntity::getUniqueVertex(unsigned int index)
{
	return mUniqueVertexList[index];
}

const Ogre::AxisAlignedBox &SubEntity::getAABBox()
{
	return mAABBox;
}

void SubEntity::setAABBox(Ogre::AxisAlignedBox box)
{
	mAABBox = box;
}

void SubEntity::generateAABBox()
{
	// Bounds calculation
	Ogre::Real squaredRadius = 0.0f;
    Ogre::Vector3 min, max;
    bool first = true;

	for (size_t jVertex = 0; jVertex < this->getNumVertices(); jVertex++)
	{
		if (first)
		{
			squaredRadius = this->getUniqueVertex(jVertex).position.squaredLength();
			min = max = this->getUniqueVertex(jVertex).position;
			first = false;
		}
		else
		{
			size_t numVertices = (unsigned int)this->getNumVertices();
			//Ogre::LogManager::getSingleton().logMessage("NumVertices:" + Ogre::StringConverter::toString(numVertices));
			//Ogre::LogManager::getSingleton().logMessage("IDVertex:" + Ogre::StringConverter::toString(jVertex) + "--" + Ogre::StringConverter::toString(iSubEntity) + "--" + Ogre::StringConverter::toString(mEntity->getSubEntity(iSubEntity)->getUniqueVertex(jVertex).position));
			squaredRadius = 
				std::max(squaredRadius,this->getUniqueVertex(jVertex).position.squaredLength());
			min.makeFloor(this->getUniqueVertex(jVertex).position);
			max.makeCeil(this->getUniqueVertex(jVertex).position);
		}
	}

	// Merge bounds
	mAABBox.setExtents(min, max);
}

}