"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FormHelper = void 0;
const test_1 = require("@playwright/test");
const timeouts_1 = require("../../../../timeouts");
const logger_1 = require("../../../../utils/logger");
const test_errors_1 = require("../../../../utils/test-errors");
const path_1 = __importDefault(require("path"));
const allure_utils_1 = require("../../../../utils/allure-utils");
class FormHelper {
    constructor(page) {
        this.page = page;
    }
    /**
   * Заполняет поле ввода значением
   * @param textField - Локатор текстового поля
   * @param value - значение для заполнения
   */
    async fillTextField(textField, value) {
        await test_1.test.step(`Заполнение поля значением "${value}"`, async () => {
            try {
                logger_1.logger.info(`Начало заполнения поля значением "${value}"`, `${this.constructor.name}.fillTextField`);
                await textField.fill(value);
                logger_1.logger.debug(`Поле успешно заполнено значением "${value}"`, `${this.constructor.name}.fillTextField`);
            }
            catch (error) {
                await (0, allure_utils_1.screenshotOnFailure)(this.page);
                throw new Error(`Не удалось заполнить текстовое поле значением ${value}`);
            }
        });
    }
    /**
   * Выбирает значение в combobox поле
   * @param comboboxField - локатор combobox поля
   * @param inputValue - значение для ввода в поле поиска
   * @param selectValue - текст элемента для выбора из списка (В случае, если не передан, используется значение inputValue)
   */
    async selectOptionInCombobox(comboboxField, inputValue, selectValue) {
        // Обратная совместимость: если передан только один параметр, он считается selectValue
        const actualSelectValue = selectValue !== undefined ? selectValue : inputValue;
        const actualInputValue = selectValue !== undefined ? inputValue : undefined;
        await test_1.test.step(`Выбор значения "${actualSelectValue}" в поле${actualInputValue ? ` с вводом "${actualInputValue}"` : ''}`, async () => {
            logger_1.logger.info(`Начало выбора значения в combobox (inputValue: "${actualInputValue || 'не указано'}", selectValue: "${actualSelectValue}")`, `${this.constructor.name}.selectOptionInCombobox`);
            // Убеждаемся, что поле видимо и кликабельно
            try {
                await (0, test_1.expect)(comboboxField).toBeVisible({ timeout: timeouts_1.TIMEOUTS.ACTION });
                await (0, test_1.expect)(comboboxField).toBeEnabled({ timeout: timeouts_1.TIMEOUTS.ACTION });
                logger_1.logger.debug(`Поле combobox видимо и доступно`, `${this.constructor.name}.selectOptionInCombobox`);
            }
            catch (error) {
                logger_1.logger.error(`Поле combobox не видимо или не активно. InputValue: "${actualInputValue || 'не указано'}", SelectValue: "${actualSelectValue}"`, `${this.constructor.name}.selectOptionInCombobox`);
                throw new Error(`Поле combobox не видимо или не активно. InputValue: "${actualInputValue || 'не указано'}", SelectValue: "${actualSelectValue}"`);
            }
            // Прокручиваем к полю, если его не видно
            await comboboxField.scrollIntoViewIfNeeded();
            // Кликаем по полю для раскрытия списка
            logger_1.logger.debug(`Клик по полю для раскрытия списка`, `${this.constructor.name}.selectOptionInCombobox`);
            await comboboxField.click();
            // Если указан inputValue, вводим его в поле поиска
            if (actualInputValue) {
                await test_1.test.step(`Ввод значения "${actualInputValue}" в поле поиска`, async () => {
                    logger_1.logger.debug(`Ввод значения "${actualInputValue}" в поле поиска`, `${this.constructor.name}.selectOptionInCombobox`);
                    try {
                        const searchInput = this.page.getByRole('textbox', { name: 'Поиск' });
                        await searchInput.fill(actualInputValue);
                        logger_1.logger.debug(`Значение "${actualInputValue}" введено в поле поиска`, `${this.constructor.name}.selectOptionInCombobox`);
                    }
                    catch (error) {
                        logger_1.logger.debug(`Поле поиска не найдено, пропускаем ввод`, `${this.constructor.name}.selectOptionInCombobox`);
                    }
                });
            }
            // Если selectValue начинается с "=", используем exact match и удаляем префикс
            const isExact = actualSelectValue.startsWith('=');
            const actualSelectValueProcessed = isExact ? actualSelectValue.substring(1) : actualSelectValue;
            // Ждем появления выпадающего списка опций
            const optionLocator = this.page.getByRole('option', { name: actualSelectValueProcessed, exact: isExact });
            try {
                await optionLocator.waitFor({ state: 'visible', timeout: timeouts_1.TIMEOUTS.ACTION });
            }
            catch (error) {
                // Если опция не найдена пробуем ввести selectValue в поле поиска
                if (!actualInputValue) {
                    try {
                        const searchInput = this.page.getByRole('textbox', { name: 'Поиск' });
                        await searchInput.fill(actualSelectValue);
                        await optionLocator.waitFor({ state: 'visible', timeout: timeouts_1.TIMEOUTS.OPTION_VISIBLE_WAIT });
                    }
                    catch (searchError) {
                        logger_1.logger.error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке`, `${this.constructor.name}.selectOptionInCombobox`);
                        await (0, allure_utils_1.screenshotOnFailure)(this.page);
                        throw new Error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке`);
                    }
                }
                else {
                    logger_1.logger.error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке после ввода "${actualInputValue}"`, `${this.constructor.name}.selectOptionInCombobox`);
                    await (0, allure_utils_1.screenshotOnFailure)(this.page);
                    throw new Error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке после ввода "${actualInputValue}"`);
                }
            }
            // Прокручиваем к опции, если она не видна
            logger_1.logger.debug(`Прокручиваем к опции "${actualSelectValueProcessed}"`, `${this.constructor.name}.selectOptionInCombobox`);
            try {
                logger_1.logger.debug(`Выбор опции "${actualSelectValueProcessed}"`, `${this.constructor.name}.selectOptionInCombobox`);
                await optionLocator.click();
            }
            catch (error) {
                logger_1.logger.debug(`Не удалось кликнуть по опции через getByRole, пробуем через getByText`, `${this.constructor.name}.selectOptionInCombobox`);
                const textLocator = this.page.getByText(actualSelectValueProcessed, { exact: isExact });
                await textLocator.click();
            }
            // Проверяем, что значение действительно выбрано
            try {
                await (0, test_1.expect)(comboboxField).toContainText(actualSelectValueProcessed, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                logger_1.logger.debug(`Значение "${actualSelectValueProcessed}" успешно выбрано в combobox`, `${this.constructor.name}.selectOptionInCombobox`);
            }
            catch (error) {
                logger_1.logger.warn(`Не удалось проверить выбранное значение, продолжаем`, `${this.constructor.name}.selectOptionInCombobox`);
            }
            logger_1.logger.info(`Выбор значения в combobox завершен (inputValue: "${actualInputValue || 'не указано'}", selectValue: "${actualSelectValue}")`, `${this.constructor.name}.selectOptionInCombobox`);
        });
    }
    /**
   * Выбирает значения в multi-combobox поле
   * @param multiComboboxField - локатор combobox поля
   * @param options - массив значений для выбора
   */
    async selectOptionsInMultiCombobox(multiComboboxField, options) {
        await test_1.test.step(`Выбор значений в combobox`, async () => {
            // Убеждаемся, что поле видимо и кликабельно
            try {
                await (0, test_1.expect)(multiComboboxField).toBeVisible({ timeout: timeouts_1.TIMEOUTS.ACTION });
                await (0, test_1.expect)(multiComboboxField).toBeEnabled({ timeout: timeouts_1.TIMEOUTS.ACTION });
                logger_1.logger.debug(`Поле combobox видимо и доступно`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
            }
            catch (error) {
                logger_1.logger.error(`Поле combobox не видимо или не активно.`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                throw new Error(`Поле combobox не видимо или не активно.`);
            }
            // Прокручиваем к полю, если его не видно
            await multiComboboxField.scrollIntoViewIfNeeded();
            // Кликаем по полю для раскрытия списка
            logger_1.logger.debug(`Клик по полю для раскрытия списка`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
            await multiComboboxField.click();
            for (const option of options) {
                const { inputValue, selectValue } = option;
                // Если указан inputValue, вводим его в поле поиска
                if (inputValue) {
                    await test_1.test.step(`Ввод значения "${inputValue}" в поле поиска`, async () => {
                        logger_1.logger.debug(`Ввод значения "${inputValue}" в поле поиска`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                        try {
                            const searchInput = this.page.getByRole('textbox', { name: 'Поиск' });
                            await searchInput.fill(inputValue);
                            logger_1.logger.debug(`Значение "${inputValue}" введено в поле поиска`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                        }
                        catch (error) {
                            logger_1.logger.debug(`Поле поиска не найдено, пропускаем ввод`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                        }
                    });
                }
                // Если selectValue начинается с "=", используем exact match и удаляем префикс
                const isExact = selectValue.startsWith('=');
                const actualSelectValueProcessed = isExact ? selectValue.substring(1) : selectValue;
                // Ждем появления выпадающего списка опций
                const optionLocator = this.page.getByRole('option', { name: actualSelectValueProcessed, exact: isExact });
                try {
                    await optionLocator.waitFor({ state: 'visible', timeout: timeouts_1.TIMEOUTS.ACTION });
                }
                catch (error) {
                    // Если опция не найдена пробуем ввести selectValue в поле поиска
                    if (!inputValue) {
                        try {
                            const searchInput = this.page.getByRole('textbox', { name: 'Поиск' });
                            await searchInput.fill(selectValue);
                            await optionLocator.waitFor({ state: 'visible', timeout: timeouts_1.TIMEOUTS.OPTION_VISIBLE_WAIT });
                        }
                        catch (searchError) {
                            logger_1.logger.error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                            throw new Error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке`);
                        }
                    }
                    else {
                        logger_1.logger.error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке после ввода "${inputValue}"`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                        throw new Error(`Не удалось найти опцию "${actualSelectValueProcessed}" в списке после ввода "${inputValue}"`);
                    }
                }
                // Прокручиваем к опции, если она не видна
                logger_1.logger.debug(`Прокручиваем к опции "${actualSelectValueProcessed}"`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                try {
                    logger_1.logger.debug(`Выбор опции "${actualSelectValueProcessed}"`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                    await optionLocator.click();
                }
                catch (error) {
                    logger_1.logger.debug(`Не удалось кликнуть по опции через getByRole, пробуем через getByText`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                    const textLocator = this.page.getByText(actualSelectValueProcessed, { exact: isExact });
                    await textLocator.click();
                }
                // Проверяем, что значение действительно выбрано
                try {
                    await (0, test_1.expect)(multiComboboxField).toContainText(actualSelectValueProcessed, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                    logger_1.logger.debug(`Значение "${actualSelectValueProcessed}" успешно выбрано в combobox`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                }
                catch (error) {
                    logger_1.logger.warn(`Не удалось проверить выбранное значение, продолжаем`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
                }
            }
            logger_1.logger.info(`Выбор значений в combobox завершен`, `${this.constructor.name}.selectOptionsInMultiCombobox`);
        });
    }
    /**
   * Заполняет поле DaData: вводит значение, ждет появления списка и выбирает элемент по тексту
   * @param daDataField - локатор поля DaData
   * @param inputValue - значение для ввода в поле
   * @param selectValue - текст элемента для выбора из списка
   * @param expectedValue - ожидаемое значение в поле после ввода
   */
    async fillDaDataField(daDataField, inputValue, selectValue, expectedValue) {
        await test_1.test.step(`Заполнение поля DaData значением "${inputValue}" и выбор "${selectValue}"`, async () => {
            logger_1.logger.info(`Начало заполнения поля DaData (inputValue: "${inputValue}", selectValue: "${selectValue}", expectedValue: "${expectedValue}")`, `${this.constructor.name}.fillDaDataField`);
            // Убеждаемся, что поле видимо и кликабельно
            try {
                await (0, test_1.expect)(daDataField).toBeVisible({ timeout: timeouts_1.TIMEOUTS.ACTION });
                await (0, test_1.expect)(daDataField).toBeEnabled({ timeout: timeouts_1.TIMEOUTS.ACTION });
                logger_1.logger.debug(`Поле DaData видимо и доступно для заполнения`, `${this.constructor.name}.fillDaDataField`);
            }
            catch (error) {
                logger_1.logger.error(`Поле DaData не видимо или не активно для заполнения. inputValue: "${inputValue}", selectValue: "${selectValue}, expectedValue: "${expectedValue}""`, `${this.constructor.name}.fillDaDataField`);
                throw new Error(`Поле DaData не видимо или не активно для заполнения. inputValue: "${inputValue}", selectValue: "${selectValue}", expectedValue: "${expectedValue}"`);
            }
            // Вводим значение
            await daDataField.fill(inputValue);
            logger_1.logger.debug(`Введено значение "${inputValue}" в поле DaData`, `${this.constructor.name}.fillDaDataField`);
            // Ждем появления списка выбора и выбираем элемент по тексту
            await test_1.test.step(`Выбор элемента "${selectValue}" из списка`, async () => {
                logger_1.logger.debug(`Ожидание появления списка и выбор элемента "${selectValue}"`, `${this.constructor.name}.fillDaDataField`);
                try {
                    // Если selectValue начинается с "=", используем exact match
                    const isExact = selectValue.startsWith('=');
                    const actualSelectValue = isExact ? selectValue.substring(1) : selectValue;
                    const optionLocator = this.page.getByRole('dialog').getByText(actualSelectValue, { exact: isExact });
                    await optionLocator.scrollIntoViewIfNeeded();
                    await optionLocator.waitFor({ state: 'visible', timeout: timeouts_1.TIMEOUTS.ACTION });
                    await optionLocator.click();
                    logger_1.logger.debug(`Элемент "${actualSelectValue}" выбран из списка`, `${this.constructor.name}.fillDaDataField`);
                    // Проверяем отображается ли введенное значение в поле
                    try {
                        if (expectedValue) {
                            logger_1.logger.info(`Проверка отображения введенного значения ${expectedValue} в поле`, `${this.constructor.name}.fillDaDataField`);
                            await test_1.expect.soft(daDataField).toHaveValue(expectedValue);
                        }
                        else {
                            logger_1.logger.info(`Проверка отображения введенного значения ${selectValue} в поле`, `${this.constructor.name}.fillDaDataField`);
                            await test_1.expect.soft(daDataField).toHaveValue(selectValue.replace(/^=/, ''));
                        }
                    }
                    catch (error) {
                        logger_1.logger.error(`Значение в поле отображается не корректно после ввода`, `${this.constructor.name}.fillDaDataField`);
                        await (0, allure_utils_1.screenshotOnFailure)(this.page);
                        throw Error;
                    }
                }
                catch (error) {
                    logger_1.logger.error(`Не удалось заполнить поле DaData. InputValue: "${inputValue}", SelectValue: "${selectValue}"`, `${this.constructor.name}.fillDaDataField`);
                    await (0, allure_utils_1.screenshotOnFailure)(this.page);
                    throw new Error(`Не удалось заполнить поле DaData. InputValue: "${inputValue}", SelectValue: "${selectValue}"`);
                }
            });
            logger_1.logger.info(`Поле DaData успешно заполнено (inputValue: "${inputValue}", selectValue: "${selectValue}")`, `${this.constructor.name}.fillDaDataField`);
        });
    }
    /**
   * Установка toggle button в заданное состояние
   * @param toggleButtonName - имя toggle button
   * @param desiredState - желаемое состояние (boolean или 'Yes' | 'No')
   */
    async setToggleButton(toggleButtonName, desiredState) {
        await test_1.test.step(`Установка toggle button "${toggleButtonName}" в состояние "${desiredState}"`, async () => {
            logger_1.logger.info(`Начало установки toggle button "${toggleButtonName}" в состояние "${desiredState}"`, `${this.constructor.name}.setToggleButton`);
            const toggleButton = this.page.getByRole('switch', { name: toggleButtonName });
            // Преобразуем желаемое состояние в boolean
            const targetBooleanState = typeof desiredState === 'boolean'
                ? desiredState
                : desiredState === 'Yes';
            // Получаем текущее состояние через aria-checked
            const currentAriaChecked = await toggleButton.getAttribute('aria-checked');
            const isCurrentlyChecked = currentAriaChecked === 'true';
            logger_1.logger.debug(`Текущее состояние toggle button "${toggleButtonName}": ${isCurrentlyChecked}, желаемое: ${targetBooleanState}`, `${this.constructor.name}.setToggleButton`);
            // Если состояние не совпадает - кликаем
            if (isCurrentlyChecked !== targetBooleanState) {
                try {
                    logger_1.logger.debug(`Клик по toggle button "${toggleButtonName}" для изменения состояния`, `${this.constructor.name}.setToggleButton`);
                    await toggleButton.click();
                }
                catch (error) {
                    logger_1.logger.error(`Ошибка при изменении состояния toggle button "${toggleButtonName}"`, `${this.constructor.name}.setToggleButton`);
                    await (0, allure_utils_1.screenshotOnFailure)(this.page);
                    throw new Error(`Ошибка при изменении состояния toggle button "${toggleButtonName}"`);
                }
                // Ждем изменения aria-checked атрибута
                await (0, test_1.expect)(toggleButton).toHaveAttribute('aria-checked', String(targetBooleanState));
                // Проверяем, что состояние действительно изменилось
                const finalState = await toggleButton.getAttribute('aria-checked');
                if (finalState !== String(targetBooleanState)) {
                    logger_1.logger.error(`Не удалось установить toggle button "${toggleButtonName}" в состояние ${targetBooleanState}. Текущее aria-checked: ${finalState}`, `${this.constructor.name}.setToggleButton`);
                    await (0, allure_utils_1.screenshotOnFailure)(this.page);
                    throw new Error(`Не удалось установить toggle button "${toggleButtonName}" в состояние ${targetBooleanState}. Текущее aria-checked: ${finalState}`);
                }
                logger_1.logger.info(`Toggle button "${toggleButtonName}" успешно установлен в состояние ${targetBooleanState}`, `${this.constructor.name}.setToggleButton`);
            }
            else {
                logger_1.logger.debug(`Toggle button "${toggleButtonName}" уже в нужном состоянии (${targetBooleanState}), изменение не требуется`, `${this.constructor.name}.setToggleButton`);
            }
        });
    }
    /**
     * Установка чекбоксов в заданное состояние
     * Проверяет текущее состояние и кликает только если нужно изменить
     * @param checkboxes - Record с локаторами чекбоксов
     * @param checkboxStates - Record с желаемыми состояниями чекбоксов (ключ -> true/false)
     */
    async setCheckboxesState(checkboxes, checkboxStates) {
        await test_1.test.step(`Заполнение чекбоксов`, async () => {
            for (const [checkboxKey, checked] of Object.entries(checkboxStates)) {
                const checkbox = checkboxes[checkboxKey];
                if (!checkbox) {
                    logger_1.logger.warn(`Чекбокс ${checkboxKey} не найден}`);
                    continue;
                }
                await test_1.test.step(`Установка чекбокса ${checkboxKey} в состояние ${checked}`, async () => {
                    const isChecked = await checkbox.isChecked();
                    if (isChecked !== checked) {
                        await checkbox.click();
                        // Проверяем, что состояние изменилось
                        const finalChecked = await checkbox.isChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                        test_1.expect.soft(finalChecked).toBe(checked);
                    }
                });
            }
        });
    }
    async chooseRadioButtons(radioButtons, radioButtonKeys) {
        await test_1.test.step(`Выбор радиокнопок `, async () => {
            for (const key of radioButtonKeys) {
                const radioButton = radioButtons[key];
                if (radioButton) {
                    await test_1.test.step(`Выбор radiobutton ${key}`, async () => {
                        try {
                            await radioButton.click();
                        }
                        catch (error) {
                            throw test_errors_1.ErrorFactory.data('selectRadioButton', 'Ошибка при выборе radiobutton', undefined, 'radioButtonKey', key, { radioButtonKey: key });
                        }
                    });
                }
                else {
                    logger_1.logger.warn(`Radiobutton с ключом ${key} не найден`, `${this.constructor.name}.ChooseRadioButtons`);
                }
            }
        });
    }
    /**
    * Загружает файл в поле для загрузки файлов
    * Механика: нажимается кнопка "Выбрать" и затем выбирается файл через диалог выбора файла
    * @param fileField - селектор кнопки "Выбрать" или Locator (может быть label, button или скрытый input)
    * @param filePath - путь к файлу (может быть относительным от resources/files или абсолютным)
    */
    async uploadFile(fileField, filePath) {
        await test_1.test.step(`Загрузка файла: ${filePath}`, async () => {
            // Определяем абсолютный путь к файлу
            let resolvedPath;
            // Если путь абсолютный (начинается с / или содержит : для Windows)
            if (filePath.startsWith('/') || (process.platform === 'win32' && /^[A-Za-z]:/.test(filePath))) {
                resolvedPath = filePath;
            }
            // Если путь уже содержит resources/files, разрешаем его относительно корня проекта
            else if (filePath.includes('resources/files') || filePath.includes('resources\\files')) {
                resolvedPath = path_1.default.resolve(process.cwd(), filePath);
            }
            // Иначе добавляем resources/files к пути
            else {
                resolvedPath = path_1.default.resolve(process.cwd(), 'resources/files', filePath);
            }
            const fileFieldLocator = typeof fileField === 'string'
                ? this.page.locator(fileField)
                : fileField;
            logger_1.logger.info(`Загрузка файла: ${resolvedPath}`, `${this.constructor.name}.uploadFile`);
            // Ожидаем появления диалога выбора файла и перехватываем его
            const [fileChooser] = await Promise.all([
                this.page.waitForEvent('filechooser', { timeout: timeouts_1.TIMEOUTS.ACTION }),
                fileFieldLocator.click()
            ]);
            // Выбираем файл в диалоге
            await fileChooser.setFiles(resolvedPath);
            await this.page.waitForTimeout(timeouts_1.TIMEOUTS.SHORT_WAIT);
            logger_1.logger.info(`Загружен файл: ${resolvedPath}`, `${this.constructor.name}.uploadFile`);
        });
    }
    /**
    * Универсальный метод для заполнения всех типов полей формы
    * @param data - данные для заполнения полей
    * @param locators - локаторы полей формы
    * @param context - контекст для логирования
    */
    async fillFormFields(data, locators, context = 'формы') {
        // =========================
        // 1. Заполнение radiobutton
        // =========================
        if (data.radioButtonsData && locators.radioButtonsLocators) {
            await this.chooseRadioButtons(locators.radioButtonsLocators, data.radioButtonsData);
        }
        // =========================
        // 2. Заполнение toggle полей
        // =========================
        if (data.toggleButtonsData && locators.toggleButtonsLocators) {
            await test_1.test.step(`Заполнение toggle кнопок`, async () => {
                for (const [toggleKey, state] of Object.entries(data.toggleButtonsData)) {
                    const toggleButton = locators.toggleButtonsLocators[toggleKey];
                    if (!toggleButton) {
                        logger_1.logger.warn(`Toggle кнопка ${toggleKey} не найдена в ${context}`);
                        continue;
                    }
                    const targetBooleanState = typeof state === 'boolean'
                        ? state
                        : state === 'Yes';
                    const currentAriaChecked = await toggleButton.getAttribute('aria-checked');
                    const isCurrentlyChecked = currentAriaChecked === 'true';
                    if (isCurrentlyChecked !== targetBooleanState) {
                        await toggleButton.click();
                        await test_1.expect.soft(toggleButton).toHaveAttribute('aria-checked', String(targetBooleanState), { timeout: timeouts_1.TIMEOUTS.EXPECT });
                    }
                }
            });
        }
        // =========================
        // 3. Заполнение combobox полей
        // =========================
        if (data.comboboxFieldsData && locators.comboboxFieldsLocators) {
            await test_1.test.step(`Заполнение combobox полей`, async () => {
                for (const [key, value] of Object.entries(data.comboboxFieldsData)) {
                    const comboboxField = locators.comboboxFieldsLocators[key];
                    if (!comboboxField) {
                        logger_1.logger.warn(`Combobox поле ${key} не найдено в ${context}`);
                        continue;
                    }
                    // Проверяем тип значения: строка или объект с inputValue и selectValue
                    if (typeof value === 'string') {
                        await this.selectOptionInCombobox(comboboxField, value);
                    }
                    else if (value && typeof value === 'object' && 'inputValue' in value && 'selectValue' in value) {
                        await this.selectOptionInCombobox(comboboxField, value.inputValue, value.selectValue);
                    }
                    else {
                        logger_1.logger.warn(`Некорректный тип значения для combobox поля ${key}: ожидается строка или объект {inputValue, selectValue}`, `${this.constructor.name}.fillFormFields`);
                    }
                }
            });
        }
        // =========================
        // 4. Заполнение multi-combobox полей
        // =========================
        if (data.multiComboboxFieldsData && locators.multiComboboxFieldsLocators) {
            for (const [key, options] of Object.entries(data.multiComboboxFieldsData)) {
                const multiComboboxField = locators.multiComboboxFieldsLocators[key];
                if (!multiComboboxField) {
                    logger_1.logger.warn(`Multi-combobox поле ${key} не найдено в ${context}`);
                    continue;
                }
                await this.selectOptionsInMultiCombobox(multiComboboxField, options);
            }
        }
        // =========================
        // 5. Заполнение текстовых полей
        // =========================
        if (data.textFieldsData && locators.textFieldsLocators) {
            await test_1.test.step(`Заполнение текстовых полей`, async () => {
                for (const [textFieldKey, value] of Object.entries(data.textFieldsData)) {
                    const textField = locators.textFieldsLocators[textFieldKey];
                    if (!textField) {
                        logger_1.logger.warn(`Поле ${textFieldKey} не найдено в ${context}`);
                        continue;
                    }
                    await textField.focus();
                    await this.fillTextField(textField, value);
                }
            });
        }
        // =========================
        // 6. Заполнение DaData полей
        // =========================
        if (data.daDataFieldsData && locators.daDataFieldsLocators) {
            await test_1.test.step(`Заполнение DaData полей`, async () => {
                for (const [key, daDataValue] of Object.entries(data.daDataFieldsData)) {
                    const daDataField = locators.daDataFieldsLocators[key];
                    if (!daDataField) {
                        logger_1.logger.warn(`DaData поле ${key} не найдено в ${context}`);
                        continue;
                    }
                    await this.fillDaDataField(daDataField, daDataValue.inputValue, daDataValue.selectValue, daDataValue.expectedValue);
                }
            });
        }
        // =========================
        // 7. Заполнение чекбоксов
        // =========================
        if (data.checkboxesData && locators.checkboxesLocators) {
            await this.setCheckboxesState(locators.checkboxesLocators, data.checkboxesData);
        }
        // =========================
        // 8. Загрузка файлов
        // =========================
        if (data.fileFieldsData && locators.fileFieldsLocators) {
            await test_1.test.step(`Загрузка файлов`, async () => {
                for (const [fileKey, filePath] of Object.entries(data.fileFieldsData)) {
                    const fileField = locators.fileFieldsLocators[fileKey];
                    if (!fileField) {
                        logger_1.logger.warn(`Поле для загрузки файла ${fileKey} не найдено в ${context}`);
                        continue;
                    }
                    await this.uploadFile(fileField, filePath);
                }
            });
        }
    }
}
exports.FormHelper = FormHelper;
