/*!
 * 
 * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
 * \copyright
 * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
 * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
 * 
 * \file main.h
 * \author (last) Peter Lucia
 * \date (last) 26-Jun-2020
 * \author (original) Behrouz NematiPour
 * \date (original) 28-Oct-2019
 * 
 */
#pragma once

// Qt
#include <QObject>

// Project

// TODO : A singleton parent class needs to be created
// to taking care of the Threading, init, quit, and so

// TODO :
// - We still need to work on threading on other classes
// - We need to have a singleton parent class
// - Some code has been added to debug can interface (We still have swap frames)
#define SINGLETON(vCLASS)                           \
private:                                            \
    explicit vCLASS(QObject *parent = nullptr);     \
    virtual  ~vCLASS() { }                          \
    vCLASS(vCLASS const &) = delete;                \
    vCLASS & operator = (vCLASS const &) = delete;  \
public:                                             \
    static vCLASS &I() {                            \
        static vCLASS _instance;                    \
        return        _instance;                    \
    }                                               \
//--------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------//
extern int        gFakeInterval;
extern QByteArray gFakeData;
extern const char*gFakeData_default;
extern bool       gSendEmptyKeepAwake;
extern bool       gFakeSeqAtBegin;
extern bool       gDisableUnhandledReport;
extern bool       gDisableTimeout;
//--------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------//
#define DEBUG_PROPERTY_CHANGED(vVARIABLE, PREFIX)  // qDebug() << "#" << #vVARIABLE << PREFIX##vVARIABLE;
//--------------------------------------------------------------------------------//
#define PROPERTY_SLOT(          vTYPE ,    vVARIABLE )    \
        protected :                                       \
        void vVARIABLE (  const vTYPE & v##vVARIABLE ) {  \
          static bool init = false;                       \
          if ( !init || _##vVARIABLE != v##vVARIABLE ) {  \
                 DEBUG_PROPERTY_CHANGED(vVARIABLE, v)     \
                 init = true;                             \
                 _##vVARIABLE  = v##vVARIABLE;            \
                 emit vVARIABLE##Changed( _##vVARIABLE ); \
          }                                               \
        }
//--------------------------------------------------------------------------------//
#define TRIGGER_SLOT(           vTYPE ,    vVARIABLE  )   \
        protected:                                        \
        void  vVARIABLE ( const vTYPE & v##vVARIABLE  ) { \
            DEBUG_PROPERTY_CHANGED(vVARIABLE, v)          \
            _##vVARIABLE  = v##vVARIABLE;                 \
            emit vVARIABLE##Triggered( _##vVARIABLE );    \
        }
//--------------------------------------------------------------------------------//
#define PROPERTY_BASE(vTYPE , vVARIABLE , vDEFVALUE, vSIGNAL)    \
      Q_PROPERTY(     vTYPE   vVARIABLE                          \
                       READ   vVARIABLE                          \
                       WRITE  vVARIABLE                          \
                       NOTIFY vVARIABLE##vSIGNAL)                \
      Q_SIGNALS:                                                 \
          void vVARIABLE##vSIGNAL( const vTYPE & v##vVARIABLE ); \
        private:                                                 \
          vTYPE    _##vVARIABLE = vDEFVALUE;                     \
        protected:                                               \
          vTYPE       vVARIABLE () const {                       \
            return _##vVARIABLE ;                                \
          }
//--------------------------------------------------------------------------------//
#define PROPERTY(      vTYPE , vVARIABLE , vDEFVALUE            ) \
        PROPERTY_BASE( vTYPE , vVARIABLE , vDEFVALUE , Changed  ) \
        PROPERTY_SLOT( vTYPE , vVARIABLE)
//--------------------------------------------------------------------------------//
#define TRIGGER(       vTYPE , vVARIABLE , vDEFVALUE            ) \
        PROPERTY_BASE( vTYPE , vVARIABLE , vDEFVALUE , Triggered) \
        TRIGGER_SLOT(  vTYPE , vVARIABLE)
//--------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------//
#define ACTION_VIEW_CONNECTION(vTYPE)                                   \
    connect(&_GuiController, SIGNAL(didActionReceive(const vTYPE &)),   \
                       this,   SLOT( onActionReceive(const vTYPE &)));
//--------------------------------------------------------------------------------//
#define ADJUST_VIEW_CONNECTION(vTYPE)                                   \
    connect(           this, SIGNAL(didAdjustment   (const vTYPE &)),   \
            &_GuiController,   SLOT( doAdjustment   (const vTYPE &)));
//--------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------//
#define ACTION_METHOD_BRIDGE_CONNECTION(vMETHOD, vSOURCE, vTYPE)        \
    connect(&vSOURCE, SIGNAL(did##vMETHOD(const    vTYPE &)),           \
            this    ,   SLOT( on##vMETHOD(const    vTYPE &)));
//--------------------------------------------------------------------------------//
#define ACTION_RECEIVE_BRIDGE_CONNECTION(vSOURCE, vTYPE)                \
    ACTION_METHOD_BRIDGE_CONNECTION(ActionReceive, vSOURCE, vTYPE)
//--------------------------------------------------------------------------------//
#define ADJUST_TRANSMT_BRIDGE_CONNECTION(vSOURCE, vTYPE)                \
    ACTION_METHOD_BRIDGE_CONNECTION(Adjustment   , vSOURCE, vTYPE)
//--------------------------------------------------------------------------------//
#define ACTION_RECEIVE_PRIVATE_SLOT(vTYPE)                              \
private Q_SLOTS:                                                        \
    void  onActionReceive (const vTYPE &vData) {                        \
        emit didActionReceive(vData);                                   \
    }
//--------------------------------------------------------------------------------//
#define ADJUST_TRANSMT_PRIVATE_SLOT_DEFINITION(vTYPE)                   \
private Q_SLOTS:                                                        \
    void  onAdjustment    (const vTYPE &vData);
//--------------------------------------------------------------------------------//
#define ADJUST_TRANSMT_PRIVATE_SLOT(vTYPE)                              \
private Q_SLOTS:                                                        \
    void  onAdjustment    (const vTYPE &vData) {                        \
        emit didAdjustment(             vData);                         \
    }
//--------------------------------------------------------------------------------//
#define ADJUST_TRANSMT_PUBLIC_SLOT(vTYPE)                               \
public Q_SLOTS:                                                         \
    void  doAdjustment    (const vTYPE &vData) {                        \
        emit didAdjustment(             vData);                         \
    }
//--------------------------------------------------------------------------------//
#define ACTION_RECEIVE_SIGNAL(vTYPE)                                    \
Q_SIGNALS:                                                              \
    void didActionReceive (const vTYPE &vData);
//--------------------------------------------------------------------------------//
#define ACTION_TRANSMT_SIGNAL(vTYPE)                                    \
Q_SIGNALS:                                                              \
    void didActionTransmit(const vTYPE &vData);
//--------------------------------------------------------------------------------//
#define ADJUST_TRANSMT_SIGNAL(vTYPE)                                    \
Q_SIGNALS:                                                              \
    void didAdjustment    (const vTYPE &vData);
//--------------------------------------------------------------------------------//
#define ACTION_RECEIVE_BRIDGE_DEFINITION(vTYPE)                         \
    ACTION_RECEIVE_PRIVATE_SLOT         (vTYPE)                         \
    ACTION_RECEIVE_SIGNAL               (vTYPE)
//--------------------------------------------------------------------------------//
#define   ADJUST_TRANSMT_BRIDGE_DEFINITION_NOEMIT(vTYPE)                \
    ADJUST_TRANSMT_PRIVATE_SLOT_DEFINITION       (vTYPE)                \
    ADJUST_TRANSMT_SIGNAL                        (vTYPE)
//--------------------------------------------------------------------------------//
#define   ADJUST_TRANSMT_BRIDGE_DEFINITION(vTYPE)                       \
    ADJUST_TRANSMT_PRIVATE_SLOT           (vTYPE)                       \
    ADJUST_TRANSMT_SIGNAL                 (vTYPE)
//--------------------------------------------------------------------------------//
#define   ADJUST_TRANSMT_BRIDGE_DEFINITION_PUBLIC(vTYPE)                \
    ADJUST_TRANSMT_PUBLIC_SLOT                   (vTYPE)                \
    ADJUST_TRANSMT_SIGNAL                        (vTYPE)
//--------------------------------------------------------------------------------//
#define REGISTER_METATYPE(vTYPE)                                        \
    qRegisterMetaType   < vTYPE > (#vTYPE);
//--------------------------------------------------------------------------------//
#define REGISTER_TYPE(vTYPE)                                            \
    qmlRegisterType     < vTYPE > (#vTYPE, 0, 1, #vTYPE);
#define GET_VARIABLE_NAME(VARIABLE) (#VARIABLE)
#define TREATMENT_PARAMETER(TYPE, NAME, DEFVALUE, MIN, MAX, RES)              \
private:                                                                      \
    TYPE _##NAME = DEFVALUE;                                                  \
    TYPE _##NAME##Min = MIN;                                                  \
    TYPE _##NAME##Max = MAX;                                                  \
    TYPE _##NAME##Res = RES;                                                  \
    bool is##NAME##Set = false;                                               \
protected:                                                                    \
    Q_PROPERTY(TYPE NAME                                                      \
               READ get_##NAME                                                \
               WRITE set_##NAME                                               \
               NOTIFY NAME##Changed)                                          \
    Q_PROPERTY(TYPE NAME##Min                                                 \
               READ NAME##Min                                                 \
               WRITE NAME##Min                                                \
               NOTIFY NAME##MinChanged)                                       \
    Q_PROPERTY(TYPE NAME##Max                                                 \
               READ NAME##Max                                                 \
               WRITE NAME##Max                                                \
               NOTIFY NAME##MaxChanged)                                       \
    Q_PROPERTY(TYPE NAME##Res                                                 \
               READ NAME##Res                                                 \
               WRITE NAME##Res                                                \
               NOTIFY NAME##ResChanged)                                       \
    void set_##NAME(const TYPE &p##NAME) {                                    \
        static bool init = false;                                             \
        if ( !init || _##NAME != p##NAME ) {                                  \
            init = true;                                                      \
            _##NAME = p##NAME;                                                \
            DEBUG_PROPERTY_CHANGED(NAME, _)                                   \
            is##NAME##Set = true;                                             \
            emit NAME##Changed(_##NAME);                                      \
            onUserModifiedParameters();                                       \
        }                                                                     \
    }                                                                         \
    TYPE NAME##Min() const { return _##NAME##Min; }                           \
    void NAME##Min(const TYPE &p##NAME##Min)                                  \
        { _##NAME##Min = p##NAME##Min; emit NAME##MinChanged(_##NAME##Min);}  \
    TYPE NAME##Max() const { return _##NAME##Max; }                           \
    void NAME##Max(const TYPE &p##NAME##Max)                                  \
        { _##NAME##Max = p##NAME##Max; emit NAME##MaxChanged(_##NAME##Max);}  \
    TYPE NAME##Res() const { return _##NAME##Res; }                           \
    void NAME##Res(const TYPE &p##NAME##Res)                                  \
        { _##NAME##Res = p##NAME##Res; emit NAME##ResChanged(_##NAME##Res);}  \
    TYPE get_##NAME() const {                                                 \
        return _##NAME;                                                       \
    }                                                                         \
    void reset_##NAME() {                                                     \
        _##NAME = DEFVALUE;                                                   \
        is##NAME##Set = false;                                                \
        emit NAME##Changed(_##NAME);                                          \
    }                                                                         \
Q_SIGNALS:                                                                    \
    void NAME##Changed(const TYPE &p##NAME);                                  \
    void NAME##MinChanged(const TYPE &p##NAME);                               \
    void NAME##MaxChanged(const TYPE &p##NAME);                               \
    void NAME##ResChanged(const TYPE &p##NAME);                               \
    void NAME##_ValidationFailed(const QString &reason);