###########################################################################
#
# 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 sys
import test
import squish
import test

from configuration import config
from dialin.ui import utils
from datetime import datetime
from dialin.ui.hd_simulator import HDSimulator
from builtins import int as pyInt
from builtins import float as pyFloat

hd = 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.rejection_msg["text"] = text
    return names.rejection_msg

def set_slider_value(slider_value= None, slider_object= None, bidirectional= False,
                     slider_range = None):
    """
    Method to drag slider to desired value
    @param slider_value : value in which slider should be placed
    @param slider_object : object of the slider
    @param bidirectional : True, if slider have 2 handler
    @return boolean (True - if user able to select slider. else, false)
    """
    slider_value = pyFloat(slider_value)
    actual_value = slider_value
    if slider_range == "Max":
        x_value =  600
    else:
        x_value = 0
    counter = 0
    while True:
        if slider_value < 0:
            slider_value = -1 * slider_value
        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 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
        else:
            if actual_value == pyFloat(slider_object.value):
                return True
            if slider_value >= pyFloat(slider_object.value):
                slider_value = slider_value + 30
            if slider_value <= pyFloat(slider_object.value):
                slider_value = slider_value - 30
        counter = counter + 1


def slider_movement_for_negative_values(slider_value= None, slider_object= None, bidirectional= False,
                     slider_range = None):
    """
    Method to drag slider for negative values value 
    @param slider_value : value in which slider should be placed
    @param slider_object : object of the slider
    @param bidirectional : True, if slider have 2 handler
    @return boolean (True - if user able to select slider. else, false)
    """
    slider_value = pyFloat(slider_value)
    actual_value = slider_value
    if slider_range == "Max":
        x_value =  600
    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