# -*- 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_post
# @author  (last)      Joseph varghese
# @date    (last)      02-Feb-2022
# This test contradicts verification of ui alarms dialog 
# section

import csv
import names
import logging
from dialin.ui import utils
from configuration import config, utility
from dialin.ui.hd_simulator import HDSimulator
from dialin.protocols.CAN import DenaliCanMessenger
from dialin.ui.hd_simulator_alarms import HDAlarmsSimulator


ALARM_EXPIRES_TIME = (0, 10, 20, 30, 30, 100)
ALARM_ID_COMBINATION = (2, 3, 5, 7, 10, 15, 20, 25, 30, 50)
alarm_id_combination = (2, 3, 5, 7, 10, 15, 20, 25, 30, 50)
contents = []
alarm_ids = []
alarm_titles = []
alarms_msgs = []
count_of_alarms = []
title_count_dict = {}
text_obj_names = [names.o_alarm_title_text,names.o_alarm_id_text,names.o_alarm_dialogue_box_msg ]
logging.basicConfig(filename='log_file.log',level=logging.INFO, datefmt='%d-%b-%y %H:%M:%S')
hd_simulator = HDSimulator()
logger = logging.getLogger("INFO")
messenger = DenaliCanMessenger('can0')
alarm = HDAlarmsSimulator(can_interface=messenger, logger=logger)

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

def read_message_title_from_alarms_conf_file(alarm_id):
    """
        This method is used to extract data from Alarms.conf file.
        @param (int) alarm_id: ID for specified alarm message.
        @returns alarm title from extracted file.
    """
    utils.waitForGUI(0.2)
    flag = False
    with open(config.ALARMS_CONF_LOCATION, 'r') as conf_file:
        for row in list(csv.reader(conf_file)):
            try:
                if flag is True:
                    alarm_title = row[0].split(' = ')
                    if len(alarm_title[1]) == 0 and alarm_title[1] != None:  
                        return 'Alarm'
                    else:
                        return alarm_title[1]
                if len(row) == 0:
                    continue
                else:
                    if row[0] == '['+str(alarm_id)+']':
                        flag = True
            except IndexError:
                test.fail("alarm title is not mapped with alarm id from Alarm.conf file")
        
        
def read_alarm_message_from_alarms_conf_file(alarm_id):
    """
        This method is used to extract data from Alarms.conf file.
        @param (int) alarm_id: ID for specified alarm message.
        @returns alarm message from extracted file.
    """
    utils.waitForGUI(0.2)
    flag = False
    status = False
    with open(config.ALARMS_CONF_LOCATION, 'r') as conf_file:
        for row in list(csv.reader(conf_file)):
            try:
                if flag is True and status is True:
                    alarm_message = row[0].split(' = ')
                    return alarm_message[1]      
                if flag is True:
                    alarm_title = row[0].split(' = ')
                    if alarm_title[0] == 'Title  ':  
                        status = True
                if len(row) == 0:
                    continue
                else:
                    if row[0] == '['+str(alarm_id)+']':
                        flag = True
            except IndexError:
                test.fail("alarm message is not mapped with alarm id from Alarm.conf file")
        
            
def minimize():
    """
    Method to minimize alarm dialog box
    @param N/A
    @output N/A
    """
    mouseClick(waitForObject(names.o_alarm_button_minimize))
    utils.waitForGUI(1) # this wait is necessary. Due to dialog animation it will be hide until the animation is done.


def maximize():
    """
    Method to maximize alarm dialog box
    @param N/A
    @output N/A
    """
    mouseClick(waitForObject(names.o_alarm_bar_maximize))
    utils.waitForGUI(1) # this wait is necessary. Due to dialog animation it will be hide until the animation is done.


def test_button(flag, vButtons):
    """
    Method to verify single button on alarm dialog box
    @param flag - (bool) alarm flag to be set
    @param vButtons - (bool) button binary
    @output N/A
    """
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag)
    test.compare(waitForObjectExists(names.o_alarm_button_ok        ).visible, 
                 vButtons == config.ALARM_BUTTONS_OK, 
                 "Button visible [OK]")
    test.compare(waitForObjectExists(names.o_alarm_button_resume    ).visible, 
                 vButtons == config.ALARM_BUTTONS_RESUME               or 
                 vButtons == config.ALARM_BUTTONS_RESUME_RINSEBACK     or
                 vButtons == config.ALARM_BUTTONS_RESUME_END           or 
                 vButtons == config.ALARM_BUTTONS_RESUME_RINSEBACK_END , 
                 "Button visible [Resume]")
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback ).visible, 
                 vButtons == config.ALARM_BUTTONS_RINSEBACK            or 
                 vButtons == config.ALARM_BUTTONS_RINSEBACK_RESUME     or
                 vButtons == config.ALARM_BUTTONS_RINSEBACK_END        or 
                 vButtons == config.ALARM_BUTTONS_RINSEBACK_RESUME_END , 
                 "Button visible [RINSEBACK]")
    test.compare(waitForObjectExists(names.o_alarm_button_end       ).visible, 
                 vButtons == config.ALARM_BUTTONS_END                  or 
                 vButtons == config.ALARM_BUTTONS_END_RESUME           or
                 vButtons == config.ALARM_BUTTONS_END_RINSEBACK        or 
                 vButtons == config.ALARM_BUTTONS_END_RESUME_RINSEBACK , 
                 "Button visible [End]")
    
    if waitForObjectExists(names.o_alarm_button_ok        ).visible: # Ok button
        obj = waitForObjectExists(names.o_ok_button_mouse_area) 
        if obj.visible : mouseClick(obj)
        utils.waitForGUI(0.5)
    if waitForObjectExists(names.o_alarm_button_resume    ).visible: # Resume button 
        obj = waitForObjectExists(names.o_resume_button_mouse_Area) 
        if obj.visible : mouseClick(obj)
        utils.waitForGUI(0.5)
    if waitForObjectExists(names.o_alarm_button_rinseback ).visible: # Rinse back button
        obj = waitForObjectExists(names.o_rinseback_mouse_area) 
        if obj.visible : mouseClick(obj)
        utils.waitForGUI(0.5)
    if waitForObjectExists(names.o_alarm_button_end       ).visible: # End button
        obj = waitForObjectExists(names.o_end_button_mouse_area) 
        if obj.visible : mouseClick(obj)
        utils.waitForGUI(0.5)
    
    alarm.cmd_alarm_condition_cleared(alarm_id = 1)

def test_all_buttons():
    """
    Method to verify multiple buttons on alarm dialog box
    @param N/A
    @output N/A
    """
    
    obj = waitForObjectExists(names.o_resume_mouse_Area) 
    if  obj.visible : mouseClick(obj)
    test.compare(waitForObjectExists(names.o_alarm_button_resume    ).visible, True ,"Button visible [Resume]")
        
    obj = waitForObjectExists(names.o_rinseback_button_mouse_area) 
    if obj.visible : mouseClick(obj)
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback ).visible, True ,"Button visible [RINSEBACK]")
        
    obj = waitForObjectExists(names.o_end_mouse_area) 
    if obj.visible : mouseClick(obj)
    test.compare(waitForObjectExists(names.o_alarm_button_end       ).visible, True ,"Button visible [End]")
    
    obj = waitForObjectExists(names.o_alarm_button_ok) 
    if obj.visible == True :
        mouseClick(obj)
        test.compare(waitForObjectExists(names.o_alarm_button_ok        ).visible, True ,"Button visible [OK]")
    else:
        test.compare(waitForObjectExists(names.o_alarm_button_ok        ).visible, False ,"Button not visible [OK]")
     
    
def verification_of_alarm_flag():
    """
    Method to verify alarm flag
    @param N/A
    @output N/A
    """
    test.startSection("verification of alarm flag.")
   
    flag_status = alarm.cmd_make_alarm_flags(no_resume=1, no_rinseback=1, no_end_treatment=1, user_must_ack=1)
    test_button(flag = flag_status, vButtons = config.ALARM_BUTTONS_OK)
    flag_status = alarm.cmd_make_alarm_flags(no_resume=1, no_rinseback=1, no_end_treatment=0, user_must_ack=0)
    test_button(flag = flag_status, vButtons = config.ALARM_BUTTONS_END)
    flag_status = alarm.cmd_make_alarm_flags(no_resume=1, no_rinseback=0, no_end_treatment=1, user_must_ack=0)
    test_button(flag = flag_status, vButtons = config.ALARM_BUTTONS_RINSEBACK)
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=1, no_end_treatment=1, user_must_ack=0)
    test_button(flag = flag_status, vButtons = config.ALARM_BUTTONS_RESUME)
    
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=1)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test_all_buttons()
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, alarms_silenced=1)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test_all_buttons()
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, no_minimize=1)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test_all_buttons()
     
    #enables and verifies no alarm silence flag
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=0, no_minimize=0, alarms_silenced=0)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test.compare(waitForObjectExists(names.o_alarm_not_silence_img   ).visible, True ,"Alarm not silence button is visible")
    test.compare(waitForObjectExists(names.o_alarm_button_ok         ).visible, False ,"Button not visible [OK]")
    test.compare(waitForObjectExists(names.o_alarm_button_resume     ).visible, True ,"Button visible [Resume]")
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback  ).visible, True ,"Button visible [RINSEBACK]")
    test.compare(waitForObjectExists(names.o_alarm_button_end        ).visible, True ,"Button visible [End]")
    test_all_buttons()
    #enables and verifies alarm silence flag
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=0, no_minimize=0, alarms_silenced=1)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test.compare(waitForObjectExists(names.o_alarm_silence_img       ).visible, True ,"Alarm silence button is visible")
    test.compare(waitForObjectExists(names.o_alarm_button_ok         ).visible, False ,"Button not visible [OK]")
    test.compare(waitForObjectExists(names.o_alarm_button_resume     ).visible, True ,"Button visible [Resume]")
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback  ).visible, True ,"Button visible [RINSEBACK]")
    test.compare(waitForObjectExists(names.o_alarm_button_end        ).visible, True ,"Button visible [End]")
    test_all_buttons()
    #enables and verifies user must acknowledge flag 
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=1, alarms_silenced=0, no_minimize=0)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test.compare(waitForObjectExists(names.o_alarm_button_ok        ).visible, True ,"Button visible [OK]")
    test.compare(waitForObjectExists(names.o_alarm_button_resume    ).visible, True ,"Button visible [Resume]")
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback ).visible, True ,"Button visible [RINSEBACK]")
    test.compare(waitForObjectExists(names.o_alarm_button_end       ).visible, True ,"Button visible [End]")
    test_all_buttons() 
    #enables and verifies alarm no minimize flag
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=0, alarms_silenced=0, no_minimize=1)
    alarm.cmd_activate_alarm_id(state = 1, alarm = 1, flags = flag_status)
    test.compare(waitForObjectExists(names.o_alarm_button_ok        ).visible, False ,"Button not visible [OK]")
    test.compare(waitForObjectExists(names.o_alarm_button_resume    ).visible, True ,"Button visible [Resume]")
    test.compare(waitForObjectExists(names.o_alarm_button_rinseback ).visible, True ,"Button visible [RINSEBACK]")
    test.compare(waitForObjectExists(names.o_alarm_button_end       ).visible, True ,"Button visible [End]")
    test_all_buttons()
    #enables alarm 4 and press all buttons on screen
    flag_status = alarm.cmd_make_alarm_flags(no_resume=0, no_rinseback=0, no_end_treatment=0, user_must_ack=1, no_minimize=1, alarms_silenced=1)
    alarm.cmd_activate_alarm_id(state = 2, alarm = 4, flags = flag_status)
    utils.waitForGUI(1)
    test_all_buttons()
    
    test.endSection()
    
def test_color_based_on_alarm_priority(alarm_priority):
    """
    Method to verify alarm dialog box color based on alarm priority
    @param alarm_priority - (int) alarm priority level
    @output N/A
    """
    test.startSection("verification of alarm dialog box color based on alarm priority -> " + config.ALARM_PRIORITY_OPTIONS[alarm_priority])
   
    test.compare(str(waitForObjectExists(names.o_modalDialog          ).color.name), config.ALARMS_COLORS_BODY[(config.ALARM_PRIORITY_OPTIONS[alarm_priority])])
    test.compare(str(waitForObjectExists(names.o_alarm_dialog_titleBar).color.name), config.ALARMS_COLORS_HEADER[(config.ALARM_PRIORITY_OPTIONS[alarm_priority])])
    
    minimize()
    test.compare(str(waitForObject      (names.o_alarm_bar            ).color.name), config.ALARMS_COLORS_BODY[(config.ALARM_PRIORITY_OPTIONS[alarm_priority])])

    maximize()
    test.endSection()


def test_message_based_on_alarm_id(alarm_id, alarm_info_dict):
    """
    Method to verify alarm message based on alarm id
    @param alarm id - (int) alarm id to be set.
    @param alarm_info_dict - (dict) Alarm dict containing title and alarm message
    @output N/A
    """
    test.startSection("verification of alarm message based on alarm id -> " + str(alarm_id))
          
    if alarm_id >= config.ALARM_ID_OUT_OF_RANGE:
        test.compare(str(waitForObjectExists(names.o_alarm_text_description).text), config.UNDEFINED_ALARM_ID_MSG.format(alarm_id), "verified alarm message for exceeded alarm id's")        
        minimize()
        test.compare(str(waitForObjectExists(names.o_alarm_bar_text        ).text), config.UNDEFINED_ALARM_ID_MSG.format(alarm_id), "verified alarm message for exceeded alarm id's")        
    else:
        test.log(str(alarm_id))
#         utils.waitForGUI(0.5)
        test.compare(str(waitForObjectExists(names.o_alarm_text_description).text), alarm_info_dict[alarm_id]['message'], "Alarm message is verified from alarm dialog box")
        minimize()
        test.compare(str(waitForObjectExists(names.o_alarm_bar_text        ).text), alarm_info_dict[alarm_id]['title'], "Alarm title is verified from alarm bar")                              
        maximize()
        if alarm_id < config.NUM_OF_ALARM_ID:
            alarm_id_text = f"ID:{alarm_id}"
            test.compare(str(waitForObjectExists(names.o_alarm_screen_id              ).text), alarm_id_text, "Alarm id is verified from alarm dialog box")                              
        alarm_message = alarm_info_dict[alarm_id]['message']
        test.compare(str(waitForObjectExists(names.o_alarm_text_description).text), alarm_message, "Alarm message is verified from alarm dialog box")

    test.endSection()
    
#Check this function 
def test_verify_alarm_mute(alarm_timeout = 0, v_flags = 0, alarm_status = "Mute"):
    """
    Method to verify alarm mute and unmute characteristics.
    @param alarm_timeout - (int) timeout delay for alarm
    @param alarm_status - (str) status of alarm
    @param v_flag - (int) flag for mute and unmute operation.
    @output N/A
    """
    test.startSection("verification of alarm " + str(alarm_status) + "condition for timeout " + str(alarm_timeout))
    test.compare(waitForObjectExists(names.o_alarm_button_mute).timeout, alarm_timeout)

    muted = v_flags == config.ALARM_MUTE_FLAG
    test.compare(waitForObjectExists(names.o_alarm_button_mute_min).visible, muted, "Mute min button is visible")
    test.compare(waitForObjectExists(names.o_alarm_button_mute_sec).visible, muted, "Mute sec button is visible")

    muteTimeout_min,muteTimeout_sec = divmod(alarm_timeout, 60)
    if muted:
        test.compare(str(waitForObjectExists(names.o_alarm_button_mute_img).source.path), "/images/iBellOff")
        test.compare(str(waitForObjectExists(names.o_alarm_button_mute_min).text), "{}"    .format(muteTimeout_min))
        test.compare(str(waitForObjectExists(names.o_alarm_button_mute_sec).text), "{0:02}".format(muteTimeout_sec))
        minimize()
        test.compare(str(waitForObjectExists(names.o_alarm_bar_mute_img   ).source.path), "/images/iBellOff" )
        test.compare(str(waitForObjectExists(names.o_alarm_bar_mute_min   ).text), "{}"    .format(muteTimeout_min))
        test.compare(str(waitForObjectExists(names.o_alarm_bar_mute_sec   ).text), "{0:02}".format(muteTimeout_sec))
        
    else:
        test.compare(str(waitForObjectExists(names.o_alarm_button_mute_img).source.path), "/images/iBellOn" )
        minimize()
        test.compare(str(waitForObjectExists(names.o_alarm_bar_mute_img   ).source.path), "/images/iBellOn" )
        
    maximize()
    test.endSection()
    
    
def verification_of_alarm_messages():
    """
    Method to verify parameters on the alarm bar
    @param N/A
    @output N/A
    """
    test.startSection("verification of alarm bar parameters")
    alarm_info_dict = utility.extract_alarm_info_from_alarms_conf_file()
    for alarm_id in range(0, config.NUM_OF_ALARM_ID):
#     for alarm_id in [73]:
        
        if alarm_id == config.ALARM_ID_NO_ALARM:
            test.log("validate alarm condition for alarm id : 0")
            alarm.cmd_set_alarm_cleared_condition(alarm_id = 0)
            alarm.cmd_activate_alarm_id(0, 0, 0, 0, 0)
            utils.waitForGUI()
            dlg        = names.o_modalDialog
            bar        = names.o_alarm_bar
            dlg_exists = object.exists(dlg)
            bar_exists = object.exists(bar)
            if not dlg_exists:
                test.compare(dlg_exists, False)
            else:
                test.compare(waitForObjectExists(dlg).visible, False)
        
            if not bar_exists:
                test.compare(True, True)
            else:
                test.compare(waitForObjectExists(bar).visible, False)
        else:
            alarm.cmd_activate_alarm_id( alarm = alarm_id)
        
            #verify alarm message based on id on alarm bar section.
            test_message_based_on_alarm_id(alarm_id, alarm_info_dict)
    
    test.endSection()           


def verification_of_alarm_parameters():
    """
    Method to verify parameters of the alarm 
    @param N/A
    @output N/A
    """
    test.startSection("verification of alarm parameters")
    
    flag_mute = alarm.cmd_make_alarm_flags(alarms_silenced=1)
    flag_unmute = alarm.cmd_make_alarm_flags(alarms_silenced=0)          
           
    mouseClick(waitForObjectExists(names.o_alarm_button_mute))
    for alarm_id in ALARM_ID_COMBINATION:   
        for alarm_index in range(config.NUM_OF_ALARM_PRIORITIES):
            alarm.cmd_activate_alarm_id(state = alarm_index, alarm = alarm_id, silence_expires = ALARM_EXPIRES_TIME[alarm_index], flags = flag_mute)
            
            #verify mute feature in application.
            test_verify_alarm_mute(alarm_timeout=ALARM_EXPIRES_TIME[alarm_index], v_flags=config.ALARM_MUTE_FLAG, alarm_status = "Mute")
            
            mouseClick(waitForObjectExists(names.o_alarm_button_mute))
            alarm.cmd_activate_alarm_id(state = alarm_index, alarm = alarm_id, flags = flag_unmute)
                        
            #verify un-mute feature in application.
            test_verify_alarm_mute(v_flags=config.ALARM_UNMUTE_FLAG, alarm_status = "UnMute")
                    
            #verify coloring based on priority.
            test_color_based_on_alarm_priority(alarm_index)
            
            #verify cleared alarm
            alarm.cmd_set_alarm_cleared(alarm_id)
            
            utils.waitForGUI(0.2)   #delay for fetching effect on UI

    test.endSection()
    

def main():
    
    utils.tstStart(__file__)
    startApplication(config.AUT_NAME)
    verification_of_alarm_messages()
    verification_of_alarm_parameters()
    verification_of_alarm_flag()
         
    utils.tstDone()