# -*- coding: utf-8 -*-

##
# Copyright (c) 2019-2020 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    tst_main_treatment_ultrafiltration
# date    2020/01/11
# author  Joseph Varghese
#
# NOTE:
# This test contradicts verification of ultrafiltration(uf) from main treatment section. 
# section


import names
from dialin.ui import utils
from dialin.common.ui_defs import TXStates as uf_states
from dialin.ui.hd_simulator import HDSimulator
from dialin.common.hd_defs import HDStandbyStates, TreatmentStates
from configuration import config

hd_simulator    = HDSimulator()

RANDOM_VOLUME = 200
RANDOM_DURATION = 300 
RANDOM_DURATION_DIFFERENCE =10
RANDOM_RATE = 1
RANDOM_RATE_DIFFERENCE = 1
RANDOM_RATE_OLD = 1
REF_UF_VOL_INDEX = 0
MEASURED_UF_VOL_INDEX = 1
ROT_SPEED_INDEX = 2
MOT_SPEED_INDEX = 3
MC_SPEED_INDEX = 4
MC_CURRENT_INDEX = 5
PWM_INDEX = 6
MIN_DIALYSATE_FLOW_RATE = 0
MIN_TREATMENT_DURATION = 0
MAX_DIALYSATE_FLOW_RATE = 0
MAX_TREATMENT_DURATION = 100
SLIDER_RANGE = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
SLIDER_PARAMETERS = (0, 0.1, 147)
ROT_SPEED = 0
MOT_SPEED = 0
MC_SPEED = 0
MC_CURRENT = 0
PWM = 0
REF_UF_VOL = 0
MEASURED_UF_VOL = 0

    
def verification_of_uf_from_main_treatment():
    """
    @return: N/A
    """
    test.compare(waitForObjectExists(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration).visible, True, "ultrafiltration section is visible")
    test.compare(format((waitForObject(names.o_treatmentHome_progressbar_start_state).minimum), '.2f'), format(utils.ml2l(config.UF_MINIMUM_VALUE), '.2f'), "ultrafiltration minimum value should be "+str(config.UF_MINIMUM_VALUE))
    test.compare(format((waitForObject(names.o_treatmentHome_progressbar_start_state).maximum), '.2f'), format(utils.ml2l(config.UF_MAXIMUM_VALUE), '.2f'), "ultrafiltration maximum value should be "+str(config.UF_MAXIMUM_VALUE))


def start_test_treatment_ultrafiltration(ultrafiltration_range, uf_state):
    """
    Test slider movement of ultrafiltration volume.
    @param ultrafiltration_range: (dictionary) uf minimum and uf maximum volume.
    @param uf_state: (int) ultrafiltration state to be set.
    @return: N/A
    """
    min_uf = ultrafiltration_range["uf_minimum"]
    max_uf = ultrafiltration_range["uf_maximum"]

    #FIXME : ultrafiltration minimum range from progress bar is not changing based on simulator input
    hd_simulator.cmd_set_treatment_parameter_ranges(MIN_TREATMENT_DURATION, MAX_TREATMENT_DURATION, min_uf, max_uf, MIN_DIALYSATE_FLOW_RATE, MAX_DIALYSATE_FLOW_RATE)
    
    for uf_value in range(min_uf, (max_uf)+1, 1):
        hd_simulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(uf_value, uf_value, ROT_SPEED, MOT_SPEED, MC_SPEED, MC_CURRENT, PWM, 0,0,0,0,0,0)
        utils.waitForGUI(0.2)
        test.compare(utils.l2ml(waitForObjectExists(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration).value), uf_value, "uf set value should be :" + str(uf_value))
        hd_simulator.cmd_send_uf_treatment_response(accepted = True, reason = 0, volume = 500)
    if uf_state == uf_states.UF_RUNNING_STATE:
        mouseClick(waitForObjectExists(names.o_ultrafiltration_pause_btn))
    if uf_state == uf_states.UF_PAUSED_STATE :
        test.compare(utils.l2ml(waitForObjectExists(names.o_volumeSlider_slider).maximum), max_uf, "maximum uf value should be :" + str(max_uf))
        test.compare(utils.l2ml(waitForObjectExists(names.o_volumeSlider_slider).minimum), min_uf, "minimum uf value should be :" + str(min_uf))
    
    
def reset_treatment_ultrafiltration():
    """
    Test to reset ultrafiltration volume.
    @param : N/A
    @return: N/A
    """
    hd_simulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(REF_UF_VOL, MEASURED_UF_VOL, ROT_SPEED, MOT_SPEED, MC_SPEED, MC_CURRENT, PWM, 0,0,0,0,0,0) 
    test.compare(waitForObjectExists(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration).value, config.UF_MINIMUM_VALUE, "uf treatment reset to 0")


def treatment_ultrafiltration_based_on_flow_parameter(ultrafiltration_flow_parameter):
    """
    Test to verify ultrafiltration volume based on flow parameters (Rotational speed, Motor speed,
    MC speed, MC current and PWM)
    @param ultrafiltration_flow_parameter[0]: (float) Ref UF Volume
    @param ultrafiltration_flow_parameter[1]: (float) Measured UF Volume
    @param ultrafiltration_flow_parameter[2]: (float) Rot Speed
    @param ultrafiltration_flow_parameter[3]: (float) Motor Speed
    @param ultrafiltration_flow_parameter[4]: (float) MC Speed
    @param ultrafiltration_flow_parameter[5]: (float) MC Current
    @param ultrafiltration_flow_parameter[6]: (float) PWM
    @return: none
    """
    # Integration team needs to determine if the new UF parameters to the simulator need to be exercised for verification.
    hd_simulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(ultrafiltration_flow_parameter[REF_UF_VOL_INDEX], ultrafiltration_flow_parameter[MEASURED_UF_VOL_INDEX],
                                                           ultrafiltration_flow_parameter[ROT_SPEED_INDEX], ultrafiltration_flow_parameter[MOT_SPEED_INDEX], ultrafiltration_flow_parameter[MC_SPEED_INDEX],
                                                           ultrafiltration_flow_parameter[MC_CURRENT_INDEX], ultrafiltration_flow_parameter[PWM_INDEX],0,0,0,0,0,0) 
    test.log("test to verify ultrafiltration flow parameters.")
    

def test_ultrafilteration_volume_slider(slider_object, value, slider_parameter):
    """
        Method to set slider handle based on custom values
        @param slider_object : (dictionary) object of treatment parameters
        @param vale : (int)value to be set on slider
        @param slider_parameter : (list) consist combination of slider minimum value, slider buffer and width buffer
    """
    minimum_slider_value = slider_parameter[0]
    slider_buffer = slider_parameter[1]
    width_buffer = slider_parameter[2]
    slider_width = ((value - minimum_slider_value)/slider_buffer) * width_buffer
    utils.waitForGUI(1)
    mouseClick(waitForObjectExists(slider_object), float(slider_width) , 3, Qt.LeftButton)
    
    test.compare(waitForObjectExists(slider_object).value, value, "slider value should set to %s" %value)
    
 
def test_treatment_ultrafiltration(uf_states):
    """
    Test to verify slider movement based on edge condition.
    @param uf_state: (int) ultrafiltration state to be set.
    @return: N/A
    """
    test.startSection("verification of uf value on main treatment section")
    #FIXME: Slider shows some unexpected behaviour during its movement.
    for option in range(len(config.TREATMENT_ULTRAFILTRATION_TESTING_OPTION)):
        if object.exists(names.o_ultrafilteration_next_btn):
            mouseClick(waitForObjectExists(names.o_ultrafilteration_next_btn))
            mouseClick(waitForObjectExists(names.o_mouseArea_MouseArea_ultrafiltration)) 
        start_test_treatment_ultrafiltration(config.TREATMENT_ULTRAFILTRATION_TESTING_OPTION[option], uf_states)
    test.endSection()
    
    
def verify_ultrafiltration_paused_state(uf_states):
    """
    Test to verify ultrafiltration paused state.
    @param uf_state: (int) ultrafiltration state to be set - pause set.
    @return: N/A
    """
    test.startSection("verification of ultrafiltration paused state")
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_accepted(uf_states)
    
    mouseClick(waitForObject(names.o_ultrafiltration_closeButton))
    utils.waitForGUI(0.2)
    test.compare(waitForObjectExists(names.o_treatmentHome_Ultrafiltration_Paused_Text).text, config.ULTRAFILTRATION_PAUSED_TEXT, "paused text verified")
    mouseClick(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration)
    
    test.compare(waitForObjectExists(names.notificationBar_NotificationBarSmall).text, config.ULTRAFILTRATION_PAUSED_TEXT, "paused text should be "+str(config.ULTRAFILTRATION_PAUSED_TEXT))
    test.compare(waitForObjectExists(names.o_resumeButton_TouchRect).text.text, config.RESUME_TEXT, "resume text should be "+str(config.RESUME_TEXT))
    test.compare(waitForObjectExists(names.o_editButton_TouchRect).text.text, config.EDIT_TEXT, "edit text should be "+str(config.EDIT_TEXT))
    test.compare(waitForObjectExists(names.o_ultrafiltration_volume_text).text, config.TITLE_TEXT, "title text should be "+str(config.TITLE_TEXT))
    
    test.log("Clicking on 'Resume Ultrafilteration' button")
    mouseClick(waitForObjectExists(names.o_ultrafiltration_resume_btn))
    mouseClick(names.o_editButton_TouchRect)
    test.compare(waitForObjectExists(names.o_treatmentHome_Ultrafiltration_Paused_Text).text, config.ULTRAFILTRATION_PAUSED_TEXT, "paused text should be "+str(config.ULTRAFILTRATION_PAUSED_TEXT))
    
    test.endSection()

def verify_edit_volume_and_duration():
    """
    Test to verify ultrafiltration paused state.
    @return: N/A
    """
    test.startSection("verification of ultrafiltration paused state")
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_accepted(uf_states.UF_PAUSED_STATE)
    
    
    mouseClick(waitForObject(names.o_ultrafiltration_closeButton))
    utils.waitForGUI(0.2)
    test.compare(waitForObjectExists(names.o_treatmentHome_Ultrafiltration_Paused_Text).text, config.ULTRAFILTRATION_PAUSED_TEXT, "paused text verified")
    mouseClick(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration)

    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response(config.ACCEPTED, 0, RANDOM_VOLUME,
                                                               RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                                               RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD)
    verify_edit_response_messages(RANDOM_VOLUME, RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                  RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD, option="Rate")
    
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response(config.ACCEPTED, 1, RANDOM_VOLUME,
                                                               RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                                               RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD)
    verify_edit_response_messages(RANDOM_VOLUME, RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                  RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD, option="Rate")
    
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response(config.ACCEPTED, 1, RANDOM_VOLUME,
                                                               RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                                               RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD)
    verify_edit_response_messages(RANDOM_VOLUME, RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                  RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD, option="Time Duration")

    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response(config.ACCEPTED, 0, RANDOM_VOLUME,
                                                               RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                                               RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD)
    verify_edit_response_messages(RANDOM_VOLUME, RANDOM_DURATION, RANDOM_DURATION_DIFFERENCE,
                                  RANDOM_RATE, RANDOM_RATE_DIFFERENCE, RANDOM_RATE_OLD, option="Time Duration")
    
    test.compare(waitForObjectExists(names.o_treatmentHome_Ultrafiltration_Paused_Text).text, config.ULTRAFILTRATION_PAUSED_TEXT, "paused text should be "+str(config.ULTRAFILTRATION_PAUSED_TEXT))
    
    test.endSection()


def verify_ultrafiltration_running_state(uf_states):
    """
    Test to verify ultrafiltration running state.
    @param uf_state: (int) ultrafiltration state to be set - running state.
    @return: N/A
    """
    test.startSection("verification of ultrafiltration running state")
    mouseClick(waitForObjectExists(names.o_mouseArea_MouseArea_ultrafiltration))
    mouseClick(waitForObject(names.o_backbutton_backbutton))
    mouseClick(waitForObject(names.o_ultrafiltration_closeButton))
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_accepted(uf_states)
    utils.waitForGUI(1)
   
    mouseClick(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration)
    test.compare(waitForObjectExists(names.o_ultrafiltration_volume_text).text, config.TITLE_TEXT, "title text verified ")

    for rejection in range(1, config.NUM_OF_REQUEST_REJECT_REASONS + 1):   
        hd_simulator.cmd_set_treatment_adjust_ultrafiltration_rejected(reason = rejection, state = uf_states)
        utils.waitForGUI(0.5)
        rejection_message = waitForObjectExists(names.o_notificationbar_response)
        test.compare(rejection_message.text, config.REJECTION_REASON[rejection], "expected rejection {msg} displayed".format(msg=config.REJECTION_REASON[rejection]))
    
    test.endSection()
    
    
def expected_uf_texts(text):
    names.o_ultrafiltration_texts["text"] = text
    return names.o_ultrafiltration_texts


def verify_edit_response_messages(volume, duration, duration_diff, rate, rate_diff, rate_old, option):
    """
        Method to verify the edit response message 
        pop up contents and select 'Increase UF Rate'
        and click on confirm button
        @param volume: (float) Ultrafiltration Volume
        @param duration: (int) Treatment Duration
        @param duration_diff: (int) Duration Difference
        @param rate: (float) Ultrafiltration Rate
        @param rate_diff: (float) Ultrafiltration Rate Difference
        @param rate_old: (float) Ultrafiltration Rate Old
    """
    test.startSection("Verify the edit response message pop up contents and select 'Increase UF Rate' and click on confirm button")
    title = waitForObjectExists(expected_uf_texts(config.TITLE_TEXT))
    test.compare(title.text, config.TITLE_TEXT, "Edit response pop up message should be {}".format(config.TITLE_TEXT))
    edit_volume_message = "To confirm new UF Volume ({:.3f}),\nselect a treatment adjustment:".format(volume/1000)
    expected_edit_volume_msg = waitForObjectExists(expected_uf_texts(edit_volume_message))
    test.compare(expected_edit_volume_msg.text, edit_volume_message, "Edit Volume title message should be {}".format(edit_volume_message))
    increase_uf_rate_text = waitForObjectExists(expected_uf_texts(config.INCREASE_UF_RATE_TEXT))
    test.compare(increase_uf_rate_text.text, config.INCREASE_UF_RATE_TEXT, "Increase UF rate box title should be {}".format(config.INCREASE_UF_RATE_TEXT))
    increase_uf_rate_msg = "The rate increases by {} mL/min,\nthe treatment duration remains the same.".format(rate)
    increase_uf_rate_msg_text = waitForObjectExists(expected_uf_texts(increase_uf_rate_msg))
    test.compare(increase_uf_rate_msg_text.text, increase_uf_rate_msg, "Increase UF rate msg should be {}".format(increase_uf_rate_msg))
    
    #TODO add back this test if the _durationAdjustmentButton ever get sets to visible
    increase_treatment_duration_msg = "The rate remains, the treatment\nduration %2 by {} minutes.".format(duration_diff)
    # increase_treatment_duration_msg_text = waitForObjectExists(expected_uf_texts(increase_treatment_duration_msg))
    # test.compare(increase_treatment_duration_msg_text.text, increase_treatment_duration_msg, "Increase treatment duration msg should be {}".format(increase_treatment_duration_msg))
    
    uf_rate_title_and_val = "UF Rate : {} mL/min".format(rate)
    uf_rate_title_and_val_text = waitForObjectExists(expected_uf_texts(uf_rate_title_and_val))
    test.compare(uf_rate_title_and_val_text.text, uf_rate_title_and_val, "UF Rate title and value should be {}".format(uf_rate_title_and_val))
    test.log(str(rate))
    test.log(str(duration))
    if option == "Rate":
        test.log("Selecting Increase UF Rate")
        mouseClick(increase_uf_rate_text)
    # else:
    #     test.log("Selecting duration")
    #     mouseClick(increase_treatment_duration_text)
    #     mouseClick(waitForObjectExists(names.o_ultrafilteration_confirm_btn))
    #     mouseClick(waitForObjectExists(names.o_mouseArea_MouseArea_ultrafiltration))
    hd_simulator.cmd_set_treatment_adjust_ultrafiltration_confirm_response(accepted=config.ACCEPTED, reason=0, volume=volume,
                                                               duration=duration, rate=rate)
    test.endSection()
    
    
def main():
    
    utils.tstStart(__file__)
    startApplication(config.AUT_NAME)
    
    #navigate to dialysis state
    hd_simulator.cmd_set_treatment_states_data(sub_mode=HDStandbyStates.STANDBY_WAIT_FOR_DISINFECT_STATE.value, uf_state=TreatmentStates.TREATMENT_START_STATE.value, saline_state=TreatmentStates.TREATMENT_START_STATE.value, heparin_state=TreatmentStates.TREATMENT_START_STATE.value,
                                      rinseback_state=TreatmentStates.TREATMENT_START_STATE.value, recirculate_state=TreatmentStates.TREATMENT_START_STATE.value, blood_prime_state=TreatmentStates.TREATMENT_START_STATE.value,
                                      treatment_end_state=TreatmentStates.TREATMENT_START_STATE.value, treatment_stop_state=TreatmentStates.TREATMENT_START_STATE.value, dialysis_state=TreatmentStates.TREATMENT_START_STATE.value) 
    
    verification_of_uf_from_main_treatment()
    
    reset_treatment_ultrafiltration()

    verify_ultrafiltration_paused_state(uf_states.UF_PAUSED_STATE)
    
    hd_simulator.cmd_set_treatment_parameter_ranges(MIN_TREATMENT_DURATION, MAX_TREATMENT_DURATION, 0, 600, MIN_DIALYSATE_FLOW_RATE, MAX_DIALYSATE_FLOW_RATE)
    for value in SLIDER_RANGE:
        test_ultrafilteration_volume_slider(names.o_volumeSlider_slider, value, SLIDER_PARAMETERS)
        
    test_treatment_ultrafiltration(uf_states.UF_PAUSED_STATE)
     
    test.startSection("verification of ultrafiltration flow parameters based on uf values")
    for options in range(len(config.TREATMENT_ULTRAFILTRATION_FLOW_PARAMETERS)):
        treatment_ultrafiltration_based_on_flow_parameter(config.TREATMENT_ULTRAFILTRATION_FLOW_PARAMETERS[options])
    test.endSection()
    
    mouseClick(waitForObjectExists(names.o_ultrafiltration_back_btn))
    verify_edit_volume_and_duration()
    
    test.log("Clicking on 'Resume Ultrafilteration' button")
    mouseClick(waitForObjectExists(names.o_ultrafiltration_resume_btn))
    mouseClick(waitForObjectExists(names.o_editButton_TouchRect))
    test_treatment_ultrafiltration(uf_states.UF_PAUSED_STATE)
        
    verify_ultrafiltration_running_state(uf_states.UF_RUNNING_STATE)
    test_treatment_ultrafiltration(uf_states.UF_RUNNING_STATE)
    
    utils.tstDone()