###########################################################################
#
# Copyright (c) 2019-2021 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    utils.py
# @author  (last)      LTTS
# @date    (last)      15-Jan-2022
#
############################################################################

import object
import names
import sys
import squish
import time
import test

from builtins import str as pyStr
from builtins import int as pyInt
from configuration import config
from dialin.ui import utils
from datetime import datetime
from dialin.ui import utils


def color_verification(exp_val = "Red", act_val = "#c53b33"):
    """
    Function to verify item color verification
    Argument:
        exp_val - Expected required value
        act_val - Color displayed on UI
    Return:
        handle the application for log
    """
    test.compare(config.COLOR_CODES[color_name],(act_val.color[name]))
    
def check_if_object_is_within_the_container(obj=None, container=None):
    """
        check if an object is inside a container
        @param obj - child UI object
        @param container - container UI object
        @return boolean
    """
    container = squish.findObject(container)
    containerPos = container.mapToGlobal(squish.QPoint(0, 0))
    container_x, container_y = pyInt(containerPos.x), pyInt(containerPos.y)
    container_width, container_height = pyInt(container.width), pyInt(container.height)
    
    obj = squish.findObject(obj)
    objPos = obj.mapToGlobal(squish.QPoint(0, 0))
    obj_x, obj_y = pyInt(objPos.x), pyInt(objPos.y)
    obj_width, obj_height = pyInt(obj.width), pyInt(obj.height)
    
    if obj_x >= container_x and obj_y >= container_y:
        if (obj_x + obj_width) <= (container_x + container_width) and (obj_y + obj_height) <= (container_y + container_height):
            return True
        
    return False
    
def scroll_to_zone(zone=None, screen_object=None, direction = None):
    """
        scroll to the UI, if object is hidden
        @param zone - object to be find out.
        @param screen_object - object of the screen.
        @return boolean
    """
    counter = 0
    while counter <= 100:
        try:
            counter += 1
            squish.findObject(zone)
            squish.snooze(0.5)
            if check_if_object_is_within_the_container(obj=zone, container=screen_object):
                return True
            else:
                raise RuntimeError
        except RuntimeError:
            ScreenObj = squish.waitForObject(screen_object)
            screenHeight = pyInt(ScreenObj.height)
            screenWidth = pyInt(ScreenObj.width)
            squish.mouseWheel(ScreenObj, screenWidth//2, 
                              screenHeight//2, 0, -50, squish.Qt.NoModifier)
        
    raise LookupError("value object is not in view to the user after trying 100 times")
    

def pressure_pop_up_text_obj(text):
    names.o_pop_up_pressure_text_obj["text"] = text
    return names.o_pop_up_pressure_text_obj

def pressure_text_obj(text):
    names.o_pressure_text_obj["text"] = text
    return names.o_pressure_text_obj
    
def get_current_date_and_time():
    
    date_format='%Y/%b/%d - %H:%M'
    date = datetime.now()
    return str(date.strftime(date_format))

def enter_keypad_value(entry):
    """
        Method to enter user desired 
        value using keypad
        @param entry: (str) User expected value
    """
    test.startSection("Entering {}".format(entry))
    for value in entry:
        value = pyInt(value)
        key_val = squish.waitForObject(keypad_input(value))
        squish.mouseClick(key_val)
        utils.waitForGUI(1)
    test.endSection()
    
def erase_entered_value(input_field):
    """
        Method to erase the entered value
        @param input_field - (obj) object of input field
    """
    test.startSection("Erasing value")
    input_field= squish.waitForObject(input_field)
    entered_value = str(input_field.text)
    for value in range(len(entered_value)+1):
        utils.waitForGUI(1)
        squish.mouseClick(squish.waitForObjectExists(names.o_back_space_key))
    
    test.compare(str(input_field.text), "", "Input field should be empty")
    test.endSection()
    
def vitals_reading_obj(reading):
    names.o_vitals_reading["text"] = reading
    return names.o_vitals_reading

def keypad_input(key_value):
    names.o_keypad_input["text"] = key_value
    return names.o_keypad_input

    
def scroll_to_zone(zone=None, screen_object=None, direction = None):
    """
    scroll to the to the value if object is hidden
    @param value - (obj) value object
    @param container - (obj) Container of the value
    @return boolean true and false
    """
    counter = 0
    while counter <= 100:
        try:
            counter += 1
            squish.findObject(zone)
            squish.snooze(0.5)
            if check_if_object_is_within_the_container(obj=zone, container=screen_object):
                return True
            else:
                raise RuntimeError
        except RuntimeError:
            ScreenObj = squish.findObject(screen_object)
            screenHeight = pyInt(ScreenObj.height)
            screenWidth = pyInt(ScreenObj.width)
            if direction is None:
                squish.mouseWheel(ScreenObj, (screenWidth-100),
                107, 0, -(screenHeight-460), squish.Qt.NoModifier)
            else:
                squish.mouseWheel(ScreenObj, (screenWidth-100),
                -(screenHeight-700), 0, 200, squish.Qt.NoModifier)
                
    raise LookupError("zone object is not in view to the user after trying 100 times")

def get_alarm_id_obj(id):
    names.o_alarm_id["text"] = id
    return names.o_alarm_id
    
def get_alarm_msg_obj(msg):
    names.o_alarm_message["text"] = msg
    return names.o_alarm_message
    
def rejection_msg(text): 
    names.o_rejection_msg["text"] = text
    return names.o_rejection_msg      
    
    
def set_arterial_ranges_min_val(art_low):
    """
    Method to set the Arterial range maximum value to user expected value
    @param art_low - (int) user expected value
    """
    test.startSection("Set Arterial range minimum value to {}".format(art_low))
    arterial_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_min = pyInt(arterial_min.minimum)
    arterial_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_max = pyInt(arterial_max.maximum)
    low_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery))
    low_handler_children = object.children(low_handler_parent)
    low_handler = low_handler_children[-2]
    width = pyInt(low_handler.width) - 8
    height = pyInt(low_handler.height)- 10
    if arterial_min == art_low:
        test.passes("Arterial range minimum is already set to {}".format(art_low))
    elif arterial_min < art_low:
        while arterial_min != art_low:
            squish.mouseDrag(low_handler, width, height, 1, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_min += 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(low_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
                break
            else:
                continue
    elif arterial_min > art_low:
        while arterial_min != art_low:
            squish.mouseDrag(low_handler, width, height, -1, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_min -= 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(low_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
                break
            else:
                continue
    # arterial blood pressure low limit should be lower than the high limit by atleast 30mmHg 
    if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(low_handler_parent.minValue, arterial_min, "Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
    else:
        test.compare(arterial_min, art_low, "Actual Arterial range minimum value: {} is equal to Expected value: {}".format(arterial_min, art_low))
    test.endSection()


def set_arterial_ranges_max_val(art_high):
    """
    Method to set the Arterial range maximum value to user expected value
    @param art_high - (int) user expected value
    """
    test.startSection("Set Arterial range maximum value to {}".format(art_high))
    arterial_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_max = pyInt(arterial_max.maximum)
    arterial_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_min = pyInt(arterial_min.minimum)
    high_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery))
    high_handler_children = object.children(high_handler_parent)
    high_handler = high_handler_children[-1]
    width = pyInt(high_handler.width) - 20
    height = pyInt(high_handler.height) - 25
    if arterial_max == art_high:
        test.passes("Arterial range maximum is already set to {}".format(art_high))
    elif arterial_max < art_high:
        while arterial_max != art_high:
            squish.mouseDrag(high_handler, -1, height, width, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_max += 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
                break
            else:
                continue
    elif arterial_max > art_high:
        while arterial_max != art_high:
            squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_max -= 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
                break
            else:
                continue
    # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
    if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(high_handler_parent.maxValue, arterial_max,
                     "Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
    else:
        test.compare(arterial_max, art_high, 
                     "Actual Arterial range maximum value: {} is equal to Expected value: {}".format(arterial_max, art_high))
    test.endSection()
    

def set_venous_ranges_max_val(ven_high):
    """
    Method to set the Venous range maximum value to user expected value
    @param ven_high - (int) user expected value
    """
    test.startSection("Set Venous range maximum value to {}".format(ven_high))
    ven_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous)
    ven_max = pyInt(ven_max.maximum)
    ven_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous)
    ven_min = pyInt(ven_min.minimum)
    high_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous))
    high_handler_children = object.children(high_handler_parent)
    high_handler = high_handler_children[-1]
    width = pyInt(high_handler.width) - 15
    height = pyInt(high_handler.height) - 10
    if ven_max == ven_high:
        test.passes("Venous range maximum is already set to {}".format(ven_high))
    elif ven_max < ven_high:
        while ven_max != ven_high:
            squish.mouseDrag(high_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            ven_max += 10
            # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if ven_max == ven_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Venous range maximum value cannot be moved beyond {}".format(ven_max))
                break
            else:
                continue
    elif ven_max > ven_high:
        while ven_max != ven_high:
            squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            ven_max -= 10
            # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if ven_max == ven_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Venous range maximum value cannot be moved beyond {}".format(ven_max))
                break
            else:
                continue
    # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
    if ven_max == ven_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(high_handler_parent.maxValue, ven_max, "Venous range maximum value cannot be moved beyond {}".format(ven_max))
    else:
        test.compare(ven_max, ven_high, "Actual Venous range maximum value: {} is equal to Expected value: {}".format(ven_max, ven_high))
    test.endSection()

#Methods for create custom treatment
def set_venous_ranges_min_val(ven_low):
    """
    Method to set the Venous range maximum value to user expected value
    @param ven_low - (int) user expected value
    """
    test.startSection("set Venous range minimum value to {}".format(ven_low))
    ven_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous)
    ven_min = pyInt(ven_min.minimum)
    ven_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous)
    ven_max = pyInt(ven_max.maximum)
    low_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Venous))
    low_handler_children = object.children(low_handler_parent)
    low_handler = low_handler_children[-2]
    width = pyInt(low_handler.width) - 15
    height = pyInt(low_handler.height) - 10
    if ven_min == ven_low:
        test.passes("Venous range minimum is already set to {}".format(ven_low))
    elif ven_min < ven_low:
        while ven_min != ven_low:
            squish.mouseDrag(low_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            ven_min += 10
            if ven_min == ven_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
                squish.mouseDrag(low_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Venous range minimum value cannot be moved beyond {}".format(ven_min))
                break
            else:
                continue
    elif ven_min > ven_low:
        while ven_min != ven_low:
            squish.mouseDrag(low_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            ven_min -= 10
            # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if ven_min == ven_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(low_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Venous range minimum value cannot be moved beyond {}".format(ven_min))
                break
            else:
                continue
    # venous blood pressure low limit should be lower than the high limit by at least 30mmHg 
    if ven_min == ven_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(low_handler_parent.minValue, ven_min,
                     "Venous range minimum value cannot be moved beyond {}".format(ven_min))
    else:
        test.compare(ven_min, ven_low, 
                     "Actual Venous range minimum value: {} is equal to Expected value: {}".format(ven_min, ven_low))
    test.endSection()

def scroll_to_value_on_pop_up(value=None, container=None):
    """
    scroll to the to the value if object is hidden
    @param value - (obj) value object
    @param container - (obj) Container of the value
    @return boolean true and false
    """
    counter = 0
    while counter <= 100:
        try:
            counter += 1
            squish.findObject(value)
            squish.snooze(0.5)
            if check_if_object_is_within_the_container(obj=value, container=container):
                return True
            else:
                raise RuntimeError
        except RuntimeError:
            ScreenObj = squish.waitForObject(container)
            screenHeight = pyInt(ScreenObj.height)
            screenWidth = pyInt(ScreenObj.width)
            squish.mouseWheel(ScreenObj, screenWidth//2, 
                              screenHeight//2, 0, -50, squish.Qt.NoModifier)
        
    raise LookupError("value object is not in view to the user after " + \
             "trying 100 times")
    

def expected_heparin_value(val):
    names.o_heparin_value["text"] = val
    return names.o_heparin_value


def msg(string):
    """
    Added ### at the right side of the string to make sure that it is a message.
    @param string: (str) the string to add trailing ### to
    @return pad_str: (str) padded string
    """
    padded_str = "###"+string
    return padded_str
    
def convert_seconds_into_min_and_sec(seconds):
    min_and_sec = time.strftime("%M:%S", time.gmtime(seconds))
    return min_and_sec


def self_test_dry_check_list_text(text):
    names.o_self_test_dry_check_list_text["text"] = text
    return names.o_self_test_dry_check_list_text

def convert_seconds_into_min_and_sec(seconds):
    min_and_sec = time.strftime("%M:%S", time.gmtime(seconds))
    return min_and_sec

def get_time(screen_title):
    """
    Method to return the current count down
    in the application
    @param screen_title - (str) current title of the screen
    @return time_text - (str) count down in the application
    """
    if screen_title == config.BEGIN_PRIME_TITLE or screen_title == config.PRIMING_TITLE:
        parent_object = object.parent(squish.waitForObjectExists(self_test_dry_check_list_text(screen_title)))
    elif screen_title == config.SYSTEM_SELF_TEST_TITLE:
        parent_object = object.parent(squish.waitForObjectExists(names.o_system_self_test))
    else:
        parent_object = object.parent(squish.waitForObjectExists(names.o_PreTreatmentBase_Filter_Flush_Text))
    time_parent_children = object.children(parent_object)
    progress_circle_parent = time_parent_children[4]
    progress_circle_parent = object.children(progress_circle_parent)
    progress_circle_parent = progress_circle_parent[0]
    progress_circle_parent = object.children(progress_circle_parent)
    progress_circle_children = object.children(progress_circle_parent[0])
    time_text = progress_circle_children[1]
    return time_text.time

def verify_countdown(screen_title, time_out, hd_simulator, dg_simulator):
    """
        Method to verify the count down 
        time in application
        @param screen_title - (str) current title of the screen
        @param time_out - (int) time out duration in secs
        @Param hd_simulator - Instance of HDSimulator class
        @Param dg_simulator - Instance of DGSimulator class
    """
    test.startSection("Verify the count down time in application")
    for count_down in range(config.COUNT_DOWN_TIME_100, config.MINIMUM_COUNTDOWN_TIME-1, -1):
        if screen_title == config.BEGIN_PRIME_TITLE:
            hd_simulator.cmd_send_pre_treatment_self_test_dry_progress_data(time_out, count_down)
        elif screen_title == config.PRIMING_TITLE:
            hd_simulator.cmd_send_pre_treatment_disposables_prime_progress_data(time_out, count_down)
        elif screen_title == config.SYSTEM_SELF_TEST_TITLE:
            hd_simulator.cmd_send_pre_treatment_self_test_no_cartridge_progress_data(time_out, count_down)
        else:
            dg_simulator.cmd_send_dg_pre_treatment_filter_flush_progress_data(time_out, count_down)
        actual_time = get_time(screen_title)
        expected_time = convert_seconds_into_min_and_sec(count_down)
        test.compare(actual_time, expected_time, "Actual count down time: {} should be equal to expected count down time {}".format(actual_time, expected_time))
        verify_the_progress(count_down, screen_title, time_out)
    test.endSection()
    
def verify_the_progress(count_down, screen_title, time_out):
    """
        Method to verify the current progress
        @param count_down - (int) current count down time
        @param screen_title - (str) current title of the screen
        @param time_out - (int) time out duration in secs
    """
    test.startSection("Verifying the current progress")
    if screen_title == config.BEGIN_PRIME_TITLE or screen_title == config.PRIMING_TITLE:
        current_progress = (squish.waitForObjectExists(names.o_self_test_dry_progress)).progressValue
    elif screen_title == config.SYSTEM_SELF_TEST_TITLE:
        current_progress = (squish.waitForObjectExists(names.o_system_self_test_progress)).progressValue
    else:
        current_progress = (squish.waitForObjectExists(names.o_filter_flush_progress)).progressValue
    #Since progress value is equal maximum count down value - current count down value
    expected_progress = time_out - count_down
    test.compare(current_progress, expected_progress, "{} should be the current progress".format(expected_progress))
    test.endSection()
       

def verify_page_step_indicator(screen_obj, treatment_step, treatment_screens):
    """    
    Method to verify the Page Step indicators [the object on top of the screen which indicates the steps passed, current, remained]
    @param treatment_step : (int) indicates the Current treatment step 
    """    
    test.startSection("verification of page step indicators")
    for page in range(len(treatment_screens)):
        bullet_children = object.children(squish.waitForObjectExists(get_bullet_object(screen_obj, page)))
        bullet_circle_color = bullet_children[0].color.name 
        bullet_border_color = bullet_children[0].border.color.name
        step_title =  squish.waitForObjectExists(get_text_object(screen_obj, treatment_screens[page])) 
        #To verify the step indicators of the completed treatment screens
        if page < treatment_step:
            test.verify(squish.waitForObjectExists(get_bullet_object(screen_obj, page)).complete)
            test.verify(not squish.waitForObjectExists(get_bullet_object(screen_obj, page)).current)
            test.compare(bullet_circle_color, config.COMPLETE_COLOR)
            test.compare(bullet_border_color, config.COMPLETE_COLOR) 
            test.compare(step_title.color.name, config.ENABLED_COLOR)
        #To verify the step indicators of the current treatment screen
        elif page == treatment_step:
            test.verify(squish.waitForObjectExists(get_bullet_object(screen_obj, page)).current,)
            test.verify(not squish.waitForObjectExists(get_bullet_object(screen_obj, page)).complete)
            test.compare(bullet_circle_color, config.CURRENT_COLOR)
            test.compare(bullet_border_color, config.COMPLETE_COLOR)
            test.compare(step_title.color.name, config.ENABLED_COLOR)
            test.verify(step_title.font.bold)  
        #To verify the step indicators of the remaining treatment screens   
        else:
            test.verify(not squish.waitForObjectExists(get_bullet_object(screen_obj, page)).current,)
            test.verify(not squish.waitForObjectExists(get_bullet_object(screen_obj, page)).complete,)
            test.compare(step_title.color.name, config.INCOMPLETE_COLOR)
            test.compare(bullet_circle_color, config.CURRENT_COLOR) 
            test.compare(bullet_border_color, config.INCOMPLETE_COLOR)     
    test.endSection()      
            
def verify_missing_object(object_to_check):
    """ 
    Method to verify the given object is invisible or is not present on the screen
    @param object_to_check: the object whose invisibility must be verified
    """    
    try:
        squish.testSettings.objectNotFoundDebugging = False
        squish.waitForObject(object_to_check,3000)
        test.fail("Given object should not be present initially")
    except LookupError as _:
        test.passes("object is not present as expected")
        
    squish.testSettings.objectNotFoundDebugging = True    
    
def set_arterial_ranges_min_val(art_low):
    """
    Method to set the Arterial range maximum value to user expected value
    @param art_low - (int) user expected value
    """
    test.startSection("Set Arterial range minimum value to {}".format(art_low))
    arterial_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_min = pyInt(arterial_min.minimum)
    arterial_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_max = pyInt(arterial_max.maximum)
    low_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery))
    low_handler_children = object.children(low_handler_parent)
    low_handler = low_handler_children[-2]
    width = pyInt(low_handler.width) - 8
    height = pyInt(low_handler.height)- 10
    if arterial_min == art_low:
        test.passes("Arterial range minimum is already set to {}".format(art_low))
    elif arterial_min < art_low:
        while arterial_min != art_low:
            squish.mouseDrag(low_handler, width, height, 1, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_min += 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(low_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
                break
            else:
                continue
    elif arterial_min > art_low:
        while arterial_min != art_low:
            squish.mouseDrag(low_handler, width, height, -1, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_min -= 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(low_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
                break
            else:
                continue
    # arterial blood pressure low limit should be lower than the high limit by atleast 30mmHg 
    if arterial_min == arterial_max - config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(low_handler_parent.minValue, arterial_min, "Arterial range minimum value cannot be moved beyond {}".format(arterial_min))
    else:
        test.compare(arterial_min, art_low, "Actual Arterial range minimum value: {} is equal to Expected value: {}".format(arterial_min, art_low))
    test.endSection()


def set_arterial_ranges_max_val(art_high):
    """
    Method to set the Arterial range maximum value to user expected value
    @param art_high - (int) user expected value
    """
    test.startSection("Set Arterial range maximum value to {}".format(art_high))
    arterial_max = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_max = pyInt(arterial_max.maximum)
    arterial_min = squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery)
    arterial_min = pyInt(arterial_min.minimum)
    high_handler_parent = object.parent(squish.waitForObjectExists(names.o_PreTreatmentCreate_rangeRect_RangeRect_Artery))
    high_handler_children = object.children(high_handler_parent)
    high_handler = high_handler_children[-1]
    width = pyInt(high_handler.width) - 20
    height = pyInt(high_handler.height) - 25
    if arterial_max == art_high:
        test.passes("Arterial range maximum is already set to {}".format(art_high))
    elif arterial_max < art_high:
        while arterial_max != art_high:
            squish.mouseDrag(high_handler, -1, height, width, 0, squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_max += 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, 1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
                break
            else:
                continue
    elif arterial_max > art_high:
        while arterial_max != art_high:
            squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
            arterial_max -= 10
            # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
            if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
                squish.mouseDrag(high_handler, width, height, -1, 0,
                          squish.Qt.NoModifier, squish.Qt.LeftButton)
                test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
                break
            else:
                continue
    # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg 
    if arterial_max == arterial_min + config.BUFFER_LOW_AND_HIGH_LIMITS:   
        test.compare(high_handler_parent.maxValue, arterial_max,
                     "Arterial range maximum value cannot be moved beyond {}".format(arterial_max))
    else:
        test.compare(arterial_max, art_high, 
                     "Actual Arterial range maximum value: {} is equal to Expected value: {}".format(arterial_max, art_high))
    test.endSection()

def get_text_object(screen_obj, txt):
    """
        To obtain a text object based on text provided
        @param screen_obj: provides the container on which the txt must be present 
        @returns a real name object
    """        
    names.o_text_object["container"] = screen_obj
    names.o_text_object["text"] = txt
    return names.o_text_object

def verify_color_of_entry(entry, vital_parameter, input_field):
    """
        Method to verify the color of entry 
        of systolic, diastolic and heart rate
        @param entry: (int) user user entered value
        @param vital_parameter - (str) parameter name under which user is entering value (sys/dia/heart rate)
        @param input_field - (obj) object of input field
    """
    test.startSection("Verify the color of {} value {}".format(vital_parameter, entry))
    input_field_color = input_field.color.name
    entry = pyInt(entry)
    if vital_parameter is config.SYSTOLIC_TEXT:
        if (entry < config.SYSTOLIC_LOWER_LIMIT) or (entry > config.SYSTOLIC_UPPER_LIMIT):
            test.compare(input_field_color, config.OUT_OF_RANGE_COLOR, "systolic value {} is out of range, systolic value should be in range of {} and {}".format(entry, config.SYSTOLIC_LOWER_LIMIT, config.SYSTOLIC_UPPER_LIMIT))
        elif (entry >= config.SYSTOLIC_LOWER_LIMIT) and (entry <= config.SYSTOLIC_UPPER_LIMIT):
            test.compare(input_field_color, config.IN_RANGE_COLOR, "systolic value {} is in range of {} and {}".format(entry, config.SYSTOLIC_LOWER_LIMIT, config.SYSTOLIC_UPPER_LIMIT))
    elif vital_parameter is config.DIASTOLIC_TEXT:
        if (entry < config.DIASTOLIC_LOWER_LIMIT) or (entry > config.DIASTOLIC_UPPER_LIMIT):
            test.compare(input_field_color, config.OUT_OF_RANGE_COLOR, "diastolic value {} is out of range, diastolic value should be in range of {} and {}".format(entry, config.DIASTOLIC_LOWER_LIMIT, config.DIASTOLIC_UPPER_LIMIT))
        elif (entry >= config.DIASTOLIC_LOWER_LIMIT) and (entry <= config.DIASTOLIC_UPPER_LIMIT):
            test.compare(input_field_color, config.IN_RANGE_COLOR, "diastolic value {} is in range of {} and {}".format(entry, config.DIASTOLIC_LOWER_LIMIT, config.DIASTOLIC_UPPER_LIMIT))
    elif vital_parameter is config.HEART_RATE_TITLE:
        if (entry < config.HEART_RATE_LOWER_LIMIT) or (entry > config.HEART_RATE_UPPER_LIMIT):
            test.compare(input_field_color, config.OUT_OF_RANGE_COLOR, "Heart Rate value {} is out of range, Heart Rate value should be in range of {} and {}".format(entry, config.HEART_RATE_LOWER_LIMIT, config.HEART_RATE_UPPER_LIMIT))
        elif (entry >= config.HEART_RATE_LOWER_LIMIT) and (entry <= config.HEART_RATE_UPPER_LIMIT):
            test.compare(input_field_color, config.IN_RANGE_COLOR, "Heart Rate value {} is in range of {} and {}".format(entry, config.HEART_RATE_LOWER_LIMIT, config.HEART_RATE_UPPER_LIMIT))
    test.endSection()

def get_bullet_object(screen_obj, num):
    """
        To obtain a bullet object based on occurrence provided.
        @param screen_obj: provides the container on which the bullet must be present
        @param num: provides the occurrence value 
        @returns a real name object
    """     
    names.o_bullet_object["container"] = screen_obj
    names.o_bullet_object["occurrence"] = num + 1
    return names.o_bullet_object  
 
def keypad_input(key_value):
    """
    Method to enter values using application UI keyboard
    @param key_value: (str) User expected value
    """
    if key_value is not None:
        names.o_keypad_input["text"] = key_value
        return names.o_keypad_input
    else:
        test.log("Invalid text for object.")
        names.o_keypad_input["text"] = None
   
   
def enter_keypad_value(entry):
    """
    Method to enter user desired 
    value using keypad
    @param entry: (str) User expected value
    """
    test.startSection("Entering {}".format(entry))
    entry = pyStr(entry)                                       #type casted into string format
    for value in entry:
        squish.mouseClick(squish.waitForObject(keypad_input(value)))
    test.endSection()
    
    
def erase_entered_value(input_field):
    """
        Method to erase the entered value
        @param input_field - (obj) object of input field
    """
    test.startSection("Erasing value")
    input_field= squish.waitForObject(input_field)
    entered_value = str(input_field.text)
    for value in range(len(entered_value)+1):
        utils.waitForGUI(1)
        squish.mouseClick(squish.waitForObjectExists(names.o_back_space_key))
    
    test.compare(str(input_field.text), "", "Input field should be empty")
    test.endSection()
    
def  get_indicators(screen_obj, txt):
    """
        Verifying the busy indicators for BiCarb Pump Check and Acid Pump Check.
        indicator object of expected text
        @param step - (str) expected text
        @return indicators - (obj) list of busy and check indicator
    """
    parent_obj = object.parent(squish.waitForObjectExists(get_text_object(screen_obj,txt)))
    children_obj = object.children(parent_obj)
    indicator_parent = children_obj[2]
    indicators = object.children(indicator_parent)
    return indicators