"""Модуль вкладки настройки LDAP Аутентификации.

Содержит класс LDAPAuthSettings для работы с вкладкой настройки LDAP Аутентификации.
Позволяет проверять состояние и взаимодействовать с элементами вкладки.
"""

import re
from playwright.sync_api import Page
from locators.text_input_locators import TextInputLocators
from locators.settings_form_locators import SettingsFormLocators
from elements.text_input_element import TextInput
from elements.text_element import Text
from elements.icon_element import Icon
from elements.checkbox_element import Checkbox
from components.toolbar_component import ToolbarComponent
from components.alert_component import AlertComponent
from components_derived.settings_form_component import SettingsFormComponent
from pages.base_page import BasePage

class LDAPAuthSettingsTab(BasePage):
    """Класс для работы с вкладкой настройки LDAP Аутентификации.

    Предоставляет методы для взаимодействия с вкладкой настройки LDAP Аутентификации.

    Args:
        page: Экземпляр страницы Playwright.
    """

    def __init__(self, page: Page) -> None:
        """Инициализирует компоненты вкладки настройки LDAP Аутентификации."""

        super().__init__(page)

        self.toolbar = ToolbarComponent(page, "LDAP")

        toolbar_button_edit = self.page.get_by_role("navigation").locator("//button[@data-testid='LDAP__btn__edit']")
        self.toolbar.add_tooltip_button(toolbar_button_edit, "edit")

        toolbar_button_save = self.page.get_by_role("navigation").locator("//button[@data-testid='LDAP__btn__submit']")
        self.toolbar.add_tooltip_button(toolbar_button_save, "save")

        toolbar_button_cancel = self.page.get_by_role("navigation"). \
                                locator("//button[@data-testid='LDAP__btn__cancelEdit']")
        self.toolbar.add_tooltip_button(toolbar_button_cancel, "cancel")

        # Форма для отображения/редактирования полей настроек LDAP Аутентификации
        self.settings_form = SettingsFormComponent(page)

        container_locator = self.page.locator(SettingsFormLocators.SETTINGS_FORM_INPUT_FORM_CONTAINER)

        # Метка "tls"
        label_tls_locator = container_locator.get_by_text("tls")
        label_tls = Text(
            page,
            label_tls_locator,
            "tls_checkbox_label"
        )
        self.settings_form.add_content_item("tls_checkbox_label", label_tls)

        # Чекбокс "tls"
        checkbox_tls = Checkbox(
            page,
            container_locator.locator("//input[@data-testid='LDAP__checkbox__tls']"),
            "tls_checkbox"
        )
        self.settings_form.add_content_item("tls_checkbox", checkbox_tls)

        self.input_fields_locators = self.settings_form.get_input_fields_locators(container_locator)

        loc = self.input_fields_locators.get("ip")
        loc_ip_input = loc.locator("//input[@data-testid='LDAP__text-field__ip']")
        ip_setting_input = TextInput(page, loc_ip_input, "ip_setting_input")
        self.settings_form.add_content_item("ip_setting_input", ip_setting_input)

        loc = self.input_fields_locators.get("Порт")
        loc_port_input = loc.locator("//input[@data-testid='LDAP__text-field__port']")
        port_setting_input = TextInput(page, loc_port_input, "port_setting_input")
        self.settings_form.add_content_item("port_setting_input", port_setting_input)

        loc = self.input_fields_locators.get("Имя пользователя")
        loc_user_input = loc.locator("//input[@data-testid='LDAP__text-field__login']")
        user_setting_input = TextInput(page, loc_user_input, "user_setting_input")
        self.settings_form.add_content_item("user_setting_input", user_setting_input)

        loc = self.input_fields_locators.get("Пароль")
        loc_password_input = loc.locator("//input[@data-testid='LDAP__text-field__password']")
        password_setting_input = TextInput(page, loc_password_input, "password_setting_input")
        self.settings_form.add_content_item("password_setting_input", password_setting_input)

        loc = self.input_fields_locators.get("Домен")
        loc_domain_input = loc.locator("//input[@data-testid='LDAP__text-field__domain']")
        domain_setting_input = TextInput(page, loc_domain_input, "domain_setting_input")
        self.settings_form.add_content_item("domain_setting_input", domain_setting_input)

        loc = self.input_fields_locators.get("DN каталог пользователей")
        loc_dn_catalog_input = loc.locator("//input[@data-testid='LDAP__text-field__base_dn']")
        dn_catalog_setting_input = TextInput(page, loc_dn_catalog_input, "dn_catalog_setting_input")
        self.settings_form.add_content_item("dn_catalog_setting_input", dn_catalog_setting_input)

        loc = self.input_fields_locators.get("Атрибут авторизации")
        loc_login_attr_input = loc.locator("//input[@data-testid='LDAP__text-field__login_attribute']")
        login_attr_setting_input = TextInput(page, loc_login_attr_input, "login_attr_setting_input")
        self.settings_form.add_content_item("login_attr_setting_input", login_attr_setting_input)

        loc = self.input_fields_locators.get("Атрибут email")
        loc_email_attr_input = loc.locator("//input[@data-testid='LDAP__text-field__email_attribute']")
        email_attr_setting_input = TextInput(page, loc_email_attr_input, "email_attr_setting_input")
        self.settings_form.add_content_item("email_attr_setting_input", email_attr_setting_input)

        loc = self.input_fields_locators.get("Атрибут sms")
        loc_sms_attr_input = loc.locator("//input[@data-testid='LDAP__text-field__sms_attribute']")
        sms_attr_setting_input = TextInput(page, loc_sms_attr_input, "sms_attr_setting_input")
        self.settings_form.add_content_item("sms_attr_setting_input", sms_attr_setting_input)

        icon_locator = loc_password_input.locator("../..").locator(TextInputLocators.ICON_PASSWORD_HIDING)
        password_hidden_icon = Icon(page, icon_locator,
                                    "password hidden icon")
        self.settings_form.add_content_item("password_hidden_icon", password_hidden_icon)

        self.alert = AlertComponent(page)

    # Действия:
    def click_cancel_button(self) -> None:
        """Нажатие кнопки 'Отменить' на тулбаре."""

        self.toolbar.check_button_visibility("cancel")
        self.toolbar.get_button_by_name("cancel").click()

    def click_edit_button(self) -> None:
        """Нажатие кнопки 'Редактировать' на тулбаре."""

        self.toolbar.check_button_visibility("edit")
        self.toolbar.get_button_by_name("edit").click()

    def click_save_button(self) -> None:
        """Нажатие кнопки 'Сохранить' на тулбаре."""

        self.toolbar.check_button_visibility("save")
        self.toolbar.get_button_by_name("save").click()

    def click_password_hidden_icon(self) -> None:
        """Нажатие на иконку скрытия пароля."""

        self.settings_form.get_content_item("password_hidden_icon").click()

    def check_checkbox_tls(self):
        """Включает чек-бокс tls."""

        self.settings_form.get_content_item("tls_checkbox").check(force=True)

    def uncheck_checkbox_tls(self):
        """Выключает чек-бокс tls."""

        self.settings_form.get_content_item("tls_checkbox").uncheck(force=True)

    def get_current_setting_values(self) -> dict:
        """Возвращает текущее значение полей настроек.

        Returns:
           str : Текущее значение полей настроек.
        """

        values = {}
        tls_checkbox = self.settings_form.get_content_item("tls_checkbox")
        values.update({"tls checked": tls_checkbox.is_checked()})

        field = self.settings_form.get_content_item("ip_setting_input")
        values.update({"ip": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("port_setting_input")
        values.update({"Порт": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("user_setting_input")
        values.update({"Имя пользователя": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("password_setting_input")
        values.update({"Пароль": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("domain_setting_input")
        values.update({"Домен": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("dn_catalog_setting_input")
        values.update({"DN каталог пользователей": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("login_attr_setting_input")
        values.update({"Атрибут авторизации": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("email_attr_setting_input")
        values.update({"Атрибут email": field.get_input_value().strip()})

        field = self.settings_form.get_content_item("sms_attr_setting_input")
        values.update({"Атрибут sms": field.get_input_value().strip()})

        return values

    def get_password_setting_value(self) -> str:
        """Возвращает текущее значение поля настроек 'Пароль'.

        Returns:
           str : Текущее отображение значения поля настроек 'Пароль'.
        """

        input_field = self.settings_form.get_content_item("password_setting_input")
        is_hidden_state = self.settings_form.get_content_item("password_hidden_icon").is_password_hidden()

        password_value = input_field.get_input_value().strip()
        if is_hidden_state:
            password_value = "." * len(password_value)
        return password_value

    def input_ip(self, text: str) -> None:
        """Заполнение поля 'IP'."""

        message_input = self.settings_form.get_content_item("ip_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_port(self, text: str) -> None:
        """Заполнение поля 'Порт'."""

        message_input = self.settings_form.get_content_item("port_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_user(self, text: str) -> None:
        """Заполнение поля 'Имя пользователя'."""

        message_input = self.settings_form.get_content_item("user_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_password(self, text: str) -> None:
        """Заполнение поля 'Пароль'."""

        message_input = self.settings_form.get_content_item("password_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_domain(self, text: str) -> None:
        """Заполнение поля 'Домен'."""

        message_input = self.settings_form.get_content_item("domain_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_dn_catalog(self, text: str) -> None:
        """Заполнение поля 'DN каталог пользователей'."""

        message_input = self.settings_form.get_content_item("dn_catalog_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_login_attribute(self, text: str) -> None:
        """Заполнение поля 'Атрибут авторизации'."""

        message_input = self.settings_form.get_content_item("login_attr_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_email_attribute(self, text: str) -> None:
        """Заполнение поля 'Атрибут email'."""

        message_input = self.settings_form.get_content_item("email_attr_setting_input")
        message_input.clear()
        message_input.input_value(text)

    def input_sms_attribute(self, text: str) -> None:
        """Заполнение поля 'Атрибут sms'."""

        message_input = self.settings_form.get_content_item("sms_attr_setting_input")
        message_input.clear()
        message_input.input_value(text)

    # Проверки:
    def check_content(self):
        """Проверяет наличие и корректность всех элементов страницы."""

        expected_input_field_names = ["ip", "Порт", "Имя пользователя", "Пароль",
                                      "Домен", "DN каталог пользователей",
                                      "Атрибут авторизации", "Атрибут email", "Атрибут sms"]

        self.should_be_toolbar()

        actual_input_field_names = self.input_fields_locators.keys()

        for name in expected_input_field_names:
            assert name in actual_input_field_names, \
            f"Expected input field name {name} is missing in actual input field names"

        for name in self.settings_form.content_items.keys():
            item = self.settings_form.get_content_item(name)
            item.check_visibility(
                f"LDAP settings input form item with name '{name}' is missing"
            )

            if name == "password_hidden_icon":
                is_hidden_state = item.is_password_hidden()
                assert is_hidden_state, "Password hidden icon should be in hidden state"

    def should_be_toolbar(self) -> None:
        """Проверяет наличие тулбара страницы, наличие и функциональность кнопок тулбара.

        Raises:
            AssertionError: Если тулбар или кнопка тулбара отсутствуют.
        """
        loc = self.page.get_by_role("navigation").filter(
              has_text=re.compile("LDAP")).locator("div").nth(1)
        self.toolbar.check_toolbar_presence_by_locator(loc, "Toolbar with title 'LDAP' is missing")

        self.toolbar.check_button_visibility("edit")
        self.toolbar.check_button_tooltip("edit", "Редактировать")

        self.toolbar.get_button_by_name("edit").click()
        self.toolbar.check_button_visibility("save")
        self.toolbar.check_button_visibility("cancel")
        self.toolbar.check_button_tooltip("save", "Сохранить")
        self.toolbar.check_button_tooltip("cancel", "Отменить")

        self.toolbar.get_button_by_name("cancel").click()
        self.toolbar.check_button_visibility("edit")

    def should_be_success_alert(self) -> None:
        """Проверяет наличие сообщения об успешном сохранении заданных параметров.

        Raises:
            AssertionError: Если тулбар отсутствует.
        """

        alert_type = self.alert.get_alert_type()
        assert alert_type == "success", f"Expected success alert, but got {alert_type} alert"

        self.alert.check_alert_presence('\nПараметры успешно\n обновлены\n')
        self.alert.check_alert_absence('\nПараметры успешно\n обновлены\n')
