#pragma once
 
#ifndef TMETAIMAGE_INCLUDED
#define TMETAIMAGE_INCLUDED
 
#include "timage.h"
#include "tthreadmessage.h"
#include "tsmartpointer.h"
#include "tvariant.h"
#include "tconstwrapper.h"
 
#include <QString>
#include <QReadLocker>
#include <QWriteLocker>
#include <QReadWriteLock>
 
#include <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;  //!< smart pointer to TMetaObject
typedef TMetaObjectP::Holder        TMetaObjectH;  //!< smart holder of TMetaObject
typedef TMetaObjectP::Const         TMetaObjectPC; //!< smart pointer to constant TMetaObject
typedef std::vector<TMetaObjectP> TMetaObjectList;
typedef TConstArrayWrapperT<TMetaObjectPC, TMetaObjectP> TMetaObjectListCW; // TMetaObjectListConstWrapper
 
//-------------------------------------------------------------------
 
class DVAPI TMetaObjectType {
public:
  const TStringId name;
 
  TMetaObjectType(const TStringId &name);
  virtual ~TMetaObjectType();
 
  void registerAlias(const TStringId &alias);
  void unregisterAlias(const TStringId &alias);
 
  virtual TMetaObjectHandler* createHandler(TMetaObject &obj) const
    { return 0; }
  virtual QString getLocalName() const
    { return QString::fromStdString(name.str()); }
};
 
//-------------------------------------------------------------------
 
class DVAPI TMetaObject: public TSmartObject, public TVariantOwner {
public:
  typedef TMetaObjectHandler* (*Fabric)(TMetaObject&);
  typedef std::map<TStringId, const TMetaObjectType*> Registry;
 
  struct LinkedList {
    TMetaObject *first, *last;
    LinkedList(): first(), last() { }
  };
  typedef std::map<TStringId, LinkedList> LinkedMap;
  typedef LinkedMap::iterator LinkedMapEntry;
 
private:
  LinkedMapEntry m_typeLink;
  TMetaObject *m_previous, *m_next;
  const TMetaObjectType *m_typeDesc;
  TMetaObjectHandler *m_handler;
  TVariant m_data;
 
  static Registry& registry();
  static LinkedMap& linkedMap();
 
  static void rewrapAll(const TStringId &type);
  void rewrap(const TStringId &type);
 
  void linkToType(const TStringId &type);
  void unlinkFromType();
 
  TMetaObject(const TMetaObject &other);
 
public:
  explicit TMetaObject(const TStringId &typeName = TStringId(), const TVariant &data = TVariant());
  explicit TMetaObject(const std::string &typeName, const TVariant &data = TVariant());
  ~TMetaObject();
 
  void setType(const TStringId &name);
  inline void setType(const std::string &name)
    { setType(TStringId(name)); }
  inline void resetType()
    { setType(TStringId()); }
 
  inline const TMetaObjectType* getTypeDesc() const
    { return m_typeDesc; }
  inline const TStringId& getType() const
    { return m_typeLink->first; }
  inline const std::string& getTypeName() const
    { return getType().str(); }
  inline const TVariant& data() const
    { return m_data; }
  inline TVariant& data()
    { return m_data; }
 
  void setDefaults();
 
  template<typename T>
  const T* getHandler() const
    { return dynamic_cast<const T*>(m_handler); }
  template<typename T>
  T* getHandler()
    { return dynamic_cast<T*>(m_handler); }
 
  TMetaObjectHandler* handler() { return m_handler; }
  const TMetaObjectHandler* handler() const { return m_handler; }
 
  void onVariantChanged(const TVariant &value) override;
 
  virtual TMetaObject* clone() const;
 
public:
  static const Registry& getRegistry() { return registry(); }
  static void registerType(const TStringId &name, const TMetaObjectType &type); //!< register new or add alias
  static void unregisterType(const TStringId &name); //!< unregister single alias
  static void unregisterType(const TMetaObjectType &type); //!< unregister all aliases
  static const TMetaObjectType* findType(const TStringId &name);
};
 
//-------------------------------------------------------------------
 
class DVAPI TMetaObjectHandler {
protected:
  class LockEvents {
  public:
    TMetaObjectHandler &owner;
    explicit LockEvents(TMetaObjectHandler &owner):
      owner(owner) { ++owner.m_locks; }
    ~LockEvents() { --owner.m_locks; }
  };
 
private:
  TMetaObject &m_object;
  const TMetaObjectType &m_typeDesc;
  TAtomicVar m_locks;
 
public:
  TMetaObjectHandler(TMetaObject &object):
    m_object(object),
    m_typeDesc(*m_object.getTypeDesc())
      { assert(m_object.getTypeDesc()); }
  virtual ~TMetaObjectHandler() { }
 
  inline const TMetaObjectType& getTypeDesc() const
    { return m_typeDesc; }
  inline const TStringId& getType() const
    { return getTypeDesc().name; }
  inline const std::string& getTypeName() const
    { return getType().str(); }
  inline const TMetaObject& object() const
    { return m_object; }
  inline TMetaObject& object()
    { return m_object; }
  inline const TStringId& getAlias() const
    { return object().getType(); }
  inline const std::string& getAliasName() const
    { return getAlias().str(); }
  inline const TVariant& data() const
    { return object().data(); }
  inline TVariant& data()
    { return object().data(); }
 
protected:
  virtual void onSetDefaults() { }
  virtual void onDataChanged(const TVariant &value) { }
  virtual void onFixData() { }
 
public:
  void setDefaults()
    { onSetDefaults(); }
  void dataChanged(const TVariant &value)
    { if (m_locks == 0) onDataChanged(value); }
  void fixData()
    { LockEvents lock(*this); onFixData(); }
};
 
//-------------------------------------------------------------------
 
//! An image containing an assistants for painting.
 
class DVAPI TMetaImage final : public TImage {
public:
  class Reader: public QReadLocker {
  private:
    const TMetaImage &m_image;
    const TMetaObjectListCW m_objects;
  public:
    Reader(const TMetaImage &image):
      QReadLocker(&image.m_rwLock),
      m_image(image),
      m_objects(image.m_objects) { }
    const TMetaImage& image() const
      { return m_image; }
    const TMetaObjectListCW& get() const
      { return m_objects; }
    const TMetaObjectListCW& operator*() const
      { return get(); }
    const TMetaObjectListCW* 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; }
    TMetaObjectList& get() const
      { return m_image.m_objects; }
    TMetaObjectList& operator*() const
      { return get(); }
    TMetaObjectList* operator->() const
      { return &get(); }
  };
 
private:
  mutable QReadWriteLock m_rwLock;
  TMetaObjectList m_objects;
 
  TMetaImage(const TMetaImage &other);
 
  //! not implemented
  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