#pragma once

#ifndef TMETAIMAGE_INCLUDED

#define TMETAIMAGE_INCLUDED

#include "timage.h"

#include "tthreadmessage.h"

#include "tsmartpointer.h"

#include "tvariant.h"

#include <qreadlocker></qreadlocker>

#include <qwritelocker></qwritelocker>

#include <qreadwritelock></qreadwritelock>

#include <string></string>

#undef DVAPI

#undef DVVAR

#ifdef TMETAIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

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

class TMetaObject;

class TMetaObjectHandler;

typedef TSmartPointerT<tmetaobject> TMetaObjectP;</tmetaobject>

typedef TSmartRefT<tmetaobject> TMetaObjectR;</tmetaobject>

typedef std::vector<tmetaobjectr> TMetaObjectRefList;</tmetaobjectr>

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

class DVAPI TMetaObject: public TSmartObject, public TVariantOwner {

public:

  typedef TMetaObjectHandler* (*Fabric)(TMetaObject&);

  typedef std::map<tstringid, fabric=""> Registry;</tstringid,>

  template<typename t=""></typename>

  class Registrator {

  public:

    typedef T Type;

    static TMetaObjectHandler* fabric(TMetaObject &obj)

      { return new Type(obj); }

    Registrator(const std::string &typeName)

      { registerType(typeName, fabric); }

    Registrator(const TStringId &typeName)

      { registerType(typeName, fabric); }

  };

private:

  TStringId m_type;

  TMetaObjectHandler *m_handler;

  TVariant m_data;

public:

  explicit TMetaObject(const TStringId &typeName = TStringId());

  explicit TMetaObject(const std::string &typeName);

  ~TMetaObject();

  void setType(const TStringId &name);

  inline void setType(const std::string &name)

    { setType(TStringId(name)); }

  inline void resetType()

    { setType(TStringId()); }

  inline const TStringId& getType() const

    { return m_type; }

  inline const std::string& getTypeName() const

    { return m_type.str(); }

  inline const TVariant& data() const

    { return m_data; }

  inline TVariant& data()

    { return m_data; }

  template<typename t=""></typename>

  const T* getHandler() const

    { return dynamic_cast<const t*="">(m_handler); }</const>

  template<typename t=""></typename>

  T* getHandler()

    { return dynamic_cast<t*>(m_handler); }</t*>

  void onVariantChanged(const TVariant &value) override;

  static Registry& registry();

  static void registerType(const TStringId &name, Fabric fabric);

  static void unregisterType(const TStringId &name);

  inline static void registerType(const std::string &name, Fabric fabric)

    { registerType(TStringId(name), fabric); }

  inline static void unregisterType(const std::string &name)

    { unregisterType(TStringId::find(name)); }

};

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

class DVAPI TMetaObjectHandler {

private:

  TMetaObject &m_object;

  TAtomicVar m_fixingData;

public:

  TMetaObjectHandler(TMetaObject &object):

    m_object(object) { }

  virtual ~TMetaObjectHandler() { }

  inline const TMetaObject& object() const

    { return m_object; }

  inline TMetaObject& object()

    { return m_object; }

  inline const TVariant& data() const

    { return object().data(); }

  inline TVariant& data()

    { return object().data(); }

protected:

  virtual void onDataChanged(const TVariant &value) { }

  virtual void onFixData() { }

public:

  void dataChanged(const TVariant &value)

    { if (m_fixingData == 0) onDataChanged(value); }

  void fixData() {

    ++m_fixingData;

    if (m_fixingData == 1) onFixData();

    --m_fixingData;

  }

};

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

//! An image containing an assistants for painting.

class DVAPI TMetaImage final : public TImage {

public:

  class Reader: public QReadLocker {

  private:

    const TMetaImage &m_image;

  public:

    Reader(const TMetaImage &image):

      QReadLocker(&image.m_rwLock), m_image(image) { }

    const TMetaImage& image() const

      { return m_image; }

    const TMetaObjectRefList& get() const

      { return m_image.m_objects; }

    const TMetaObjectRefList& operator*() const

      { return get(); }

    const TMetaObjectRefList* operator->() const

      { return &get(); }

  };

  class Writer: public QWriteLocker {

  private:

    TMetaImage &m_image;

  public:

    Writer(TMetaImage &image):

      QWriteLocker(&image.m_rwLock), m_image(image) { }

    TMetaImage& image() const

      { return m_image; }

    TMetaObjectRefList& get() const

      { return m_image.m_objects; }

    TMetaObjectRefList& operator*() const

      { return get(); }

    TMetaObjectRefList* operator->() const

      { return &get(); }

  };

private:

  mutable QReadWriteLock m_rwLock;

  TMetaObjectRefList m_objects;

  //! not implemented

  TMetaImage(const TMetaImage &other);

  TMetaImage &operator=(const TMetaImage &) { return *this; }

public:

  TMetaImage();

  ~TMetaImage();

  //! Return the image type

  TImage::Type getType() const override { return TImage::META; }

  //! Return a clone of image

  TImage* cloneImage() const override;

  //! Return the bbox of the image

  TRectD getBBox() const override;

};

#endif