# -*- 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_ui_alarms_list
# @author  (last)      Papiya Mandal
# @date    (last)      04-02-2022
#

import logging
import names

from configuration import config, utility
from dialin.ui import utils
from builtins import int as pyInt
from dialin.common.alarm_priorities import AlarmPriorities
from dialin.ui.hd_simulator import HDSimulator
from dialin.protocols.CAN import DenaliCanMessenger
from dialin.ui.hd_simulator_alarms import HDAlarmsSimulator
from random import randint, choice, choices

hd_simulator = HDSimulator()

logging.basicConfig(filename='log_file.log',level=logging.INFO, datefmt='%d-%b-%y %H:%M:%S')
logger = logging.getLogger("INFO")
messenger = DenaliCanMessenger('can0')
alarm = HDAlarmsSimulator(can_interface=messenger, logger=logger)

def maximize_alarm_list()-> None:
    """
        Method to maximize the notification bar
    """
    mouseClick(waitForObjectExists(names.o_notification_bar_alarm_list_button))    
    
def minimize()-> None:
    """
        Method to minimize the Alarm Dialogue bar
    """
    mouseClick(waitForObjectExists(names.o_minimize_button))
        
def set_only_alarm_list_btn(no_minimize):
    """
        Method to remove the minimize and maximize button
        @return - flags 
    """
    flags = alarm.cmd_make_alarm_flags(no_minimize=no_minimize)
    return flags

def open_alarm_list_when_only_alarm_list_btn_is_available():
    """
        Method to open 'Alarm list' when only 'Alarm list' button is available
    """
    test.log("Opening 'Alarm list'")
    mouseClick(waitForObjectExists(names.o_alarm_list_minimize_maximize_button))
    alarm_list_text = waitForObject(names.o_alarm_list_title_text)
    if alarm_list_text.visible is False:
        utils.waitForGUI(1)
        mouseClick(waitForObject(names.o_alarm_list_minimize_maximize_button))
    else:
        test.log("Alarm List is displayed")
    alarm_list_title_text = alarm_list_text.text.toUtf8().constData()
    test.compare(alarm_list_title_text, config.ALARM_LIST_TITLE)


def generate_alarm_ids():
    """
        Method to generate 10 random alarm IDs
        @return alarm_id_list - (list) list of 10 random alarm IDs
    """
    alarm_id_list = []
    id_count = 0
    while id_count < 10:
        id = randint(1, config.NUM_OF_MSG_ID)
        if id in alarm_id_list:
            pass
        else:
            alarm_id_list.append(id)
            id_count += 1
    return alarm_id_list


def generate_states():
    """
        Method to generate 10 states between HIGH, MEDIUM, LOW, NONE
        @return id_list- (list) list of 10 states
    """
    state_list = choices(list(config.ALARM_PRIORITIES), k=10)
    return state_list


def set_the_alarm(alarm_id_list, state_list, flags=None):
    """
        Method to set the alarm
        @param alarm_id_list - (list) List of Alarm IDs
        @param state_list - (list)List of Alarm States(HIGH/MEDIUM/LOW)
        @flags - (int) See 'cmd_make_alarm_flags'
    """
    test.startSection("Settings Alarms")
    for index, alarm_id in enumerate(alarm_id_list):
        test.log("Setting alarm priority '{}' for Alarm ID '{}' and its respective message '{}'".format(config.ALARM_PRIORITIES[state_list[index]], alarm_id, config.ALARM_ID_AND_MESSAGES[alarm_id]))
        alarm.cmd_activate_alarm_id(state=state_list[index], alarm=alarm_id, flags=flags)
        alarm.cmd_set_alarm_triggered(alarm_id = alarm_id, field_descriptor_1 = 1, data_field_1 = 1,
                                field_descriptor_2 = 2, data_field_2 = 2,
                                priority = 1, rank = 1, clear_top = 1)
    test.endSection()
        
def arrange_the_alarm_list(alarm_id_list, accept=config.ACCEPTED, reason_id=0):
    """
        Method to arrange the alarm list and Accept or Reject the Alarm list
        @param alarm_id_list - (list) list of activated Alarm IDs
        @param accept: (bool) if the list is Accepted/Rejected
        @param reason: (int) Reason of Rejection
    """
    arranged_alarm_list = []
    count = len(alarm_id_list)
    for i in range(count):
        alarm_id = choice(alarm_id_list)
        arranged_alarm_list.append(alarm_id)
        alarm_id_list.remove(alarm_id)
    alarm.cmd_send_active_list_response(accept=accept, reason=reason_id,
                                        a0=arranged_alarm_list[0], a1=arranged_alarm_list[1], 
                                        a2=arranged_alarm_list[2], a3=arranged_alarm_list[3], 
                                        a4=arranged_alarm_list[4], a5=arranged_alarm_list[5], 
                                        a6=arranged_alarm_list[6], a7=arranged_alarm_list[7], 
                                        a8=arranged_alarm_list[8], a9=arranged_alarm_list[9])
    return arranged_alarm_list

    
def verify_alarm_list(arranged_alarm_list, accept=None, reason_id=0):
    """
        Method to verify the Messages under 'Alarm list'
        @param arranged_alarm_list - (list) alarm list
        @param accept - (bool) Accepted/Rejected
        @param reason_id - (int) Reason for rejecting the alarm list
    """
    test.startSection("Verify the Messages under 'Alarm list'")
    if accept==config.ACCEPTED:
        alarm_id_parent_list = {}
        for index, id in enumerate(arranged_alarm_list):
            
            utility.scroll_to_value_on_pop_up(value=utility.get_alarm_id_obj(id), container=names.o_alarm_list_container)
            alarm_id = waitForObject(utility.get_alarm_id_obj(id))
            alarm_id_parent = object.parent(alarm_id)
            alarm_id_parent_list[id] = alarm_id_parent
            alarm_msg = waitForObject(utility.get_alarm_msg_obj(config.ALARM_ID_AND_MESSAGES[id]))
            test.log("Verifying 'Alarm ID'")
            alarm_id = pyInt(alarm_id.text.toUtf8().constData())
            test.compare(alarm_id, id, "Actual 'Alarm ID': {} should be equal to Expected 'Alarm ID': {}".format(alarm_id, id))
            test.log("Verifying 'Alarm Message'")
            alarm_msg = alarm_msg.text
            test.compare(alarm_msg, config.ALARM_ID_AND_MESSAGES[id], "Actual 'Alarm Message': {} should be equal to Expected 'Alarm Message': {}".format(alarm_msg, config.ALARM_ID_AND_MESSAGES[id]))            
        test.log("Verifying the Alarm's position in 'Alarm list'")
        alarm_list_parent = waitForObject(names.o_alarm_list)
        alarm_list = object.children(alarm_list_parent)
        
        for index, alarm_id in enumerate(alarm_id_parent_list):
            test.compare(alarm_list[index], alarm_id_parent_list[alarm_id], "Alarm ID: {} is at position {}".format(alarm_id, index))
    else:
        expected_message = config.REJECTION_REASON[0] + "\n" + config.REJECTION_REASON[reason_id]
        rejected_alarm_list_msg = waitForObject(names.o_rejected_alarm_list_msg)
        rejected_alarm_list_msg = rejected_alarm_list_msg.text
        test.compare(rejected_alarm_list_msg, expected_message, "When 'Alarm list' is not accepted then '{}' should be displayed on 'Alarm List' pop up".format(expected_message))
    test.endSection()
        
        
def verify_alarm_list_when_only_alarm_list_button_is_available(accept=None, reason_id=None):
    """
        Method to set the alarms, arrange them 
        in a list and verify the correct alarm ID
        and its respective message is added to the list
        @param accept - (bool) Accepted/Rejected
        @param reason_id - (int) Reason for rejecting the alarm list
    """
    test.startSection("Set the alarms, arrange them in a list and verify the correct Alarm ID and its respective message is added to the list")
    alarm_id_list = generate_alarm_ids()
    utils.waitForGUI(1)
    set_the_alarm(alarm_id_list=alarm_id_list, state_list=generate_states(), flags=set_only_alarm_list_btn(no_minimize=1))
    utils.waitForGUI(1)
    arranged_alarm_list = arrange_the_alarm_list(alarm_id_list=alarm_id_list,accept=accept,reason_id=reason_id)
    utils.waitForGUI(1)
    open_alarm_list_when_only_alarm_list_btn_is_available()
    utils.waitForGUI(1)
    verify_alarm_list(arranged_alarm_list=arranged_alarm_list, accept=accept,reason_id=reason_id)
    test.endSection()
    

def verify_alarm_list_when_minimize_button_is_available(accept=None, reason_id=None):
    """
        Method to set the alarms, arrange them 
        in a list and verify the correct alarm ID
        and its respective message is added to the list
        @param accept - (bool) Accepted/Rejected
        @param reason_id - (int) Reason for rejecting the alarm list
    """
    test.startSection("Set the alarms, arrange them in a list and verify the correct Alarm ID and its respective message is added to the list")
    alarm_id_list = generate_alarm_ids()
    utils.waitForGUI(1)
    set_the_alarm(alarm_id_list=alarm_id_list, state_list=generate_states(), flags=set_only_alarm_list_btn(no_minimize=0))
    utils.waitForGUI(1)
    arranged_alarm_list = arrange_the_alarm_list(alarm_id_list=alarm_id_list, accept=accept,reason_id=reason_id)
    utils.waitForGUI(1)
    minimize()
    utils.waitForGUI(1)
    maximize_alarm_list()
    utils.waitForGUI(1)
    verify_alarm_list(arranged_alarm_list=arranged_alarm_list, accept=accept,reason_id=reason_id)
    test.endSection()
    
    
def verify_alarm_msg_for_undefined_alarm_id() -> None:
    """
        Method to set undefined alarm
        and verify the respective message
        displayed
    """
    test.startSection("Set undefined alarm and verify the respective message displayed")
    
    ALARM_IDS = [900, 300, 499]
    alarm_id_parent_list = {}
    for index, alarm_id in enumerate(ALARM_IDS):
        test.log("Setting alarm ID {}".format(alarm_id))
        
        alarm.cmd_activate_alarm_id(state=2, alarm=alarm_id, flags=set_only_alarm_list_btn(no_minimize=1))
    alarm.cmd_send_active_list_response(accept=config.ACCEPTED, reason=0, a0=ALARM_IDS[0], a1=ALARM_IDS[1], a2=ALARM_IDS[2])
    utils.waitForGUI(1)
    open_alarm_list_when_only_alarm_list_btn_is_available()
    utils.waitForGUI(1)
    for id in ALARM_IDS:
        alarm_id = waitForObject(utility.get_alarm_id_obj(id))
        alarm_id_parent = object.parent(alarm_id)
        alarm_id_parent_list[id] = alarm_id_parent
        expected_msg = "{} [{}]".format(config.UNDEFINED_ALARM_ID_MSG, str(id))
        alarm_msg = waitForObject(utility.get_alarm_msg_obj(msg=expected_msg))
        test.log("Verifying 'Alarm ID'")
        alarm_id = pyInt(alarm_id.text.toUtf8().constData())
        test.compare(alarm_id, id, "Actual 'Alarm ID': {} should be equal to Expected 'Alarm ID': {}".format(alarm_id, id))
                
        test.log("Verifying 'Alarm Message'")
        alarm_msg = alarm_msg.text.toUtf8().constData()
        test.compare(alarm_msg, expected_msg, "Actual 'Alarm Message': {} should be equal to Expected Alarm Message': {}".format(alarm_msg, expected_msg))
                
        test.log("Verifying the Alarm's position in 'Alarm list'")
        alarm_list_parent = waitForObject(names.o_alarm_list)
        alarm_list = object.children(alarm_list_parent)
        
    for index, alarm_id in enumerate(alarm_id_parent_list):
        test.compare(alarm_list[index],alarm_id_parent_list[alarm_id], "Alarm ID: {} is at position {}".format(alarm_id, index))
    test.endSection()

def verify_alarm_dialogue_is_displayed(id, state):
    """
        Method to verify the Alarm Dialogue 
        is opened automatically from 'Alarm list' 
        screen when new non-zero alarm is generated
        and verify the undefined alarm id message
        @param id - (int) Alarm ID
        @param state- (int) Alarm priority
    """
    test.startSection("Verify the Alarm Dialogue is opened automatically from 'Alarm list' screen when new non-zero alarm is generated and verify the undefined alarm id message")
    
    alarm.cmd_activate_alarm_id(state=state, alarm=id, flags=set_only_alarm_list_btn(no_minimize=0))

    utils.waitForGUI(1)
    if object.exists(names.o_alarm_title_text):
        alarm_title = waitForObject(names.o_alarm_title_text)
        alarm_title = alarm_title.text.toUtf8().constData()
        test.log("Verifying the Alarm title")
        expected_title = "{} [{}]".format(config.ALARM_TITLE, id)
        test.compare(alarm_title, expected_title, "Alarm Dialogue bar is displayed upon generation of alarm and title '{}' is displayed".format(config.ALARM_TITLE, id))
        test.log("Verifying generated alarm message")
        alarm_msg = waitForObject(names.o_alarm_dialogue_box_msg)
        alarm_msg = alarm_msg.text
        expected_msg = "{} [{}]".format(config.UNDEFINED_ALARM_ID_MSG, str(id))
        test.compare(alarm_msg, expected_msg, "Expected message {} should be displayed on alarm dialogue bar".format(expected_msg))
    test.endSection()
    
def main():
    
    utils.tstStart(__file__)
    startApplication(config.AUT_NAME)
    
    verify_alarm_list_when_minimize_button_is_available(accept=config.ACCEPTED, reason_id=0)
    
    utils.waitForGUI(1)
    verify_alarm_list_when_minimize_button_is_available(accept=config.REJECTED, reason_id=20)
    
    utils.waitForGUI(1)
    verify_alarm_list_when_only_alarm_list_button_is_available(accept=config.ACCEPTED, reason_id=0)
    utils.waitForGUI(1)
    verify_alarm_list_when_only_alarm_list_button_is_available(accept=config.REJECTED, reason_id=7)
    
    utils.waitForGUI(1)
    verify_alarm_msg_for_undefined_alarm_id()
    
    utils.waitForGUI(1)
    verify_alarm_dialogue_is_displayed(id=1000, state=AlarmPriorities.ALARM_PRIORITY_MEDIUM.value)
    
    utils.tstDone()