"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CardBlockFormService = void 0;
const test_1 = require("@playwright/test");
const logger_1 = require("../../../utils/logger");
const timeouts_1 = require("../../../timeouts");
const FormDataFilterUtils_1 = require("../../BasePage/utils/FormDataFilterUtils");
class CardBlockFormService {
    constructor(deps) {
        this.deps = deps;
    }
    // Вспомогательные private методы
    // ----------------------------------------------------------------------------------------------
    validateParams(params) {
        const { blockKey, triggerButtonKey, rowKey, expectedRowData, formFields } = params;
        // Базовые проверки
        if (!blockKey.trim())
            throw new Error('blockKey обязателен');
        if (!triggerButtonKey?.trim())
            throw new Error('triggerButtonKey обязателен');
        if (!rowKey?.trim())
            throw new Error('rowKey обязателен');
        if (!expectedRowData || typeof expectedRowData !== 'object' || Object.keys(expectedRowData).length === 0) {
            throw new Error('expectedRowData должен быть непустым объектом');
        }
        if (!formFields || typeof formFields !== 'object') {
            throw new Error('formFields обязателен');
        }
    }
    filterFormFields(formFields, modalConfig) {
        const logCtx = `${this.constructor.name}.filterFormDataByRole`;
        return {
            filteredTextFieldsData: formFields.textFieldsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.textFieldsData, modalConfig, 'textFields', logCtx) : undefined,
            filteredComboboxFieldsData: formFields.comboboxFieldsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.comboboxFieldsData, modalConfig, 'comboboxFields', logCtx) : undefined,
            filteredFileFieldsData: formFields.fileFieldsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.fileFieldsData, modalConfig, 'fileFields', logCtx) : undefined,
            filteredRadioButtonsData: formFields.radioButtonsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.radioButtonsData, modalConfig, 'radioButtons', logCtx) : undefined,
            filteredCheckboxesData: formFields.checkboxesData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.checkboxesData, modalConfig, 'checkboxes', logCtx) : undefined,
            filteredToggleButtonsData: formFields.toggleButtonsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.toggleButtonsData, modalConfig, 'toggleButtons', logCtx) : undefined,
            filteredDaDataFieldsData: formFields.daDataFieldsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.daDataFieldsData, modalConfig, 'daDataFields', logCtx) : undefined,
            filteredMultiComboboxFieldsData: formFields.multiComboboxFieldsData ? (0, FormDataFilterUtils_1.filterFormDataByRole)(formFields.multiComboboxFieldsData, modalConfig, 'multiComboboxFields', logCtx) : undefined
        };
    }
    // Вспомогательный метод для определения текущего состояния редактируемости блока
    async getCurrentBlockState(editButton, saveButton, cancelButton) {
        try {
            const isSaveVisible = await saveButton.isVisible();
            // Если Save видна - значит в режиме редактирования
            if (isSaveVisible) {
                return 'editable';
            }
            // Дополнительная проверка через Cancel или Edit
            if (cancelButton && await cancelButton.isVisible().catch(() => false)) {
                return 'editable';
            }
            const isEditVisible = await editButton.isVisible();
            if (!isEditVisible) {
                return 'editable';
            }
            return 'notEditable';
        }
        catch (error) {
            logger_1.logger.warn(`Ошибка при определении состояния блока: ${error}`);
            return 'notEditable';
        }
    }
    async verifyBlockButtonsState(editButton, saveButton, cancelButton, expectedState = 'view') {
        if (expectedState === 'edit') {
            // Состояние режима редактирования
            await test_1.expect.soft(editButton).toBeHidden({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            await test_1.expect.soft(saveButton).toBeVisible({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            if (cancelButton) {
                await test_1.expect.soft(cancelButton).toBeVisible({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            }
        }
        else {
            // Обычное состояние (режим просмотра)
            await test_1.expect.soft(editButton).toBeVisible({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            await test_1.expect.soft(saveButton).toBeHidden({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            if (cancelButton) {
                await test_1.expect.soft(cancelButton).toBeHidden({ timeout: timeouts_1.TIMEOUTS.EXPECT });
            }
        }
    }
    async openAndFillModal(blockKey, triggerButtonKey, modalWindowKey, filteredFields, saveButtonKey, logCtx) {
        const { filteredTextFieldsData, filteredComboboxFieldsData, filteredFileFieldsData, filteredRadioButtonsData, filteredCheckboxesData, filteredToggleButtonsData, filteredDaDataFieldsData, filteredMultiComboboxFieldsData } = filteredFields;
        const role = this.deps.getRole();
        // 1. Открытие модального окна
        const blockButtons = this.deps.getBlockButtons(blockKey);
        if (!blockButtons) {
            throw new Error(`Кнопки блока ${blockKey} не найдены`);
        }
        const triggerButton = blockButtons[triggerButtonKey];
        if (!triggerButton) {
            throw new Error(`Кнопка "${triggerButtonKey}" не найдена в BlockButtons блока ${blockKey}`);
        }
        const modalConfig = this.deps.findBlockModalWindowConfig(blockKey, modalWindowKey ?? triggerButtonKey);
        if (!modalConfig) {
            logger_1.logger.warn(`Конфигурация модального окна блока ${blockKey} для роли ${role} не найдена. Будут заполнены все переданные поля.`, `${logCtx}`);
        }
        await test_1.test.step(`Открытие модального окна`, async () => {
            if (!modalConfig?.modalWindowBody) {
                throw new Error(`Конфигурация модального окна блока ${blockKey} (modalWindowKey: ${modalWindowKey ?? triggerButtonKey}) не найдена или не содержит modalWindowBody`);
            }
            await this.deps.openBlockModalWindow(triggerButton, modalConfig.modalWindowBody);
        });
        // 2. Получение локаторов
        const modalFormLocators = this.deps.getBlockModalWindowFormLocators(blockKey, modalWindowKey);
        // 3. Заполнение полей формы
        await this.deps.formHelperFillFormFields({
            textFieldsData: filteredTextFieldsData,
            comboboxFieldsData: filteredComboboxFieldsData,
            fileFieldsData: filteredFileFieldsData,
            radioButtonsData: filteredRadioButtonsData,
            checkboxesData: filteredCheckboxesData,
            toggleButtonsData: filteredToggleButtonsData,
            daDataFieldsData: filteredDaDataFieldsData,
            multiComboboxFieldsData: filteredMultiComboboxFieldsData
        }, modalFormLocators, 'модального окна');
        // 4. Сохранение
        const modalButtons = this.deps.getBlockModalWindowButtons(blockKey, modalWindowKey);
        if (!modalButtons || !modalButtons[saveButtonKey]) {
            throw new Error(`Кнопка сохранения ${saveButtonKey} не найдена`);
        }
        const modalBody = modalConfig?.modalWindowBody;
        if (!modalBody) {
            throw new Error(`Конфигурация модального окна блока ${blockKey} не содержит modalWindowBody`);
        }
        await this.deps.performModalTerminalActionToCloseModalWindow(modalButtons[saveButtonKey], modalBody, 'Сохранение и закрытие модального окна');
    }
    async fillBlockForm(blockKey, filteredFields, blockFormLocators) {
        const { filteredTextFieldsData, filteredComboboxFieldsData, filteredFileFieldsData, filteredRadioButtonsData, filteredCheckboxesData, filteredToggleButtonsData, filteredDaDataFieldsData, filteredMultiComboboxFieldsData } = filteredFields;
        await this.deps.formHelperFillFormFields({
            textFieldsData: filteredTextFieldsData,
            comboboxFieldsData: filteredComboboxFieldsData,
            radioButtonsData: filteredRadioButtonsData,
            fileFieldsData: filteredFileFieldsData,
            daDataFieldsData: filteredDaDataFieldsData,
            checkboxesData: filteredCheckboxesData,
            toggleButtonsData: filteredToggleButtonsData,
            multiComboboxFieldsData: filteredMultiComboboxFieldsData
        }, blockFormLocators, `блоке ${blockKey}`);
    }
    // --------------------------------------------------------------------------------------------------------
    // Публичные методы для использования
    // --------------------------------------------------------------------------------------------------------
    async switchBlockEditableState(blockKey, targetState, buttonKeys, logContext = 'BaseCard.switchBlockEditableState') {
        const role = this.deps.getRole();
        this.deps.validateBlockParams(blockKey, role);
        const blockButtons = this.deps.getBlockButtons(blockKey);
        if (!blockButtons) {
            throw new Error(`Кнопки блока ${blockKey} не найдены`);
        }
        const editButtonKey = buttonKeys?.Edit || 'Edit';
        const saveButtonKey = buttonKeys?.Save || 'Save';
        const cancelButtonKey = buttonKeys?.Cancel || 'Cancel';
        const editButton = blockButtons[editButtonKey];
        const saveButton = blockButtons[saveButtonKey];
        const cancelButton = blockButtons[cancelButtonKey];
        if (!editButton) {
            throw new Error(`Кнопка редактирования "${editButtonKey}" не найдена в блоке ${blockKey}`);
        }
        if (!saveButton) {
            throw new Error(`Кнопка сохранения "${saveButtonKey}" не найдена в блоке ${blockKey}`);
        }
        logger_1.logger.debug(`Переключение блока ${blockKey} в состояние ${targetState} для роли ${role}`, `${logContext}`);
        await test_1.test.step(`Переключение блока ${blockKey} в состояние ${targetState}`, async () => {
            // Проверяем текущее состояние
            const currentState = await this.getCurrentBlockState(editButton, saveButton, cancelButton);
            logger_1.logger.debug(`Текущее состояние блока ${blockKey}: ${currentState}`, logContext);
            if (currentState === targetState) {
                logger_1.logger.debug(`Блок ${blockKey} уже находится в состоянии ${targetState}, переключение не требуется`, logContext);
                return;
            }
            // Выполняем переключение
            if (targetState === 'editable') {
                // Переход в режим редактирования
                await editButton.click();
                await editButton.page().waitForTimeout(timeouts_1.TIMEOUTS.SHORT_WAIT);
                // Проверяем результат
                await this.verifyBlockButtonsState(editButton, saveButton, cancelButton, 'edit');
                logger_1.logger.debug(`Блок ${blockKey} переключен в режим редактирования`, logContext);
            }
            else {
                // Переход в режим просмотра
                if (cancelButton) {
                    await cancelButton.click();
                    await cancelButton.page().waitForTimeout(timeouts_1.TIMEOUTS.SHORT_WAIT);
                    logger_1.logger.debug(`Блок ${blockKey} переключен в режим просмотра через кнопку Cancel`, logContext);
                }
                else {
                    await saveButton.click();
                    await saveButton.page().waitForTimeout(timeouts_1.TIMEOUTS.SHORT_WAIT);
                    await this.deps.tryFindErrorMessage();
                    logger_1.logger.debug(`Блок ${blockKey} переключен в режим просмотра через кнопку Save`, logContext);
                }
                // Проверяем результат
                await this.verifyBlockButtonsState(editButton, saveButton, cancelButton, 'view');
            }
        });
        logger_1.logger.info(`Блок ${blockKey} успешно переключен в состояние ${targetState}`, `${logContext}`);
    }
    async checkFormFieldsState(blockConfig, blockFormLocators, mode) {
        const shouldBeDisabled = mode === 'notEditable';
        const fieldConfigs = [
            { locators: blockFormLocators.textFieldsLocators, config: blockConfig.textFields },
            { locators: blockFormLocators.comboboxFieldsLocators, config: blockConfig.comboboxFields, },
            { locators: blockFormLocators.toggleButtonsLocators, config: blockConfig.toggleButtons },
            { locators: blockFormLocators.multiComboboxFieldsLocators, config: blockConfig.multiComboboxFields },
            { locators: blockFormLocators.radioButtonsLocators, config: blockConfig.radioButtons },
            { locators: blockFormLocators.checkboxesLocators, config: blockConfig.checkboxes }
        ];
        for (const { locators, config } of fieldConfigs) {
            if (!locators || !config)
                continue;
            for (const fieldKey of config) {
                const field = locators[fieldKey];
                if (field) {
                    if (shouldBeDisabled) {
                        await test_1.expect.soft(field).toBeDisabled({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                    }
                    else {
                        await test_1.expect.soft(field).toBeEnabled({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                    }
                }
            }
        }
    }
    async fillFormAndAddRowInBlock(blockKey, triggerButtonKey, rowKey, expectedRowData, isFirstRow, saveButtonKey, modalWindowKey, formFields, logContext = 'BaseCard.fillFormAndAddRowInBlock', onRowVerified) {
        // 1. Валидация основных параметров
        this.validateParams({ blockKey, triggerButtonKey, rowKey, expectedRowData, formFields });
        // 2. Определяем label блока и роль
        const tableLabel = this.deps.getBlockTableLabel(blockKey);
        const role = this.deps.getRole();
        logger_1.logger.debug(`Заполнение формы и добавление строки в таблицу "${tableLabel}" блока ${blockKey}. Кнопка: ${triggerButtonKey}`, `${logContext}`);
        // 3. Ищем конфигурацию модального окна
        const modalConfig = this.deps.findBlockModalWindowConfig(blockKey, modalWindowKey ?? triggerButtonKey);
        if (!modalConfig) {
            logger_1.logger.warn(`Конфигурация модального окна блока ${blockKey} для роли ${role} не найдена. Будут заполнены все переданные поля.`, `${logContext}`);
        }
        // 4. Фильтрация полей формы
        const filteredFields = this.filterFormFields(formFields, modalConfig);
        // 5. Открытие модального окна --> Заполнение формы --> Сохранение формы
        await this.openAndFillModal(blockKey, triggerButtonKey, modalWindowKey, filteredFields, saveButtonKey, logContext);
        // 6. Проверяем, что строка действительно добавилась и появилась в гриде
        await test_1.test.step('Проверка добавленной строки в таблице', async () => {
            await this.deps.verifyTableRowInBlock(rowKey, expectedRowData, tableLabel, isFirstRow, onRowVerified);
        });
        logger_1.logger.info(`Заполнение формы и добавление строки в таблицу "${tableLabel}" блока ${blockKey} завершено успешно`, `${logContext}`);
    }
    async fillInlineBlockForm(blockKey, formFields, logContext = 'BaseCard.fillInlineBlockForm') {
        const role = this.deps.getRole();
        this.deps.validateBlockParams(blockKey, role);
        const blockConfig = this.deps.getBlockWithFormConfiguration(blockKey, role);
        const blockFormLocators = this.deps.getBlockFormWithInputsLocators(blockKey);
        if (!blockConfig) {
            throw new Error(`Конфигурация блока ${blockKey} для роли ${role} не найдена`);
        }
        logger_1.logger.debug(`Заполнение инлайн-формы блока ${blockKey} для роли ${role}`, `${logContext}`);
        await test_1.test.step(`Заполнение инлайн-формы блока ${blockKey}`, async () => {
            // Фильтрация полей формы
            const filteredFields = this.filterFormFields(formFields, blockConfig);
            logger_1.logger.debug(`Поля формы для блока ${blockKey} отфильтрованы`, logContext);
            // Заполнение полей формы
            await this.fillBlockForm(blockKey, filteredFields, blockFormLocators);
            logger_1.logger.debug(`Форма блока ${blockKey} заполнена`, logContext);
        });
        logger_1.logger.info(`Заполнение инлайн-формы блока ${blockKey} завершено успешно`, `${logContext}`);
    }
    async checkInlineBlockFormValues(blockKey, expectedFieldsValues, logContext = 'BaseCard.checkInlineBlockFormValues') {
        const role = this.deps.getRole();
        this.deps.validateBlockParams(blockKey, role);
        logger_1.logger.debug(`Проверка значений полей блока ${blockKey} для роли ${role}`, logContext);
        await test_1.test.step(`Проверка значений полей блока ${blockKey}`, async () => {
            // Получаем локаторы полей формы блока
            const blockFormLocators = this.deps.getBlockFormWithInputsLocators(blockKey);
            // =========================
            // 1. Проверка значений в текстовых полях
            // =========================
            if (expectedFieldsValues.textFields) {
                const textFields = expectedFieldsValues.textFields;
                await test_1.test.step('Проверка значений в текстовых полях', async () => {
                    await Promise.all(Object.entries(textFields).map(async ([fieldKey, expectedValue]) => {
                        const textField = blockFormLocators.textFieldsLocators?.[fieldKey];
                        if (!textField) {
                            logger_1.logger.warn(`Текстовое поле ${fieldKey} не найдено в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка значения текстового поля ${fieldKey}`, async () => {
                            await test_1.expect.soft(textField).toHaveValue(expectedValue, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                            logger_1.logger.debug(`Текстовое поле ${fieldKey} содержит ожидаемое значение: ${expectedValue}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 2. Проверка значений в combobox полях
            // =========================
            if (expectedFieldsValues.comboboxFields) {
                const comboboxFields = expectedFieldsValues.comboboxFields;
                await test_1.test.step('Проверка значений в combobox полях', async () => {
                    await Promise.all(Object.entries(comboboxFields).map(async ([fieldKey, expectedValue]) => {
                        const comboboxField = blockFormLocators.comboboxFieldsLocators?.[fieldKey];
                        if (!comboboxField) {
                            logger_1.logger.warn(`Combobox поле ${fieldKey} не найдено в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка значения combobox поля ${fieldKey}`, async () => {
                            await test_1.expect.soft(comboboxField).toHaveValue(expectedValue, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                            logger_1.logger.debug(`Combobox поле ${fieldKey} содержит ожидаемое значение: ${expectedValue}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 3. Проверка значений в file полях
            // =========================
            if (expectedFieldsValues.fileFields) {
                const fileFields = expectedFieldsValues.fileFields;
                await test_1.test.step('Проверка значений в file полях', async () => {
                    await Promise.all(Object.entries(fileFields).map(async ([fieldKey, expectedValue]) => {
                        const fileField = blockFormLocators.fileFieldsLocators?.[fieldKey];
                        if (!fileField) {
                            logger_1.logger.warn(`File поле ${fieldKey} не найдено в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка значения file поля ${fieldKey}`, async () => {
                            await test_1.expect.soft(fileField).toHaveValue(expectedValue, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                            logger_1.logger.debug(`File поле ${fieldKey} содержит ожидаемое значение: ${expectedValue}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 4. Проверка значений в radioButtons
            // =========================
            if (expectedFieldsValues.radioButtons) {
                const radioButtons = expectedFieldsValues.radioButtons;
                await test_1.test.step('Проверка значений в radioButtons', async () => {
                    await Promise.all(radioButtons.map(async (radioKey) => {
                        const radioButton = blockFormLocators.radioButtonsLocators?.[radioKey];
                        if (!radioButton) {
                            logger_1.logger.warn(`RadioButton ${radioKey} не найдена в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка состояния radioButton ${radioKey}`, async () => {
                            await test_1.expect.soft(radioButton).toBeChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                            logger_1.logger.debug(`RadioButton ${radioKey} выбран`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 5. Проверка значений в checkboxes
            // =========================
            if (expectedFieldsValues.checkboxes) {
                const checkboxes = expectedFieldsValues.checkboxes;
                await test_1.test.step('Проверка значений в checkboxes', async () => {
                    await Promise.all(Object.entries(checkboxes).map(async ([checkboxKey, expectedValue]) => {
                        const checkbox = blockFormLocators.checkboxesLocators?.[checkboxKey];
                        if (!checkbox) {
                            logger_1.logger.warn(`Чекбокс ${checkboxKey} не найден в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка состояния чекбокса ${checkboxKey}`, async () => {
                            if (expectedValue) {
                                await test_1.expect.soft(checkbox).toBeChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                            }
                            else {
                                await test_1.expect.soft(checkbox).not.toBeChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                            }
                            logger_1.logger.debug(`Чекбокс ${checkboxKey} имеет ожидаемое состояние: ${expectedValue}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 6. Проверка значений в toggleButtons
            // =========================
            if (expectedFieldsValues.toggleButtons) {
                const toggleButtons = expectedFieldsValues.toggleButtons;
                await test_1.test.step('Проверка значений в toggleButtons', async () => {
                    await Promise.all(Object.entries(toggleButtons).map(async ([toggleKey, expectedValue]) => {
                        const toggleButton = blockFormLocators.toggleButtonsLocators?.[toggleKey];
                        if (!toggleButton) {
                            logger_1.logger.warn(`Toggle кнопка ${toggleKey} не найдена в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка состояния toggle кнопки ${toggleKey}`, async () => {
                            const isChecked = expectedValue === true || expectedValue === 'Yes';
                            if (isChecked) {
                                await test_1.expect.soft(toggleButton).toBeChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                            }
                            else {
                                await test_1.expect.soft(toggleButton).not.toBeChecked({ timeout: timeouts_1.TIMEOUTS.EXPECT });
                            }
                            logger_1.logger.debug(`Toggle кнопка ${toggleKey} имеет ожидаемое состояние: ${isChecked}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 7. Проверка значений в daDataFields
            // =========================
            if (expectedFieldsValues.daDataFields) {
                const daDataFields = expectedFieldsValues.daDataFields;
                await test_1.test.step('Проверка значений в daData полях', async () => {
                    await Promise.all(Object.entries(daDataFields).map(async ([daDataKey, expectedValue]) => {
                        const daDataField = blockFormLocators.daDataFieldsLocators?.[daDataKey];
                        if (!daDataField) {
                            logger_1.logger.warn(`DaData поле ${daDataKey} не найдено в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка значения daData поля ${daDataKey}`, async () => {
                            await test_1.expect.soft(daDataField).toHaveValue(expectedValue, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                            logger_1.logger.debug(`DaData поле ${daDataKey} содержит ожидаемое значение: ${expectedValue}`, logContext);
                        });
                    }));
                });
            }
            // =========================
            // 8. Проверка значений в multiComboboxFields
            // =========================
            if (expectedFieldsValues.multiComboboxFields) {
                const multiComboboxFields = expectedFieldsValues.multiComboboxFields;
                await test_1.test.step('Проверка значений в multiCombobox полях', async () => {
                    await Promise.all(Object.entries(multiComboboxFields).map(async ([fieldKey, expectedValuesArray]) => {
                        const multiComboboxField = blockFormLocators.multiComboboxFieldsLocators?.[fieldKey];
                        if (!multiComboboxField) {
                            logger_1.logger.warn(`MultiCombobox поле ${fieldKey} не найдено в блоке ${blockKey}`, logContext);
                            return;
                        }
                        await test_1.test.step(`Проверка значения multiCombobox поля ${fieldKey}`, async () => {
                            for (const expectedValue of expectedValuesArray) {
                                await test_1.expect.soft(multiComboboxField).toContainText(expectedValue, { timeout: timeouts_1.TIMEOUTS.EXPECT });
                            }
                            logger_1.logger.debug(`MultiCombobox поле ${fieldKey} содержит ожидаемые значения: ${expectedValuesArray.join(', ')}`, logContext);
                        });
                    }));
                });
            }
        });
        logger_1.logger.info(`Проверка значений полей блока ${blockKey} завершена успешно`, logContext);
    }
}
exports.CardBlockFormService = CardBlockFormService;
