/**
  * @RDE_HEADER@
  * BulkRenderer
  * $Id$
  * $HeadURL$
  * $Author$
  */
#pragma once

// Own
#include "symbol_dictionary.h"
#include "symbol_result.h"


// Qt
#include <QSharedPointer>
#include <QVector>
#include <QString>


// Forward

//----------------------------------------------------------------------------
namespace AdvancedSymbology
{

//----------------------------------------------------------------------------
class ADVANCED_SYMBOLOGY_EXPORT BulkRendererBase : public QObject
{
  Q_OBJECT
public:
  BulkRendererBase() = default;
  virtual ~BulkRendererBase() = default;

public Q_SLOTS:
  void onSingleResultReady()
  {
    ++m_resultReadyCounter;
    if (m_resultReadyCounter >= m_requestCount)
      emit resultsReady();
  }

Q_SIGNALS:
  /// Signal emits when all results are ready
  void resultsReady();

protected:
  uint m_resultReadyCounter = 0;
  uint m_requestCount       = 0;
};

//----------------------------------------------------------------------------
template<class INPUT_TYPE>
class BulkRenderer : public BulkRendererBase
{
public:
  using RequestResult       = QPair<INPUT_TYPE, QSharedPointer<SymbolResultWatcher>>;
  using RequestResultVector = QVector<RequestResult>;

  explicit BulkRenderer(SymbologyType symbologyType)
    : m_symbologyType(symbologyType)
  {}
  virtual ~BulkRenderer() = default;


  void addRequest(const INPUT_TYPE &request)
  {
    m_requestResultVector.append(RequestResult(request, QSharedPointer<AdvancedSymbology::SymbolResultWatcher>(new AdvancedSymbology::SymbolResultWatcher(this))));
  }

  int size() { return m_requestResultVector.size(); }

  virtual void run() = 0;

  void cancel()
  {
    for (RequestResult &requestResult : m_requestResultVector)
    {
      QSharedPointer<SymbolResultWatcher> watcher = requestResult.second;
      if (watcher)
        watcher->cancel();
    } // for
  }

  void reset()
  {
    // will destroy the associated SymbolResults if the shdPtr has last reference.
    // In that case waitForFinished will be called.
    m_requestResultVector.clear();

    // to be complete:
    m_resultReadyCounter = 0;
    m_requestCount       = 0;
  }

  const RequestResultVector &results() const
  {
    return m_requestResultVector;
  }

  QSharedPointer<SymbolResultWatcher> getResult(const INPUT_TYPE &request)
  {
    for (const RequestResult &requestResult : m_requestResultVector)
    {
      if (requestResult.first == request)
        return requestResult.second;
    }
    return nullptr;
  }


protected:
  void setupWatcher()
  {
    m_resultReadyCounter  = 0;
    m_requestCount        = m_requestResultVector.size();

    // start every single render request:
    for (RequestResult &requestResult : m_requestResultVector)
    {
//      requestResult.second =
//          QSharedPointer<SymbolResultWatcher> (new SymbolResultWatcher());
      connect(requestResult.second.data(), &SymbolResultWatcher::resultReady,
              this, &BulkRendererBase::onSingleResultReady, Qt::QueuedConnection);
    } // for
  }

protected:
  SymbologyType       m_symbologyType = SymbologyType::None;
  RequestResultVector m_requestResultVector;
};



//----------------------------------------------------------------------------
class ADVANCED_SYMBOLOGY_EXPORT BulkRendererFindImage : public BulkRenderer<SymbolDataToRender>
{
public:
  explicit BulkRendererFindImage(SymbologyType symbologyType)
    : BulkRenderer<SymbolDataToRender>(symbologyType)
  {}

  virtual ~BulkRendererFindImage() = default;

  void run() override
  {
    setupWatcher();

    const SymbolDictionary &dict = SymbolDictionary::dictionary(m_symbologyType);

    // start every single render request:
    for (RequestResult &requestResult : m_requestResultVector)
    {
      // 1st
      const SymbolDataToRender &input = requestResult.first;

      // 2nd
      QSharedPointer<SymbolResultWatcher> watcher = requestResult.second;
      if (watcher)
        watcher->setSymbolResult(dict.findImage(input));
    } // for
  }
};

//----------------------------------------------------------------------------
class ADVANCED_SYMBOLOGY_EXPORT BulkRendererFindBaseSymbol : public BulkRenderer<QString>
{
public:
  explicit BulkRendererFindBaseSymbol(SymbologyType symbologyType)
    : BulkRenderer<QString>(symbologyType)
  {}

  virtual ~BulkRendererFindBaseSymbol() = default;

  void run() override
  {
    setupWatcher();

    const SymbolDictionary &dict = SymbolDictionary::dictionary(m_symbologyType);

    // start every single render request:
    for (RequestResult &requestResult : m_requestResultVector)
    {
      // 1st
      const QString &input = requestResult.first;

      // 2nd
      QSharedPointer<SymbolResultWatcher> watcher = requestResult.second;
      if (watcher)
        watcher->setSymbolResult(dict.findBaseSymbol(input));
    } // for
  }
};

//----------------------------------------------------------------------------
class ADVANCED_SYMBOLOGY_EXPORT BulkRendererFindPreview : public BulkRenderer<QString>
{
public:
  explicit BulkRendererFindPreview(SymbologyType symbologyType)
    : BulkRenderer<QString>(symbologyType)
  {}

  void run() override
  {
    setupWatcher();

    const SymbolDictionary &dict = SymbolDictionary::dictionary(m_symbologyType);

    // start every single render request:
    for (RequestResult &requestResult : m_requestResultVector)
    {
      // 1st
      const QString &input = requestResult.first;

      // 2nd
      QSharedPointer<SymbolResultWatcher> watcher = requestResult.second;
      if (watcher)
        watcher->setSymbolResult(dict.findPreview(input));
    } // for
  }
};


} // namespace AdvancedSymbology