#pragma once

#include <QObject>
#include <QString>
#include <QVariant>
#include "StructBuilder.h"

namespace CodeGen
{
class NameWrapper : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString name READ name)
  Q_PROPERTY(QString nameCc READ nameCc)
  Q_PROPERTY(QString nameFlc READ nameFlc)
public:
  NameWrapper(const QString &name, QObject *parent)
    : QObject(parent)
    , m_name(name)
  {}

  QString name() const { return m_name; }
  QString nameCc() const { return StructBuilder::camelCaseString(name(), true); }
  QString nameFlc() const { return StructBuilder::firstCharLowercase(nameCc()); }
private:
  const QString m_name;
};

class VariantListWrapper : public NameWrapper
{
  Q_OBJECT
  Q_PROPERTY(QVariantList member READ member)
public:

  using NameWrapper::NameWrapper;
  ~VariantListWrapper()
  {
    for (const QVariant &v : qAsConst(m_member))
    {
      auto ptr = v.value<QObject *>();
      delete ptr;
    }
  }

  QVariantList member() const { return m_member; }
protected:
  QVariantList m_member;
};


class MemberInformationWrapper final : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString cppMemberName READ cppMemberName)
  Q_PROPERTY(QString cppMemberNameCc READ cppMemberNameCc)
  Q_PROPERTY(QString cppStructName READ cppStructName)
  Q_PROPERTY(QString cppType READ cppType)
  Q_PROPERTY(QString cppToQvPre READ cppToQvPre)
  Q_PROPERTY(QString cppToQvPost READ cppToQvPost)
  Q_PROPERTY(QString cppFromQvPre1 READ cppFromQvPre1)
  Q_PROPERTY(QString cppFromQvPre2 READ cppFromQvPre2)
  Q_PROPERTY(QString cppFromQvPost READ cppFromQvPost)
  Q_PROPERTY(QString cppDefault READ cppDefault)
  Q_PROPERTY(QString dbTableName READ dbTableName)
  Q_PROPERTY(QString dbColumnName READ dbColumnName)
  Q_PROPERTY(QString dbColumnNameView READ dbColumnNameView)
  Q_PROPERTY(QString ddsToQVariant READ ddsToQVariant)
  Q_PROPERTY(QString qVariantToDds READ qVariantToDds)
  Q_PROPERTY(QString ddsToJsonElement READ ddsToJsonElement)
  Q_PROPERTY(QString jsonElementToDds READ jsonElementToDds)
  Q_PROPERTY(QString dbToJsonElement READ dbToJsonElement)
  Q_PROPERTY(QString jsonElementToDb READ jsonElementToDb)
  Q_PROPERTY(bool dbHasSequence READ dbHasSequence)
  Q_PROPERTY(bool isOptional READ isOptional)
public:
  MemberInformationWrapper(const MemberInformation &mi, QObject *parent)
    : QObject(parent)
    , m_mi(mi)
  {}

  QString cppMemberName() const { return m_mi.cpp.memberName; }
  QString cppMemberNameCc() const { return StructBuilder::camelCaseString(m_mi.cpp.memberName, true); }
  QString cppStructName() const { return m_mi.cpp.structName; }
  QString cppType() const { return m_mi.cpp.type; }
  QString cppToQvPre() const { return m_mi.cpp.toVariantPre; }
  QString cppToQvPost() const { return m_mi.cpp.toVariantPost; }
  QString cppFromQvPre1() const { return m_mi.cpp.fromVariantPre1; }
  QString cppFromQvPre2() const { return m_mi.cpp.fromVariantPre2; }
  QString cppFromQvPost() const { return m_mi.cpp.fromVariantPost; }
  QString cppDefault() const { return m_mi.cpp.defaultValue; }
  QString dbTableName() const { return m_mi.db.table; }
  QString dbColumnName() const { return m_mi.db.columnName; }
  QString dbColumnNameView() const { return m_mi.db.getColumnNameView(); }
  QString cppDdsType() const { return m_mi.cpp.ddsType.isEmpty() ? cppType() : m_mi.cpp.ddsType; }
  QString ddsToQVariant() const;  
  QString qVariantToDds() const;  
  QString ddsToJsonElement() const; 
  QString jsonElementToDds() const; 
  QString dbToJsonElement() const; 
  QString jsonElementToDb() const; 
  bool dbHasSequence() const { return m_mi.db.hasSequence; }
  bool isOptional() const { return m_mi.cpp.isOptional; }

  
  QString cppToJsonPre() const { return m_mi.cpp.toJsonPre.isNull() ? m_mi.cpp.toVariantPre : m_mi.cpp.toJsonPre; }
  QString cppToJsonPost() const { return m_mi.cpp.toJsonPost.isNull() ? m_mi.cpp.toVariantPost : m_mi.cpp.toJsonPost; }
  QString cppFromJsonPre2() const { return m_mi.cpp.fromJsonPre2.isNull() ? m_mi.cpp.fromVariantPre2: m_mi.cpp.fromJsonPre2; }
  QString cppFromJsonPost() const { return m_mi.cpp.fromJsonPost.isNull() ? m_mi.cpp.fromVariantPost : m_mi.cpp.fromJsonPost; }

  MemberInformation info() const
  {
    return m_mi;
  }
private:
  const MemberInformation m_mi;
};

class MemberInformationListWrapper : public VariantListWrapper
{
  Q_OBJECT
  Q_PROPERTY(QVariantList cppMember READ cppMember)
  Q_PROPERTY(QVariantList jsonMember READ jsonMember)
  Q_PROPERTY(QVariantList fkMember READ fkMember)
  Q_PROPERTY(QVariantList selectRemoveMember READ selectRemoveMember)
  Q_PROPERTY(QVariantList viewMember READ viewMember)
  Q_PROPERTY(MemberInformationWrapper *ddsKey READ ddsKey)
  Q_PROPERTY(MemberInformationWrapper *primaryKey READ primaryKey)
public:
  explicit MemberInformationListWrapper(const QString &name, const QVector<MemberInformation> &member, QObject *parent)
    : VariantListWrapper(name, parent)
  {
    for (const MemberInformation &mi : member)
      m_member += QVariant::fromValue(new MemberInformationWrapper(mi, this));
  }
  
  QVariantList memberByFilter(const std::function<bool(const MemberInformation &mi)> &acceptFilter) const
  {
    QVariantList vl;
    vl.reserve(m_member.size());
    for (const QVariant &v : m_member)
    {
      MemberInformationWrapper *mi = v.value<MemberInformationWrapper *>();
      if (mi && acceptFilter(mi->info()))
        vl += v;
    }
    return vl;
  }

  QVariantList cppMember() const
  {
    return memberByFilter([](const MemberInformation &mi) { return mi.cpp.usedForCppStruct; });
  }
  QVariantList jsonMember() const
  {
    return memberByFilter([](const MemberInformation &mi) { return mi.cpp.usedForJson; });
  }
  QVariantList fkMember() const
  {
    return memberByFilter([](const MemberInformation &mi) { return mi.db.isForeignKey; });
  }
  QVariantList selectRemoveMember() const
  {
    return memberByFilter([](const MemberInformation &mi) { return mi.db.generateSelectRemove; });
  }
  QVariantList viewMember() const
  {
    return memberByFilter([](const MemberInformation &mi) { return mi.db.usedForView; });
  }
  MemberInformationWrapper *ddsKey() const
  {
    for (const QVariant &v : m_member)
    {
      MemberInformationWrapper *mi = v.value<MemberInformationWrapper *>();
      if (mi->info().isDdsKey)
        return mi;
    }
    return nullptr;
  }
  MemberInformationWrapper *primaryKey() const
  {
    for (const QVariant &v : m_member)
    {
      MemberInformationWrapper *mi = v.value<MemberInformationWrapper *>();
      if (mi->info().db.isPrimaryKey)
        return mi;
    }
    return nullptr;
  }
};


class TableWrapper final : public NameWrapper
{
  Q_OBJECT
  Q_PROPERTY(QVector<MemberInformationWrapper *> member READ member)
  
  Q_PROPERTY(MemberInformationWrapper *serialMember READ serialMember)
  
  
  Q_PROPERTY(MemberInformationWrapper *baseId READ baseId)
  
  Q_PROPERTY(MemberInformationWrapper *primaryKey READ primaryKey)
public:
  
  explicit TableWrapper(const QString &name,
                        const QVector<MemberInformationWrapper *> &member,
                        MemberInformationWrapper *serialMember,
                        MemberInformationWrapper *baseId,
                        MemberInformationWrapper *primaryKey,
                        QObject *parent)
    : NameWrapper(name, parent)
    , m_member(member)
    , m_serialMember(serialMember)
    , m_baseId(baseId)
    , m_primaryKey(primaryKey)
  {}

  QVector<MemberInformationWrapper *> member() const { return m_member; }
  MemberInformationWrapper *serialMember() const { return m_serialMember; }
  MemberInformationWrapper *baseId() const { return m_baseId; }
  MemberInformationWrapper *primaryKey() const { return m_primaryKey; }

private:
  QVector<MemberInformationWrapper *> m_member;
  MemberInformationWrapper *m_serialMember;
  MemberInformationWrapper *m_baseId;
  MemberInformationWrapper *m_primaryKey;
};

class DbStructWrapper final : public MemberInformationListWrapper
{
  Q_OBJECT
  Q_PROPERTY(QVariantList insertStructures READ insertStructures)
  Q_PROPERTY(QString viewTableName READ viewTableName)
  Q_PROPERTY(bool deleteWithoutPkAllowed READ deleteWithoutPkAllowed)
  Q_PROPERTY(MemberInformationWrapper *primaryKey READ primaryKey)
  Q_PROPERTY(QVariantList dbNotifications READ dbNotifications)

public:
  explicit DbStructWrapper(const CompleteStructInformation &csi, QObject *parent)
    : MemberInformationListWrapper(csi.structName, csi.member, parent)
    , m_csi(csi)
  {
    m_dbNotifications.reserve(m_csi.dbNotifications.size());
    for (const auto &notification : qAsConst(m_csi.dbNotifications))
      m_dbNotifications += QVariant(notification.methodName);
  }

  MemberInformationWrapper *primaryKey() const
  {
    for (const QVariant &v : m_member)
    {
      MemberInformationWrapper *mi = v.value<MemberInformationWrapper *>();
      if (mi->info().db.isPrimaryKey && mi->info().db.table == primaryTableName())
        return mi;
    }
    return nullptr;
  }
  QVariantList insertStructures();

  bool deleteWithoutPkAllowed() const { return m_csi.tables.size() == 1; }
  QVariantList dbNotifications() const { return m_dbNotifications; }
  QString primaryTableName() const { return m_csi.primaryTable->name; }
  QString viewTableName() const { return (m_csi.tables.size() == 1) ? primaryTableName() : m_csi.viewName; }
private:
  const CompleteStructInformation m_csi;
  QVariantList m_dbNotifications;
};

class CustomFunctionWrapper final : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString signature READ signature)
public:
  explicit CustomFunctionWrapper(const QString &signature, QObject *parent)
    : QObject(parent)
    , m_signature(signature)
  {}
  QString signature() const { return m_signature; }
private:
  const QString m_signature;
};


class IdlEnumKeyValueWrapper final : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString key READ key)
  Q_PROPERTY(int value READ value)
public:
  explicit IdlEnumKeyValueWrapper(const EnumKeyValuePair &ekvp, QObject *parent)
    : QObject(parent)
    , m_ekvp(ekvp)
  {}

  QString key() const { return m_ekvp.key; }
  int value() const { return m_ekvp.value; }

private:
  const EnumKeyValuePair m_ekvp;
};

class IdlDataWrapper final : public NameWrapper
{
  Q_OBJECT
  Q_PROPERTY(QString type READ type)
  Q_PROPERTY(QString comment READ comment)
  Q_PROPERTY(QString isKey READ isKey)
  Q_PROPERTY(QString isOptional READ isOptional)
  Q_PROPERTY(QString cppType READ cppType)
  Q_PROPERTY(QString cppTypeCr READ cppTypeCr)
  Q_PROPERTY(QString nameGetter READ nameGetter)
public:
  IdlDataWrapper(const IdlData &data,
                 QObject *parent)
    : NameWrapper(data.name, parent)
    , m_data(data)
  {}

  QString type() const { return m_data.dataTypeInfo->idlType(); }
  QString comment() const { return m_data.comment; }
  QString isKey() const { return m_data.isKey ? QStringLiteral(" \t //@key") : QString(); }
  QString isOptional() const { return m_data.isOptional ? QStringLiteral(" \t //@Optional") : QString(); }
  QString cppType() const { return m_data.dataTypeInfo->cppType(); }
  QString cppTypeCr() const { return m_data.dataTypeInfo->cppTypeConstRef(); }
  QString nameGetter() const { return m_data.name + (m_data.isOptional ? QStringLiteral("().get") : QString()); }
private:
  const IdlData m_data;
};

class IdlEnumWrapper final : public VariantListWrapper
{
  Q_OBJECT
public:
  explicit IdlEnumWrapper(const EnumInformation &ei, QObject *parent)
    : VariantListWrapper(ei.enumName, parent)
  {
    m_member.reserve(ei.values.size());
    for (const auto &val : ei.values)
      m_member += QVariant::fromValue(new IdlEnumKeyValueWrapper(val, this));
  }
};

class IdlStructWrapper final : public VariantListWrapper
{
  Q_OBJECT
  Q_PROPERTY(QString comment READ comment)
  Q_PROPERTY(QString baseValueType READ baseValueType)
  Q_PROPERTY(QString extensibility READ extensibility)
public:
  explicit IdlStructWrapper(const CompleteTopicTypeInformation &ctti, QObject *parent)
    : VariantListWrapper(ctti.name, parent)
    , m_ctti(ctti)
  {
    m_member.reserve(m_ctti.members.size());
    for (const auto &val : qAsConst(m_ctti.members))
      m_member += QVariant::fromValue(new IdlDataWrapper(val, this));
  }

  QString comment() const { return m_ctti.comment; }
  QString baseValueType() const { return m_ctti.baseValueType; }
  QString extensibility() const { return extensibility2String(m_ctti.extensibility); }

private:
  const CompleteTopicTypeInformation m_ctti;
  static QString extensibility2String(dds::core::xtypes::ExtensibilityKind extensiblity);
};

class IdlServiceWrapper final : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QString svcName READ svcName)
  Q_PROPERTY(QString baseFilePath READ baseFilePath)
public:
  IdlServiceWrapper(const QString &svcName, const QString &baseFilePath)
    : m_svcName(svcName)
    , m_baseFilePath(baseFilePath)
  {}
  QString svcName() const { return m_svcName; }
  QString baseFilePath() const { return m_baseFilePath; }
private:
  const QString m_svcName;
  const QString m_baseFilePath;
};

class FunctionTopicWrapper final : public NameWrapper
{
  Q_OBJECT
  Q_PROPERTY(QString onReply READ onReply)
  Q_PROPERTY(QString onRequest READ onRequest)
  Q_PROPERTY(QString onError READ onError)
  Q_PROPERTY(bool isCoreFt READ isCoreFt)
  Q_PROPERTY(bool routeInReplay READ routeInReplay)

  Q_PROPERTY(QString reply READ reply)
  Q_PROPERTY(QString replyFlc READ replyFlc)
  Q_PROPERTY(QString replyHandler READ replyHandler)
  Q_PROPERTY(QString replyHandlerFlc READ replyHandlerFlc)
  Q_PROPERTY(QString replyType READ replyType)
  Q_PROPERTY(QString replyTypeFro READ replyTypeFro)
  Q_PROPERTY(QVariantList replyParams READ replyParams)
  Q_PROPERTY(QString replyHandlerHash READ replyHandlerHash WRITE setReplyHandlerHash)

  Q_PROPERTY(QString request READ request)
  Q_PROPERTY(QString requestFlc READ requestFlc)
  Q_PROPERTY(QString requestHandler READ requestHandler)
  Q_PROPERTY(QString requestHandlerFlc READ requestHandlerFlc)
  Q_PROPERTY(QString requestType READ requestType)
  Q_PROPERTY(QVariantList requestParams READ requestParams)

public:
  FunctionTopicWrapper(const FunctionTopic &ft,
                       const CompleteTopicTypeInformation &siRequest,
                       const CompleteTopicTypeInformation &siReply,
                       QObject *parent)
    : NameWrapper(ft.name, parent)
    , m_ft(ft)
    , m_request(siRequest)
    , m_reply(siReply)
  {}
  QString onReply() const { return QLatin1String("on") + m_ft.replyTopicName; }
  QString onRequest() const { return QLatin1String("on") + m_ft.requestTopicName; }
  QString onError() const { return QLatin1String("on") + m_ft.name + QLatin1String("Error"); }
  bool isCoreFt() const { return (m_ft.replyTopicType == QStringLiteral("Core::FunctionReply") || m_ft.replyTopicType == QStringLiteral("FunctionReply")); }
  bool routeInReplay() const { return m_ft.routeInReplay; }

  QString reply() const { return m_ft.replyTopicName; }
  QString replyFlc() const { return StructBuilder::firstCharLowercase(reply()); }
  QString replyHandler() const { return m_ft.replyTopicName + QLatin1String("Handler"); }
  QString replyHandlerFlc() const { return StructBuilder::firstCharLowercase(replyHandler()); }
  QString replyType() const { return m_reply.name; }
  QString replyTypeFro() const { return isCoreFt() ? QStringLiteral("Core::FunctionReplyObject") : m_reply.name; }

  QString request() const { return m_ft.requestTopicName; }
  QString requestFlc() const { return StructBuilder::firstCharLowercase(request()); }
  QString requestHandler() const { return m_ft.requestTopicName + QLatin1String("Handler"); }
  QString requestHandlerFlc() const { return StructBuilder::firstCharLowercase(requestHandler()); }
  QString requestType() const { return m_request.name; }

  void addRequestParams(const QVector<IdlData> &params)
  {
    for (const auto &param : params)
      m_requestParams.push_back(QVariant::fromValue(new IdlDataWrapper(param, this)));
  }
  QVariantList requestParams() const
  {
    return m_requestParams;
  }
  void addReplyParams(const QVector<IdlData> &params)
  {
    for (const auto &param : params)
      m_replyParams.push_back(QVariant::fromValue(new IdlDataWrapper(param, this)));
  }
  QVariantList replyParams() const
  {
    return m_replyParams;
  }

  QString replyHandlerHash() const
  {
    return m_replyHandlerHash;
  }
  void setReplyHandlerHash(const QString &hash)
  {
    m_replyHandlerHash = hash;
  }

private:
  const FunctionTopic m_ft;
  const CompleteTopicTypeInformation m_request;
  const CompleteTopicTypeInformation m_reply;
  QVariantList m_requestParams;
  QVariantList m_replyParams;
  QString m_replyHandlerHash;
};

class FunctionTopicsWrapper final : public VariantListWrapper
{
  Q_OBJECT
public:
  Q_PROPERTY(QVariantList topicsToRouteInReplay READ topicsToRouteInReplay)

  using VariantListWrapper::VariantListWrapper;

  FunctionTopicWrapper *addFunctionTopic(const FunctionTopic &ft,
                                         const CompleteTopicTypeInformation &siRequest,
                                         const CompleteTopicTypeInformation &siReply)
  {
    FunctionTopicWrapper *ret = new FunctionTopicWrapper(ft, siRequest, siReply, this);
    m_member += QVariant::fromValue(ret);
    return ret;
  }

  
  QVariantList topicsToRouteInReplay() const
  {
    QVariantList vl;
    vl.reserve(m_member.size());
    for (const QVariant &v : m_member)
    {
      FunctionTopicWrapper *ft = v.value<FunctionTopicWrapper *>();
      if (ft->routeInReplay())
        vl += v;
    }
    return vl;
  }
};

class DataTopicWrapper final : public NameWrapper
{
  Q_OBJECT
  Q_PROPERTY(QString serviceName READ serviceName)
  Q_PROPERTY(QString type READ type)
  Q_PROPERTY(QString typeFq READ typeFq)
  Q_PROPERTY(QVariant key READ key)
  Q_PROPERTY(bool dtcImpl READ dtcImpl)
  Q_PROPERTY(bool dtsImpl READ dtsImpl)
  Q_PROPERTY(bool recordTopic READ recordTopic)
  Q_PROPERTY(QVariant recTable READ recTable)
  Q_PROPERTY(QVariantList trColumns READ trColumns)
  Q_PROPERTY(bool hasTrColumns READ hasTrColumns)
  Q_PROPERTY(bool routeToClient READ routeToClient)
  Q_PROPERTY(bool routeToServer READ routeToServer)
  Q_PROPERTY(bool routeInReplay READ routeInReplay)
  Q_PROPERTY(bool autosubscribe READ isAutoSubscribe)

public:
  DataTopicWrapper(const CompleteTopicTypeInformation &ctti, QObject *parent)
    : NameWrapper(ctti.name, parent)
    , m_ctti(ctti)
    , m_keyData(nullptr)
    , m_recordData(nullptr)
  {}

  void setKeyColumnData(const IdlData &data)
  {
    delete m_keyData;
    m_keyData = new IdlDataWrapper(data, this);
  }

  void setTrColumns(const QVector<IdlData> &params)
  {
    for (const auto &param : params)
      m_trColumns.push_back(QVariant::fromValue(new IdlDataWrapper(param, this)));
  }

  QVariantList trColumns() const
  {
    return m_trColumns;
  }

  bool hasTrColumns() const
  {
    return !m_trColumns.empty();
  }

  void setRecordTableInformation(const CompleteTableInformation &cti)
  {
    delete m_recordData;
    m_recordData = new MemberInformationListWrapper(cti.name, cti.columns, this);
    m_ctti.recordTopic = true;  
  }

  QString serviceName() const { return m_ctti.serviceName; }
  QString type() const  { return m_ctti.name; }
  QString typeFq() const;
  QVariant key() const { return m_keyData ? QVariant::fromValue(m_keyData) : QVariant(); }
  bool dtsImpl() const { return m_ctti.dtsAutogen; }
  bool dtcImpl() const { return m_ctti.dtcAutogen; }
  bool recordTopic() const { return m_ctti.recordTopic && m_recordData; }
  bool routeToClient() const { return m_ctti.routeToClient; }
  bool routeToServer() const { return m_ctti.routeToServer; }
  bool routeInReplay() const { return m_ctti.routeInReplay; }
  bool isAutoSubscribe() const { return m_ctti.autosubscribe; }
  QVariant recTable() const { return recordTopic() ? QVariant::fromValue(m_recordData) : QVariant(); }
private:
  CompleteTopicTypeInformation m_ctti;
  IdlDataWrapper *m_keyData;
  MemberInformationListWrapper *m_recordData;
  QVariantList m_trColumns;
};

class DataTopicsWrapper final : public VariantListWrapper
{
  Q_OBJECT
public:
  Q_PROPERTY(QVariantList topicsToRouteInReplay READ topicsToRouteInReplay)
  Q_PROPERTY(QVariantList topicsToRouteToClient READ topicsToRouteToClient)
  Q_PROPERTY(QVariantList topicsToRouteToServer READ topicsToRouteToServer)

  using VariantListWrapper::VariantListWrapper;

  DataTopicWrapper *addDataTopic(const CompleteTopicTypeInformation &ctti)
  {
    DataTopicWrapper *ret = new DataTopicWrapper(ctti, this);
    m_member += QVariant::fromValue(ret);
    return ret;
  }

  
  QVariantList memberByFilter(const std::function<bool(const DataTopicWrapper *dtw)> &acceptFilter) const
  {
    QVariantList vl;
    vl.reserve(m_member.size());
    for (const QVariant &v : m_member)
    {
      DataTopicWrapper *dtw = v.value<DataTopicWrapper *>();
      if (dtw && acceptFilter(dtw))
        vl += v;
    }
    return vl;
  }

  QVariantList topicsToRouteInReplay() const
  {
    return memberByFilter([](const DataTopicWrapper *dtw) { return dtw->routeInReplay(); });
  }
  QVariantList topicsToRouteToClient() const
  {
    return memberByFilter([](const DataTopicWrapper *dtw) { return dtw->routeToClient(); });
  }
  QVariantList topicsToRouteToServer() const
  {
    return memberByFilter([](const DataTopicWrapper *dtw) { return dtw->routeToServer(); });
  }
};

class IdlServicesWrapper final : public VariantListWrapper
{
  Q_OBJECT
public:
  using VariantListWrapper::VariantListWrapper;

  void addService(const QString &svcName, const QString &baseFilePath)
  {
    m_member += QVariant::fromValue(new IdlServiceWrapper(svcName, baseFilePath));
  }
};

}