###########################################################################
#
# Copyright (c) 2020-2023 Diality Inc. - All Rights Reserved.
#
# 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    dd_selection_handler.py
# @author  (last)      Mohammad Suleiman
# @date    (original)  11--2023
#
############################################################################

from ..common import *
from ..protocols.CAN import DenaliMessage, DenaliChannels
from ..utils import *
from time import time
from random import random


def reset(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_INIT.value)
    rsp_payload += integer_to_bytearray(HDInitStates.POST_STATE_START.value)
    parent.demoSelection = 2  # setup event to change state on demoTimer
    parent.demoCount = 3
    parent.demoGroupCount = None
    return rsp_id, rsp_payload


def auto_transit_to_standby(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_STAN.value)
    rsp_payload += integer_to_bytearray(HDStandbyStates.STANDBY_START_STATE.value)
    parent.demoSelection = 0  # wait for user
    return rsp_id, rsp_payload


def filter_flush(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_PRET.value)
    rsp_payload += integer_to_bytearray(PreTreatmentSubModes.HD_PRE_TREATMENT_WATER_SAMPLE_STATE.value)
    parent.demoSelection = 5  # <TBD next is Water Sample
    parent.demoCount = 2 * 60  # TBD const
    parent.demoCountdownId = MsgIds.MSG_ID_DG_FILTER_FLUSH_PROGRESS_DATA
    parent.demoCountdownChannel = DenaliChannels.dg_to_ui_ch_id  # flush is a DG action
    return rsp_id, rsp_payload


def water_sample(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_WATER_SAMPLE_STATE.value,
        PreTreatmentSampleWaterStates.SAMPLE_WATER_STATE.value,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    parent.demoSelection = 0  # wait for user
    parent.demoCountdownChannel = None  # release to use default
    parent.demoCountdownId = None
    return rsp_id, rsp_payload


def consumable_self_test(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE.value,
        0,  # 0  Water sample state
        parent.demoTimedIncValue,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    return rsp_id, rsp_payload


def cartridge_self_test(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE.value,
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        PreTreatmentNoCartSelfTestStates.NO_CART_SELF_TESTS_PRESSURE_CHECKS_STATE.value,
        # TBD!  2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    parent.demoCountdownId = MsgIds.MSG_ID_HD_NO_CART_SELF_TEST_PROGRESS_DATA
    parent.demoSelection = 8  # Setup event to change to HD_PRE_TREATMENT_CART_INSTALL_STATE
    parent.demoCount = 30
    return rsp_id, rsp_payload


def cartridge_installation(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_CART_INSTALL_STATE.value,
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # TBD! 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    parent.demoSelection = 0  # TBD! setup event to change to // Wait for user
    return rsp_id, rsp_payload


def dry_self_test(parent):
    if parent.demoTimedIncValue == PreTreatmentDrySelfTestsStates.DRY_SELF_TESTS_STOPPED_STATE.value:  # Skip Stop state
        parent.demoTimedIncValue = PreTreatmentDrySelfTestsStates.DRY_SELF_TESTS_COMPLETE_STATE.value  # And move to Complete state
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_SELF_TEST_DRY_STATE.value,
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        parent.demoTimedIncValue,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    if parent.demoTimedIncValue >= PreTreatmentDrySelfTestsStates.NUM_OF_DRY_SELF_TESTS_STATES.value - 1:
        parent.demoTimedIncValue = PreTreatmentPrimeStates.HD_PRIME_WAIT_FOR_USER_START_STATE.value - 1  # 1st pass is v+1
        parent.demoSelection = 10  # TBD! setup event to change to  ... Wait for User
        parent.demoCount = 0  # TBD! don't advance until user 'Start Prime'
    else:
        parent.demoCountdownId = MsgIds.MSG_ID_HD_DRY_SELF_TEST_PROGRESS_DATA
        # TBD setup above: parent.demoGroupCount = 14 * 4  # aggregate counter

    return rsp_id, rsp_payload


def prime_circuits_with_dialysate(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_PRIME_STATE.value,
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 4 Self-tests when the cartridge is dry state
        parent.demoTimedIncValue,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    parent.demoCountdownId = MsgIds.MSG_ID_HD_PRIMING_STATUS_DATA
    parent.demoGroupCount = PreTreatmentPrimeStates.NUM_OF_HD_PRIME_STATES.value * 5  # aggregate count up to  TBD! cleanup numbers
    if parent.demoTimedIncValue == PreTreatmentPrimeStates.HD_PRIME_WAIT_FOR_USER_START_STATE.value:
        parent.demoSelection = 0  # Wait for User
        # parent.demoGroupCounter = 0  # aggregate counter
    # TBD! could skip HD_PRIME_PAUSE?
    elif parent.demoTimedIncValue >= PreTreatmentPrimeStates.NUM_OF_HD_PRIME_STATES.value - 1:
        parent.demoTimedIncValue = None  ## TBD!!
        parent.demoSelection = 11  # on next countdown transition
        parent.demoCount = 0  # immediate timeout  # TBD!! Hack to make counter neat
        parent.demoGroupCounter = parent.demoGroupCount  # aggregate counter
    # TBD else:
    # TBD    parent.demoCountdownId = MsgIds.MSG_ID_HD_PRIMING_STATUS_DATA  # TBD! need an aggregate time/timer
    return rsp_id, rsp_payload


def recirculate_primed_circuits_1(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_RECIRCULATE_STATE.value,
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        PreTreatmentRecircStates.PRE_TREATMENT_RECIRC_STATE.value,
        # 6 Re-circulate blood and dialysate circuits state
        0,  # 7 Patient connection state
        0,
        0
    )
    parent.demoSelection = 0  # Then wait for User
    parent.demoGroupCount = None  # clear aggregate count
    return rsp_id, rsp_payload


def recirculate_primed_circuits_2(parent):
    rsp_id = MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA
    rsp_payload = struct.pack(
        "<" + str(PreTreatmentSubModes.NUM_OF_HD_PRE_TREATMENT_STATES.value + 1) + "i",
        PreTreatmentSubModes.HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE.value,
        0,  # 0  Water sample state
        0,  # 1 Consumable self-tests state
        0,  # 2 No cartridge self-tests state
        0,  # 3 Consumable and cartridge installation state
        0,  # 4 Self-tests when the cartridge is dry state
        0,  # 5 Prime blood and dialysate circuits and run wet self-tests state
        0,  # 6 Re-circulate blood and dialysate circuits state
        PreTreatmentPatientConnectionStates.PRE_TREATMENT_PAT_CONN_WAIT_FOR_UF_VOL_STATE.value,
        # 7 Patient connection state
        0,
        0
    )
    parent.demoSelection = 0  # Then wait for User
    parent.demoGroupCount = None  # clear aggregate count
    return rsp_id, rsp_payload


def start_treatment(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_TREA.value)
    rsp_payload += integer_to_bytearray(0)
    parent.demoCountdownId = MsgIds.MSG_ID_HD_BLOOD_PRIME_PROGRESS_DATA
    parent.demoCount = 0
    parent.demoCounter = 1
    # parent.demoGroupCount = int(120 / 8)  # TBD! fix const numbers
    # parent.demoGroupCount = -1
    parent.demoSelection = 21  # Initiate Blood Prime
    parent.blood_prime_set_point_blood_flow = 20
    return rsp_id, rsp_payload


def blood_prime(parent):
    rsp_id = MsgIds.MSG_ID_TREATMENT_STATE_DATA
    rsp_payload = struct.pack("<10i",
                              TreatmentStates.TREATMENT_BLOOD_PRIME_STATE.value,  # 0 Treatment Submode
                              0,  # 1 UF state
                              0,  # 2 Saline bolus state
                              0,  # 3 Hep state
                              0,  # 4 Rinseback state
                              0,  # 5 Recirc state
                              0,  # 6 Blood Prime state
                              0,  # 7 End state
                              0,  # 8 Stop state
                              0,  # 9 Dialysis state
                              )
    parent.demoSelection = 22  # Complete Blood Prime -> Dialysis
    parent.demoCountdownId = MsgIds.MSG_ID_HD_BLOOD_PRIME_PROGRESS_DATA
    parent.demoCount = int(120 / 8)  # TBD! fix const numbers
    parent.demoCounter = -1  # give slight delay
    return rsp_id, rsp_payload


def start_dialysis(parent):
    rsp_id = None
    rsp_payload = None
    # preset timing info
    parent.treatment_start_time_s = time()
    parent.cmd_set_treatment_time(sec_total=parent.treatment_time_sec, sec_elapsed=0,
                                sec_remain=parent.treatment_time_sec)
    parent.heparin_out_ml = parent.heparin_bolus_ml
    if parent.heparin_bolus_ml > 0:
        parent.heparin_state = HeparinStates.HEPARIN_STATE_INITIAL_BOLUS  # Initial heparin bolus delivery in progress
    else:
        parent.heparin_state = HeparinStates.HEPARIN_STATE_STOPPED  # Heparin delivery stopped by alarm or not yet started
    parent.uf_state = TreatmentDialysisStates.DIALYSIS_START_STATE  # 0 Treatment Submode

    parent.demoCount = parent.demoSpeed - 1
    parent.demoGroupCount = parent.treatment_time_sec  # TBD!! replace with user setting
    parent.demoGroupCounter = 0
    parent.demoSelection = 29  # start dialysis
    return rsp_id, rsp_payload


def enter_normal_uf(parent):
    rsp_id = MsgIds.MSG_ID_TREATMENT_STATE_DATA
    parent.uf_state = TreatmentDialysisStates.DIALYSIS_UF_STATE  # 1 UF state
    parent.saline_state = SalineBolusStates.SALINE_BOLUS_STATE_IDLE  # 2 Saline bolus state
    rsp_payload = struct.pack("<10i",
                              TreatmentStates.TREATMENT_DIALYSIS_STATE.value,  # 0 Treatment Submode
                              parent.uf_state.value,  # 1 UF state
                              parent.saline_state.value,  # 2 Saline bolus state
                              parent.heparin_state.value,  # 3 Hep state
                              0,  # 4 Rinseback state
                              0,  # 5 Recirc state
                              0,  # 6 Blood Prime state
                              0,  # 7 End state
                              0,  # 8 Stop state
                              0,  # 9 Dialysis state
                              )
    parent.demoSelection = 30  # ongoing data update
    return rsp_id, rsp_payload


def dialysis_data_update(parent):
    rsp_id = None
    rsp_payload = None
    parent.blood_stop_time_s = time()  # reset timer
    parent.treatment_stop_time_s = parent.blood_stop_time_s
    prev_heparin_state = parent.heparin_state
    prev_saline_state = parent.saline_state

    # MSG_ID_BLOOD_FLOW_DATA
    parent.blood_flow_measured_ml_per_min += (random() - 0.5) * 10  # TBD! replace magic numbers
    if parent.blood_flow_measured_ml_per_min > (parent.blood_flow_set_point_ml_per_min + 30):
        parent.blood_flow_measured_ml_per_min -= 5
    parent.cmd_set_treatment_blood_flow_rate(flow_set_pt=parent.blood_flow_set_point_ml_per_min,
                                           measured_flow=parent.blood_flow_measured_ml_per_min,
                                           rot_speed=0, mot_speed=0, mc_speed=0,
                                           mc_current=0, pwm=0, rotor_count=0,
                                           pres_flow=parent.blood_flow_set_point_ml_per_min, rotor_hall=0)

    # MSG_ID_DIALYSATE_FLOW_DATA
    parent.dialysate_flow_measured_ml_per_min += (random() - 0.5) * 5  # TBD! replace magic numbers
    if parent.dialysate_flow_measured_ml_per_min > (parent.dialysate_flow_set_point_ml_per_min + 30):
        parent.dialysate_flow_measured_ml_per_min -= 5
    parent.cmd_set_treatment_dialysate_flow_rate(flow_set_pt=parent.dialysate_flow_set_point_ml_per_min,
                                               measured_flow=parent.dialysate_flow_measured_ml_per_min,
                                               rot_speed=0.0,
                                               mot_speed=0.0,
                                               mc_speed=0.0,
                                               mc_current=0.0,
                                               pwm=0.0,
                                               rotor_count=0,
                                               presFlow=parent.dialysate_flow_set_point_ml_per_min,
                                               rotorHall=0)

    # MSG_ID_PRESSURE_OCCLUSION_DATA

    arterial_min_limit = int(parent.arterial_pressure_mid_mmHg - (parent.demo_treatment_params.data_int[
                            TreatmentParameters.TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW.value] / 2))

    arterial_max_limit = int(parent.arterial_pressure_mid_mmHg + (parent.demo_treatment_params.data_int[
                            TreatmentParameters.TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW.value] / 2))

    venous_min_limit = int(parent.venous_pressure_mid_mmHg - (parent.demo_treatment_params.data_int[
                            TreatmentParameters.TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW.value] / 2))

    venous_max_limit = int(parent.venous_pressure_mid_mmHg + (parent.demo_treatment_params.data_int[
                            TreatmentParameters.TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW.value] / 2))

    parent.arterial_pressure_mmHg += (random() - 0.5) * 10  # TBD! replace magic wander numbers

    if parent.arterial_pressure_mmHg > (parent.arterial_pressure_mid_mmHg + 30):
        parent.arterial_pressure_mmHg -= 5
    # Stay within limits
    if int(parent.arterial_pressure_mmHg) < arterial_min_limit:
        parent.arterial_pressure_mmHg = arterial_min_limit
    elif int(parent.arterial_pressure_mmHg) > arterial_max_limit:
        parent.arterial_pressure_mmHg = arterial_max_limit

    parent.venous_pressure_mmHg += (random() - 0.5) * 10
    if parent.venous_pressure_mmHg > (parent.venous_pressure_mid_mmHg + 30):
        parent.venous_pressure_mmHg -= 5
    # Stay within limits
    if int(parent.venous_pressure_mmHg) < venous_min_limit:
        parent.venous_pressure_mmHg = venous_min_limit
    elif int(parent.venous_pressure_mmHg) > venous_max_limit:
        parent.venous_pressure_mmHg = venous_max_limit
    parent.cmd_set_pressure_occlusion_data(arterial_prs=parent.arterial_pressure_mmHg,
                                         venous_prs=parent.venous_pressure_mmHg,
                                         blood_pump_occlusion=0,
                                         pressure_limit_state=0,
                                         arterial_min_limt=arterial_min_limit,
                                         arterial_max_limt=arterial_max_limit,
                                         venous_min_limit=venous_min_limit,
                                         venous_max_limit=venous_max_limit,
                                         arterial_long_filtered_pressure=parent.arterial_pressure_mmHg,
                                         venous_long_filtered_pressure=parent.venous_pressure_mmHg)
    # MSG_ID_RTC_EPOCH
    # tbd!

    # MSG_ID_DIALYSATE_OUT_FLOW_DATA
    # TBD!! parameters seem swapped and off by 1000x ??
    # parent.cmd_set_treatment_ultrafiltration_outlet_flow_data(ref_uf_vol=parent.uf_volume_set_l,
    #                                                         measured_uf_vol=parent.uf_volume_out_l,
    #                                                         rot_speed=0.0, mot_speed=0.0, mc_speed=0.0,
    #                                                         mc_current=0.0, pwm=0.0)
    parent.uf_volume_out_l = min(parent.uf_volume_out_l + parent.uf_rate_l_per_sec, parent.uf_volume_set_l)
    parent.cmd_set_treatment_ultrafiltration_outlet_flow_data(ref_uf_vol=parent.uf_volume_out_l * 1000.0,
                                                        measured_uf_vol=parent.uf_volume_set_l * 1000.0,
                                                        rot_speed=0.0, mot_speed=0.0, mc_speed=0.0,
                                                        mc_current=0.0, pwm=0.0, corr_offset=0.0,
                                                        pump_calculated_rate=0.0, uf_calculated_rate=0.0,
                                                        rotor_hall=0, current_uf_rate=(parent.uf_rate_l_per_sec * 60))

    # MSG_ID_LOAD_CELL_READINGS

    # MSG_ID_TREATMENT_TIME
    if parent.treatment_time_sec != parent.demoGroupCount:  # handle user change in treatment time
        parent.demoGroupCount = max(parent.treatment_time_sec, parent.demoGroupCounter)

    ctr_elapsed_sec = min(parent.demoGroupCounter, parent.demoGroupCount)
    ctr_remain_sec = parent.demoGroupCount - parent.demoGroupCounter

    parent.cmd_set_treatment_time(sec_total=parent.demoGroupCount, sec_elapsed=ctr_elapsed_sec,
                                sec_remain=ctr_remain_sec)

    parent.demoGroupCounter -= 1  # TBD! effectively freeze countdown MAYBE?

    # MSG_ID_HD_HEPARIN_DATA_BROADCAST
    if ctr_remain_sec < (parent.heparin_stop_min * 60.0):
        parent.heparin_state = HeparinStates.HEPARIN_STATE_COMPLETED
    else:
        if parent.heparin_pause == False:
            parent.heparin_out_ml += parent.heparin_rate_ml_per_s * parent.demoSpeed
            parent.heparin_state = HeparinStates.HEPARIN_STATE_DISPENSING
        else:
            parent.heparin_state = HeparinStates.HEPARIN_STATE_PAUSED

        parent.heparin_expected_ml = (ctr_remain_sec - (
                    parent.heparin_stop_min * 60.0)) * parent.heparin_rate_ml_per_s + parent.heparin_out_ml
        parent.cmd_set_treatment_heparin_data(cumulative=parent.heparin_out_ml, required=parent.heparin_expected_ml)

    # sub selections within Dialysis Data Update
    if parent.demoSelection == 30:  # Standard UF Dialysis . . . . . . . . . .
        parent.demoGroupCounter += 1  # TBD! effectively unfreeze countdown MAYBE?
        if parent.demoGroupCounter >= parent.demoGroupCount:  # end of Treatment
            parent.demoGroupCount = None
            parent.demoGroupCounter = 0
            parent.demoSelection = 40

    elif parent.demoSelection == 31:  # Saline Bolus . . . . . . . . . . . . .
        parent.uf_state = TreatmentDialysisStates.DIALYSIS_SALINE_BOLUS_STATE
        parent.saline_state = SalineBolusStates.SALINE_BOLUS_STATE_IN_PROGRESS  # 2 Saline bolus state
        parent.demoSelection = 32
        parent.salineVolume_ml = 0.0  # reset

    elif parent.demoSelection == 32:  # Saline Bolus delivery
        rsp_id = MsgIds.MSG_ID_SALINE_BOLUS_DATA
        bolus_target_ml = parent.demo_treatment_params.data_int[
            TreatmentParameters.TREATMENT_PARAM_SALINE_BOLUS_VOLUME_ML.value]
        new_volume_ml = bolus_target_ml - parent.salineVolume_ml
        if parent.salineBolusRate_mlpersec <= new_volume_ml:
            new_volume_ml = parent.salineBolusRate_mlpersec  # incremental
        else:
            parent.demoSelection = 33  # done after this, so move on
        parent.salineVolume_ml += new_volume_ml
        parent.salineVolCum_ml += new_volume_ml
        rsp_payload = struct.pack("<i 2f",
                                  bolus_target_ml,  # 0 Target
                                  parent.salineVolCum_ml,  # 1 cumulative bolus for this treatment
                                  parent.salineVolume_ml,  # 2 delivered in this bolus so far
                                  )

    elif parent.demoSelection == 33:  # Saline Bolus delivery
        # TBD!! need to explicitly stop anything??
        parent.saline_state = SalineBolusStates.SALINE_BOLUS_STATE_IDLE  # Return to dialysis
        parent.uf_state = TreatmentDialysisStates.DIALYSIS_UF_STATE
        parent.demoSelection = 30

    if (prev_heparin_state != parent.heparin_state) or \
            (prev_saline_state != parent.saline_state):
        rsp_id = MsgIds.MSG_ID_TREATMENT_STATE_DATA
        rsp_payload = struct.pack("<10i",
                                  TreatmentStates.TREATMENT_DIALYSIS_STATE.value,  # 0 Treatment Submode
                                  parent.uf_state.value,  # 1 UF state
                                  parent.saline_state.value,  # 2 Saline bolus state
                                  parent.heparin_state.value,  # 3 Hep state
                                  0,  # 4 Rinseback state
                                  0,  # 5 Recirc state
                                  0,  # 6 Blood Prime state
                                  0,  # 7 End state
                                  0,  # 8 Stop state
                                  0,  # 9 Dialysis state
                                  )

    return rsp_id, rsp_payload


def rinseback(parent):
    rsp_channel_id = DenaliChannels.hd_to_ui_ch_id  # default

    set_rinseback_state = None
    new_volume_ml = parent.rinsebackVelocity_ml_per_sec  # incremental
    parent.demoCount = 0
    parent.demoGroupCount = None  # int(parent.rinseback_volume_set_ml / parent.rinsebackVelocity_ml_per_sec + 0.99)
    parent.demoCountdownId = None

    if parent.demoSelection == 40:  # Rinseback stop before
        set_rinseback_state = TreatmentRinsebackStates.RINSEBACK_STOP_INIT_STATE
        parent.rinseback_volume_out_ml = 0
        parent.demoSelection = 49  # then wait for user

    elif parent.demoSelection == 41:  # Rinseback running
        set_rinseback_state = TreatmentRinsebackStates.RINSEBACK_RUN_STATE
        parent.demoSelection = 42  # next state

    elif parent.demoSelection == 42:  # Rinseback in process
        remain_volume_ml = parent.rinseback_volume_set_ml - parent.rinseback_volume_out_ml
        if remain_volume_ml <= new_volume_ml:
            new_volume_ml = remain_volume_ml
            parent.demoSelection = 43  # done after this, so move on
        parent.rinseback_volume_out_ml += new_volume_ml
        parent.rinseback_volume_all_ml += new_volume_ml

    elif parent.demoSelection == 43:  # Rinseback stop after
        set_rinseback_state = TreatmentRinsebackStates.RINSEBACK_STOP_STATE
        parent.demoSelection = 49

    elif parent.demoSelection == 44:  # Rinseback pause
        set_rinseback_state = TreatmentRinsebackStates.RINSEBACK_PAUSED_STATE
        parent.demoSelection = 49

    elif parent.demoSelection == 45:  # Additional Rinseback
        set_rinseback_state = TreatmentRinsebackStates.RINSEBACK_RUN_ADDITIONAL_STATE
        parent.demoSelection = 42

    elif parent.demoSelection == 49:  # Rinseback wait for user
        pass

    # for all Rinseback states:
    if parent.demoSelection <= 42:  # actively/recently moving blood
        parent.blood_stop_time_s = time()  # reset timer

    rsp_id = MsgIds.MSG_ID_HD_RINSEBACK_PROGRESS
    used_time = max(0, 120 - (int(time() - parent.blood_stop_time_s)))
    rsp_payload = struct.pack("<2f 4i",
                              parent.rinseback_volume_set_ml,  # 0 (float) the target  volume in mL
                              float(parent.rinseback_volume_all_ml),  # 1 (float) the current volume in mL
                              int(round(new_volume_ml * 60)),  # 2 (uint ) the current flow rate in mL/min
                              120,  # 3 (uint ) Total Timeout
                              used_time,  # 4 (uint ) Current Timeout count down
                              (parent.demoSelection == 43)  # 5 (int/bool) complete
                              )
    tmr_message = DenaliMessage.build_message(channel_id=rsp_channel_id,  # TBD!! dup code with below
                                              message_id=rsp_id.value,
                                              payload=rsp_payload)
    print("\nT send message:", MsgIds(rsp_id).name, tmr_message)
    parent.can_interface.send(tmr_message, 0)

    # on Rinsback state changes:
    if set_rinseback_state is not None:
        rsp_id = MsgIds.MSG_ID_TREATMENT_STATE_DATA
        rsp_payload = struct.pack("<10i",
                                  TreatmentStates.TREATMENT_RINSEBACK_STATE.value,  # 0 Treatment Submode
                                  TreatmentDialysisStates.DIALYSIS_UF_STATE.value,  # 1 UF state
                                  0,  # 2 Saline bolus state
                                  0,  # 3 Hep state
                                  set_rinseback_state.value,  # 4 Rinseback state
                                  0,  # 5 Recirc state
                                  0,  # 6 Blood Prime state
                                  0,  # 7 End state
                                  0,  # 8 Stop state
                                  0,  # 9 Dialysis state
                                  )

    return rsp_id, rsp_payload


def confirmation_request(parent):
    rsp_id = MsgIds.MSG_ID_HD_UI_CONFIRMATION_REQUEST
    rsp_payload = integer_to_bytearray(6)
    rsp_payload += integer_to_bytearray(0)
    rsp_payload += integer_to_bytearray(0)
    parent.demoSelection = 0  # Wait for User
    parent.demoCount = 0
    return rsp_id, rsp_payload


def op_mode_data(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_POST.value)
    rsp_payload += integer_to_bytearray(PostTreatmentStates.HD_POST_TREATMENT_DRAIN_RESERVOIRS_STATE.value)
    parent.message_queue_mutex.acquire()
    parent._send_treatment_log()
    parent.message_queue_mutex.release()
    parent.demoSelection = 0
    parent.demoCount = 0
    return rsp_id, rsp_payload


def wait_for_disinfect_state(parent):
    rsp_id = MsgIds.MSG_ID_HD_OP_MODE_DATA
    rsp_payload = integer_to_bytearray(HDOpModes.MODE_STAN.value)
    rsp_payload += integer_to_bytearray(HDStandbyStates.STANDBY_WAIT_FOR_DISINFECT_STATE.value)
    parent.demoSelection = 0  # wait for user
    return rsp_id, rsp_payload