#include <memory>

// TnzCore includes
#include "tgl.h"

// TnzExt includes
#include "ext/meshtexturizer.h"

// tcg includes
#include "tcg/tcg_list.h"

// Qt includes
#include <QString>
#include <QCache>
#include <QMutex>
#include <QMutexLocker>

#include "ext/ttexturesstorage.h"

//***************************************************************************************
//    Local namespace - structures
//***************************************************************************************

struct TexturesContainer {
	MeshTexturizer m_texturizer; //!< The mesh texturizer - actual textures container
	tcg::list<QString> m_keys;   //!< Keys in the storage

public:
	TexturesContainer() {}

private:
	TexturesContainer(const TexturesContainer &);
	TexturesContainer &operator=(const TexturesContainer &);
};

//***************************************************************************************
//    Local namespace - variables
//***************************************************************************************

namespace
{

QMutex l_mutex(QMutex::Recursive); // A mutex is needed to synchronize access to the following objects

std::map<int, TexturesContainer *> l_texturesContainers;	 // Texture Containers by display lists space id
QCache<QString, DrawableTextureDataP> l_objects(500 * 1024); // 500 MB cache for now - NOTE: MUST be allocated before the following

} // namespace

//***************************************************************************************
//    Local namespace - global functions
//***************************************************************************************

namespace
{

inline QString textureString(int dlSpaceId, const std::string &texId)
{
	return QString::number(dlSpaceId) + "_" + QString::fromStdString(texId);
}

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

inline void deleteTexturesContainer(const std::pair<int, TexturesContainer *> &pair)
{
	delete pair.second;
}
}

//***************************************************************************************
//    DrawableTextureData implementation
//***************************************************************************************

DrawableTextureData::~DrawableTextureData()
{
	QMutexLocker locker(&l_mutex);

	TexturesContainer *texContainer = l_texturesContainers[m_dlSpaceId];

	if (m_dlSpaceId >= 0) {
		// Load the container's display lists space (remember current OpenGL context, too)
		TGLDisplayListsProxy *proxy = TGLDisplayListsManager::instance()->dlProxy(m_dlSpaceId);

		TGlContext currentContext = tglGetCurrentContext();

		// Unbind the textures
		{
			QMutexLocker locker(proxy->mutex());

			proxy->makeCurrent();
			texContainer->m_texturizer.unbindTexture(m_texId);
		}

		// Restore OpenGL context - equivalent to tglDoneCurrent if currentContext == TGlContext()
		tglMakeCurrent(currentContext);
	} else
		// Temporary - use current OpenGL context directly
		texContainer->m_texturizer.unbindTexture(m_texId);

	texContainer->m_keys.erase(m_objIdx);
}

//***************************************************************************************
//    TTexturesStorage implementation
//***************************************************************************************

TTexturesStorage::TTexturesStorage()
{
	// This singleton is dependent on TGLDisplayListsManager
	TGLDisplayListsManager::instance()->addObserver(this);
}

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

TTexturesStorage::~TTexturesStorage()
{
	l_objects.clear();
	std::for_each(l_texturesContainers.begin(), l_texturesContainers.end(), deleteTexturesContainer);
}

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

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

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

DrawableTextureDataP TTexturesStorage::loadTexture(
	const std::string &textureId, const TRaster32P &ras, const TRectD &geometry)
{
	// Try to retrieve the proxy associated to current OpenGL context
	TGlContext currentContext = tglGetCurrentContext();
	int dlSpaceId = TGLDisplayListsManager::instance()->displayListsSpaceId(currentContext);

	QString texString(::textureString(dlSpaceId, textureId));

	// Deal with containers
	QMutexLocker locker(&l_mutex);

	// If necessary, allocate a textures container
	std::map<int, TexturesContainer *>::iterator it = l_texturesContainers.find(dlSpaceId);
	if (it == l_texturesContainers.end())
		it = l_texturesContainers.insert(std::make_pair(dlSpaceId, new TexturesContainer)).first;

	MeshTexturizer &texturizer = it->second->m_texturizer;

	DrawableTextureDataP dataPtr = std::make_shared<DrawableTextureData>();
	DrawableTextureData *data = dataPtr.get();

	data->m_dlSpaceId = dlSpaceId;
	data->m_texId = texturizer.bindTexture(ras, geometry);
	data->m_objIdx = it->second->m_keys.push_back(texString);
	data->m_textureData = texturizer.getTextureData(data->m_texId);

	l_objects.insert(texString, new DrawableTextureDataP(dataPtr),
					 (ras->getLx() * ras->getLy() * ras->getPixelSize()) >> 10);

	if (dlSpaceId < 0) {
		// obj is a temporary. It was pushed in the cache to make space for it - however, it must not be
		// stored. Remove it now.
		l_objects.remove(texString);
	}

	return dataPtr;
}

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

void TTexturesStorage::unloadTexture(const std::string &textureId)
{
	QMutexLocker locker(&l_mutex);

	// Remove the specified texture from ALL the display lists spaces
	std::map<int, TexturesContainer *>::iterator it, iEnd(l_texturesContainers.end());
	for (it = l_texturesContainers.begin(); it != iEnd; ++it)
		l_objects.remove(::textureString(it->first, textureId));
}

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

void TTexturesStorage::onDisplayListDestroyed(int dlSpaceId)
{
	QMutexLocker locker(&l_mutex);

	// Remove the textures container associated with dlSpaceId
	std::map<int, TexturesContainer *>::iterator it = l_texturesContainers.find(dlSpaceId);
	if (it == l_texturesContainers.end())
		return;

	tcg::list<QString>::iterator st, sEnd(it->second->m_keys.end());

	for (st = it->second->m_keys.begin(); st != sEnd;) // Note that the increment is performed BEFORE the texture is removed.
		l_objects.remove(*st++);					   // This is because texture removal may destroy the key being addressed,
													   // whose iterator would then be invalidated.
	delete it->second;
	l_texturesContainers.erase(it);
}

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

DrawableTextureDataP TTexturesStorage::getTextureData(const std::string &textureId)
{
	// Get current display lists space
	TGlContext currentContext = tglGetCurrentContext();
	int dlSpaceId = TGLDisplayListsManager::instance()->displayListsSpaceId(currentContext);

	// If there is no known associated display lists space, the texture cannot be stored.
	if (dlSpaceId < 0)
		return DrawableTextureDataP();

	QMutexLocker locker(&l_mutex);

	// Search the texture object
	QString texString(::textureString(dlSpaceId, textureId));
	if (!l_objects.contains(texString))
		return DrawableTextureDataP();

	return *l_objects.object(texString);
}