#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);
}