#include "trenderer.h"
#include "trasterfx.h"
 
#include <algorithm>
 
#include "tpredictivecachemanager.h"
 
//************************************************************************************************
//    Preliminaries
//************************************************************************************************
 
class TPredictiveCacheManagerGenerator final
    : public TRenderResourceManagerGenerator {
public:
  TPredictiveCacheManagerGenerator() : TRenderResourceManagerGenerator(true) {}
 
  TRenderResourceManager *operator()(void) override {
    return new TPredictiveCacheManager;
  }
};
 
MANAGER_FILESCOPE_DECLARATION_DEP(TPredictiveCacheManager,
                                  TPredictiveCacheManagerGenerator,
                                  TFxCacheManager::deps())
 
//-------------------------------------------------------------------------
 
TPredictiveCacheManager *TPredictiveCacheManager::instance() {
  return static_cast<TPredictiveCacheManager *>(
      // TPredictiveCacheManager::gen()->getManager(TRenderer::instance())
      TPredictiveCacheManager::gen()->getManager(TRenderer::renderId()));
}
 
//************************************************************************************************
//    TPredictiveCacheManager::Imp definition
//************************************************************************************************
 
//=======================
//    PredictionData
//-----------------------
 
struct PredictionData {
  const ResourceDeclaration *m_decl;
  int m_usageCount;
 
  PredictionData(const ResourceDeclaration *declaration)
      : m_decl(declaration), m_usageCount(1) {}
};
 
//============================================================================================
 
//=====================================
//    TPredictiveCacheManager::Imp
//-------------------------------------
 
class TPredictiveCacheManager::Imp {
public:
  int m_renderStatus;
  bool m_enabled;
 
  std::map<TCacheResourceP, PredictionData> m_resources;
  QMutex m_mutex;
 
public:
  Imp()
      : m_renderStatus(TRenderer::IDLE)
      , m_enabled(TRenderer::instance().isPrecomputingEnabled()) {}
 
  void run(TCacheResourceP &resource, const std::string &alias, const TFxP &fx,
           double frame, const TRenderSettings &rs,
           ResourceDeclaration *resData) {
    switch (m_renderStatus) {
    case TRenderer::IDLE:
    case TRenderer::COMPUTING:
      getResourceComputing(resource, alias, fx, frame, rs, resData);
      break;
    case TRenderer::TESTRUN:
      getResourceTestRun(resource, alias, fx, frame, rs, resData);
      break;
    }
  }
 
private:
  void getResourceTestRun(TCacheResourceP &resource, const std::string &alias,
                          const TFxP &fx, double frame,
                          const TRenderSettings &rs,
                          ResourceDeclaration *resData);
 
  void getResourceComputing(TCacheResourceP &resource, const std::string &alias,
                            const TFxP &fx, double frame,
                            const TRenderSettings &rs,
                            ResourceDeclaration *resData);
};
 
//************************************************************************************************
//    TPredictiveCacheManager methods
//************************************************************************************************
 
TPredictiveCacheManager::TPredictiveCacheManager()
    : m_imp(new TPredictiveCacheManager::Imp()) {}
 
//---------------------------------------------------------------------------
 
TPredictiveCacheManager::~TPredictiveCacheManager() {}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::setMaxTileSize(int maxTileSize) {}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::setBPP(int bpp) {}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::getResource(TCacheResourceP &resource,
                                          const std::string &alias,
                                          const TFxP &fx, double frame,
                                          const TRenderSettings &rs,
                                          ResourceDeclaration *resData) {
  if (!m_imp->m_enabled) return;
 
  m_imp->run(resource, alias, fx, frame, rs, resData);
}
 
//************************************************************************************************
//    Notification-related functions
//************************************************************************************************
 
void TPredictiveCacheManager::Imp::getResourceTestRun(
    TCacheResourceP &resource, const std::string &alias, const TFxP &fx,
    double frame, const TRenderSettings &rs, ResourceDeclaration *resData) {
  assert(resData && resData->m_rawData);
  if (!(resData && resData->m_rawData))
    // This is a very rare case. I've seen it happen once in a 'pathologic' case
    // which involved affines truncation while building aliases.
    // The rendering system didn't expect the truncated part 'resurface' in a
    // downstream fx with a slightly different affine alias.
 
    // TODO: Affines should be coded completely in the aliases... in a compact
    // way though.
    return;
 
  if (!resource) resource = TCacheResourceP(alias, true);
 
  // Lock against concurrent threads
  // QMutexLocker locker(&m_mutex);    //preComputing is currently
  // single-threaded
 
  std::map<TCacheResourceP, PredictionData>::iterator it =
      m_resources.find(resource);
 
  if (it != m_resources.end())
    it->second.m_usageCount++;
  else {
    // Already initializes usageCount at 1
    m_resources.insert(std::make_pair(resource, PredictionData(resData))).first;
  }
}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::Imp::getResourceComputing(
    TCacheResourceP &resource, const std::string &alias, const TFxP &fx,
    double frame, const TRenderSettings &rs, ResourceDeclaration *resData) {
  // If there is no declaration data, either the request can be resolved in one
  // computation code (therefore it is uninteresting for us), or it was never
  // declared.
  // Anyway, return.
  if (!resData) return;
 
  // NO! The refCount is dynamically depleted - could become 0 from n...
  // assert(!(resData->m_tiles.size() == 1 && resData->m_tiles[0].m_refCount ==
  // 1));
 
  if (!resource) resource = TCacheResourceP(alias);
 
  if (!resource) return;
 
  // Lock against concurrent threads
  QMutexLocker locker(&m_mutex);
 
  std::map<TCacheResourceP, PredictionData>::iterator it =
      m_resources.find(resource);
 
  if (it == m_resources.end()) return;
 
  if (--it->second.m_usageCount <= 0) m_resources.erase(it);
}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::onRenderStatusStart(int renderStatus) {
  m_imp->m_renderStatus = renderStatus;
}
 
//---------------------------------------------------------------------------
 
void TPredictiveCacheManager::onRenderStatusEnd(int renderStatus) {
  switch (renderStatus) {
  case TRenderer::TESTRUN:
 
    // All resources which have just 1 computation tile, which is also
    // referenced
    // only once, are released.
 
    std::map<TCacheResourceP, PredictionData>::iterator it;
    for (it = m_imp->m_resources.begin(); it != m_imp->m_resources.end();) {
      const ResourceDeclaration *decl = it->second.m_decl;
 
      if (decl->m_tiles.size() == 1 && decl->m_tiles[0].m_refCount == 1) {
        std::map<TCacheResourceP, PredictionData>::iterator jt = it++;
        m_imp->m_resources.erase(jt);
      } else
        it++;
    }
  }
}