/**
  * @RDE_HEADER@
  * Class PropertyResult
  * $Id$
  * $HeadURL$
  * $Author$
  */
#pragma once

// Own
#include "advanced_symbology_export.h"
#include "symbol_dictionary_types.h"
#include "symbol_properties.h"
#include "result_watcher.h"
#include <SymbologyImpl/advanced_symbology_logging.h>


// Qt
#include <QObject>


// forward
class QUuid;

//----------------------------------------------------------------------------
/**
 * Store PropertyResult
 */
namespace AdvancedSymbology
{

using SymbolPropertyList = QList<SymbolProperties>;

/**
 * @brief The PropertyResult class
 */

/**
 * @brief The PropertyResult class mainly contains a SymbolPropertyList.
 * It´s based on the future pattern. So the real result can only be retrieved if
 * the asynchron operation has finished (and the result is ready).
 * To standardize this you should use a propper watcher: PropertyResultWatcher.
 *
 * \sa \ref secResultWatcherExample
 */
class ADVANCED_SYMBOLOGY_EXPORT PropertyResult : public QObject
{
  Q_OBJECT

  /*! \name Construction, Destruction */
  //@{
public:
  ///< Constructor
  explicit PropertyResult();

  ///< Destructor
  virtual ~PropertyResult();
  //@}

  /*! \name Data regarding requested */
  //@{
  //@}

  /*! \name Data regarding processing*/
  //@{
  /**
   * @brief taskId internal taskId
   * @return internal taskId
   */
  const QUuid              &taskId() const;

  /*! \name Data regarding result*/
  //@{
  /**
   * @brief Get SymbolPropertyList
   * @return SymbolPropertyList
   */
  SymbolPropertyList properties() const;
  //@}


Q_SIGNALS:
  /// This signal is for internal usage only. Use PropertyResultWatcher!
  void resultReadyInternal();

protected:
  friend class SymbolDictionaryImpl;
  void fireResultReady();

  friend class ResultWatcher<PropertyResult>;
  bool isResultReady() const;

  void setTaskId(const QUuid &uuid);
  void setProperties(const SymbolPropertyList &properties);

private:
  class Private;
  /**
      * The private d->pointer to not break BC when changing internals of this class
     */
  Private *d = nullptr;

  LOGGER_T m_logger;      ///< Interface of the Logging-Facility
};


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

/**
 * @brief The PropertyResultWatcher class takes one PropertyResult using setPropertyResult.
 * If the background operation has finished, the signal resultReady is emitted exactly one time.
 *
 * \sa \ref secResultWatcherExample
 */
class ADVANCED_SYMBOLOGY_EXPORT PropertyResultWatcher : public ResultWatcher<PropertyResult>
{
  Q_OBJECT

  using BaseClass = ResultWatcher<PropertyResult>;

public:
  ///< Constructor
  explicit PropertyResultWatcher(QObject *parent = nullptr);
  ///< Destructor
  ~PropertyResultWatcher() = default;

  QSharedPointer<PropertyResult> propertyResult() const;
  void setPropertyResult(const QSharedPointer<PropertyResult> &propertyResult);


protected:
  LOGGER_T      m_logger;      ///< Interface of the Logging-Facility
};


} // namespace AdvancedSymbology