import importer
import unittest
import xmlrunner
import time
from lib import q2_library, modal_page
from pages.ngam import main_page, login_page
from pages.ngam.transactions import activity_center_page


class TSTR_1957_da_withlimit_single_domesticwire_approve(unittest.TestCase):
    driver = None
    util = None
    ENV = 'CI'
    BROWSER = 'CHROME_MAC'
    TRACKING_ID = None

    @classmethod
    def setUpClass(cls):
        cls.util = q2_library.Utilities()
        cls.util.load_config(cls)
        cls.input = cls.util.read_data_file("payments/tstr_1957_data.json")
        cls.driver = cls.util.get_browser(5)
        cls.url = cls.util.get_config("base_url")
        cls.user = cls.util.get_credentials('dual_action_with_limit_user')
        cls.password = cls.util.get_credentials('password_ma')
        cls.second_user = cls.util.get_credentials('dual_actionfx_user_1')
        cls.current_page = None
        cls.tracking_id = None

    def test_01_navigation(self):
        """Open the browser"""
        self.driver.get(self.url)
        self.driver.maximize_window()
        self.assertIn("4", self.driver.title, "Checking the title has the correct value")

    def test_02_login_successful(self):
        """Login the app"""
        login = login_page.LoginPage(self.driver)
        login.enter_username(self.user)
        login.enter_password(self.password)
        main_page = login.click_submit_button()
        msg = main_page.validate_welcome_msg()
        self.assertIn("Welcome back", msg, "Login was successful")

    def test_03_payments(self):
        """Going to payments"""
        menu = main_page.Menu(self.driver)
        menu.open_menu_item(self.input["commercial_menu"])
        payment_page = menu.open_menu_child_item(self.input["payments_menu"])
        self.__class__.current_page = payment_page
        payment_page.wait_for_page_to_load()
        self.assertTrue(payment_page.is_page_loaded(), "Checking if the payments page is loaded")

    def test_04_payments_page(self):
        """Setting the template"""
        self.payment_page = self.current_page
        self.payment_page.click_new_payment_drop_down()
        recipient_and_amount_page = self.payment_page.click_new_payment_dropdown_val(self.input['template_type'], "Single")
        recipient_and_amount_page.wait_for_page_to_load()
        self.__class__.current_page = recipient_and_amount_page
        self.assertTrue(recipient_and_amount_page.is_page_loaded(), "Check if the Recipient and Amount Page was loaded")

    def test_05_recipient_amount_tab(self):
        """Going to recipient Tab"""
        recipient_and_amount_page = self.current_page
        recipient_and_amount_page.select_list_view()
        recipient_and_amount_page.choose_recipient(self.input["recipient1"])
        recipient_and_amount_page.enter_amount(self.input["recipient1"], self.input["amount1"])
        warning_msg = recipient_and_amount_page.check_for_alac_warning_msg(self.input["warning_msg"])
        warning_msg2 = recipient_and_amount_page.check_for_alac_warning_msg(self.input["warning_msg2"])
        subsidiary_tab = recipient_and_amount_page.click_next_button()
        self.__class__.current_page = subsidiary_tab
        validations = warning_msg and warning_msg2 and subsidiary_tab.is_page_loaded()
        self.assertTrue(validations, "Checking that the Subsidiary tab got loaded")

    def test_06_subsidiary_tab(self):

        subsidiary_tab = self.current_page
        subsidiary_tab.select_list_view()
        subsidiary_tab.choose_subsidiary(self.input["subsidiary"], 1)
        account_tab = subsidiary_tab.click_next_button()
        self.__class__.current_page = account_tab
        validations = account_tab.is_page_loaded()
        self.assertTrue(validations, "Checking if the Account tab got loaded")

    def test_07_go_accounts_tab(self):
        """Going account tab """
        account_tab = self.current_page
        account_tab.choose_from_account(self.input["account"])
        review_submit_tab = account_tab.click_next_button()
        self.__class__.current_page = review_submit_tab
        self.assertTrue(review_submit_tab.is_page_loaded(), "Checking that the Review & Submit tab got loaded")

    def test_08_go_review_submit_tab(self):
        """Submitting transaction """
        review_submit_tab = self.current_page
        review_submit_tab.select_date()
        is_alert_present = review_submit_tab.is_error_message_present(self.input["ach_review_message"])
        is_draft_enabled = review_submit_tab.is_draft_enabled()
        is_approve_disabled = not review_submit_tab.is_approve_enabled()
        is_total_amount_correct = review_submit_tab.get_total_amt_in_overview() == self.input[
            "total_amount_in_overview"]
        is_send_payment_as_correct = review_submit_tab.get_send_payment_as_str() == self.input["subsidiary"]
        is_from_account_correct = self.input[
                                      "from_account_in_overview"] in review_submit_tab.get_txt_frm_acc_overview()
        is_recipient1_correct = review_submit_tab.get_rec_display_name(1) == self.input["recipient1"]
        self.assertTrue(
            is_alert_present and is_draft_enabled and is_approve_disabled and is_total_amount_correct and is_send_payment_as_correct and
            is_from_account_correct and is_recipient1_correct,
            "Checking that overview information is correct")

    def test_09_draft_payment(self):
        """Checking that the modal information is correct"""
        review_submit_tab = self.current_page
        modal = review_submit_tab.click_draft()
        self.__class__.current_page = modal
        is_color_correct = modal.get_modal_color() == self.input["ach_batch_drafted_color"]
        is_message_present = modal.get_modal_text() == self.input["ach_batch_message"]
        self.__class__.tracking_id = modal.get_ach_draft_modal_data("Tracking ID").split("Tracking ID: #", 1)[1]
        self.assertTrue(is_color_correct and is_message_present,
                        "Checking that the modal information is correct")

    def test_10_go_to_activity_center(self):
        """Going to Activity Center page"""
        modal = self.current_page
        modal.go_to_activity_center()
        self.activity_center = activity_center_page.ActivityCenterPage(self.driver)
        self.assertTrue(self.activity_center.is_single_transactions_tab_loaded(),
                        "Check if the Activity page is displayed")

    def test_11_validate_Wire(self):
        """Validating transfer info"""
        activity_center_p = activity_center_page.ActivityCenterPage(self.driver)
        activity_center_p.expand_transaction()
        header_status = activity_center_p.return_header_status() == self.input["header_status"]
        approval_header = activity_center_p.return_header_approvals() == self.input["header_approvals"]
        approval_dropdown_element = not activity_center_p.is_actions_menu_item_present(self.input["dropdown_action"])
        activity_center_p.expand_transaction()
        step_state = str(activity_center_p.get_trans_fld_data(self.input["trans_approve_fld"], "1.")).split(".")[1] == \
                     self.input["trans_draft_fld"]
        activity_center_p.expand_transaction()
        self.assertTrue(header_status and approval_header and approval_dropdown_element and step_state,
                        "Check if one or more validations are correct")

    def test_12_log_off(self):
        """Logging off the app"""
        self.menu = main_page.Menu(self.driver)
        self.menu.open_menu_item('Log Off')
        self.__class__.current_page = login_page.LoginPage(self.driver)
        self.current_page.wait_for_page_to_load()
        self.assertTrue(self.current_page.is_login_page_loaded(), "Checking that the user logged off correctly")

    def test_13_login_successful(self):
        """Login into the app"""
        self.current_page.enter_username(self.second_user)
        self.current_page.enter_password(self.password)
        self.__class__.current_page = self.current_page.click_submit_button()
        msg = self.current_page.validate_welcome_msg()
        self.assertIn('Welcome back', msg, "Login was successful")

    def test_14_go_to_activity_center(self):
        """Going to Activity Center Page"""
        self.menu = main_page.Menu(self.driver)
        self.menu.open_menu_item(self.input['transaction_menu'])
        self.activity_center_page = self.menu.open_menu_child_item(self.input['activity_center'])
        self.activity_center_page.wait_for_page_to_load()
        self.assertTrue(self.activity_center_page.is_page_loaded(), "Checking that the Activity Center page got loaded")

    def test_15_check_transaction(self):
        """Checking the transaction information """
        activity_center_p = activity_center_page.ActivityCenterPage(self.driver)
        activity_center_p.select_transaction_type_from_dropdown(self.input["transaction_type"])
        activity_center_p.click_column_to_display(self.input["checkbox_filter_option"])
        activity_center_p.filter_by_trans_id(self.tracking_id)
        activity_center_p.click_apply_filter()

        header_status = activity_center_p.return_header_status() == self.input["header_status"]
        approval_header = activity_center_p.return_header_approvals() == self.input["header_approvals"]
        is_approval_option_present = activity_center_p.is_actions_menu_item_present(self.input["dropdown_action"])
        activity_center_p.expand_transaction()
        step_state = str(activity_center_p.get_trans_fld_data(self.input["trans_approve_fld"], "1.")).split(".")[1] == \
                     self.input["trans_draft_fld"]
        activity_center_p.expand_transaction()
        self.assertTrue(header_status and approval_header and is_approval_option_present and step_state,
                        "Check for some of the previous validations to ensure those are True")

    def test_16_approve_transaction(self):
        """Approving the transaction"""
        activity_center_p = activity_center_page.ActivityCenterPage(self.driver)
        activity_center_p.click_actions_link()
        activity_center_p.click_actions_menu_item(self.input["dropdown_action"])
        activity_center_p.click_confirm()

        approve_modal_page = modal_page.ModalPage(self.driver)
        approve_draft_color = approve_modal_page.return_title_color() == self.input["ach_approval_color"]
        approve_modal_page.click_close_modal()
        self.assertTrue(approve_draft_color, "The Title color is not green for the Approval Modal")

    def test_17_go_to_activity_center(self):
        """Going to Activity Center Page"""
        activity_center_p = activity_center_page.ActivityCenterPage(self.driver)
        header_status = activity_center_p.return_header_status() == self.input["header_status_auth"]
        approval_header = activity_center_p.return_header_approvals() == self.input["header_approvals_auth"]
        activity_center_p.expand_transaction()
        approval_dropdown_element = activity_center_p.is_actions_menu_item_present(self.input["dropdown_action"])
        activity_center_p.expand_transaction()
        step_state = str(activity_center_p.get_trans_fld_data(self.input["trans_approve_fld"], "1.")).split("\n")[1] == \
                     self.input["trans_draft_fld_auth"]
        self.assertTrue(header_status and approval_header and approval_dropdown_element == False and step_state,
                        "Check if one or more validations are correct")

    def test_18_log_off(self):
        """Logging off the app"""
        self.menu = main_page.Menu(self.driver)
        self.menu.open_menu_item('Log Off')
        self.__class__.current_page = login_page.LoginPage(self.driver)
        self.current_page.wait_for_page_to_load()
        self.assertTrue(self.current_page.is_login_page_loaded(), "Checking that the user logged off correctly")

    def setUp(self):
        self.util.set_up(self)

    def tearDown(self):
        self.util.tear_down(self)

    @classmethod
    def tearDownClass(cls):
        cls.util.close_the_browser(cls.driver)


if __name__ == '__main__':
    q2_library.Utilities().set_parameters_to_this(TSTR_1957_da_withlimit_single_domesticwire_approve)
    with open('test-reports/TSTR_1957_da_withlimit_single_domesticwire_approve.xml', 'wb') as output:
        unittest.main(testRunner=xmlrunner.XMLTestRunner(output=output, verbosity=2),
                      failfast=False, buffer=False, catchbreak=False)