/**
 * This source file is part of OgreColladaPlugin
 * an addon for OGRE (Object-oriented Graphics Rendering Engine)
 * For the latest info, see http://www.ogre3d.org/
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.

 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
 * http://www.gnu.org/copyleft/lesser.txt.
 *
 * @author	Philipp Hartl
 * @see		README
 */

#include "OgreColladaLibrary.h"
#include "OgreColladaCamera.h"
#include "OgreColladaGeometry.h"
#include "OgreColladaLight.h"
#include "OgreColladaMaterial.h"
#include "OgreColladaTexture.h"
#include "OgreColladaSyntax.h"
#include "OgreColladaUtils.h"

#include "OgreStringConverter.h"

namespace Ogre
{
	//-------------------------------------------------------------------------
	template <class T> 
	ColladaLibrary<T>::ColladaLibrary() { }

	//-------------------------------------------------------------------------
	template <class T> 
	ColladaLibrary<T>::~ColladaLibrary()
	{
		if (!mEntities.empty())
		{
			for (typename ColladaLibraryVector::iterator i = mEntities.begin(); 
                                i != mEntities.end(); 
                                ++i)
			{
				OGRE_DELETE(*i);
			}
			mEntities.clear();
		}
	}

	//-------------------------------------------------------------------------
	template <class T>
	void ColladaLibrary<T>::initialise(ColladaDocument *doc, xmlNode *node)
	{
		for (xmlNode *child = node->children; child != NULL; child = child->next)
		{
			if (child->type != XML_ELEMENT_NODE) continue;

			// create new library instance
			T *entity = new T(doc, child);
			entity->initialise();

			mEntities.push_back(entity);
		}
	}

	//-------------------------------------------------------------------------
	template <class T>
    T *ColladaLibrary<T>::getEntity(const String &id) const
	{
		for (typename ColladaLibraryVector::const_iterator i = mEntities.begin(); i != mEntities.end(); ++i)
		{
			if (id == (*i)->getId()) return (*i);
		}
		return NULL;
	}

	//-------------------------------------------------------------------------
	ColladaLibraryContainer::ColladaLibraryContainer(ColladaDocument *doc) : mDoc(doc) 
	{
		mCameras	= new ColladaLibrary<ColladaCamera>();
		mImages	    = new ColladaLibrary<ColladaImage>();
		mLights		= new ColladaLibrary<ColladaLight>();
		mTextures	= new ColladaLibrary<ColladaTexture>();
		mMaterials  = new ColladaLibrary<ColladaMaterial>();
		mGeometries = new ColladaLibrary<ColladaGeometry>();
	}

	//-------------------------------------------------------------------------
	ColladaLibraryContainer::~ColladaLibraryContainer(void) 
	{
		OGRE_DELETE(mGeometries);
		OGRE_DELETE(mMaterials);
		OGRE_DELETE(mTextures);
		OGRE_DELETE(mLights);
		OGRE_DELETE(mImages);
		OGRE_DELETE(mCameras);
		
		mDoc  = NULL;
	}

	//-------------------------------------------------------------------------
	void ColladaLibraryContainer::doImport(xmlNode *node)
	{
		// get the library type property
		String type = ColladaUtils::getProperty(node, CS_ATR_TYPE);
		// the corresponding enumeration type
		ColladaLibrarySpecific::Type libtype = ColladaLibrarySpecific::getType(type);

		if (libtype != ColladaLibrarySpecific::UNKNOWN)
		{
			if (libtype == ColladaLibrarySpecific::CAMERA) mCameras->initialise(mDoc, node);
			else if (libtype == ColladaLibrarySpecific::GEOMETRY) mGeometries->initialise(mDoc, node);
			else if (libtype == ColladaLibrarySpecific::IMAGE) mImages->initialise(mDoc, node);
			else if (libtype == ColladaLibrarySpecific::LIGHT) mLights->initialise(mDoc, node);
			else if (libtype == ColladaLibrarySpecific::MATERIAL) mMaterials->initialise(mDoc, node);
			else if (libtype == ColladaLibrarySpecific::TEXTURE) mTextures->initialise(mDoc, node);
			else LogManager::getSingleton().logMessage("ColladaLibraryContainer::doImport - <library type=" + type + "> unsupported");
		}
		// unknwon
		else 
		{
			LogManager::getSingleton().logMessage("ColladaLibraryContainer::doImport - <library type=" + type + "> unknown");
		}		
	}

	//-------------------------------------------------------------------------
	ColladaCamera *ColladaLibraryContainer::getCamera(const String &id) const
	{
		return mCameras->getEntity(id);
	}

	//-------------------------------------------------------------------------
	ColladaImage *ColladaLibraryContainer::getImage(const String &id) const
	{
		return	mImages->getEntity(id);
	}

	//-------------------------------------------------------------------------
	ColladaLight *ColladaLibraryContainer::getLight(const String &id) const
	{
		return mLights->getEntity(id);
	}

	//-------------------------------------------------------------------------
	ColladaMaterial *ColladaLibraryContainer::getMaterial(const String &id) const
	{
		return	mMaterials->getEntity(id);
	}

	//-------------------------------------------------------------------------
	ColladaTexture *ColladaLibraryContainer::getTexture(const String &id) const
	{
		return mTextures->getEntity(id);
	}

	//-------------------------------------------------------------------------
	ColladaEntity *ColladaLibraryContainer::importInstance(const String &id)
	{
		// look in the library entities for the identifier	
		ColladaEntity *entity = NULL;

		// first start with geometries
		entity = mGeometries->getEntity(id);

		// camera
		if (entity == NULL) entity = mCameras->getEntity(id);

		// light
		if (entity == NULL) entity = mLights->getEntity(id);

		if (entity == NULL) return NULL;

		// try to import the instance
		if (!entity->doImport())
		{
			LogManager::getSingleton().logMessage("ColladaLibraryContainer::importInstance - doImport of instance " + id + " failed! Entity: " + StringConverter::toString(entity->getEntityType()));
		}

		return entity;
	}

	//-------------------------------------------------------------------------
	namespace ColladaLibrarySpecific
	{
		Type getType(const String &s)
		{
			if (s == CS_VAL_LIBRARY_TYPE_ANIMATION) return ANIMATION;
			else if (s == CS_VAL_LIBRARY_TYPE_CAMERA) return CAMERA;
			else if (s == CS_VAL_LIBRARY_TYPE_CODE) return CODE;
			else if (s == CS_VAL_LIBRARY_TYPE_CONTROLLER) return CONTROLLER;
			else if (s == CS_VAL_LIBRARY_TYPE_GEOMETRY) return GEOMETRY;
			else if (s == CS_VAL_LIBRARY_TYPE_IMAGE) return IMAGE;
			else if (s == CS_VAL_LIBRARY_TYPE_LIGHT) return LIGHT;
			else if (s == CS_VAL_LIBRARY_TYPE_MATERIAL) return MATERIAL;
			else if (s == CS_VAL_LIBRARY_TYPE_PROGRAM) return PROGRAM;
			else if (s == CS_VAL_LIBRARY_TYPE_TEXTURE) return TEXTURE;
			else return UNKNOWN;
		}
	}
}