//Qt includes
#include <QMap>
#include <QSettings>
#include <QDate>
#include <QDir>
#include <QFileInfo>
#include <QFileInfoList>

//#define USE_SQLITE_HDPOOL

#ifdef USE_SQLITE_HDPOOL
//SQLite include
#include "sqlite/sqlite3.h"
#endif

#include "tcacheresourcepool.h"

//Debug
//#define DIAGNOSTICS
//#include "diagnostics.h"

//******************************************************************************************
//    Cache Resource Pool BACKED ON DISK
//******************************************************************************************

//STILL UNDER DEVELOPMENT...
class THDCacheResourcePool
{
public:
	THDCacheResourcePool() {}
	~THDCacheResourcePool() {}
};

//*************************************************************************************
//    Cache resource pool methods involved with HD Pool management
//*************************************************************************************

inline bool TCacheResourcePool::isHDActive()
{
#ifdef USE_SQLITE_HDPOOL
	return m_hdPool && m_hdPool->isActive();
#else
	return false;
#endif
}

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

void TCacheResourcePool::reset()
{
	setPath("", "", "");
}

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

// Prevents the resources in memory from backing to disk. Observe that
// the actual content of the resource is NOT invalidated - since resources
// are intended as 'reference-protected' material which is expected to last
// as long as references are held.
void TCacheResourcePool::invalidateAll()
{
	QMutexLocker locker(&m_memMutex);

	MemResources::iterator it;
	for (it = m_memResources.begin(); it != m_memResources.end(); ++it)
		it->second->invalidate();
}

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

inline QString TCacheResourcePool::getPoolRoot(QString cacheRoot, QString projectName, QString sceneName)
{
	return QString(cacheRoot + "/render/" + projectName + "/" + sceneName + "/");
}

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

//! Connects to the pool associated to the given project/scene pair.
//! \warning As this closes the current connection before opening a new one,
//! make sure that no pool access happens at this point. You should also
//! verify that no resource from the old pair still exists.
void TCacheResourcePool::setPath(QString cacheRoot, QString projectName, QString sceneName)
{
	//There should be no resource in memory.
	assert(m_memResources.empty());

	//However, just in case, invalidate all resources so that no more resource backing
	//operation take place for current resources, from now on.
	//No care is paid as to whether active transactions currently exist. You
	//have been warned by the way....
	invalidateAll();

	delete m_hdPool;
	m_hdPool = 0;
	m_path = TFilePath();

#ifdef USE_SQLITE_HDPOOL

	if (!(cacheRoot.isEmpty() || projectName.isEmpty() || sceneName.isEmpty())) {
		QString hdPoolRoot(getPoolRoot(cacheRoot, projectName, sceneName));
		m_hdPool = new THDCacheResourcePool(hdPoolRoot);
		m_path = m_hdPool->getResourcesFilePath();
	}

#endif
}

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

void TCacheResourcePool::startBacking(TCacheResource *resource)
{
	assert(isHDActive());
	if (!isHDActive())
		return;

#ifdef USE_SQLITE_HDPOOL

	resource->m_backEnabled = true;

	m_hdPool->buildBackingPath(resource);

#endif
}

//******************************************************************************************
//    Cache resource pool implementation
//******************************************************************************************

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

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

TCacheResourcePool::TCacheResourcePool()
	: m_memMutex(QMutex::Recursive), m_searchCount(0), m_foundIterator(false), m_searchIterator(m_memResources.end()), m_hdPool(0), m_path()
{
	//Open the settings for cache retrieval
}

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

TCacheResourcePool::~TCacheResourcePool()
{
	//Temporary
	//performAutomaticCleanup();

	delete m_hdPool;
}

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

const TFilePath &TCacheResourcePool::getPath() const
{
	return m_path;
}

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

//! Initializes an optimized search on the pool for a specific resource, caching successive
//! results.
//! \note Pool searches are serialized, and calls to this method lock the pool's mutex until a
//! corresponding number of endCachedSearch() methods are invoked.
void TCacheResourcePool::beginCachedSearch()
{
	m_memMutex.lock();
	m_searchCount++;
}

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

//! The inverse to beginCachedSearch(). This method \b MUST be called in correspondence to
//! beginCachedSearch() calls.
void TCacheResourcePool::endCachedSearch()
{
	if (--m_searchCount <= 0) {
		m_foundIterator = false;
		m_searchIterator = m_memResources.end();
	}
	m_memMutex.unlock();
}

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

//! Attempts retrieval of the resource with specified name, and eventually creates it if
//! the createIfNone parameter is set.
TCacheResource *TCacheResourcePool::getResource(const std::string &name, bool createIfNone)
{
	//DIAGNOSTICS_TIMER("#times.txt | getResource Overall time");
	//DIAGNOSTICS_MEANTIMER("#times.txt | getResource Mean time");

	TCacheResource *result = 0;

	//NOTA: Passa ad un oggetto lockatore. Quello e' in grado di gestire i casi di eccezioni ecc..
	beginCachedSearch();

	//Search for an already allocated resource
	if (m_searchIterator == m_memResources.end()) {
		m_searchIterator = m_memResources.lower_bound(name);
		if (m_searchIterator != m_memResources.end())
			if (!(name < m_searchIterator->first))
				m_foundIterator = true;
			else if (m_searchIterator != m_memResources.begin())
				m_searchIterator--;
	}

	if (m_foundIterator) {
		result = m_searchIterator->second;

		endCachedSearch();
		return result;
	}

	{
		QString resourcePath;
		QString resourceFlags;

		if (isHDActive()) {
#ifdef USE_SQLITE_HDPOOL

			//DIAGNOSTICS_TIMER("#times.txt | HDPOOL getResource Overall time");
			//DIAGNOSTICS_MEANTIMER("#times.txt | HDPOOL getResource Mean time");

			//Search in the HD pool
			ReadQuery query(m_hdPool);

			bool ret = query.prepare(
				"SELECT Path, Flags FROM Resources WHERE Name = '" + QString::fromStdString(name) + "';");

			//If an error occurred, assume the resource does not exist. Doing nothing works fine.
			assert(ret);

			if (query.step()) {
				resourcePath = query.value(0);
				resourceFlags = query.value(1);
			}

#endif
		}

		if (!resourcePath.isEmpty() || createIfNone) {
			TCacheResource *result = new TCacheResource;
			result->m_pos = m_searchIterator =
				m_memResources.insert(m_searchIterator, std::make_pair(name, result));

//DIAGNOSTICS_STRSET("#resources.txt | RISORSE | " + QString::number((UINT) result) + " | Name",
//QString::fromStdString(name).left(70));

#ifdef USE_SQLITE_HDPOOL
			if (isHDActive())
				m_hdPool->loadResourceInfos(result, resourcePath);
#endif

			m_foundIterator = true;
			endCachedSearch();

			return result;
		}
	}

	endCachedSearch();
	return 0;
}

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

void TCacheResourcePool::releaseResource(TCacheResource *resource)
{
	QMutexLocker locker(&m_memMutex);

	//Re-check the resource's reference count. This is necessary since a concurrent
	//thread may have locked the memMutex for resource retrieval BEFORE this one.
	//If that is the case, the resource's refCount has increased back above 0.
	if (resource->m_refCount > 0)
		return;

#ifdef USE_SQLITE_HDPOOL
	QMutexLocker flushLocker(isHDActive() ? &m_hdPool->m_flushMutex : 0);

	if (isHDActive()) {
		//Flush all resource updates as this resource is being destroyed
		m_hdPool->flushResources();

		//Save the resource infos
		m_hdPool->saveResourceInfos(resource);
	}
#endif

	m_memResources.erase(resource->m_pos);
	delete resource;
}