#include "trenderresourcemanager.h"
#include "trenderer.h"

//***********************************************************************************************
//    Resource managers builder for instance-scoped resource managers
//***********************************************************************************************

/*
This manager class is used to create and destroy instance-scope managers through the
renderStart/renderEnd notifications. Observe that this involves maintenance of a container
structure of the active renderIds against resource managers.
*/

class RenderInstanceManagersBuilder : public TRenderResourceManager
{
	T_RENDER_RESOURCE_MANAGER

	typedef std::vector<TRenderResourceManager *> ManagersVector;
	std::map<unsigned long, ManagersVector> m_managersMap;

public:
	RenderInstanceManagersBuilder() {}
	~RenderInstanceManagersBuilder() {}

	static RenderInstanceManagersBuilder *instance();

	TRenderResourceManager *getManager(unsigned long renderId, unsigned int idx) const;

	void onRenderInstanceStart(unsigned long id);
	void onRenderInstanceEnd(unsigned long id);

	bool renderHasOwnership() { return false; }
};

//===============================================================================================

class RenderInstanceManagersBuilderGenerator : public TRenderResourceManagerGenerator
{
public:
	TRenderResourceManager *operator()(void)
	{
		return RenderInstanceManagersBuilder::instance();
	}
};

MANAGER_FILESCOPE_DECLARATION(RenderInstanceManagersBuilder, RenderInstanceManagersBuilderGenerator);

//***********************************************************************************************
//    Stub managers and generators
//***********************************************************************************************

/*
These manager-generator stubs are substitutes used to maintain dependency order about managers
which have render instance scope. They retrieve ordered event calls that are passed to the
dedicated instanceScope handler.
*/

class InstanceResourceManagerStub : public TRenderResourceManager
{
	TRenderResourceManagerGenerator *m_generator;

public:
	InstanceResourceManagerStub(TRenderResourceManagerGenerator *generator)
		: m_generator(generator)
	{
	}

	void onRenderInstanceStart(unsigned long id);
	void onRenderInstanceEnd(unsigned long id);

	void onRenderFrameStart(double f);
	void onRenderFrameEnd(double f);

	virtual void onRenderStatusStart(int renderStatus);
	virtual void onRenderStatusEnd(int renderStatus);
};

//===============================================================================================

class StubGenerator : public TRenderResourceManagerGenerator
{
	TRenderResourceManagerGenerator *m_generator;

public:
	StubGenerator(TRenderResourceManagerGenerator *generator)
		: m_generator(generator)
	{
	}

	TRenderResourceManager *operator()()
	{
		return new InstanceResourceManagerStub(m_generator);
	}
};

//***********************************************************************************************
//    TRenderResourceManagerGenerator methods
//***********************************************************************************************

std::vector<TRenderResourceManagerGenerator *> &TRenderResourceManagerGenerator::generators()
{
	static std::vector<TRenderResourceManagerGenerator *> generatorsInstance;
	return generatorsInstance;
}

//-------------------------------------------------------------------------

std::vector<TRenderResourceManagerGenerator *> &TRenderResourceManagerGenerator::generators(bool instanceScope)
{
	static std::vector<TRenderResourceManagerGenerator *> generatorsInstance;
	static std::vector<TRenderResourceManagerGenerator *> generatorsRenderer;
	return instanceScope ? generatorsInstance : generatorsRenderer;
}

//===============================================================================================

TRenderResourceManagerGenerator::TRenderResourceManagerGenerator(bool renderInstanceScope)
	: m_instanceScope(renderInstanceScope)
{
	//In case this has a renderInstanceScope, build a stub generator
	if (renderInstanceScope) {
		RenderInstanceManagersBuilder::gen(); //Stubs depend on this manager

		static std::vector<TRenderResourceManagerGenerator *> stubGenerators;
		stubGenerators.push_back(new StubGenerator(this));
	}

	generators().push_back(this);

	std::vector<TRenderResourceManagerGenerator *> &scopeGenerators =
		generators(renderInstanceScope);

	scopeGenerators.push_back(this);
	m_managerIndex = scopeGenerators.size() - 1;
}

//-------------------------------------------------------------------------

TRenderResourceManager *TRenderResourceManagerGenerator::getManager(const TRenderer &renderer) const
{
	return m_instanceScope ? 0 : renderer.getManager(m_managerIndex);
}

//-------------------------------------------------------------------------

TRenderResourceManager *TRenderResourceManagerGenerator::getManager(unsigned long renderId) const
{
	return m_instanceScope ? RenderInstanceManagersBuilder::instance()->getManager(renderId, m_managerIndex) : 0;
}

//***********************************************************************************************
//    "Instance-scoped Managers" - Management methods
//***********************************************************************************************

RenderInstanceManagersBuilder *RenderInstanceManagersBuilder::instance()
{
	static RenderInstanceManagersBuilder theInstance;
	return &theInstance;
}

//-------------------------------------------------------------------------

inline TRenderResourceManager *RenderInstanceManagersBuilder::
	getManager(unsigned long renderId, unsigned int idx) const
{
	std::map<unsigned long, ManagersVector>::const_iterator it = m_managersMap.find(renderId);
	return it == m_managersMap.end() ? 0 : it->second[idx];
}

//-------------------------------------------------------------------------

void RenderInstanceManagersBuilder::onRenderInstanceStart(unsigned long id)
{
	//Build the instance managers
	std::map<unsigned long, ManagersVector>::iterator it =
		m_managersMap.insert(std::make_pair(id, ManagersVector())).first;

	std::vector<TRenderResourceManagerGenerator *> &instanceScopeGenerators =
		TRenderResourceManagerGenerator::generators(true);

	unsigned int i;
	for (i = 0; i < instanceScopeGenerators.size(); ++i)
		it->second.push_back((*instanceScopeGenerators[i])());
}

//-------------------------------------------------------------------------

void RenderInstanceManagersBuilder::onRenderInstanceEnd(unsigned long id)
{
	//Delete the instance managers
	std::map<unsigned long, ManagersVector>::iterator it =
		m_managersMap.find(id);

	assert(it != m_managersMap.end());

	unsigned int i;
	for (i = 0; i < it->second.size(); ++i) {
		if (it->second[i]->renderHasOwnership())
			delete it->second[i];
	}

	m_managersMap.erase(it);
}

//===============================================================================================

void InstanceResourceManagerStub::onRenderInstanceStart(unsigned long id)
{
	RenderInstanceManagersBuilder::instance()->getManager(id,
														  m_generator->getGeneratorIndex())
		->onRenderInstanceStart(id);
}

//-------------------------------------------------------------------------

void InstanceResourceManagerStub::onRenderInstanceEnd(unsigned long id)
{
	RenderInstanceManagersBuilder::instance()->getManager(id,
														  m_generator->getGeneratorIndex())
		->onRenderInstanceEnd(id);
}

//-------------------------------------------------------------------------

void InstanceResourceManagerStub::onRenderFrameStart(double f)
{
	RenderInstanceManagersBuilder::instance()->getManager(
												 TRenderer::renderId(),
												 m_generator->getGeneratorIndex())
		->onRenderFrameStart(f);
}

//-------------------------------------------------------------------------

void InstanceResourceManagerStub::onRenderFrameEnd(double f)
{
	RenderInstanceManagersBuilder::instance()->getManager(
												 TRenderer::renderId(),
												 m_generator->getGeneratorIndex())
		->onRenderFrameEnd(f);
}

//-------------------------------------------------------------------------

void InstanceResourceManagerStub::onRenderStatusStart(int renderStatus)
{
	RenderInstanceManagersBuilder::instance()->getManager(
												 TRenderer::renderId(),
												 m_generator->getGeneratorIndex())
		->onRenderStatusStart(renderStatus);
}

//-------------------------------------------------------------------------

void InstanceResourceManagerStub::onRenderStatusEnd(int renderStatus)
{
	RenderInstanceManagersBuilder::instance()->getManager(
												 TRenderer::renderId(),
												 m_generator->getGeneratorIndex())
		->onRenderStatusEnd(renderStatus);
}