"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseGridPage = exports.DEFAULT_GRID_ROW_MENU_ACTION_TEST_IDS = void 0;
const test_1 = require("@playwright/test");
const BasePage_1 = require("../BasePage/BasePage");
const logger_1 = require("../../utils/logger");
const timeouts_1 = require("../../timeouts");
const services_1 = require("./services");
/** Общий testId кнопки меню действий строки грида (используется по умолчанию для страниц с type: 'menu'). */
exports.DEFAULT_GRID_ROW_MENU_ACTION_TEST_IDS = { RowMenuButton: 'actionMenu' };
class BaseGridPage extends BasePage_1.BasePage {
    /**
     * Возвращает Record testId → ключ для кнопок действий строки.
     * Переопределите в наследнике и верните объект из локаторов, чтобы использовать стандартную реализацию getGridRowActionButtons.
     * По умолчанию возвращает кнопку меню (RowMenuButton: 'actionMenu') для страниц с действиями через меню.
     */
    getGridRowActionTestIds() {
        return exports.DEFAULT_GRID_ROW_MENU_ACTION_TEST_IDS;
    }
    /**
     * Получает Record локаторов кнопок действий строки для конкретной строки.
     * Стандартная реализация строит локаторы по getGridRowActionTestIds(). Можно переопределить в наследниках при другой разметке.
     * @param rowLocator - локатор строки, для которой нужно получить кнопки
     * @returns Record с локаторами кнопок действий строки или null
     */
    getGridRowActionButtons(rowLocator) {
        const testIds = this.getGridRowActionTestIds();
        if (!testIds || Object.keys(testIds).length === 0) {
            return null;
        }
        const rowActionButtons = {};
        for (const [key, testId] of Object.entries(testIds)) {
            rowActionButtons[key] = rowLocator.getByTestId(testId).first();
        }
        return rowActionButtons;
    }
    constructor(page) {
        super(page);
        // Инициализируем сервис для работы со строками таблицы
        this.gridRowService = new services_1.GridRowService(this.page, this.textUtils);
        // Инициализируем сервис для работы с модальными окнами
        this.gridModalService = new services_1.GridModalService(this.ModalWindowBody, {
            getButtons: (modalWindowKey) => this.getModalWindowButtons(modalWindowKey),
            getTextFields: (modalWindowKey) => this.getModalWindowTextFields(modalWindowKey)
        });
        // Инициализируем сервисы
        this.gridRowActionsService = this.createGridRowActionsService();
        this.gridFormService = this.createGridFormService();
    }
    /**
     * Создает сервис для работы с формами грида.
     * @returns GridFormService
     */
    createGridFormService() {
        return new services_1.GridFormService({
            getRole: () => this.getRoleOrThrow(),
            validateRole: (role) => this.validateRole(role),
            getModalWindowConfigurations: (role) => this.getModalWindowConfigurations(role),
            findModalWindowConfig: (modalWindowKey, addButtonKey) => this.findModalWindowConfig(modalWindowKey, addButtonKey),
            getButton: (key) => this.GridButtons[key],
            openModalWindow: (triggerButton) => this.openModalWindow(triggerButton),
            getModalWindowBody: (_modalWindowKey) => this.ModalWindowBody,
            getModalWindowButtons: (modalWindowKey) => this.getModalWindowButtons(modalWindowKey),
            getModalWindowFormLocators: (modalWindowKey) => this.getModalWindowFormLocators(modalWindowKey),
            performModalTerminalActionToCloseModalWindow: (button, body, stepName) => this.performModalTerminalActionToCloseModalWindow(button, body, stepName),
            verifyTableRow: (rowKey, expectedRowData, isFirstRow, onRowFound) => this.verifyTableRow(rowKey, expectedRowData, isFirstRow, onRowFound),
            formHelperFillFormFields: (data, locators, context) => this.formHelper.fillFormFields(data, locators, context),
            tryFindErrorMessage: () => this.tryFindErrorMessage(),
            waitForLoadState: () => this.page.waitForLoadState('networkidle'),
        });
    }
    /**
     * Создает сервис для работы с действиями над строками грида.
     * @returns GridRowActionsService
     */
    createGridRowActionsService() {
        return new services_1.GridRowActionsService({
            getRole: () => this.getRoleOrThrow(),
            validateRole: (role) => this.validateRole(role),
            getConfig: (role) => this.getGridRowActionsConfiguration(role),
            getRowActionButtons: (row) => this.getGridRowActionButtons(row),
            getMenuItems: () => this.GridRowActionMenuItems || null,
            base: {
                openRowActionsMenuBase: (menuButtonLocator) => super.openRowActionsMenuBase(menuButtonLocator),
                closeRowActionsMenuBase: () => super.closeRowActionsMenuBase(),
                clickRowActionBase: (actionKey, cfg, rowButtons, menuItems) => super.clickRowActionBase(actionKey, cfg, rowButtons, menuItems),
                checkRowActionsBase: (cfg, rowButtons, menuItems) => super.checkRowActionsBase(cfg, rowButtons, menuItems),
                editRowBase: (cfg, rowButtons, menuItems, modalBody) => super.editRowBase(cfg, rowButtons, menuItems, modalBody),
                viewRowBase: (cfg, rowButtons, menuItems, modalBody) => super.viewRowBase(cfg, rowButtons, menuItems, modalBody),
                deleteRowBase: (cfg, rowButtons, menuItems, confirmDelete) => super.deleteRowBase(cfg, rowButtons, menuItems, confirmDelete)
            },
            findModalWindowConfig: (modalWindowKey) => this.findModalWindowConfig(modalWindowKey),
            confirmAction: () => this.confirmAction()
        });
    }
    /**
    * Метод для получения конфигурации модальных окон в зависимости от роли
    * Должен быть переопределен в наследниках, если страница имеет модальные окна
    * По умолчанию возвращает пустой массив
    * @param role - роль пользователя
    * @returns Массив конфигураций модальных окон (может быть пустым, если модальных окон нет)
    */
    getModalWindowConfigurations(_role) {
        return [];
    }
    /**
     * Метод для получения конфигурации действий строки в зависимости от роли
     * Должен быть переопределен в наследниках, если страница имеет действия строки
     * По умолчанию возвращает null
     * @param role - роль пользователя
     * @returns Конфигурация действий строки или null, если действия не настроены
     */
    getGridRowActionsConfiguration(_role) {
        return null;
    }
    // ------------------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------------------
    // Геттеры полей, кнопок
    /**
    * Метод для получения Record кнопок модального окна
    * Должен быть переопределен в наследниках, если страница имеет модальные окна
    * По умолчанию возвращает null
    * @param modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowButtons(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record полей ввода модального окна
    * Должен быть переопределен в наследниках, если страница имеет модальные окна
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowTextFields(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record radiobutton модального окна (для вариативного содержания)
    * Должен быть переопределен в наследниках, если модальное окно имеет вариативное содержание
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowRadioButtons(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record чекбоксов модального окна (для вариативного содержания)
    * Должен быть переопределен в наследниках, если модальное окно имеет чекбоксы
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowCheckboxes(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record слайдеров модального окна (для вариативного содержания)
    * Должен быть переопределен в наследниках, если модальное окно имеет слайдеры
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowSliders(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record кнопок Toggle модального окна
    * Должен быть переопределен в наследниках, если модальное окно имеет кнопки Toggle
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowToggleButtons(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record combobox полей модального окна
    * Должен быть переопределен в наследниках, если модальное окно имеет поля combobox
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowComboboxFields(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record полей DaData модального окна
    * Должен быть переопределен в наследниках, если модальное окно имеет поля DaData
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowDaDataFields(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record полей multiCombobox модального окна
    * Должен быть переопределен в наследниках, если модальное окно имеет поля multiCombobox
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowMultiComboboxFields(_modalWindowKey) {
        return null;
    }
    /**
    * Метод для получения Record полей для загрузки файлов модального окна
    * Должен быть переопределен в наследниках, если модальное окно имеет поля для загрузки файлов
    * По умолчанию возвращает null
    * @param _modalWindowKey - ключ модального окна (опционально для случаев, если на странице несколько модальных окон)
    */
    getModalWindowFileFields(_modalWindowKey) {
        return null;
    }
    // -------------------------------------------------------------------------------------------------------------------------
    /**
     * Собирает все локаторы полей формы модального окна
     * @param modalWindowKey - ключ модального окна (опционально)
     * @returns объект локаторов для formHelper.fillFormFields
     */
    getModalWindowFormLocators(modalWindowKey) {
        return {
            textFieldsLocators: this.getModalWindowTextFields(modalWindowKey),
            comboboxFieldsLocators: this.getModalWindowComboboxFields(modalWindowKey),
            fileFieldsLocators: this.getModalWindowFileFields(modalWindowKey),
            radioButtonsLocators: this.getModalWindowRadioButtons(modalWindowKey),
            checkboxesLocators: this.getModalWindowCheckboxes(modalWindowKey),
            toggleButtonsLocators: this.getModalWindowToggleButtons(modalWindowKey),
            daDataFieldsLocators: this.getModalWindowDaDataFields(modalWindowKey),
            multiComboboxFieldsLocators: this.getModalWindowMultiComboboxFields(modalWindowKey)
        };
    }
    /**
    * Валидирует входной параметр role
    * @param role - роль пользователя
    * @throws Error если параметр невалиден
    */
    validateRole(role) {
        const validRoles = ['Admin', 'Client', 'Agent', 'Bank'];
        if (!validRoles.includes(role)) {
            throw new Error(`role должен быть одним из: ${validRoles.join(', ')}. Получено: ${role}`);
        }
    }
    /**
     * Проверяет видимость кнопок грида
     */
    async checkGridButtons() {
        const role = this.getRoleOrThrow();
        this.validateRole(role);
        await test_1.test.step(`Проверка кнопок грида для роли ${role}`, async () => {
            logger_1.logger.debug(`Проверка кнопок грида для роли ${role}`, `${this.constructor.name}.checkGridButtons`);
            const config = this.getGridPageConfiguration(role);
            const allButtons = config.buttons.concat(config.notVisibleButtons || []);
            const buttonPromises = [];
            for (const buttonKey of allButtons) {
                if (!this.GridButtons[buttonKey]) {
                    logger_1.logger.warn(`Кнопка с ключом ${buttonKey} не найдена в GridButtons`, `${this.constructor.name}.checkGridButtons`);
                    continue;
                }
                logger_1.logger.debug(`Проверка кнопки ${buttonKey}`, `${this.constructor.name}.checkGridButtons`);
                buttonPromises.push(test_1.test.step(`Проверка кнопки ${buttonKey}`, async () => {
                    if (config.notVisibleButtons?.includes(buttonKey)) {
                        await test_1.expect.soft(this.GridButtons[buttonKey]).toBeHidden({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                    }
                    else {
                        await test_1.expect.soft(this.GridButtons[buttonKey]).toBeVisible({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                    }
                }));
            }
            // Запускаем все проверки кнопок параллельно
            await Promise.all(buttonPromises);
            logger_1.logger.info(`Проверка кнопок грида завершена. Проверено кнопок: ${buttonPromises.length}`, `${this.constructor.name}.checkGridButtons`);
        });
    }
    /**
     * Проверяет видимость полей фильтрации грида.
     */
    async checkGridFilters() {
        const role = this.getRoleOrThrow();
        this.validateRole(role);
        await test_1.test.step(`Проверка полей фильтрации грида для роли ${role}`, async () => {
            logger_1.logger.debug(`Проверка полей фильтрации грида для роли ${role}`, `${this.constructor.name}.checkGridFilters`);
            const config = this.getGridPageConfiguration(role);
            if (!config.textFilters) {
                logger_1.logger.warn(`В конфигурации грида не было найдена полей фильтров`, `${this.constructor.name}.checkGridFilters`);
                throw new Error('В конфигурации грида не было найдена полей фильтров');
            }
            // Создаем массив промисов для всех проверок
            const checkFilters = [];
            for (const filterKey of config.textFilters.concat(config.notVisibleTextFilters || [])) {
                if (!this.GridFilters[filterKey]) {
                    logger_1.logger.warn(`Поле-фильтр с ключом ${filterKey} не найдено в GridFilters`, `${this.constructor.name}.checkGridFilters`);
                    continue;
                }
                logger_1.logger.debug(`Проверка поля фильтрации ${filterKey}`, `${this.constructor.name}.checkGridFilters`);
                // Создаем промис для каждой проверки
                checkFilters.push(test_1.test.step(`Проверка поля фильтрации ${filterKey}`, async () => {
                    if (config.notVisibleTextFilters?.includes(filterKey)) {
                        await test_1.expect.soft(this.GridFilters[filterKey]).toBeHidden();
                    }
                    else {
                        await test_1.expect.soft(this.GridFilters[filterKey]).toBeVisible();
                    }
                }));
            }
            // Запускаем все проверки параллельно
            await Promise.all(checkFilters);
            logger_1.logger.info(`Проверка полей фильтрации грида завершена. Проверено полей: ${checkFilters.length}`, `${this.constructor.name}.checkGridFilters`);
        });
    }
    // =========================
    // Методы для работы со строками таблицы
    // =========================
    /**
     * Проверяет наличие необходимых колонок в таблице по их названиям.
     * @param columnNames - массив названий колонок для проверки (например, ['Фамилия', 'Имя', 'Email'])
     */
    async verifyRequiredColumns(columnNames) {
        await this.gridRowService.verifyRequiredColumns(columnNames, this.constructor.name);
    }
    /**
     * Поиск строки по rowKey
     * @param rowKey - ключевое поле строки (уникальный идентификатор строки в таблице)
     * @param rowData - объект с данными строки, где ключ - название колонки, значение - ожидаемое значение ячейки
     * @param isNewlyAdded - если true, проверяет только что добавленную строку
     * @returns Locator строки или null, если строка не найдена
     */
    async findTableRow(rowKey, rowData, isNewlyAdded = false) {
        return this.gridRowService.findTableRow(rowKey, rowData, isNewlyAdded, this.constructor.name);
    }
    /**
     * Кликает по ссылке в строке таблицы
     * @param rowKey - ключевое поле строки
     * @param rowData - объект с данными строки
     * @param isNewlyAdded - если true, проверяет только что добавленную строку
     * @param textByClick - текст ссылки для клика
     * @throws Error если строка не найдена или ссылка не найдена
     */
    async clickInTableRow(rowKey, rowData, isNewlyAdded, textByClick) {
        logger_1.logger.debug(`Клик по ссылке "${textByClick}" в строке таблицы`, `${this.constructor.name}.clickInTableRow`);
        const row = await this.findTableRow(rowKey, rowData, isNewlyAdded);
        if (!row) {
            throw new Error(`Строка из метода findTableRow не была получена для таблицы  → ${JSON.stringify(rowData)}`);
        }
        const link = row.getByRole('link', { name: textByClick });
        const linkCount = await link.count();
        if (linkCount === 0) {
            throw new Error(`Ссылка с текстом "${textByClick}" не найдена в строке таблицы → ${JSON.stringify(rowData)}`);
        }
        await link.click();
    }
    /**
     * Ищет строку в таблице без выброса ошибки (для проверки отсутствия строки)
     * @param rowKey - ключевое поле строки
     * @param rowData - объект с данными строки
     * @returns Locator строки или null, если строка не найдена
     */
    async findTableRowSilent(rowKey, rowData) {
        return this.gridRowService.findTableRowSilent(rowKey, rowData, this.constructor.name);
    }
    /**
     * Проверяет строку в таблице
     * @param rowKey - ключевое поле строки (уникальный идентификатор строки в таблице)
     * @param rowData - объект с данными строки, где ключ - название колонки, значение - ожидаемое значение ячейки
     * @param isNewlyAdded - если true, проверяет только что добавленную строку
     * @param onRowFound - Колбэк, который вызывается после нахождения строки (вызывается даже при ошибках проверки). Применим для очистки мусора в случае падения теста
     */
    async verifyTableRow(rowKey, rowData, isNewlyAdded, onRowFound) {
        await this.gridRowService.verifyTableRow(rowKey, rowData, isNewlyAdded, this.constructor.name, onRowFound);
    }
    /**
    * Заполняет форму, добавляет строку и проверяет, что строка появилась в гриде
    *
    * @param triggerButtonKey - ключ кнопки добавления строки
    * @param rowKey - ключевое поле строки (уникальный идентификатор строки в гриде)
    * @param expectedRowData - ожидаемые данные строки (ключ — название колонки)
    * @param isFirstRow - является ли строка первой в таблице.
    * @param saveButtonKey - ключ кнопки сохранения
    * @param modalWindowKey - ключ модального окна
    * @param formFields - Объект с полями формы
    * @param onRowVerified - Колбэк, который вызывается после нахождения строки (вызывается даже при ошибках проверки). Применим для очистки мусора в случае падения теста
    */
    async fillFormAndAddRow(triggerButtonKey, rowKey, expectedRowData, isFirstRow = false, saveButtonKey = 'ButtonSave', modalWindowKey, formFields, onRowVerified) {
        await this.gridFormService.fillFormAndAddRow(triggerButtonKey, rowKey, expectedRowData, isFirstRow, saveButtonKey, modalWindowKey, formFields, onRowVerified);
    }
    /**
     * Проверяет все элементы грида (кнопки и поля)
     */
    async checkAllGridElements() {
        const role = this.getRoleOrThrow();
        this.validateRole(role);
        logger_1.logger.info(`Проверка всех элементов грида для роли ${role}`, `${this.constructor.name}.checkAllGridElements`);
        // Параллельный запуск
        await Promise.all([
            this.checkGridButtons(),
            this.checkGridFilters()
        ]);
        logger_1.logger.info(`Проверка всех элементов грида завершена`, `${this.constructor.name}.checkAllGridElements`);
    }
    /**
     * Открывает модальное окно по кнопке-триггеру
     * @param triggerButton - локатор кнопки, открывающей модальное окно
     * @returns true если модальное окно успешно открыто, false в случае ошибки
     */
    async openModalWindow(triggerButton) {
        return this.gridModalService.openModalWindow(triggerButton, () => this.tryFindErrorMessage(), this.constructor.name);
    }
    /**
     * Проверяет видимость кнопок в модальном окне
     * @param buttons - Record кнопок модального окна
     * @param config - конфигурация модального окна
     */
    async checkModalWindowButtons(_buttons, config) {
        await this.gridModalService.checkButtons(config, config.modalWindowKey, this.constructor.name);
    }
    /**
     * Проверяет видимость и редактируемость полей в модальном окне
     * @param fields - Record полей модального окна
     * @param config - конфигурация модального окна
     */
    async checkModalWindowFields(_fields, config) {
        await this.gridModalService.checkFields(config, config.modalWindowKey, this.constructor.name);
    }
    /**
     * Проверяет одно модальное окно (открытие, проверка элементов, закрытие)
     * @param config - конфигурация модального окна
     * @param modalWindowKey - ключ модального окна (опционально)
     * @returns true если проверка прошла успешно, false в случае ошибки
     */
    async checkSingleModalWindow(config, modalWindowKey) {
        logger_1.logger.info(`Проверка модального окна`, `${this.constructor.name}.checkSingleModalWindow`);
        try {
            const buttons = this.getModalWindowButtons(modalWindowKey);
            const triggerButton = this.GridButtons[config.triggerButtonKey];
            const closeButton = buttons?.[config.closeButtonKey];
            if (!triggerButton) {
                logger_1.logger.warn(`Кнопка-триггер ${config.triggerButtonKey} не найдена`, `${this.constructor.name}.checkSingleModalWindow`);
                return false;
            }
            if (!closeButton) {
                logger_1.logger.warn(`Кнопка закрытия ${config.closeButtonKey} не найдена`, `${this.constructor.name}.checkSingleModalWindow`);
                return false;
            }
            await test_1.test.step(`Проверка модального окна (открытие → проверка → закрытие)`, async () => {
                // Открытие модального окна
                await this.openModalWindow(triggerButton);
                try {
                    // Проверка элементов модального окна
                    await this.checkModalWindowButtons({}, config);
                    await this.checkModalWindowFields({}, config);
                }
                catch (checkError) {
                    logger_1.logger.error(`Ошибка при проверке элементов модального окна: ${checkError}`, `${this.constructor.name}.checkSingleModalWindow`);
                }
            });
            logger_1.logger.info(`Проверка модального окна завершена успешно`, `${this.constructor.name}.checkSingleModalWindow`);
            return true;
        }
        catch (error) {
            logger_1.logger.error(`Ошибка при проверке модального окна: ${error}`, `${this.constructor.name}.checkSingleModalWindow`);
            return false;
        }
    }
    /**
     * Находит конфигурацию модального окна по ключу или triggerButtonKey.
     * @param role - роль пользователя
     * @param modalWindowKey - опциональный ключ модального окна (custom key, затем индекс modalWindowN, затем как triggerButtonKey)
     * @param triggerButtonKey - при отсутствии modalWindowKey используется для поиска по triggerButtonKey; иначе возвращается первый конфиг
     * @returns найденная конфигурация или undefined
     */
    findModalWindowConfig(modalWindowKey, triggerButtonKey) {
        const role = this.getRoleOrThrow();
        const modalConfigs = this.getModalWindowConfigurations(role);
        if (!modalConfigs || modalConfigs.length === 0) {
            return undefined;
        }
        if (modalWindowKey) {
            // Сначала ищем по явному modalWindowKey в конфиге
            const configByKey = modalConfigs.find(c => c.modalWindowKey === modalWindowKey);
            if (configByKey) {
                return configByKey;
            }
            // Затем пробуем как индекс (modalWindow1, modalWindow2...)
            const configIndex = parseInt(modalWindowKey.replace(/\D/g, ''), 10) - 1;
            if (configIndex >= 0 && configIndex < modalConfigs.length) {
                return modalConfigs[configIndex];
            }
            // Если не нашли по индексу, пробуем как triggerButtonKey (для editRow/viewRow)
            const configByTrigger = modalConfigs.find(c => c.triggerButtonKey === modalWindowKey);
            if (configByTrigger) {
                return configByTrigger;
            }
            return undefined;
        }
        // Если modalWindowKey не передан, ищем по triggerButtonKey или возвращаем первый
        if (triggerButtonKey) {
            return modalConfigs.find(c => c.triggerButtonKey === triggerButtonKey);
        }
        return modalConfigs[0];
    }
    // =========================
    // Методы работы с действиями над строкой грида
    // =========================
    /**
     * Проверяет, доступно ли действие для текущей роли.
     * @param actionKey - ключ действия
     * @returns true если действие доступно
     */
    isRowActionAvailable(actionKey) {
        return this.gridRowActionsService.isRowActionAvailable(actionKey, this.constructor.name);
    }
    /**
     * Открывает меню действий над строкой.
     * @param rowLocator - локатор строки
     */
    async openRowActionsMenu(rowLocator) {
        await this.gridRowActionsService.openRowActionsMenu(rowLocator, this.constructor.name);
    }
    /**
     * Закрывает меню действий над строкой
     */
    async closeRowActionsMenu() {
        await this.gridRowActionsService.closeRowActionsMenu();
    }
    /**
     * Универсальный метод для выполнения действия со строкой.
     * @param rowLocator - локатор строки
     * @param actionKey - ключ действия (например, 'MenuItemEdit' или 'RowEditButton')
     */
    async clickRowAction(rowLocator, actionKey) {
        await this.gridRowActionsService.clickRowAction(rowLocator, actionKey, this.constructor.name);
    }
    /**
     * Проверяет видимость кнопок действий строки.
     * @param rowLocator - локатор строки
     */
    async checkGridRowActions(rowLocator) {
        await this.gridRowActionsService.checkRowActions(rowLocator, this.constructor.name);
    }
    /**
     * Открывает строку на редактирование.
     * @param rowLocator - локатор строки
     * @param modalWindowKey - ключ модального окна (опционально)
     * @returns true если модальное окно успешно открыто
     */
    async editRow(rowLocator, modalWindowKey) {
        return this.gridRowActionsService.editRow(rowLocator, modalWindowKey, this.constructor.name);
    }
    /**
     * Открывает строку на просмотр (readonly).
     * @param rowLocator - локатор строки
     * @param modalWindowKey - ключ модального окна (опционально)
     * @returns true если модальное окно успешно открыто
     */
    async viewRow(rowLocator, modalWindowKey) {
        return this.gridRowActionsService.viewRow(rowLocator, modalWindowKey, this.constructor.name);
    }
    /**
     * Удаляет строку (с подтверждением, если требуется).
     * @param rowLocator - локатор строки
     * @param confirmDelete - нужно ли подтверждение удаления (по умолчанию true)
     * @returns true если удаление успешно
     */
    async deleteRow(rowLocator, confirmDelete = true) {
        return this.gridRowActionsService.deleteRow(rowLocator, confirmDelete, this.constructor.name);
    }
    /**
     * Редактирует строку с заполнением формы, сохранением и проверкой результата.
     * @param rowLocator - локатор строки
     * @param expectedRowData - ожидаемые данные после сохранения (для проверки) (обязательный)
     * @param saveButtonKey - ключ кнопки сохранения (по умолчанию 'ButtonSave')
     * @param formFields - Объект с полями для заполнения
     * @param modalWindowKey - ключ модального окна (опционально)
     * @param onRowVerified - Колбэк, который вызывается после нахождения строки (вызывается даже при ошибках проверки). Применим для очистки мусора в случае падения теста
     */
    async editRowAndVerify(rowLocator, expectedRowData, saveButtonKey = 'ButtonSave', formFields, modalWindowKey, onRowVerified) {
        const role = this.getRoleOrThrow();
        logger_1.logger.info(`Начало редактирования строки с проверкой для роли ${role}`, `${this.constructor.name}.editRowAndVerify`);
        const verifyFn = async () => {
            const rowKey = Object.keys(expectedRowData)[0];
            await this.verifyTableRow(rowKey, expectedRowData, false, onRowVerified);
        };
        await super.editRowAndVerifyBase(() => this.editRow(rowLocator, modalWindowKey), formFields, (key) => { try {
            return this.getModalWindowFormLocators(key ?? modalWindowKey);
        }
        catch {
            return null;
        } }, (key) => this.getModalWindowButtons(key), saveButtonKey, verifyFn);
    }
    /**
     * Просматривает строку и проверяет данные.
     * @param rowLocator - локатор строки
     * @param expectedData - ожидаемые данные для проверки
     * @param modalWindowKey - ключ модального окна
     */
    async viewRowAndVerify(rowLocator, expectedData, modalWindowKey) {
        const role = this.getRoleOrThrow();
        logger_1.logger.info(`Начало просмотра строки с проверкой для роли ${role}`, `${this.constructor.name}.viewRowAndVerify`);
        await super.viewRowAndVerifyBase(() => this.viewRow(rowLocator, modalWindowKey), expectedData, (key) => this.getModalWindowTextFields(key), (key) => this.getModalWindowButtons(key));
    }
    /**
     * Удаляет строку и проверяет, что она исчезла.
     * @param rowKey - ключевое поле строки
     * @param rowData - данные строки для поиска
     * @param confirmDelete - нужно ли подтверждение
     */
    async deleteRowAndVerify(rowKey, rowData, confirmDelete = true) {
        const role = this.getRoleOrThrow();
        logger_1.logger.info(`Начало удаления строки с проверкой для роли ${role} (rowKey: ${rowKey})`, `${this.constructor.name}.deleteRowAndVerify`);
        await super.deleteRowAndVerifyBase(() => this.findTableRow(rowKey, rowData, false), async (row) => {
            const _result = await this.deleteRow(row, confirmDelete);
            if (!_result) {
                throw new Error('Строка не была удалена');
            }
        }, () => this.findTableRowSilent(rowKey, rowData), rowData);
    }
    /**
     * Реализация метода активации/деактивации для гридов.
     */
    async toggleActivationForGrid(rowLocator, action, actionType, requireConfirmation) {
        await this.gridRowActionsService.toggleActivationForGrid(rowLocator, action, actionType, requireConfirmation, this.constructor.name);
    }
    /**
    * Активирует или деактивирует строку в гриде.
    * @param rowLocator - локатор строки
    * @param action - действие: 'activate' или 'deactivate'
    * @param actionType - тип действия: 'menu' или 'button' (опционально)
    * @param requireConfirmation - требуется ли подтверждение (опционально)
    */
    async toggleActivation(rowLocator, action, actionType, requireConfirmation) {
        return this.toggleActivationForGrid(rowLocator, action, actionType, requireConfirmation);
    }
    async deleteGridTrashAfterFail(rowLocator, confirmDelete) {
        try {
            logger_1.logger.info(`Зачистка мусора после падения теста по ключу строки`, `${this.constructor.name}.deleteTrashAfterFail`);
            await this.page.keyboard.press('Escape');
            await this.deleteRow(rowLocator, confirmDelete);
            logger_1.logger.info(`Мусор после теста зачищен. Строка удалена`, `${this.constructor.name}.deleteTrashAfterFail`);
        }
        catch (error) {
            logger_1.logger.info(`Мусор не был зачищен, т.к не был найден по ключу`, `${this.constructor.name}.deleteTrashAfterFail`);
        }
    }
}
exports.BaseGridPage = BaseGridPage;
