/*!
 *
 * 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    VCommonAdjustmentVitals.cpp
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      10-Jan-2024
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  23-Jun-2021
 *
 */
#include "VCommonAdjustmentVitals.h"

// Qt
#include "QDateTime"

// Project
#include "GuiController.h"
#include "TreatmentLog.h"
//#include "BluetoothInterface.h"

VIEW_DEF_CLASS_ADJUSTMENT(VTreatmentVitals)

/*!
 * \brief   Connection Initializer
 * \details All the class signal/slot connections are defined here.
*/
void View::VTreatmentVitals::initConnections() {
    connect(this, SIGNAL(  intervalChanged  (const quint8 &)),
            this,   SLOT(onIntervalChanged  (              )));
}

void View::VTreatmentVitals::onActionReceive(const TreatmentVitalsData &vData)
{
//    update_rt      (vData.mSystolic, vData.mDiastolic, vData.mHeartRate);
    update      (vData.mSystolic, vData.mDiastolic, vData.mHeartRate);
    emit didTrigger(vData.mSystolic, vData.mDiastolic, vData.mHeartRate);

    qDebug() << tr("**************8Vital received,%1,%2,%3")
                     .arg(vData.mSystolic )
                     .arg(vData.mDiastolic)
                     .arg(vData.mHeartRate);

    LOG_APPED_UI(tr("Vital received,%1,%2,%3")
                     .arg(vData.mSystolic )
                     .arg(vData.mDiastolic)
                     .arg(vData.mHeartRate));
}

/*!
 * \brief   View::VTreatmentVitals::doConfirm
 * \details Append the user measured BP/HR in to the list of the Treatment Log Average data
 * \param   vSystolic   - Blood Pressure Systolic
 * \param   vDiastolic  - Blood Pressure Diastolic
 * \param   vHeartRate  - Heart Rate
 */
void View::VTreatmentVitals::doConfirm( quint16 vSystolic,
                                        quint16 vDiastolic,
                                        quint16 vHeartRate) {
    adjustment_Accepted         ( true );
    adjustment_Reason           ( 0    );

    update(vSystolic, vDiastolic, vHeartRate);
    treatmentLog();
    LOG_APPED_UI(tr("Vital Confirmed,%1,%2,%3")
              .arg(_systolic )
              .arg(_diastolic)
              .arg(_heartRate)
              );
    timerReset();
}

/*!
 * \brief   View::VTreatmentVitals::doSkip
 * \details logs the vital entry skip
 */
void View::VTreatmentVitals::doSkip()
{
    LOG_APPED_UI(tr("Vital Skipped"));
    timerReset();
}

/*!
 * \brief   View::VTreatmentVitals::doReset
 * \details reset the previously read vital values
 * \param   vEnabled - Disable or enable the vitals.
 * \note    it's still unknown that how to stop in case of the treatment ended by alarm or system fault.
 */
void View::VTreatmentVitals::doReset()
{
    epoch          ( 0 );
    lastRead       ( "");
    systolic       ( 0 );
    diastolic      ( 0 );
    heartRate      ( 0 );

    enableDialog   ( 0 );

    // force notify the Gui
    emit epochChanged       ( 0 );
    emit lastReadChanged    ( "");
    emit systolicChanged    ( 0 );
    emit diastolicChanged   ( 0 );
    emit heartRateChanged   ( 0 );
}

/*!
 * \brief   View::VTreatmentVitals::update
 * \details updating the properties and set the timestamp
 * \param   vSystolic   - Blood Pressure Systolic
 * \param   vDiastolic  - Blood Pressure Diastolic
 * \param   vHeartRate  - Heart Rate
 */
void View::VTreatmentVitals::update(quint16 vSystolic, quint16 vDiastolic, quint16 vHeartRate)
{
    QDateTime    currentDateTime = QDateTime::currentDateTime();
    epoch       (currentDateTime.toSecsSinceEpoch());
    lastRead    (currentDateTime.toString(_Settings.getDatetimeFormat()));
    systolic    ( vSystolic  );
    diastolic   ( vDiastolic );
    heartRate   ( vHeartRate );

    // *** has to be the last to let the information to be set and then emit the signal ***
    // *** otherwise will use the previous values before being set.                     ***
    adjustment(true);
}

/*!
 * \brief   View::VTreatmentVitals::update_rt
 * \details The vital properties will only be updated if the user confirms the read values.
 *          But this ones are for debugging purposes and will be updated all the time in Real Time when the vitals received.
 * \param   vSystolic   - Blood Pressure Systolic
 * \param   vDiastolic  - Blood Pressure Diastolic
 * \param   vHeartRate  - Heart Rate
 */
void View::VTreatmentVitals::update_rt(quint16 vSystolic, quint16 vDiastolic, quint16 vHeartRate)
{
    systolic__rt   ( vSystolic  );
    diastolic_rt   ( vDiastolic );
    heartRate_rt   ( vHeartRate );
}

/*!
 * \brief   View::VTreatmentVitals::treatmentLog
 * \details Appends the vitals values to the treatment log list (for later store in the TxLog at the end of Tx)
 * \note    the method update has to be called before calling this method to update the property values used in this method.
 */
void View::VTreatmentVitals::treatmentLog()
{
    TreatmentLogAvrgeData data  ;
    data.mTimeStamp = _epoch    ;
    data.mSystolic  = _systolic ;
    data.mDiastolic = _diastolic;
    data.mHeartRate = _heartRate;
    _TreatmentLog.append(data)  ;
}

/*!
 * \brief   View::VTreatmentVitals::timerEvent
 * \details The override method to handle the timer for the vital measurement interval
 */
void View::VTreatmentVitals::timerEvent(QTimerEvent *)
{
    if ( ! _timerId  ) return; // No timer started or failed starting
    if ( ! _interval ) return; // if interval is 0/OFF return

    /* DEBUG:*/ qDebug() << __FUNCTION__ << _counter_sec << _counter_min << _interval << _timerId;
    _counter_sec++;

    min_left(_counter_min     );
    sec_left(60 - _counter_sec);

    countdown(QStringLiteral("%1:%2").arg(_min_left,2,10,QChar('0')).arg(_sec_left,2,10,QChar('0')));

    if ( _counter_sec % 60 ) return; // only check every minute

    if ( ! _counter_min ) {
        timerStop();
        qDebug() << "**** TIME IS UP" ;
        emit didTrigger();
    }
    else {
        _counter_min--;
        _counter_sec = 0;
    }
}

void View::VTreatmentVitals::onIntervalChanged()
{
    /* DEBUG: */qDebug() << __FUNCTION__ << _counter_sec << _counter_min << _interval << _timerId;
    if ( _interval ) timerReset();
    else             timerStop (); // Timer stop is resetting timer too.
}

/*!
 * \brief   View::VTreatmentVitals::start
 * \details Starts the timer by 1 min interval
 * \note    the vital times are all minutes.
 */
void View::VTreatmentVitals::timerStart()
{
    if (   _timerId  ) killTimer(_timerId); // this typically should not happen.
    if ( ! _interval ) return;              // if interval is 0/OFF return
    /* DEBUG:*/ qDebug() << __FUNCTION__ << _counter_sec << _counter_min << _interval << _timerId;
    timerReset();
    _timerId = startTimer(1000); // 1 sec interval which will used as 1 min in timerEvent (easier to debug)
}


void View::VTreatmentVitals::timerReset()
{
    if ( _interval ) {
        // ( -1 ) :the interval is 0 based but if as an example we set the counter to 5 then 5 itself gets a minute to pass which makes it 6 min.
        _counter_min = _interval - 1;
    }
    else { // if _interval == 0, counter should set to 0 too not to -1
        _counter_min = 0;
    }
    _counter_sec = 0;
    /* DEBUG: */qDebug() << __FUNCTION__ << _counter_sec << _counter_min << _interval << _timerId;
}

/*!
 * \brief   View::VTreatmentVitals::stop
 * \details stops the timer and resets the interval
 */
void View::VTreatmentVitals::timerStop()
{
    if ( ! _timerId  ) return; // No timer started or failed starting
     /*DEBUG:*/ qDebug() << __FUNCTION__ << _counter_sec << _counter_min << _interval << _timerId;
    killTimer(_timerId);
    _timerId        = 0;
    timerReset();
}