# -*- 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)      Papiya Mandal
# @date    (last)      27-Jan-2022
#

import names
import logging

# from time import sleep
from dialin.ui import utils
# from dialin.ui import unittests

from builtins import int as pyInt
from configuration.config import *
from configuration.utility import start_application, scroll_to_value_on_pop_up
from dialin.ui.hd_simulator import HDSimulator
# from dialin.ui.dg_simulator import DGSimulator
from dialin.protocols.CAN import DenaliCanMessenger
from dialin.ui.hd_simulator_alarms import HDAlarmsSimulator
from random import randint, choice, choices

      
hd = 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)

NUM_OF_MSG_ID = 289


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(2)
        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, ALARM_LIST_TITLE)


def generate_alarm_ids():
    """
        Method to generate 10 random
        alarm IDs
        @return alarm_id_list: list of 10 random alarm IDs
    """
    alarm_id_list = []
    id_count = 0
    while id_count < 10:
        id = randint(1, 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 of 10 states
    """
    state_list = choices(list(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 of Alarm IDs
        @param state_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 '{priority}'".format(priority=ALARM_PRIORITIES[state_list[index]]) +
                 " for Alarm ID '{alarm_id}' ".format(alarm_id=alarm_id) +
                 "and its respective message '{msg}'".format(msg=ALARM_ID_AND_MESSAGES[alarm_id]))
        
        alarm.cmd_activate_alarm_id(state=state_list[index], 
                                    alarm=alarm_id,
                                    flags=flags)
    test.endSection()
    
    
def arrange_the_alarm_list(alarm_id_list, accept=ACCEPTED, reason_id=0):
    """
        Method to arrange the alarm list 
        and Accept or Reject the Alarm list
        @param alarm_id_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: Reason for rejecting the alarm list
    """
    test.startSection("Verify the Messages under 'Alarm list'")
    if accept==ACCEPTED:
        alarm_id_parent_list = {}
        for index, id in enumerate(arranged_alarm_list):
            
            scroll_to_value_on_pop_up(value=names.get_alarm_id_obj(id=id), 
                           container=names.o_alarm_list_container)
            alarm_id = waitForObject(names.get_alarm_id_obj(id=id))
            alarm_id_parent = object.parent(alarm_id)
            alarm_id_parent_list[id] = alarm_id_parent
            alarm_msg = waitForObject(\
                        names.get_alarm_msg_obj(msg=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': {alarm_id} ".format(alarm_id=alarm_id) +
                        "should be equal to Expected 'Alarm ID': {id}".format(id=id))
            
            test.log("Verifying 'Alarm Message'")
            alarm_msg = alarm_msg.text.toUtf8().constData()
            test.compare(alarm_msg, ALARM_ID_AND_MESSAGES[id], 
                         "Actual 'Alarm Message': {alarm_msg} ".format(\
                            alarm_msg=alarm_msg) +
                         "should be equal to Expected " +
                         "'Alarm Message': {expected_msg}".format\
                         (expected_msg=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: {alarm_id} is at position {index}".format(\
                                    alarm_id=alarm_id, index=index) )
    elif accept==REJECTED:
        
        expected_message = REJECTION_REASON[0] + "\n" + REJECTION_REASON[reason_id]
        rejected_alarm_list_msg = waitForObject(names.o_rejected_alarm_list_msg)
        rejected_alarm_list_msg = rejected_alarm_list_msg.text.toUtf8().constData()
        test.compare(rejected_alarm_list_msg, expected_message,
                     "When 'Alarm list' is not accepted " +
                     "then '{expected_message}' should be ".format(\
                                    expected_message=expected_message) +
                     "displayed on 'Alarm List' pop up")
    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
    """
    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(2)
    set_the_alarm(alarm_id_list=alarm_id_list, 
                  state_list=generate_states(), 
                flags=set_only_alarm_list_btn(no_minimize=1))
    utils.waitForGUI(2)
    arranged_alarm_list = arrange_the_alarm_list(alarm_id_list=alarm_id_list,
                                accept=accept,reason_id=reason_id )
    utils.waitForGUI(2)
    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
    """
    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(2)
    set_the_alarm(alarm_id_list=alarm_id_list, 
                  state_list=generate_states(),
                  flags=set_only_alarm_list_btn(no_minimize=0))
    utils.waitForGUI(2)
    arranged_alarm_list = arrange_the_alarm_list(alarm_id_list=alarm_id_list,
                                accept=accept,reason_id=reason_id )
    utils.waitForGUI(2)
    minimize()
    utils.waitForGUI(5)
    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 = [290, 300, 499]
    alarm_id_parent_list = {}
    for index, alarm_id in enumerate(ALARM_IDS):
        test.log("Setting alarm ID {alarm_id}".format(alarm_id=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=ACCEPTED, 
                                        reason=0,
                                        a0=ALARM_IDS[0], a1=ALARM_IDS[1], 
                                        a2=ALARM_IDS[2])
    utils.waitForGUI(2)
    open_alarm_list_when_only_alarm_list_btn_is_available()
    utils.waitForGUI(1)
    for id in ALARM_IDS:
        alarm_id = waitForObject(names.get_alarm_id_obj(id=id))
        alarm_id_parent = object.parent(alarm_id)
        alarm_id_parent_list[id] = alarm_id_parent
        expected_msg = "{msg} [{id}]".format(msg=UNDEFINED_ALARM_ID_MSG,
                                            id=str(id))
        alarm_msg = waitForObject(\
                            names.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': {alarm_id} ".format(alarm_id=alarm_id) +
                             "should be equal to Expected 'Alarm ID': " +
                             "{id}".format(id=id))
                
        test.log("Verifying 'Alarm Message'")
        alarm_msg = alarm_msg.text.toUtf8().constData()
        test.compare(alarm_msg, expected_msg, 
                    "Actual 'Alarm Message': {alarm_msg} ".format(alarm_msg=alarm_msg) +
                    "should be equal to Expected " +
                    "'Alarm Message': {expected_msg}".format(expected_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: {alarm_id} is at position {index}".format(alarm_id=alarm_id,
                                                                          index=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: Alarm ID
        @param state: 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(2)
    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 = "{alarm_title} [{id}]".format(\
                                            alarm_title=ALARM_TITLE, id=id)
        test.compare(alarm_title, expected_title, "Alarm Dialogue bar " +
                    "is displayed upon generation of alarm " +
                    "and title '{alarm_title}' is displayed".format(\
                                            alarm_title=ALARM_TITLE, id=id))
        test.log("Verifying generated alarm message")
        alarm_msg = waitForObject(names.o_alarm_dialogue_box_msg)
        alarm_msg = alarm_msg.text.toUtf8().constData()
        expected_msg = "{msg} [{id}]".format(msg=UNDEFINED_ALARM_ID_MSG,
                                            id=str(id))
        test.compare(alarm_msg, expected_msg, 
                     "Expected message {msg} ".format(msg=expected_msg) +
                     "should be displayed on alarm dialogue bar")
    test.endSection()
  
    
def main():
    
    utils.tstStart(__file__)
    startApplication(AUT_NAME)
    
    test.log("GIVEN: 10 Alarms are generated")
    test.log("AND: Minimize button is Available")
    test.log("WHEN: Arranged 10 Alarms under 'Alarm list'")
    test.log("AND: 'Alarm list is accepted and 'Alarm Dialogue'" +
             "is minimized and 'Alarm list' is opened")
    test.log("THEN: All the 10 Alarms is displayed in 'Alarm list' " +
             "in defined order")
    verify_alarm_list_when_minimize_button_is_available(accept=ACCEPTED,
                                                                reason_id=0)
    
    utils.waitForGUI(1)
    
    test.log("GIVEN: 10 Alarms are generated")
    test.log("AND: Minimize button is Available")
    test.log("WHEN: Arranged 10 Alarms under 'Alarm list'")
    test.log("AND: 'Alarm list is Rejected and 'Alarm Dialogue'" +
             "is minimized and 'Alarm list' is opened")
    test.log("THEN: Only rejection message should display and " +
             "No Alarms should be displayed")
    verify_alarm_list_when_minimize_button_is_available(accept=REJECTED, 
                                                reason_id=20)
    
    utils.waitForGUI(1)
    
    test.log("GIVEN: 10 Alarms are generated")
    test.log("AND: Minimize button is removed")
    test.log("WHEN: Arranged 10 Alarms under 'Alarm list'")
    test.log("AND: 'Alarm list is accepted and 'Alarm list'" +
             "is opened")
    test.log("THEN: All the 10 Alarms is displayed in 'Alarm list' " +
             "in defined order")
    verify_alarm_list_when_only_alarm_list_button_is_available(accept=ACCEPTED,
                                                                reason_id=0)
    utils.waitForGUI(1)
    
    test.log("GIVEN: 10 Alarms are generated")
    test.log("AND: Minimize button is removed")
    test.log("WHEN: Arranged 10 Alarms under 'Alarm list'")
    test.log("AND: 'Alarm list is Rejected and 'Alarm list'" +
             "is opened")
    test.log("THEN: Only rejection message should display and " +
             "No Alarms should be displayed")
    verify_alarm_list_when_only_alarm_list_button_is_available(accept=REJECTED, 
                                                reason_id=7)
    
    utils.waitForGUI(1)
    
    test.log("GIVEN: 3 Undefined Alarms are generated")
    test.log("AND: Minimize button is Available")
    test.log("WHEN: Arranged 3 Alarms under 'Alarm list'")
    test.log("AND: 'Alarm list is Accepted and 'Alarm Dialogue'" +
             "is minimized and 'Alarm list' is opened")
    test.log("THEN: Undefined Alarm ID message is displayed along with ID")
    verify_alarm_msg_for_undefined_alarm_id()
    
    utils.waitForGUI(1)
    verify_alarm_dialogue_is_displayed(id=1000, state=2)
    
    utils.tstDone()