#include "VCreateTreatment.h"

// Qt

// Project
#include "filehandler.h"
#include "MsgDefs.h"

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


VCreateTreatment::VCreateTreatment(QObject *parent) : QObject(parent)
{
    connect(&_FileSaver, SIGNAL(fileSaved(bool)),
            this, SLOT(onFinishedSaveNewTreatment(bool)));

    connect(this, SIGNAL(validateParamsWithFW(GuiActionType,QVariantList)),
            &_GuiController, SLOT(doActionTransmit(GuiActionType,QVariantList)));

    connect(&_GuiController, SIGNAL(didActionReceive(GuiActionType,QVariantList)),
            this, SLOT(onFWValidationResponse(GuiActionType,QVariantList)));
    loadTreatmentParameterRanges();

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

/**
 * \brief VCreateTreatment::loadTreatmentParameterRanges
 *  Loads treatment parameters from a json file
 * \return QJsonObject holding the treatment parameters
 */
QJsonObject VCreateTreatment::loadTreatmentParameterRanges(const QString &path)
{
    QJsonObject obj;
    if (!FileHandler::readJSON(path, obj))
    {
        // TODO: notify user
    }

    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();
        // options
        else if (key == GET_VARIABLE_NAME(salineBolusOptions))                  _salineBolusOptions = jsonArrayToStringList(value.toArray());
        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 VCreateTreatment::onResetCreateTreatment()
{
    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 VCreateTreatment::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 VCreateTreatment::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 VCreateTreatment::onFinishedCreate() {

    setTreatmentData();

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


#ifdef QT_DEBUG
    emit showConfirm();
#else
    // Request that FW validates the selected parameters
    QVariantList messageData = {
        treatmentData.bloodFlowRate,
        treatmentData.dialysateFlowRate,
        treatmentData.duration,
        treatmentData.heparinDispensingRate,
        treatmentData.heparinBolusVolume,
        treatmentData.heparinStopTime,
        treatmentData.salineBolus,
        treatmentData.acidConcentrate,
        treatmentData.bicarbonateConcentrate,
        treatmentData.dialyzerType,
        treatmentData.dialysateTemp,
        treatmentData.arterialPressureLimitLow,
        treatmentData.arterialPressureLimitHigh,
        treatmentData.venousPressureLimitLow,
        treatmentData.venousPressureLimitHigh,
        treatmentData.bloodPressureMeasureInterval,
        treatmentData.rinsebackFlowRate
    };
    GuiActionType messageAction = GuiActions::ID_CreateTreatmentReq;

    emit validateParamsWithFW(messageAction, messageData);

    qDebug() << "Requesting FW validation of new treatment parameters";
    LOG_EVENT("Requesting FW validation of new treatment parameters");

#endif
}

/**
 * \brief VCreateTreatment::enumToString
 *  Convenience functiont to convert an enum to a string
 * \param vEnum - the enum value
 * \return QString - the enum name
 */
QString VCreateTreatment::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 VCreateTreatment::onFWValidationResponse(const GuiActionType &actionType, const QVariantList &messageData) {

    if (actionType != GuiActionType::ID_CreateTreatmentRsp)
        return false;

    Model::MTreatmentParametersResponse response;
    AdjustTreatmentParametersResponseData data = response.fromVariantList(messageData);

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

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

    if (success)
        emit showConfirm();

    return success;
}

/**
 * \brief VCreateTreatment::onFinishedConfirm
 * Emits treatment data to gui controller,
 * who emits to application controller and the
 * application controller will save the data to disk.
 */
void VCreateTreatment::onFinishedConfirm() {
    qDebug() << "Finished create treatment confirm...";


    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)}
    };

    if (saveTreatmentProfile())
        saveNewTreatment(obj);

    emit didCreateTreatment(treatmentData);
    emit showPrime();
}

/**
 * \brief ApplicationController::saveNewTreatment
 *  Saves a new treatment to the filesystem.
 * \param doc - QJsonDocument containing the new treatment parameters.
 * \returns QString - the file to be written to
 *
 */
QString VCreateTreatment::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
 *  Gets the parameter ranges data prepared for CSV file format
 * @return QString - the data to write to CSV
 */
QString VCreateTreatment::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("salineBolusOptions,%0\n").arg(salineBolusOptions().join(sep));
    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
 *  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 VCreateTreatment::saveTreatmentRangesCSV(const QString &filename)
{
    QString csvData = getParameterRangesDataCSV();

    return FileHandler::write(filename, csvData);
}

void VCreateTreatment::onFinishedSaveNewTreatment(bool success)
{
    if (success) {
        qDebug() << "------------------> Saved a new treatment.";
    } else {
        qDebug() << "------------------> Failed to save new treatment.";
    }
}

/**
 * \brief VCreateTreatment::onFnishedPrime
 * Called when priming qml selections are complete.
 * TODO: Placed here for now. Likely will be moved eventually.
 */
void VCreateTreatment::onFinishedPrime() {
    qDebug() << "Finished create treatment prime...";
    emit showBegin();

}

/**
 * \brief VCreateTreatment::start
 * Called when user is ready to begin a new treatment.
 * TODO: Placed here for now. Likely will be moved eventually.
 */
void VCreateTreatment::onStart() {
    qDebug() << "Starting Begin Treatment...";

}

/**
 * \brief VCreateTreatment::validate
 *  Validates the create new treatment input.
 * \param vData - the selected TreatmentParametersData
 * \return true on success, false otherwise.
 */
bool VCreateTreatment::validate(const AdjustTreatmentParametersRequestData &vData)
{
    bool success = true;

    if (!isbloodFlowRateSet)
        success = false;

    if (!isdialysateFlowRateSet)
        success = false;

    if (!isdurationSet)
        success = false;

    if (!isheparinDispensingRateSet)
        success = false;

    if (!isheparinBolusVolumeSet)
        success = false;

    if (!isheparinStopTimeSet)
        success = false;

    if (!issalineBolusVolumeSet)
        success = false;

    if (!isacidConcentrateSet)
        success = false;

    if (!isbicarbonateConcentrateSet)
        success = false;

    if (!isdialyzerTypeSet)
        success = false;

    if (!isdialysateTempSet)
        success = false;

    if (!isarterialPressureLimitLowSet)
        success = false;

    if (!isarterialPressureLimitHighSet)
        success = false;

    if (!isvenousPressureLimitLowSet)
        success = false;

    if (!isvenousPressureLimitHighSet)
        success = false;

    if (!isbloodPressureMeasureIntervalSet)
        success = false;

    if (!isrinsebackFlowRateSet)
        success = false;

    if (!success) {
        return false;
    }
    if (vData.bloodFlowRate < _bloodFlowRateMin ||
            vData.bloodFlowRate > _bloodFlowRateMax)
    {
        emit bloodFlowRate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.dialysateFlowRate < _dialysateFlowRateMin ||
            vData.dialysateFlowRate > _dialysateFlowRateMax )
    {
        emit dialysateFlowRate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.duration < _durationMin || vData.duration > _durationMax)
    {
        emit duration_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.heparinDispensingRate < _heparinDispensingRateMin ||
            vData.heparinDispensingRate > _heparinDispensingRateMax)
    {
        emit heparinDispensingRate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.heparinBolusVolume < _heparinBolusVolumeMin ||
            vData.heparinBolusVolume > _heparinBolusVolumeMax)
    {
        emit heparinBolusVolume_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }

    if (vData.heparinStopTime < _heparinStopTimeMin ||
            vData.heparinStopTime > _heparinStopTimeMax)
    {
        emit heparinStopTime_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }

    if (!indexInItems(vData.salineBolus, _salineBolusOptions))
    {
        emit salineBolusVolume_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (!indexInItems(vData.acidConcentrate, _acidConcentrateOptions))
    {
        emit acidConcentrate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (!indexInItems(vData.bicarbonateConcentrate, _bicarbonateConcentrateOptions))
    {
        emit bicarbonateConcentrate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (!indexInItems(vData.dialyzerType, _dialyzerTypeOptions))
    {
        emit dialyzerType_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.dialysateTemp < _dialysateTempMin ||
            vData.dialysateTemp > _dialysateTempMax)
    {
        emit dialysateTemp_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.arterialPressureLimitLow < _arterialPressureLimitLowMin ||
            vData.arterialPressureLimitLow > _arterialPressureLimitLowMax ||
                vData.arterialPressureLimitLow > vData.arterialPressureLimitHigh)
    {
        emit arterialPressureLimitLow_ValidationFailed(uiRejections.value(LOW_HIGH_INCOMPATIBLE));
        success = false;
    }
    if (vData.arterialPressureLimitHigh < _arterialPressureLimitHighMin ||
            vData.arterialPressureLimitHigh > _arterialPressureLimitHighMax ||
                vData.arterialPressureLimitHigh < vData.arterialPressureLimitLow)
    {
        emit arterialPressureLimitHigh_ValidationFailed(uiRejections.value(LOW_HIGH_INCOMPATIBLE));
        success = false;
    }
    if (vData.venousPressureLimitLow < _venousPressureLimitLowMin ||
            vData.venousPressureLimitLow > _venousPressureLimitLowMax ||
                vData.venousPressureLimitLow > vData.venousPressureLimitHigh)
    {
        emit venousPressureLimitLow_ValidationFailed(uiRejections.value(LOW_HIGH_INCOMPATIBLE));
        success = false;
    }
    if (vData.venousPressureLimitHigh < _venousPressureLimitHighMin ||
            vData.venousPressureLimitHigh > _venousPressureLimitHighMax ||
                vData.venousPressureLimitHigh < vData.venousPressureLimitLow)
    {
        emit venousPressureLimitHigh_ValidationFailed(uiRejections.value(LOW_HIGH_INCOMPATIBLE));
        success = false;
    }
    if (vData.bloodPressureMeasureInterval < _bloodPressureMeasureIntervalMin ||
            vData.bloodPressureMeasureInterval > _bloodPressureMeasureIntervalMax)
    {
        emit bloodPressureMeasureInterval_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }
    if (vData.rinsebackFlowRate < _rinsebackFlowRateMin ||
            vData.rinsebackFlowRate > _rinsebackFlowRateMax)
    {
        emit rinsebackFlowRate_ValidationFailed(uiRejections.value(OUT_OF_RANGE));
        success = false;
    }

    return success;
}

/**
 * \brief VCreateTreatment::indexInItems
 *  Checks if the index is in the QStringList
 * \param idx (int) the index
 * \param items (QStringList) The list of strings to check
 * \return True if it is in the list, false otherwise
 */
bool VCreateTreatment::indexInItems(quint32 idx, const QStringList &items)
{
    if (idx > (quint32)items.size() - 1)
        return false;
    else
        return true;
}

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

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