import { api } from '../api.js';
import { escapeHtml, showAlert, hideAlert } from '../utils.js';

const DAY_OPTIONS = [
    { value: 1, label: 'Понедельник' },
    { value: 2, label: 'Вторник' },
    { value: 3, label: 'Среда' },
    { value: 4, label: 'Четверг' },
    { value: 5, label: 'Пятница' },
    { value: 6, label: 'Суббота' },
    { value: 7, label: 'Воскресенье' }
];

const PARITY_LABELS = {
    BOTH: 'каждую неделю',
    ODD: 'нечётная',
    EVEN: 'чётная'
};

const SEMESTER_LABELS = {
    autumn: 'осенний',
    spring: 'весенний'
};

const WHOLE_GROUP_SUBGROUP_VALUE = '__whole_group__';

const LESSON_TYPE_LIMITS = [
    {
        key: 'lecture',
        label: 'Лекции',
        hoursField: 'lectureAcademicHours',
        startWeekField: 'lectureStartWeek',
        hoursInputId: 'schedule-rule-lecture-hours',
        startWeekInputId: 'schedule-rule-lecture-start-week'
    },
    {
        key: 'laboratory',
        label: 'Лабораторные',
        hoursField: 'laboratoryAcademicHours',
        startWeekField: 'laboratoryStartWeek',
        hoursInputId: 'schedule-rule-laboratory-hours',
        startWeekInputId: 'schedule-rule-laboratory-start-week'
    },
    {
        key: 'practice',
        label: 'Практики',
        hoursField: 'practiceAcademicHours',
        startWeekField: 'practiceStartWeek',
        hoursInputId: 'schedule-rule-practice-hours',
        startWeekInputId: 'schedule-rule-practice-start-week'
    }
];

export async function initSchedule() {
    const ruleForm = document.getElementById('schedule-rule-form');
    const ruleFormTitle = document.getElementById('schedule-rule-form-title');
    const ruleIdInput = document.getElementById('schedule-rule-id');
    const ruleSubjectSelect = document.getElementById('schedule-rule-subject');
    const ruleSemesterSelect = document.getElementById('schedule-rule-semester');
    const ruleTypeInputs = Object.fromEntries(LESSON_TYPE_LIMITS.map(config => [config.key, {
        hours: document.getElementById(config.hoursInputId),
        startWeek: document.getElementById(config.startWeekInputId)
    }]));
    const ruleGroupsBox = document.getElementById('schedule-rule-groups-box');
    const ruleGroupsMenu = document.getElementById('schedule-rule-groups-menu');
    const ruleGroupsText = document.getElementById('schedule-rule-groups-text');
    const ruleGroupCheckboxes = document.getElementById('schedule-rule-group-checkboxes');
    const ruleSlotsContainer = document.getElementById('schedule-rule-slots');
    const ruleResetButton = document.getElementById('schedule-rule-reset');
    const slotAddButton = document.getElementById('schedule-slot-add');
    const rulesTbody = document.getElementById('schedule-tbody');
    const refreshRulesButton = document.getElementById('schedule-refresh');

    let rules = [];
    let subjects = [];
    let groups = [];
    let teachers = [];
    let classrooms = [];
    let lessonTypes = [];
    let subgroups = [];
    let timeSlots = [];
    let semesters = [];

    bindEvents();

    try {
        await Promise.all([loadBaseLists(), loadTimeSlots(), loadYears()]);
        renderRuleGroups([]);
        renderRuleSlots([{}]);
        await loadRules();
    } catch (error) {
        showAlert('schedule-rule-alert', error.message || 'Ошибка загрузки данных расписания', 'error');
    }

    function bindEvents() {
        refreshRulesButton?.addEventListener('click', loadRules);
        ruleResetButton?.addEventListener('click', resetRuleForm);
        slotAddButton?.addEventListener('click', () => renderRuleSlots([...readRuleSlots(false), {}]));

        ruleSlotsContainer.addEventListener('click', (event) => {
            const removeButton = event.target.closest('.schedule-slot-remove');
            const subgroupBox = event.target.closest('.slot-subgroup-box');
            const subgroupMenu = event.target.closest('.slot-subgroup-menu');

            if (removeButton) {
                const slots = readRuleSlots(false);
                slots.splice(Number(removeButton.dataset.index), 1);
                renderRuleSlots(slots.length ? slots : [{}]);
                return;
            }

            if (subgroupBox) {
                toggleSlotSubgroupMenu(event, subgroupBox);
                return;
            }

            if (subgroupMenu) {
                event.stopPropagation();
            }
        });

        ruleGroupsBox.addEventListener('click', toggleRuleGroupsMenu);
        ruleGroupsBox.addEventListener('keydown', handleRuleGroupsKeydown);
        ruleGroupsMenu.addEventListener('click', event => event.stopPropagation());
        ruleGroupCheckboxes.addEventListener('change', () => {
            updateRuleGroupsText();
            renderRuleSlots(readRuleSlots(false));
        });
        document.addEventListener('click', () => {
            closeRuleGroupsMenu();
            closeSlotSubgroupMenus();
        });
        ruleSlotsContainer.addEventListener('change', (event) => {
            if (event.target.closest('.slot-lesson-type')) {
                renderRuleSlots(readRuleSlots(false));
                return;
            }
            if (event.target.closest('.slot-subgroup-checkboxes')) {
                updateSlotSubgroupText(event.target.closest('.schedule-slot-row'));
            }
        });
        ruleForm.addEventListener('submit', saveRule);
        rulesTbody.addEventListener('click', handleRuleTableClick);
    }

    async function loadBaseLists() {
        [subjects, groups, teachers, classrooms, lessonTypes, subgroups] = await Promise.all([
            api.get('/api/subjects'),
            api.get('/api/groups'),
            api.get('/api/users/teachers'),
            api.get('/api/classrooms'),
            api.get('/api/lesson-types'),
            api.get('/api/subgroups')
        ]);
        populateSubjectSelects();
    }

    async function loadYears() {
        const academicYears = await api.get('/api/admin/calendar/years');
        semesters = academicYears.flatMap(year => year.semesters || []);
        populateSemesterSelects();
    }

    async function loadRules() {
        rulesTbody.innerHTML = '<tr><td colspan="7" class="loading-row">Загрузка...</td></tr>';
        try {
            rules = await api.get('/api/admin/schedule-rules');
            renderRules();
        } catch (error) {
            rulesTbody.innerHTML = `<tr><td colspan="7" class="loading-row">Ошибка загрузки: ${escapeHtml(error.message)}</td></tr>`;
        }
    }

    function renderRules() {
        if (!rules.length) {
            rulesTbody.innerHTML = '<tr><td colspan="7" class="loading-row">Правила расписания не созданы</td></tr>';
            return;
        }
        rulesTbody.innerHTML = rules.map(rule => `
            <tr>
                <td>${rule.id}</td>
                <td>${escapeHtml(rule.subjectName || '-')}</td>
                <td>${escapeHtml(formatSemester(rule))}</td>
                <td>${escapeHtml((rule.groupNames || []).join(', ') || '-')}</td>
                <td>${renderRuleLoadSummary(rule)}</td>
                <td>${renderRuleSlotsSummary(rule.slots)}</td>
                <td>
                    <button class="btn-edit-classroom btn-edit-rule" data-id="${rule.id}">Изменить</button>
                    <button class="btn-delete btn-delete-rule" data-id="${rule.id}">Удалить</button>
                </td>
            </tr>
        `).join('');
    }

    function renderRuleSlotsSummary(slots) {
        if (!slots || !slots.length) return '<span class="muted">Нет слотов</span>';
        return slots.map(slot => {
            const parity = PARITY_LABELS[slot.parity] || slot.parity || '-';
            const parts = [
                slot.dayName,
                slot.timeSlotLabel,
                parity,
                slotSubgroupNames(slot).join(', '),
                slot.teacherName,
                slot.classroomName,
                slot.lessonTypeName,
                slot.lessonFormat
            ].filter(Boolean);
            return `<div class="schedule-slot-summary">${escapeHtml(parts.join(' · '))}</div>`;
        }).join('');
    }

    function renderRuleLoadSummary(rule) {
        const rows = LESSON_TYPE_LIMITS
            .map(config => ({
                label: config.label,
                hours: Number(rule[config.hoursField] || 0),
                startWeek: Number(rule[config.startWeekField] || 1)
            }))
            .filter(item => item.hours > 0);
        if (!rows.length) return '<span class="muted">Часы не указаны</span>';
        return rows.map(item => (
            `<div class="schedule-slot-summary">${escapeHtml(`${item.label}: ${item.hours} ч, с ${item.startWeek} недели`)}</div>`
        )).join('');
    }

    async function handleRuleTableClick(event) {
        const editButton = event.target.closest('.btn-edit-rule');
        const deleteButton = event.target.closest('.btn-delete-rule');

        if (editButton) {
            const rule = rules.find(item => item.id == editButton.dataset.id)
                || await api.get('/api/admin/schedule-rules/' + editButton.dataset.id);
            fillRuleForm(rule);
            return;
        }

        if (deleteButton) {
            if (!confirm('Удалить правило расписания?')) return;
            try {
                await api.delete('/api/admin/schedule-rules/' + deleteButton.dataset.id);
                showAlert('schedule-rule-alert', 'Правило расписания удалено', 'success');
                await loadRules();
            } catch (error) {
                showAlert('schedule-rule-alert', error.message || 'Ошибка удаления правила', 'error');
            }
        }
    }

    async function saveRule(event) {
        event.preventDefault();
        hideAlert('schedule-rule-alert');
        try {
            const payload = buildRulePayload();
            const id = ruleIdInput.value;
            const saved = id
                ? await api.put('/api/admin/schedule-rules/' + id, payload)
                : await api.post('/api/admin/schedule-rules', payload);
            showAlert('schedule-rule-alert', `Правило "${saved.subjectName || 'расписания'}" сохранено`, 'success');
            resetRuleForm();
            await loadRules();
        } catch (error) {
            showAlert('schedule-rule-alert', error.message || 'Ошибка сохранения правила', 'error');
        }
    }

    function buildRulePayload() {
        const groupIds = selectedRuleGroupIds();
        const slots = readRuleSlots(true);
        if (!ruleSubjectSelect.value) throw new Error('Выберите дисциплину');
        if (!ruleSemesterSelect.value) throw new Error('Выберите семестр');
        const typeLimits = readTypeLimits();
        validateTypeLimits(typeLimits, slots);
        if (!groupIds.length) throw new Error('Выберите хотя бы одну группу');
        if (!slots.length) throw new Error('Добавьте хотя бы один слот занятия');
        return {
            id: ruleIdInput.value ? Number(ruleIdInput.value) : null,
            subjectId: Number(ruleSubjectSelect.value),
            semesterId: Number(ruleSemesterSelect.value),
            ...typeLimits,
            groupIds,
            slots
        };
    }

    function fillRuleForm(rule) {
        ruleFormTitle.textContent = 'Редактирование правила расписания';
        ruleIdInput.value = rule.id;
        ruleSubjectSelect.value = rule.subjectId || '';
        ruleSemesterSelect.value = rule.semesterId || '';
        fillTypeLimits(rule);
        syncSelects(ruleSubjectSelect, ruleSemesterSelect);
        renderRuleGroups(rule.groupIds || []);
        renderRuleSlots(rule.slots && rule.slots.length ? rule.slots : [{}]);
        hideAlert('schedule-rule-alert');
        ruleForm.scrollIntoView({ behavior: 'smooth', block: 'start' });
    }

    function resetRuleForm() {
        ruleForm.reset();
        ruleFormTitle.textContent = 'Новое правило расписания';
        ruleIdInput.value = '';
        fillTypeLimits({});
        renderRuleGroups([]);
        renderRuleSlots([{}]);
        syncSelects(ruleSubjectSelect, ruleSemesterSelect);
        hideAlert('schedule-rule-alert');
    }

    function renderRuleGroups(selectedIds) {
        if (!groups.length) {
            ruleGroupCheckboxes.innerHTML = '<div class="loading-row">Нет групп</div>';
            updateRuleGroupsText();
            return;
        }
        const selected = new Set((selectedIds || []).map(String));
        ruleGroupCheckboxes.innerHTML = groups.map(group => `
            <label class="checkbox-item">
                <input type="checkbox" value="${group.id}" ${selected.has(String(group.id)) ? 'checked' : ''}>
                <span class="checkmark"></span>
                <span>${escapeHtml(group.name)}</span>
            </label>
        `).join('');
        updateRuleGroupsText();
    }

    function renderRuleSlots(slots) {
        ruleSlotsContainer.innerHTML = (slots || [{}]).map((slot, index) => `
            <div class="schedule-slot-row ${isLaboratorySlot(slot) ? 'has-subgroup' : ''}" data-index="${index}">
                <div class="form-group"><label>День</label><select class="slot-day" required>${options(DAY_OPTIONS, slot.dayOfWeek)}</select></div>
                <div class="form-group"><label>Чётность</label><select class="slot-parity" required>${options(Object.entries(PARITY_LABELS).map(([value, label]) => ({ value, label })), slot.parity || 'BOTH')}</select></div>
                <div class="form-group"><label>Пара</label><select class="slot-time" required>${options(timeSlots.map(toTimeSlotOption), slot.timeSlotId)}</select></div>
                <div class="form-group"><label>Преподаватель</label><select class="slot-teacher" required>${options(teachers.map(toTeacherOption), slot.teacherId)}</select></div>
                <div class="form-group"><label>Аудитория</label><select class="slot-classroom" required>${options(classrooms.map(toClassroomOption), slot.classroomId)}</select></div>
                <div class="form-group"><label>Тип</label><select class="slot-lesson-type" required>${options(lessonTypes.map(toLessonTypeOption), slot.lessonTypeId)}</select></div>
                ${isLaboratorySlot(slot) ? renderSubgroupField(slot, index) : ''}
                <div class="form-group"><label>Формат</label><select class="slot-format" required>${options([{ value: 'Очно', label: 'Очно' }, { value: 'Онлайн', label: 'Онлайн' }], slot.lessonFormat || 'Очно')}</select></div>
                <button type="button" class="btn-delete schedule-slot-remove" data-index="${index}">Удалить</button>
            </div>
        `).join('');
    }

    function readRuleSlots(validate) {
        const rows = Array.from(ruleSlotsContainer.querySelectorAll('.schedule-slot-row'));
        return rows.map((row, index) => {
            const subgroupIds = readSlotSubgroupIds(row);
            const slot = {
                id: null,
                dayOfWeek: Number(row.querySelector('.slot-day').value),
                parity: row.querySelector('.slot-parity').value,
                timeSlotId: Number(row.querySelector('.slot-time').value),
                subgroupId: subgroupIds[0] || null,
                subgroupIds,
                teacherId: Number(row.querySelector('.slot-teacher').value),
                classroomId: Number(row.querySelector('.slot-classroom').value),
                lessonTypeId: Number(row.querySelector('.slot-lesson-type').value),
                lessonFormat: row.querySelector('.slot-format').value
            };
            if (validate && (!slot.dayOfWeek || !slot.parity || !slot.timeSlotId
                || !slot.teacherId || !slot.classroomId || !slot.lessonTypeId || !slot.lessonFormat)) {
                throw new Error(`Заполните слот ${index + 1}`);
            }
            if (validate) {
                validateSlotSubgroup(slot, index);
            }
            return slot;
        });
    }

    function readTypeLimits() {
        return LESSON_TYPE_LIMITS.reduce((payload, config) => {
            const inputs = ruleTypeInputs[config.key];
            payload[config.hoursField] = Number(inputs.hours.value || 0);
            payload[config.startWeekField] = Number(inputs.startWeek.value || 1);
            return payload;
        }, {});
    }

    function fillTypeLimits(rule) {
        LESSON_TYPE_LIMITS.forEach(config => {
            const inputs = ruleTypeInputs[config.key];
            inputs.hours.value = rule[config.hoursField] ?? 0;
            inputs.startWeek.value = rule[config.startWeekField] ?? 1;
        });
    }

    function validateTypeLimits(typeLimits, slots) {
        const selectedTypeKeys = new Set(slots.map(slot => lessonTypeKeyById(slot.lessonTypeId)).filter(Boolean));
        let hasHours = false;
        for (const config of LESSON_TYPE_LIMITS) {
            const hours = typeLimits[config.hoursField];
            const startWeek = typeLimits[config.startWeekField];
            if (hours < 0) throw new Error('Количество часов по типам занятий не может быть отрицательным');
            if (!startWeek || startWeek <= 0) throw new Error('Неделя начала занятий должна быть больше нуля');
            if (hours > 0) hasHours = true;
            if (hours > 0 && !selectedTypeKeys.has(config.key)) {
                throw new Error(`Для типа "${config.label}" добавьте хотя бы один слот`);
            }
            if (hours === 0 && selectedTypeKeys.has(config.key)) {
                throw new Error(`Для типа "${config.label}" укажите часы или удалите слоты этого типа`);
            }
        }
        if (!hasHours) throw new Error('Укажите часы хотя бы для одного типа занятий');
    }

    function validateSlotSubgroup(slot, index) {
        const typeKey = lessonTypeKeyById(slot.lessonTypeId);
        const subgroupIds = slotSubgroupIds(slot);
        if (subgroupIds.length && typeKey !== 'laboratory') {
            throw new Error(`В слоте ${index + 1} подгруппа доступна только для лабораторных`);
        }
        if (!subgroupIds.length) return;

        const selectedGroups = new Set(selectedRuleGroupIds().map(String));
        const subgroupGroupIds = new Set();
        for (const subgroupId of subgroupIds) {
            const selectedSubgroup = subgroups.find(item => String(item.id) === String(subgroupId));
            if (!selectedSubgroup) {
                throw new Error(`В слоте ${index + 1} подгруппа не найдена`);
            }
            if (!selectedGroups.has(String(selectedSubgroup.groupId))) {
                throw new Error(`В слоте ${index + 1} подгруппа должна относиться к выбранным группам правила`);
            }
            if (subgroupGroupIds.has(String(selectedSubgroup.groupId))) {
                throw new Error(`В слоте ${index + 1} выберите не больше одной подгруппы каждой группы`);
            }
            subgroupGroupIds.add(String(selectedSubgroup.groupId));
        }
    }

    async function loadTimeSlots() {
        const slots = await api.get('/api/admin/time-slots');
        timeSlots = slots
            .filter(slot => slot.scopeApplyMode === 'DEFAULT')
            .sort((a, b) => (a.orderNumber || 0) - (b.orderNumber || 0));
    }

    function populateSubjectSelects() {
        ruleSubjectSelect.innerHTML = '<option value="">Выберите дисциплину</option>' +
            subjects.map(subject => `<option value="${subject.id}">${escapeHtml(subject.name)}</option>`).join('');
        syncSelects(ruleSubjectSelect);
    }

    function populateSemesterSelects() {
        const semesterOptions = '<option value="">Выберите семестр</option>' +
            semesters.map(semester => `<option value="${semester.id}">${escapeHtml(semesterLabel(semester))}</option>`).join('');
        ruleSemesterSelect.innerHTML = semesterOptions;
        syncSelects(ruleSemesterSelect);
    }

    function options(items, selectedValue) {
        const selected = selectedValue == null ? '' : String(selectedValue);
        return '<option value="">Выберите</option>' + items.map(item => {
            const value = String(item.value);
            return `<option value="${escapeHtml(value)}" ${value === selected ? 'selected' : ''}>${escapeHtml(item.label)}</option>`;
        }).join('');
    }

    function subgroupOptions(slot) {
        if (!isLaboratorySlot(slot)) {
            return '<option value="">Только для лабораторных</option>';
        }
        const selectedGroupIds = selectedRuleGroupIds();
        if (selectedGroupIds.length !== 1) {
            return '<option value="">Выберите группу правила</option>';
        }
        const selected = slotSubgroupIds(slot)[0] == null
            ? WHOLE_GROUP_SUBGROUP_VALUE
            : String(slotSubgroupIds(slot)[0]);
        const selectedGroups = new Set(selectedGroupIds.map(String));
        const matchingSubgroups = subgroups
            .filter(subgroup => selectedGroups.has(String(subgroup.groupId)))
            .sort((a, b) => subgroupLabel(a).localeCompare(subgroupLabel(b), 'ru-RU'));
        return `<option value="${WHOLE_GROUP_SUBGROUP_VALUE}" ${selected === WHOLE_GROUP_SUBGROUP_VALUE ? 'selected' : ''}>Вся группа</option>` + matchingSubgroups.map(subgroup => {
            const value = String(subgroup.id);
            return `<option value="${escapeHtml(value)}" ${value === selected ? 'selected' : ''}>${escapeHtml(subgroupLabel(subgroup))}</option>`;
        }).join('');
    }

    function renderSubgroupField(slot, index) {
        return selectedRuleGroupIds().length > 1
            ? renderSubgroupMultiSelect(slot, index)
            : `<div class="form-group"><label>Подгруппа</label><select class="slot-subgroup">${subgroupOptions(slot)}</select></div>`;
    }

    function renderSubgroupMultiSelect(slot, index) {
        const selected = new Set(slotSubgroupIds(slot).map(String));
        const selectedGroups = new Set(selectedRuleGroupIds().map(String));
        const matchingSubgroups = subgroups
            .filter(subgroup => selectedGroups.has(String(subgroup.groupId)))
            .sort((a, b) => subgroupLabel(a).localeCompare(subgroupLabel(b), 'ru-RU'));
        const items = matchingSubgroups.length
            ? matchingSubgroups.map(subgroup => {
                const value = String(subgroup.id);
                return `
                    <label class="checkbox-item">
                        <input type="checkbox" value="${escapeHtml(value)}" ${selected.has(value) ? 'checked' : ''}>
                        <span class="checkmark"></span>
                        <span>${escapeHtml(subgroupLabel(subgroup))}</span>
                    </label>
                `;
            }).join('')
            : '<div class="loading-row">Нет подгрупп выбранных групп</div>';

        return `
            <div class="form-group slot-subgroup-multi">
                <label>Подгруппы</label>
                <div class="custom-multi-select">
                    <div class="select-box slot-subgroup-box" role="button" tabindex="0" aria-expanded="false">
                        <span class="select-text">${escapeHtml(slotSubgroupText(slot))}</span>
                        <svg class="dropdown-icon" width="12" height="8" viewBox="0 0 12 8" fill="none" xmlns="http://www.w3.org/2000/svg">
                            <path d="M1 1.5L6 6.5L11 1.5" stroke="#9ca3af" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
                        </svg>
                    </div>
                    <div class="dropdown-menu slot-subgroup-menu">
                        <div class="checkbox-group-vertical slot-subgroup-checkboxes" data-index="${index}">
                            ${items}
                        </div>
                    </div>
                </div>
            </div>
        `;
    }

    function readSlotSubgroupIds(row) {
        const subgroupValue = row.querySelector('.slot-subgroup')?.value || '';
        const checkboxValues = Array.from(row.querySelectorAll('.slot-subgroup-checkboxes input[type="checkbox"]:checked'))
            .map(input => Number(input.value))
            .filter(Boolean);
        return checkboxValues.length
            ? checkboxValues
            : (subgroupValue && subgroupValue !== WHOLE_GROUP_SUBGROUP_VALUE ? [Number(subgroupValue)] : []);
    }

    function slotSubgroupIds(slot) {
        if (Array.isArray(slot.subgroupIds) && slot.subgroupIds.length) {
            return slot.subgroupIds.map(Number).filter(Boolean);
        }
        return slot.subgroupId ? [Number(slot.subgroupId)] : [];
    }

    function slotSubgroupNames(slot) {
        if (Array.isArray(slot.subgroupNames) && slot.subgroupNames.length) {
            return slot.subgroupNames.filter(Boolean);
        }
        return slot.subgroupName ? [slot.subgroupName] : [];
    }

    function slotSubgroupText(slot) {
        const selectedIds = slotSubgroupIds(slot);
        if (!selectedIds.length) return 'Все выбранные группы';
        if (selectedIds.length === 1) {
            const subgroup = subgroups.find(item => String(item.id) === String(selectedIds[0]));
            return subgroup ? subgroupLabel(subgroup) : 'Выбрана 1 подгруппа';
        }
        return `Выбрано подгрупп: ${selectedIds.length}`;
    }

    function selectedRuleGroupIds() {
        return Array.from(ruleGroupCheckboxes.querySelectorAll('input[type="checkbox"]:checked'))
            .map(input => Number(input.value));
    }

    function toggleRuleGroupsMenu(event) {
        event.stopPropagation();
        const isOpen = ruleGroupsMenu.classList.contains('open');
        document.querySelectorAll('.dropdown-menu').forEach(menu => menu.classList.remove('open'));
        document.querySelectorAll('.select-box').forEach(box => box.classList.remove('active'));
        if (isOpen) {
            closeRuleGroupsMenu();
            return;
        }
        ruleGroupsMenu.classList.add('open');
        ruleGroupsBox.classList.add('active');
        ruleGroupsBox.setAttribute('aria-expanded', 'true');
    }

    function handleRuleGroupsKeydown(event) {
        if (event.key === 'Enter' || event.key === ' ') {
            event.preventDefault();
            toggleRuleGroupsMenu(event);
        }
        if (event.key === 'Escape') {
            closeRuleGroupsMenu();
        }
    }

    function closeRuleGroupsMenu() {
        ruleGroupsMenu.classList.remove('open');
        ruleGroupsBox.classList.remove('active');
        ruleGroupsBox.setAttribute('aria-expanded', 'false');
    }

    function toggleSlotSubgroupMenu(event, box) {
        event.stopPropagation();
        const menu = box.closest('.custom-multi-select')?.querySelector('.slot-subgroup-menu');
        if (!menu) return;
        const isOpen = menu.classList.contains('open');
        document.querySelectorAll('.dropdown-menu').forEach(item => item.classList.remove('open'));
        document.querySelectorAll('.select-box').forEach(item => item.classList.remove('active'));
        if (isOpen) {
            box.setAttribute('aria-expanded', 'false');
            return;
        }
        menu.classList.add('open');
        box.classList.add('active');
        box.setAttribute('aria-expanded', 'true');
    }

    function closeSlotSubgroupMenus() {
        ruleSlotsContainer.querySelectorAll('.slot-subgroup-menu').forEach(menu => menu.classList.remove('open'));
        ruleSlotsContainer.querySelectorAll('.slot-subgroup-box').forEach(box => {
            box.classList.remove('active');
            box.setAttribute('aria-expanded', 'false');
        });
    }

    function updateSlotSubgroupText(row) {
        if (!row) return;
        const text = row.querySelector('.slot-subgroup-box .select-text');
        if (!text) return;
        const selectedIds = readSlotSubgroupIds(row);
        if (!selectedIds.length) {
            text.textContent = 'Все выбранные группы';
            return;
        }
        if (selectedIds.length === 1) {
            const subgroup = subgroups.find(item => String(item.id) === String(selectedIds[0]));
            text.textContent = subgroup ? subgroupLabel(subgroup) : 'Выбрана 1 подгруппа';
            return;
        }
        text.textContent = `Выбрано подгрупп: ${selectedIds.length}`;
    }

    function updateRuleGroupsText() {
        const selectedIds = selectedRuleGroupIds();
        if (!groups.length) {
            ruleGroupsText.textContent = 'Нет групп';
            return;
        }
        if (!selectedIds.length) {
            ruleGroupsText.textContent = 'Выберите группы...';
            return;
        }
        if (selectedIds.length === 1) {
            const selectedGroup = groups.find(group => String(group.id) === String(selectedIds[0]));
            ruleGroupsText.textContent = selectedGroup?.name || 'Выбрана 1 группа';
            return;
        }
        ruleGroupsText.textContent = `Выбрано групп: ${selectedIds.length}`;
    }

    function toTimeSlotOption(slot) {
        return { value: slot.id, label: `${slot.orderNumber} пара, ${trimTime(slot.startTime)} - ${trimTime(slot.endTime)}` };
    }

    function toTeacherOption(teacher) {
        return { value: teacher.id, label: teacher.fullName || teacher.username || `ID ${teacher.id}` };
    }

    function toClassroomOption(classroom) {
        const capacity = classroom.capacity ? `, ${classroom.capacity} чел.` : '';
        return { value: classroom.id, label: `${classroom.name}${capacity}` };
    }

    function toLessonTypeOption(lessonType) {
        return { value: lessonType.id, label: lessonType.name || lessonType.lessonType || `ID ${lessonType.id}` };
    }

    function lessonTypeKeyById(lessonTypeId) {
        const lessonType = lessonTypes.find(item => String(item.id) === String(lessonTypeId));
        return lessonType ? lessonTypeKey(lessonType) : null;
    }

    function isLaboratorySlot(slot) {
        return lessonTypeKeyById(slot.lessonTypeId) === 'laboratory';
    }

    function subgroupLabel(subgroup) {
        return `${subgroup.groupName || `Группа ${subgroup.groupId}`}: ${subgroup.name}`;
    }

    function lessonTypeKey(lessonType) {
        const name = String(lessonType.name || lessonType.lessonType || '').toLowerCase();
        if (name.includes('лекц')) return 'lecture';
        if (name.includes('лаб')) return 'laboratory';
        if (name.includes('практ')) return 'practice';
        return null;
    }

    function semesterLabel(semester) {
        const type = normalizeSemesterType(semester.semesterType);
        return `${semester.academicYearTitle || '-'}, ${SEMESTER_LABELS[type] || type} (${semester.startDate} - ${semester.endDate})`;
    }

    function formatSemester(rule) {
        const type = normalizeSemesterType(rule.semesterType);
        return `${rule.academicYearTitle || '-'}, ${SEMESTER_LABELS[type] || type || '-'}`;
    }

    function normalizeSemesterType(type) {
        return String(type || '').toLowerCase();
    }

    function trimTime(value) {
        if (!value) return '';
        return String(value).slice(0, 5);
    }

    function syncSelects(...selects) {
        selects.filter(Boolean).forEach(select => {
            select.dispatchEvent(new Event('change', { bubbles: true }));
        });
    }
}