/*!
 *
 * Copyright (c) 2021-2024 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    RxProfiles.h
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      13-Mar-2024
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  04-May-2021
 *
 */
#pragma once

// Qt
#include <QObject>
#include <QFutureWatcher>
#include <QString>

// Project
#include "main.h" // Doxygen : do not remove
#include "Logger.h"

// define
#define _RxProfilesController Storage::RxProfiles::I() //TODO: Change name to be a controller

namespace Storage {


/*!
 * \brief The RxProfiles class
 * This class is the controller which converts/saves/exports model to be used in the UI/RxProfiles
 */
class RxProfiles : public QObject
{
    Q_OBJECT

    const int       _interval       = 1000; // 1s
    const int       _pendingInterval= 60  ; // 1m
          int       _pendingCounter = 0   ; //
    const int       _RxLimit        = 10  ; // SRS-

    const QString   _sep                 = ",";

    QString     _rxProfilesPath;
    const char* _rxProfiles     = "rxp";

    QFutureWatcher<bool> _saveWatcher;
    QFutureWatcher<bool> _exportWatcher;
    QFutureWatcher<bool> _importWatcher;

    QString _dateFormat                     = "yyyy/MM/dd"  ;
    QString _timeFormat                     = "HH:mm"       ;
    QString _datetimeFormat                 = _dateFormat + " " + _timeFormat;

    // TODO : A Unit class needs to be created to have all the unit string and all the required conversions.
    QString _unitTextFlowRate               = tr("mL/min"   );
    QString _unitTextDurationHour           = tr("hour"     );
    QString _unitTextDurationMin            = tr("min"      );
    QString _unitTextConcentration          = tr("mEq/L"    );
    QString _unitTextTemperature            = tr("C"        );
    QString _unitTextVolume                 = tr("L"        );
    QString _unitTextFluid                  = tr("mL"       );
    QString _unitTextHeparinConcentration   = tr("IU/mL"    );
    QString _unitTextDispensingRate         = tr("mL/hr"    );
    QString _unitTextBloodPressure          = tr("mmHg"     );



    enum Role {
        eTitle,
        eValue,
        eCount
    };

    enum RxProfilesIndex {
        eBloodFlowRate                      ,
        eDialysateFlowRate                  ,
        eTreatmentDuration                  ,
        eAcidConcentrateType                ,
        eBicarbonateConcentrateType         ,
        eDialysateTemperature               ,
        eDialyzerType                       ,
        eHeparinConcentration               ,
        eHeparinBolusVolume                 ,
        eHeparinDispenseRate                ,
        eHeparinStop                        ,
        eVitalSigns                         ,
        eProfileName                        ,
        eFavorite                           ,
        eLastModifiedDate                   ,
        eRxProfilesIndexCount
    };

    typedef QHash<QString, RxProfilesIndex> RxKeyMap;

    const QStringList _titles {
        tr("Qb"                         ), // eBloodFlowRate
        tr("Qd"                         ), // eDialysateFlowRate
        tr("Dur"                        ), // eTreatmentDuration
        tr("AC"                         ), // eAcidConcentrateType
        tr("Bicarb"                     ), // eBicarbonateConcentrateType
        tr("dT"                         ), // eDialysateTemperature
        tr("Dialyzer"                   ), // eDialyzerType
        tr("UFH Concentration"          ), // eHeparinConcentration
        tr("UFH Bolus Volume"           ), // eHeparinBolusVolume
        tr("UFH Dispense Rate"          ), // eHeparinDispenseRate
        tr("UFH Stop"                   ), // eHeparinStop
        tr("VS"                         ), // eVitalSigns
    };


    const QStringList _units {
        _unitTextFlowRate                   , // eBloodFlowRate
        _unitTextFlowRate                   , // eDialysateFlowRate
        _unitTextDurationMin                , // eTreatmentDuration
        ""                                  , // eAcidConcentrateType
        ""                                  , // eBicarbonateConcentrateType
        _unitTextTemperature                , // eDialysateTemperature
        ""                                  , // eDialyzerType
        _unitTextHeparinConcentration       , // eHeparinConcentration
        _unitTextFluid                      , // eHeparinBolusVolume
        _unitTextDispensingRate             , // eHeparinDispenseRate
        _unitTextDurationMin                , // eHeparinStop
        _unitTextDurationMin                , // eVitalSigns
    };

    const RxKeyMap    _rxKeyMap {
       { "Qb"       , eBloodFlowRate                    },
       { "Qd"       , eDialysateFlowRate                },
       { "Dur"      , eTreatmentDuration                },
       { "AC"       , eAcidConcentrateType              },
       { "Bicarb"   , eBicarbonateConcentrateType       },
       { "dT"       , eDialysateTemperature             },
       { "Dialyzer" , eDialyzerType                     },
       { "UFHCond"  , eHeparinConcentration             },
       { "UFHVol"   , eHeparinBolusVolume               },
       { "UFHRate"  , eHeparinDispenseRate              },
       { "UFHStop"  , eHeparinStop                      },
       { "VS"       , eVitalSigns                       }
       };

    QString string(quint8 vIndex , const QStringList &vStringList) const {
        QString str = "";
        if (vIndex < vStringList.count()) {
            str = vStringList[vIndex];
            str.remove(_sep);
        }
        return str;
    }

    QString title(quint8 vIndex) const { return string(vIndex, _titles      );}
    QString value(quint8 vIndex) const { return string(vIndex, _values      );}
    QString unit (quint8 vIndex) const { return string(vIndex, _units       );}

    // Lists
    QStringList _values;

    void initConnections();

    bool saveLog            (const QString &fileName);
    void saveLogConcurrent  (const QString &fileName);
    bool exportLog          ();
    void exportLogConcurrent();
    bool importLog          ();
    void importLogConcurrent();

    bool fileLimitReached          ();


    NOTIFIER(isIdle)
    SINGLETON(RxProfiles)

//protected:
//    void timerEvent(QTimerEvent *) override;

public:
    void initModel(const QString &vFile);
    void clearModel() {
        _values.clear();
        for (int i = 0; i < eRxProfilesIndexCount; i++) _values << "";
    }

    const QStringList titles    () const { return _titles   ; }
    const QStringList units     () const { return _units    ; }
    const QStringList values    () const { return _values   ; }

    QString rxProfilesPath      ()                     ;

private slots:
    void    onSave      ();
    void    onExport    ();
    void    onImport    ();

public slots:
    bool    doCreate     (); // check if file limit reached and make a temp file
    bool    doEdit       (const QString &fileName); //Open model to be current
    bool    doDelete     (const QString &fileName);
    bool    doDuplicate  (const QString &fileName); //Check if file limit has been reached and make temp file, then display new screen
//    void    doFavorite   ();
    void    doSave       (const QString &fileName);
    void    doExport     ();
    void    doImport     ();
    void    doInitRxProfiles();
signals:
    void    didNotification             ( const QString &vNotification  );

    void    didFilesList        ( const QString &vRxProfileList , const QStringList &vRxProfile );
    void    didRxProfileList    ( const QFileInfoList &vRxProfileList  );
};

}