// Qt includes

#include <qmap></qmap>

#include <qsettings></qsettings>

#include <qdate></qdate>

#include <qdir></qdir>

#include <qfileinfo></qfileinfo>

#include <qfileinfolist></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;

}