###########################################################################
#
# 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 names
import object
import squish
import test
import time

from builtins import int as pyInt
from configuration import config
from dialin.ui import utils
from datetime import datetime
from dialin.common.hd_defs import HDOpModes
from dialin.ui.hd_simulator import HDSimulator

hd_simulator = HDSimulator()


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 true and false
    """
    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 page_step_indicator_verification(pre_treatment_step, pre_treatment_items_object):
    """
    Method to verify the Page Step indicators on top of the screen which indicates the steps passed, current, remained]
    @param pre_treatment_step :(int) indicates the Current pre-treatment step 
    @param pre_treatment_items_object :(dictionary) pre_treatment bullet object
    @return N/A
    """
    test.startSection("Method to verify the Page Step indicators")
    for page in range(1, len(config.PRE_TREATMENT_SCREENS)):
        pre_treatment_items_object["occurrence"] = page
        bullet_children = object.children(squish.waitForObject(pre_treatment_items_object))
        bullet_circle_color = bullet_children[0].color.name 
        bullet_border_color = bullet_children[0].border.color.name
        step_title =  bullet_children[2]
        #To verify the step indicators of the completed pre treatment screens
        if page < pre_treatment_step:
            test.verify(squish.waitForObjectExists(pre_treatment_items_object).complete, str(config.PRE_TREATMENT_SCREENS[page]+" complete attribute should be True"))
            test.verify(not squish.waitForObjectExists(pre_treatment_items_object).current, str(config.PRE_TREATMENT_SCREENS[page]+" current attribute should be false"))
            test.compare(bullet_circle_color, config.COMPLETE_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet color hex should be "+str(config.COMPLETE_COLOR)))
            test.compare(bullet_border_color, config.COMPLETE_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet border color hex should be "+str(config.COMPLETE_COLOR))) 
            test.compare(step_title.color.name, config.ENABLED_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" title color hex should be "+str(config.ENABLED_COLOR)))
        #To verify the step indicators of the current pre treatment screen
        elif page == pre_treatment_step:
            test.verify(squish.waitForObjectExists(pre_treatment_items_object).current, str(config.PRE_TREATMENT_SCREENS[page]+" complete attribute should be True"))
            test.verify(not squish.waitForObjectExists(pre_treatment_items_object).complete, str(config.PRE_TREATMENT_SCREENS[page]+" current attribute should be false"))
            test.compare(bullet_circle_color,config.CURRENT_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet color hex should be "+str(config.CURRENT_COLOR)))
            test.compare(bullet_border_color,config.COMPLETE_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet border color hex should be "+str(config.COMPLETE_COLOR)))
            test.compare(step_title.color.name,config.ENABLED_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" title color hex should be "+str(config.ENABLED_COLOR)))
            test.verify(step_title.font.bold, str(config.PRE_TREATMENT_SCREENS[page]+" title font bold should be "+str(config.ENABLED_COLOR)))  
        #To verify the step indicators of the remaining pre-treatment screens   
        else:
            test.verify(not squish.waitForObjectExists(pre_treatment_items_object).current, str(config.PRE_TREATMENT_SCREENS[page]+" complete attribute should be false"))
            test.verify(not squish.waitForObjectExists(pre_treatment_items_object).complete, str(config.PRE_TREATMENT_SCREENS[page]+" current attribute should be false"))
            test.compare(step_title.color.name,config.INCOMPLETE_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" title color hex should be "+str(config.INCOMPLETE_COLOR)))
            test.compare(bullet_circle_color,config.CURRENT_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet circle color hex should be "+str(config.CURRENT_COLOR))) 
            test.compare(bullet_border_color,config.INCOMPLETE_COLOR, str(config.PRE_TREATMENT_SCREENS[page]+" bullet border color hex should be "+str(config.INCOMPLETE_COLOR)))     

    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 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:
        x_value = 0
    counter = 0
    while True:
        squish.mouseDrag(slider_object, x_value, 0, slider_value, 0, squish.Qt.NoModifier,
                     squish.Qt.LeftButton)
        if counter == 50:
            test.fail("User unable to fix slider slider_value")
            return False
        if bidirectional is True:
            if slider_range == "Low":
                if actual_value == pyFloat(slider_object.minValue):
                    return True
                if slider_value >= pyFloat(slider_object.minValue):
                    slider_value = slider_value + 30
                if slider_value <= pyFloat(slider_object.minValue):
                    slider_value = slider_value - 30
            if slider_range == "Max":
                if actual_value == pyFloat(slider_object.maxValue):
                    return True
                if slider_value >= pyFloat(slider_object.maxValue):
                    slider_value = slider_value + 30
                if slider_value <= pyFloat(slider_object.maxValue):
                    slider_value = slider_value - 30
        counter = counter + 1
        
        
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: str):
    """
    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: (str) padded string
    """
    pad_str = "###"+string
    return pad_str


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 navigate_to_pretreatment_screen(mode):
    """
        Method to navigate to sub mode under pre-treatment screen
        @param mode - (int) pre treatment state
    """
    hd_simulator.cmd_set_hd_operation_mode_data(HDOpModes.MODE_PRET.value,0)
    hd_simulator.cmd_send_pre_treatment_state_data(sub_mode=mode, water_sample_state=0,
    consumables_self_test_state=0, no_cartridge_self_test_state=0,
    installation_state=0, dry_self_test_state=0, prime_state=0,
    recirculate_state=0, patient_connection_state=0)
    
    
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 get_time(screen_title):
    """
        Method to return the current count down 
        in the application
        @param screen_title - (str) current title of the screen
    """
    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 == 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):
    """
        Method to verify the count down 
        time in application
        @param screen_title - (str) current title of the screen
    """
    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(300, count_down)
        elif screen_title == config.PRIMING_TITLE:
            hd_simulator.cmd_send_pre_treatment_disposables_prime_progress_data(300, count_down)
        elif screen_title == config.SYSTEM_SELF_TEST_TITLE:
            hd_simulator.cmd_send_pre_treatment_self_test_no_cartridge_progress_data(300, count_down)
        else:
            dg_simulator.cmd_send_dg_pre_treatment_filter_flush_progress_data(300, 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)
    test.endSection()
    
    
def verify_the_progress(count_down, screen_title):
    """
        Method to verify the current progress
        @param count_down - (int) current count down time
        @param screen_title - (str) current title of the screen
    """
    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 = config.MAXIMUM_COUNTDOWN_TIME - 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, pre_treatment_step):
    """    
    Method to verify the Page Step indicators [the object on top of the screen which indicates the steps passed, current, remained]
    @param pre_treatment_step : indicates the Current pre-treatment step 
    """  
    test.startSection("verification of page step indicators")
    for page in range(len(config.PRE_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, config.PRE_TREATMENT_SCREENS[page])) 

        if page < pre_treatment_step:
            test.log("To verify the step indicator of the completed pre-treatment screen " + config.PRE_TREATMENT_SCREENS[page]) 
            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, " the bullet color must be " + str(config.COMPLETE_COLOR))
            test.compare(bullet_border_color, config.COMPLETE_COLOR," the bullet border color must be " + str(config.COMPLETE_COLOR)) 
            test.compare(step_title.color.name, config.ENABLED_COLOR, " the text color must be " + str(config.ENABLED_COLOR))

        elif page == pre_treatment_step:
            test.log("To verify the step indicators of the current pre-treatment screen " + config.PRE_TREATMENT_SCREENS[page]) 
            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," the bullet color must be " + str(config.CURRENT_COLOR))
            test.compare(bullet_border_color,config.COMPLETE_COLOR, " the bullet border color must be " + str(config.COMPLETE_COLOR))
            test.compare(step_title.color.name,config.ENABLED_COLOR, " the text color must be " + str(config.ENABLED_COLOR))
            test.verify(step_title.font.bold, " the current text must be in bold")  

        else:
            test.log("To verify the step indicators of the remaining pre-treatment screen " + config.PRE_TREATMENT_SCREENS[page])
            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, " the text color must be " + str(config.INCOMPLETE_COLOR))
            test.compare(bullet_circle_color,config.CURRENT_COLOR," the bullet color must be " + str(config.CURRENT_COLOR)) 
            test.compare(bullet_border_color,config.INCOMPLETE_COLOR, " the bullet border color must be " + str(config.INCOMPLETE_COLOR))
    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 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  get_indicators(screen_obj, txt):
    """
        Verifying the busy indicators for BiCarb Pump Check and Acid Pump Check.
        indicator object of expected txt
        @param step - (str) expected txt
        @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