/*!
 *
 * Copyright (c) 2022-2023 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    VTreatmentCreate(legacy).cpp
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      28-Feb-2022
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  28-Feb-2022
 *
 */

// Qt

// Project
#include "VTreatmentCreate.h"
#include "FileHandler.h"
#include "MsgDefs.h"

using namespace Gui;
using namespace View;
using namespace Storage;

VTreatmentCreate::VTreatmentCreate(QObject *parent) : QObject(parent)
{
    ADJUST_VIEW_CONNECTION(AdjustParametersValidationRequestData )
    ACTION_VIEW_CONNECTION(AdjustParametersValidationResponseData)
    ADJUST_VIEW_CONNECTION(    AdjustParametersConfirmRequestData)


    connect(this, SIGNAL(requestConcurrentSave(QString,QString,bool)),
            &_FileSaver, SLOT(onConcurrentSave(QString,QString,bool)));

    loadTreatmentParameterRanges();
}

/**
 * \brief VCreateTreatment::loadTreatmentParameterRanges
 *  Loads treatment parameters from a json file
 * \return QJsonObject holding the treatment parameters
 */
QJsonObject VTreatmentCreate::loadTreatmentParameterRanges(const QString &path)
{
    QJsonObject obj;
    if (!FileHandler::read(path, obj))
    {
        // TODO: notify user
        LOG_EVENT(tr("Could not load treatment parameter ranges from %1").arg(path));
        return QJsonObject();
    }

    foreach (const QString& key, obj.keys())
    {
        QJsonValue value = obj.value(key);

        if      (key == GET_VARIABLE_NAME(bloodFlowRateMin))                    _bloodFlowRateMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(bloodFlowRateMax))                    _bloodFlowRateMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(dialysateFlowRateMin))                _dialysateFlowRateMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(dialysateFlowRateMax))                _dialysateFlowRateMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(durationMin))                         _durationMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(durationMax))                         _durationMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinDispensingRateMin))            _heparinDispensingRateMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinDispensingRateMax))            _heparinDispensingRateMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinBolusVolumeMin))               _heparinBolusVolumeMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinBolusVolumeMax))               _heparinBolusVolumeMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinStopTimeMin))                  _heparinStopTimeMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(heparinStopTimeMax))                  _heparinStopTimeMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(salineBolusVolumeMin))                _salineBolusVolumeMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(salineBolusVolumeMax))                _salineBolusVolumeMax = value.toInt();
        // options
        else if (key == GET_VARIABLE_NAME(acidConcentrateOptions))              _acidConcentrateOptions = jsonArrayToStringList(value.toArray());
        else if (key == GET_VARIABLE_NAME(bicarbonateConcentrateOptions))       _bicarbonateConcentrateOptions = jsonArrayToStringList(value.toArray());
        else if (key == GET_VARIABLE_NAME(dialyzerTypeOptions))                 _dialyzerTypeOptions = jsonArrayToStringList(value.toArray());

        else if (key == GET_VARIABLE_NAME(dialysateTempMin))                    _dialysateTempMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(dialysateTempMax))                    _dialysateTempMax = value.toInt();
        // arterial
        else if (key == GET_VARIABLE_NAME(arterialPressureLimitLowMin))         _arterialPressureLimitLowMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(arterialPressureLimitLowMax))         _arterialPressureLimitLowMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(arterialPressureLimitHighMin))        _arterialPressureLimitHighMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(arterialPressureLimitHighMax))        _arterialPressureLimitHighMax = value.toInt();
        // venous
        else if (key == GET_VARIABLE_NAME(venousPressureLimitLowMin))           _venousPressureLimitLowMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(venousPressureLimitLowMax))           _venousPressureLimitLowMax = value.toInt();
        else if (key == GET_VARIABLE_NAME(venousPressureLimitHighMin))          _venousPressureLimitHighMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(venousPressureLimitHighMax))          _venousPressureLimitHighMax = value.toInt();

        else if (key == GET_VARIABLE_NAME(bloodPressureMeasureIntervalMin))     _bloodPressureMeasureIntervalMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(bloodPressureMeasureIntervalMax))     _bloodPressureMeasureIntervalMax = value.toInt();

        else if (key == GET_VARIABLE_NAME(rinsebackFlowRateMin))                _rinsebackFlowRateMin = value.toInt();
        else if (key == GET_VARIABLE_NAME(rinsebackFlowRateMax))                _rinsebackFlowRateMax = value.toInt();
        else
        {
            qDebug() << "Invalid treatment parameter range: " << key;
            LOG_EVENT(tr("Invalid treatment parameter found: %0").arg(key));
        }
    }

    return obj;
}

/**
 * \brief VCreateTreatment::onResetCreateTreatment
 *  Resets the create treatment page to the default values.
 *  Disables the continue button.
 */
void VTreatmentCreate::doResetCreateTreatment()
{
    reset_bloodFlowRate();
    reset_dialysateFlowRate();
    reset_duration();
    reset_heparinDispensingRate();
    reset_heparinBolusVolume();
    reset_heparinStopTime();
    reset_salineBolusVolume();
    reset_acidConcentrate();
    reset_bicarbonateConcentrate();
    reset_dialyzerType();
    reset_dialysateTemp();
    reset_arterialPressureLimitLow();
    reset_arterialPressureLimitHigh();
    reset_venousPressureLimitLow();
    reset_venousPressureLimitHigh();
    reset_bloodPressureMeasureInterval();
    reset_rinsebackFlowRate();

    continueEnabled(false);

    emit resetCreateTreatment();
}


/**
 * \brief VCreateTreatment::jsonArrayToStringList
 *  Converts a jsonarray of strings to a QStringList
 * \param arr (QJsonArray) to convert
 * \return (QStringList) The list of strings in the array
 */
QStringList VTreatmentCreate::jsonArrayToStringList(const QJsonArray &arr)
{
    QStringList result;
    foreach (const QJsonValue &val, arr) {
        result.append(val.toString());
    }
    return result;
}

/**
 * \brief VCreateTreatment::setTreatmentData
 *   Assigns treatment parameters to the treatment data structure.
 */
void VTreatmentCreate::setTreatmentData() {

    treatmentData.bloodFlowRate = _bloodFlowRate;
    treatmentData.dialysateFlowRate = _dialysateFlowRate;
    treatmentData.duration = _duration;
    treatmentData.heparinDispensingRate = _heparinDispensingRate;
    treatmentData.heparinBolusVolume = _heparinBolusVolume;
    treatmentData.heparinStopTime = _heparinStopTime;
    treatmentData.salineBolus = _salineBolusVolume;

    treatmentData.acidConcentrate = _acidConcentrate;
    treatmentData.bicarbonateConcentrate = _bicarbonateConcentrate;
    treatmentData.dialyzerType = _dialyzerType;
    treatmentData.dialysateTemp = _dialysateTemp;
    treatmentData.arterialPressureLimitLow = _arterialPressureLimitLow;
    treatmentData.arterialPressureLimitHigh = _arterialPressureLimitHigh;
    treatmentData.venousPressureLimitLow = _venousPressureLimitLow;
    treatmentData.venousPressureLimitHigh = _venousPressureLimitHigh;
    treatmentData.bloodPressureMeasureInterval = _bloodPressureMeasureInterval;
    treatmentData.rinsebackFlowRate = _rinsebackFlowRate;
}

/**
 * \brief VCreateTreatment::onFinishedCreate
 * Validates the treatment profile locally, then requests validation of it with FW
 */
void VTreatmentCreate::doFinishedCreate() {

    setTreatmentData();

    if (!validate(treatmentData))
    {
        qDebug() << "Local create treatment validation failed.";
        LOG_EVENT("Local create treatment validation failed.");
        return;
    }

    // Request that FW validates the selected parameters
    emit didAdjustment(treatmentData);

    LOG_DEBUG("Requesting FW validation of new treatment parameters");

}

/**
 * \brief VCreateTreatment::enumToString
 *  Convenience function to convert an enum to a string
 * \param vEnum - the enum value
 * \return QString - the enum name
 */
QString VTreatmentCreate::enumToString(GuiRequestReasons vEnum)
{
    const QMetaObject *mo = qt_getEnumMetaObject(vEnum);
    int enumIdx = mo->indexOfEnumerator(qt_getEnumName(vEnum));
    QString mText = mo->enumerator(enumIdx).valueToKey(vEnum);
    if ( ! mText.isEmpty() ) {
        return mText;
    }
    return QString("[%1] Unknown Rejection Reason").arg(vEnum);
}

/**
 * \brief VCreateTreatment::onFWValidationResponse
 *  Slot to handle a validation response from FW
 * \param actionType The action type must be a create treatment response
 * \param messageData The message data must contain the reject reason codes for all parameters
 * \returns True if FW OK's treatment parameters, false otherwise
 */
bool VTreatmentCreate::onActionReceive(AdjustParametersValidationResponseData data) {

    bool success = true;
    if (data.bloodFlowRate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        emit scrollToParameter(GET_VARIABLE_NAME(data.bloodFlowRate));
        success = false;
        emit bloodFlowRate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.bloodFlowRate)));
    }
    if (data.dialysateFlowRate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.dialysateFlowRate));
        success = false;
        emit dialysateFlowRate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.dialysateFlowRate)));
    }
    if (data.duration != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.duration));
        success = false;
        emit duration_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.duration)));
    }
    if (data.heparinDispensingRate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.heparinDispensingRate));
        success = false;
        emit heparinDispensingRate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.heparinDispensingRate)));
    }
    if (data.heparinBolusVolume != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.heparinBolusVolume));
        success = false;
        emit heparinBolusVolume_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.heparinBolusVolume)));
    }
    if (data.heparinStopTime != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.heparinStopTime));
        success = false;
        emit heparinStopTime_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.heparinStopTime)));
    }
    if (data.salineBolus != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.salineBolus));
        success = false;
        emit salineBolusVolume_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.salineBolus)));
    }
    if (data.acidConcentrate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.acidConcentrate));
        success = false;
        emit acidConcentrate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.acidConcentrate)));
    }
    if (data.bicarbonateConcentrate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.bicarbonateConcentrate));
        success = false;
        emit bicarbonateConcentrate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.bicarbonateConcentrate)));
    }
    if (data.dialyzerType != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.dialyzerType));
        success = false;
        emit dialyzerType_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.dialyzerType)));
    }
    if (data.dialysateTemp != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.dialysateTemp));
        success = false;
        emit dialysateTemp_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.dialysateTemp)));
    }
    if (data.arterialPressureLimitLow != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.arterialPressureLimitLow));
        success = false;
        emit arterialPressureLimitLow_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.arterialPressureLimitLow)));
    }
    if (data.arterialPressureLimitHigh != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.arterialPressureLimitHigh));
        success = false;
        emit arterialPressureLimitHigh_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.arterialPressureLimitHigh)));
    }
    if (data.venousPressureLimitLow != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.venousPressureLimitLow));
        success = false;
        emit venousPressureLimitLow_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.venousPressureLimitLow)));
    }
    if (data.venousPressureLimitHigh != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.venousPressureLimitHigh));
        success = false;
        emit venousPressureLimitHigh_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.venousPressureLimitHigh)));
    }
    if (data.bloodPressureMeasureInterval != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.bloodPressureMeasureInterval));
        success = false;
        emit bloodPressureMeasureInterval_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.bloodPressureMeasureInterval)));
    }
    if (data.rinsebackFlowRate != Gui::GuiRequestReasons::REQUEST_REJECT_REASON_NONE) {
        if (success) emit scrollToParameter(GET_VARIABLE_NAME(data.rinsebackFlowRate));
        success = false;
        emit rinsebackFlowRate_ValidationFailed(enumToString(static_cast<GuiRequestReasons>(data.rinsebackFlowRate)));
    }

    if (! data.mAccepted) {
        success = false;
        emit fwValidationFailed("");
    }

    qDebug() << "fw validation success = " << success;

    if (success)
    {
        emit fwValidationSuccess();
    }

    return success;
}

/**
 * \brief   VCreateTreatment::onFinishedConfirm
 * \details Emits treatment data to gui controller,
 *          who emits to application controller and the
 *          application controller will save the data to disk.
 * \note    Finished create treatment confirm...
 */
void VTreatmentCreate::doFinishedConfirm() {
    QJsonObject obj {
        {"bloodFlowRate",               QString::number(treatmentData.bloodFlowRate)},
        {"dialysateFlowRate",           QString::number(treatmentData.dialysateFlowRate)},
        {"duration",                    QString::number(treatmentData.duration)},
        {"heparinDispensingRate",       QString::number(treatmentData.heparinDispensingRate)},
        {"heparinBolusVolume",          QString::number(treatmentData.heparinBolusVolume)},
        {"heparinStopTime",             QString::number(treatmentData.heparinStopTime)},
        {"acidConcentrate",             QString::number(treatmentData.acidConcentrate)},
        {"bicarbonateConcentrate",      QString::number(treatmentData.bicarbonateConcentrate)},
        {"dialyzerType",                QString::number(treatmentData.dialyzerType)},
        {"dialysateTemp",               QString::number(treatmentData.dialysateTemp)},
        {"arterialPressureLimitLow",    QString::number(treatmentData.arterialPressureLimitLow)},
        {"arterialPressureLimitHigh",   QString::number(treatmentData.arterialPressureLimitHigh)},
        {"venousPressureLimitLow",      QString::number(treatmentData.venousPressureLimitLow)},
        {"venousPressureLimitHigh",     QString::number(treatmentData.venousPressureLimitHigh)},
        {"bloodPressureMeasureInterval",QString::number(treatmentData.bloodPressureMeasureInterval)},
        {"rinsebackFlowRate",           QString::number(treatmentData.rinsebackFlowRate)}
    };

    QString treatmentParameters = QJsonDocument(obj).toJson(QJsonDocument::Indented);
    LOG_EVENT(QString("Create Treatment Confirm: %1").arg(treatmentParameters));
    if (saveTreatmentProfile())
        saveNewTreatment(obj);

    // Tell FW we confirm
    confirmTreatmentRequest.requestedState = AdjustParametersConfirmRequestData::eConfirm;
    emit didAdjustment(confirmTreatmentRequest);
}

/**
 * \brief   ApplicationController::saveNewTreatment
 * \details Saves a new treatment to the file system.
 * \param   doc - QJsonDocument containing the new treatment parameters.
 * \returns QString - the file to be written to
 *
 */
QString VTreatmentCreate::saveNewTreatment(const QJsonObject &obj, const QString &dir)
{
    QJsonDocument document(obj);
    int i = 0;
    while (QFile(QString("%0treatment%1.json").arg(dir).arg(i)).exists())
    {
        i++;
    }
    QString filename = QString("%0treatment%1.json").arg(dir).arg(i);
    emit requestConcurrentSave(filename, document.toJson(), false);
    return filename;
}

/**
 * \brief   VCreateTreatment::getParameterRangesDataCSV
 * \details Gets the parameter ranges data prepared for CSV file format
 * \return  QString - the data to write to CSV
 */
QString VTreatmentCreate::getParameterRangesDataCSV()
{
    QString csvData;
    QString sep = ",";

    csvData += QString("bloodFlowRateMin,%0\n").arg(bloodFlowRateMin());
    csvData += QString("bloodFlowRateMax,%0\n").arg(bloodFlowRateMax());
    csvData += QString("dialysateFlowRateMin,%0\n").arg(dialysateFlowRateMin());
    csvData += QString("dialysateFlowRateMax,%0\n").arg(dialysateFlowRateMax());
    csvData += QString("durationMin,%0\n").arg(durationMin());
    csvData += QString("durationMax,%0\n").arg(durationMax());
    csvData += QString("heparinDispensingRateMin,%0\n").arg(heparinDispensingRateMin());
    csvData += QString("heparinDispensingRateMax,%0\n").arg(heparinDispensingRateMax());
    csvData += QString("heparinBolusVolumeMin,%0\n").arg(heparinBolusVolumeMin());
    csvData += QString("heparinBolusVolumeMax,%0\n").arg(heparinBolusVolumeMax());
    csvData += QString("heparinStopTimeMin,%0\n").arg(heparinStopTimeMin());
    csvData += QString("heparinStopTimeMax,%0\n").arg(heparinStopTimeMax());
    csvData += QString("salineBolusVolumeMin,%0\n").arg(salineBolusVolumeMin());
    csvData += QString("salineBolusVolumeMax,%0\n").arg(salineBolusVolumeMax());
    csvData += QString("acidConcentrateOptions,%0\n").arg(acidConcentrateOptions().join(sep));
    csvData += QString("bicarbonateConcentrateOptions,%0\n").arg(bicarbonateConcentrateOptions().join(sep));
    csvData += QString("dialyzerTypeOptions,%0\n").arg(dialyzerTypeOptions().join(sep));
    csvData += QString("dialysateTempMin,%0\n").arg(dialysateTempMin());
    csvData += QString("dialysateTempMax,%0\n").arg(dialysateTempMax());
    csvData += QString("arterialPressureLimitLowMin,%0\n").arg(arterialPressureLimitLowMin());
    csvData += QString("arterialPressureLimitLowMax,%0\n").arg(arterialPressureLimitLowMax());
    csvData += QString("arterialPressureLimitHighMin,%0\n").arg(arterialPressureLimitHighMin());
    csvData += QString("arterialPressureLimitHighMax,%0\n").arg(arterialPressureLimitHighMax());
    csvData += QString("venousPressureLimitLowMin,%0\n").arg(venousPressureLimitLowMin());
    csvData += QString("venousPressureLimitLowMax,%0\n").arg(venousPressureLimitLowMax());
    csvData += QString("venousPressureLimitHighMin,%0\n").arg(venousPressureLimitHighMin());
    csvData += QString("venousPressureLimitHighMax,%0\n").arg(venousPressureLimitHighMax());
    csvData += QString("bloodPressureMeasureIntervalMin,%0\n").arg(bloodPressureMeasureIntervalMin());
    csvData += QString("bloodPressureMeasureIntervalMax,%0\n").arg(bloodPressureMeasureIntervalMax());
    csvData += QString("rinsebackFlowRateMin,%0\n").arg(rinsebackFlowRateMin());
    csvData += QString("rinsebackFlowRateMax,%0\n").arg(rinsebackFlowRateMax());

    return csvData;
}

/*!
 * \brief   VCreateTreatment::saveTreatmentRangesCSV
 * \details Saves the treatment ranges to a CSV file
 * \param   filename - the csv file to save the ranges to
 * \return  bool - true if successful, false otherwise
 */
bool VTreatmentCreate::saveTreatmentRangesCSV(const QString &filename)
{
    QString csvData = getParameterRangesDataCSV();
    return FileHandler::write(filename, csvData);
}

/**
 * \brief   VCreateTreatment::validate
 * \details Validates the create new treatment input.
 * \param   vData - the selected TreatmentParametersData
 * \return  true on success, false otherwise.
 */
bool VTreatmentCreate::validate(const AdjustParametersValidationRequestData &vData)
{
    if (!isbloodFlowRateSet                 ) return false;
    if (!isdialysateFlowRateSet             ) return false;
    if (!isdurationSet                      ) return false;
    if (!isheparinDispensingRateSet         ) return false;
    if (!isheparinBolusVolumeSet            ) return false;
    if (!isheparinStopTimeSet               ) return false;
    if (!issalineBolusVolumeSet             ) return false;
    if (!isacidConcentrateSet               ) return false;
    if (!isbicarbonateConcentrateSet        ) return false;
    if (!isdialyzerTypeSet                  ) return false;
    if (!isdialysateTempSet                 ) return false;
    if (!isarterialPressureLimitLowSet      ) return false;
    if (!isarterialPressureLimitHighSet     ) return false;
    if (!isvenousPressureLimitLowSet        ) return false;
    if (!isvenousPressureLimitHighSet       ) return false;
    if (!isbloodPressureMeasureIntervalSet  ) return false;
    if (!isrinsebackFlowRateSet             ) return false;
    return true;
}

/**
 * \brief VCreateTreatment::doUserModifiedParameters
 * Manages enabling / disabling the continue button
 */
void VTreatmentCreate::doUserModifiedParameters()
{
    setTreatmentData();

    continueEnabled(validate(treatmentData));
    emit continueEnabledChanged(continueEnabled());
}

/*!
 * \brief   VCreateTreatment::doGetPrescriptionParameterNames
 * \details Gets a list of the prescription parameter names.
 * \return  (QStringList) A list of the prescription parameter names
 */
QStringList VTreatmentCreate::doGetPrescriptionParameterNames()
{
    return QStringList() << "Blood Flow Rate"
                         << "Dialysate Flow Rate"
                         << "Duration"
                         << "Heparin Dispensing Rate"
                         << "Heparin Bolus Volume"
                         << "Heparin Stop Time"
                         << "Saline Bolus Volume";

}

/*!
 * \brief   VCreateTreatment::doGetPrescriptionParameterValues
 * \details Gets a list of the prescription parameter values
 * \return  (QStringList) The list of parameter values with units
 */
QStringList VTreatmentCreate::doGetPrescriptionParameterValues()
{
    return QStringList() << QString("%0 mL/min").arg(_bloodFlowRate)
                         << QString("%0 mL/min").arg(_dialysateFlowRate)
                         << QString("%0 min").arg(_duration)
                         << QString("%0 mL/hr").arg(_heparinDispensingRate)
                         << QString("%0 mL").arg(_heparinBolusVolume)
                         << QString("%0 min").arg(_heparinStopTime)
                         << QString("%0 mL").arg(_salineBolusVolume);
}

/*!
 * \brief VCreateTreatment::doGetOperatingParameterNames
 *  Gets a list of the operating parameter names
 * \return (QStringList) The list of operating parameter names
 */
QStringList VTreatmentCreate::doGetOperatingParameterNames()
{
    return QStringList() << "Acid Concentrate"
                         << "Bicarbonate Concentrate"
                         << "Dialyzer Type"
                         << "Dialysate Temperature"
                         << "Arterial Pressure Limit Low"
                         << "Arterial Pressure Limit High"
                         << "Venous Pressure Limit Low"
                         << "Venous Pressure Limit High"
                         << "Blood Pressure Measure Interval"
                         << "Rinseback Rate";
}

/*!
 * \brief   VCreateTreatment::doGetOperatingParameterValues
 * \details Gets the operating parameter values
 * \return  (QStringList) The list of operating parameter values with units where applicable
 */
QStringList VTreatmentCreate::doGetOperatingParameterValues()
{
    QString aConcentrate;
    QString bCarbConcentrate;
    QString dType;
    if ((acidConcentrateOptions().length() - 1 < (int)_acidConcentrate))
        aConcentrate = "None";
    else
        aConcentrate = acidConcentrateOptions().at(acidConcentrate());
    if ((bicarbonateConcentrateOptions().length() - 1 < (int)_bicarbonateConcentrate))
        bCarbConcentrate = "None";
    else
        bCarbConcentrate = bicarbonateConcentrateOptions().at(bicarbonateConcentrate());
    if ((dialyzerTypeOptions().length() - 1 < (int)_dialyzerType) || ((int)_dialyzerType < 0))
        dType = "None";
    else
        dType = dialyzerTypeOptions().at(dialyzerType());
    return QStringList() << aConcentrate
                         << bCarbConcentrate
                         << dType
                         << QString("%0 C").arg(_dialysateTemp)
                         << QString("%0 mmHg").arg(_arterialPressureLimitLow)
                         << QString("%0 mmHg").arg(_arterialPressureLimitHigh)
                         << QString("%0 mmHg").arg(_venousPressureLimitLow)
                         << QString("%0 mmHg").arg(_venousPressureLimitHigh)
                         << QString("%0 min").arg(_bloodPressureMeasureInterval)
                         << QString("%0 min").arg(_rinsebackFlowRate);
}

/**
 * \brief   VCreateTreatment::doCancelConfirmParameters
 * \details Notifies FW the user has canceled confirming the treatment parameters
 * \note    Telling FW user is canceling confirm treatment parameters...
 */
void VTreatmentCreate::doCancelConfirmParameters()
{
    confirmTreatmentRequest.requestedState = AdjustParametersConfirmRequestData::eCancel;
    emit didAdjustment(confirmTreatmentRequest);
}