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 CELL_PARITY_LAYOUT = [
    { parity: 'ODD', label: 'Нечётная' },
    { parity: 'EVEN', label: 'Чётная' }
];

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

const WHOLE_GROUP_SUBGROUP_VALUE = '__whole_group__';
const ACADEMIC_HOURS_PER_SLOT = 2;

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');
    const visualToggleButton = document.getElementById('schedule-visual-toggle');
    const visualCloseButton = document.getElementById('schedule-visual-close');
    const visualDrawer = document.getElementById('schedule-visual-drawer');
    const visualBackdrop = document.getElementById('schedule-visual-backdrop');
    const visualStage = document.getElementById('schedule-visual-stage');
    const visualSummary = document.getElementById('schedule-visual-summary');
    const visualGroupFilter = document.getElementById('schedule-visual-group-filter');
    const visualUseFormButton = document.getElementById('schedule-visual-use-form');
    const visualSelectAllButton = document.getElementById('schedule-visual-select-all');

    let rules = [];
    let subjects = [];
    let groups = [];
    let teachers = [];
    let classrooms = [];
    let lessonTypes = [];
    let subgroups = [];
    let timeSlots = [];
    let semesters = [];
    let selectedVisualGroupIds = new Set();
    let visualGroupFilterTouched = false;

    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), {}]));
        visualToggleButton?.addEventListener('click', toggleVisualDrawer);
        visualCloseButton?.addEventListener('click', closeVisualDrawer);
        visualBackdrop?.addEventListener('click', closeVisualDrawer);
        visualGroupFilter?.addEventListener('change', handleVisualGroupFilterChange);
        visualUseFormButton?.addEventListener('click', () => {
            visualGroupFilterTouched = false;
            selectedVisualGroupIds = new Set();
            renderVisualSchedule();
        });
        visualSelectAllButton?.addEventListener('click', () => {
            selectedVisualGroupIds = new Set(collectVisualGroups().map(group => String(group.id)));
            visualGroupFilterTouched = true;
            renderVisualSchedule();
        });
        document.addEventListener('keydown', (event) => {
            if (event.key === 'Escape') closeVisualDrawer();
        });

        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();
            renderVisualSchedule();
        } catch (error) {
            rulesTbody.innerHTML = `<tr><td colspan="7" class="loading-row">Ошибка загрузки: ${escapeHtml(error.message)}</td></tr>`;
            setVisualState('Ошибка загрузки правил расписания');
        }
    }

    function renderRules() {
        if (!rules.length) {
            rulesTbody.innerHTML = '<tr><td colspan="7" class="loading-row">Правила расписания не созданы</td></tr>';
            renderVisualSchedule();
            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 toggleVisualDrawer() {
        if (!visualDrawer) return;
        if (visualDrawer.classList.contains('open')) {
            closeVisualDrawer();
        } else {
            openVisualDrawer();
        }
    }

    function openVisualDrawer() {
        if (!visualDrawer) return;
        visualDrawer.classList.add('open');
        visualDrawer.setAttribute('aria-hidden', 'false');
        visualToggleButton?.classList.add('open');
        visualToggleButton?.setAttribute('aria-expanded', 'true');
        visualToggleButton?.setAttribute('aria-label', 'Скрыть визуальное расписание');
        if (visualToggleButton) visualToggleButton.textContent = '›';
        if (visualBackdrop) visualBackdrop.hidden = false;
    }

    function closeVisualDrawer() {
        if (!visualDrawer) return;
        visualDrawer.classList.remove('open');
        visualDrawer.setAttribute('aria-hidden', 'true');
        visualToggleButton?.classList.remove('open');
        visualToggleButton?.setAttribute('aria-expanded', 'false');
        visualToggleButton?.setAttribute('aria-label', 'Показать визуальное расписание');
        if (visualToggleButton) visualToggleButton.textContent = '‹';
        if (visualBackdrop) visualBackdrop.hidden = true;
    }

    function renderVisualSchedule() {
        if (!visualStage || !visualSummary) return;
        if (!rules.length) {
            visualSummary.textContent = 'Нет сохранённых правил';
            setVisualState('Сохраните правила расписания, чтобы увидеть матрицу по группам');
            return;
        }

        const allGroups = collectVisualGroups();
        syncVisualGroupFilter(allGroups);
        const columns = allGroups.filter(group => selectedVisualGroupIds.has(String(group.id)));
        const slots = timeSlots.length ? timeSlots.map(visualSlotFromTimeSlot) : collectVisualSlotsFromRules();
        if (!allGroups.length || !slots.length) {
            visualSummary.textContent = 'Недостаточно данных для построения';
            setVisualState('У правил должны быть группы и слоты занятий');
            return;
        }
        if (!columns.length) {
            visualSummary.textContent = 'Выберите группы для просмотра';
            setVisualState('Отметьте одну или несколько групп в фильтре');
            return;
        }

        const lessonsByCell = buildVisualLessonsByCell(selectedVisualGroupIds);
        const rows = buildVisualRows(columns, slots, lessonsByCell);
        if (!rows.length) {
            visualSummary.textContent = `${columns.length} ${groupCountLabel(columns.length)} · пар не найдено`;
            setVisualState('Для выбранных групп нет активных пар в сохранённых правилах');
            return;
        }

        visualSummary.textContent = `${rules.length} ${ruleCountLabel(rules.length)} · ${columns.length} ${groupCountLabel(columns.length)} · ${rows.length} ${rowCountLabel(rows.length)}`;
        visualStage.innerHTML = `
            <div class="schedule-visual-table-wrap">
                <table class="schedule-visual-table">
                    <thead>
                        <tr>
                            <th class="schedule-visual-day-head">День</th>
                            <th class="schedule-visual-time-head">Время</th>
                            ${columns.map(group => `<th>${escapeHtml(group.name)}</th>`).join('')}
                        </tr>
                    </thead>
                    <tbody>${rows.map(renderVisualRow).join('')}</tbody>
                </table>
            </div>
        `;
    }

    function buildVisualRows(columns, slots, lessonsByCell) {
        const rows = [];
        DAY_OPTIONS.forEach(day => {
            const dayRows = slots
                .map(slot => ({
                    day,
                    slot,
                    cells: columns.map(group => ({
                        group,
                        lessons: lessonsByCell.get(visualCellKey(group.id, day.value, slot.key)) || []
                    }))
                }))
                .filter(row => row.cells.some(cell => cell.lessons.length));

            dayRows.forEach((row, index) => {
                rows.push({
                    ...row,
                    dayRowspan: index === 0 ? dayRows.length : 0
                });
            });
        });
        return rows;
    }

    function renderVisualRow(row) {
        return `
            <tr>
                ${row.dayRowspan ? `<td class="schedule-visual-day-cell" rowspan="${row.dayRowspan}">${escapeHtml(row.day.label)}</td>` : ''}
                <td class="schedule-visual-time-cell">
                    <strong>${escapeHtml(row.slot.orderLabel)}</strong>
                    <span>${escapeHtml(row.slot.timeLabel)}</span>
                </td>
                ${row.cells.map(cell => {
                    const emptyClass = cell.lessons.length ? '' : ' schedule-visual-lesson-cell-empty';
                    return `<td class="schedule-visual-lesson-cell${emptyClass}">${renderVisualCellContent(cell.lessons)}</td>`;
                }).join('')}
            </tr>
        `;
    }

    function buildVisualLessonsByCell(allowedGroupIds) {
        const grouped = new Map();
        const activeWeeks = buildActiveWeeksByRuleSlot();
        rules.forEach(rule => {
            (rule.slots || []).forEach((slot, index) => {
                const slotKey = visualRuleSlotKey(slot, index);
                (rule.groupIds || []).forEach((groupId, groupIndex) => {
                    if (!allowedGroupIds.has(String(groupId))) return;
                    const weeks = activeWeeks.get(activeWeekKey(rule.id, groupId, slotKey)) || [];
                    if (!weeks.length) return;
                    const lesson = {
                        id: `${rule.id}:${slotKey}:${groupId}`,
                        parity: slot.parity || 'BOTH',
                        subjectName: rule.subjectName || 'Без дисциплины',
                        teacherName: slot.teacherName || '',
                        classroomName: slot.classroomName || '',
                        lessonTypeName: slot.lessonTypeName || '',
                        lessonFormat: slot.lessonFormat || '',
                        subgroupNames: slotSubgroupNames(slot),
                        weekText: compactWeekRanges(weeks),
                        groupName: (rule.groupNames || [])[groupIndex] || groupNameById(groupId)
                    };
                    const key = visualCellKey(groupId, slot.dayOfWeek, visualSlotKey(slot));
                    if (!grouped.has(key)) grouped.set(key, []);
                    grouped.get(key).push(lesson);
                });
            });
        });
        grouped.forEach(items => items.sort(compareVisualLessons));
        return grouped;
    }

    function buildActiveWeeksByRuleSlot() {
        const activeWeeks = new Map();
        rules.forEach(rule => {
            const maxWeeks = maxWeeksForRule(rule);
            (rule.groupIds || []).forEach(groupId => {
                LESSON_TYPE_LIMITS.forEach(config => {
                    const totalHours = Number(rule[config.hoursField] || 0);
                    if (totalHours <= 0) return;
                    const categorySlots = (rule.slots || [])
                        .map((slot, index) => ({ slot, index }))
                        .filter(item => lessonTypeKeyById(item.slot.lessonTypeId) === config.key)
                        .sort(compareSlotItems);
                    if (!categorySlots.length) return;

                    let consumedHours = 0;
                    const startWeek = Math.max(1, Number(rule[config.startWeekField] || 1));
                    for (let week = startWeek; week <= maxWeeks && consumedHours < totalHours; week += 1) {
                        for (const item of categorySlots) {
                            if (consumedHours >= totalHours) break;
                            if (!slotAppliesToWeek(item.slot, week)) continue;
                            const key = activeWeekKey(rule.id, groupId, visualRuleSlotKey(item.slot, item.index));
                            if (!activeWeeks.has(key)) activeWeeks.set(key, []);
                            activeWeeks.get(key).push(week);
                            consumedHours += ACADEMIC_HOURS_PER_SLOT;
                        }
                    }
                });
            });
        });
        return activeWeeks;
    }

    function renderVisualCellContent(lessons) {
        if (!lessons.length) return '';
        const oddLessons = lessons.filter(lesson => lesson.parity === 'BOTH' || lesson.parity === 'ODD');
        const evenLessons = lessons.filter(lesson => lesson.parity === 'BOTH' || lesson.parity === 'EVEN');
        const shouldSplit = lessons.some(l => l.parity !== 'BOTH');

        if (!shouldSplit) {
            return `<div class="schedule-visual-unified">${uniqueVisualLessons(lessons).map(renderVisualLesson).join('')}</div>`;
        }

        return CELL_PARITY_LAYOUT.map(({ parity, label }) => {
            const parityLessons = parity === 'ODD' ? oddLessons : evenLessons;
            return `
                <div class="schedule-visual-half schedule-visual-half-${parity.toLowerCase()}">
                    <span class="schedule-visual-half-label">${escapeHtml(label)}</span>
                    ${parityLessons.length ? parityLessons.map(renderVisualLesson).join('') : ''}
                </div>
            `;
        }).join('');
    }

    function uniqueVisualLessons(lessons) {
        const unique = new Map();
        lessons.forEach(lesson => {
            unique.set(visualLessonSignature([lesson]), lesson);
        });
        return Array.from(unique.values()).sort(compareVisualLessons);
    }

    function renderVisualLesson(lesson) {
        const meta = [
            lesson.lessonTypeName,
            lesson.lessonFormat,
            lesson.teacherName,
            lesson.classroomName
        ].filter(Boolean).join(' · ');
        const subgroupText = lesson.subgroupNames.join(', ');
        return `
            <article class="schedule-visual-lesson">
                <strong>${escapeHtml(lesson.subjectName)}${lesson.weekText ? ` <span>${escapeHtml(lesson.weekText)}</span>` : ''}</strong>
                ${subgroupText ? `<small>${escapeHtml(subgroupText)}</small>` : ''}
                ${meta ? `<small>${escapeHtml(meta)}</small>` : ''}
            </article>
        `;
    }

    function collectVisualGroups() {
        const byId = new Map();
        rules.forEach(rule => {
            (rule.groupIds || []).forEach((id, index) => {
                if (!byId.has(String(id))) {
                    byId.set(String(id), {
                        id,
                        name: (rule.groupNames || [])[index] || groupNameById(id)
                    });
                }
            });
        });
        return Array.from(byId.values()).sort((a, b) => naturalCompare(a.name, b.name));
    }

    function collectVisualSlotsFromRules() {
        const byKey = new Map();
        rules.flatMap(rule => rule.slots || []).forEach(slot => {
            const key = visualSlotKey(slot);
            if (!byKey.has(key)) {
                byKey.set(key, {
                    key,
                    orderNumber: slot.timeSlotOrder,
                    orderLabel: slot.timeSlotOrder ? `${slot.timeSlotOrder} пара` : 'Пара',
                    timeLabel: slot.timeSlotLabel || 'Время не указано'
                });
            }
        });
        return Array.from(byKey.values()).sort(compareVisualSlots);
    }

    function visualSlotFromTimeSlot(slot) {
        return {
            key: String(slot.id),
            orderNumber: slot.orderNumber,
            orderLabel: slot.orderNumber ? `${slot.orderNumber} пара` : 'Пара',
            timeLabel: slot.startTime || slot.endTime ? `${trimTime(slot.startTime)}-${trimTime(slot.endTime)}` : 'Время не указано'
        };
    }

    function setVisualState(message) {
        if (!visualStage) return;
        visualStage.innerHTML = `<div class="loading-row schedule-visual-state">${escapeHtml(message)}</div>`;
    }

    function handleVisualGroupFilterChange(event) {
        if (!event.target.matches('input[type="checkbox"]')) return;
        selectedVisualGroupIds = new Set(Array.from(visualGroupFilter.querySelectorAll('input[type="checkbox"]:checked'))
            .map(input => String(input.value)));
        visualGroupFilterTouched = true;
        renderVisualSchedule();
    }

    function syncVisualGroupFilter(allGroups) {
        ensureVisualGroupSelection(allGroups);
        if (!visualGroupFilter) return;
        if (!allGroups.length) {
            visualGroupFilter.innerHTML = '<span class="muted">Нет групп в правилах</span>';
            return;
        }
        visualGroupFilter.innerHTML = allGroups.map(group => {
            const id = String(group.id);
            return `
                <label class="schedule-visual-group-chip">
                    <input type="checkbox" value="${escapeHtml(id)}" ${selectedVisualGroupIds.has(id) ? 'checked' : ''}>
                    <span>${escapeHtml(group.name)}</span>
                </label>
            `;
        }).join('');
    }

    function ensureVisualGroupSelection(allGroups) {
        const availableIds = new Set(allGroups.map(group => String(group.id)));
        selectedVisualGroupIds = new Set(Array.from(selectedVisualGroupIds).filter(id => availableIds.has(id)));
        if (visualGroupFilterTouched) return;

        const formIds = selectedRuleGroupIds()
            .map(String)
            .filter(id => availableIds.has(id));
        if (!visualGroupFilterTouched && formIds.length) {
            selectedVisualGroupIds = new Set(formIds);
            return;
        }

        if (!selectedVisualGroupIds.size && allGroups.length) {
            selectedVisualGroupIds = new Set([String(allGroups[0].id)]);
        }
    }

    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 }));
        });
    }

    function visualCellKey(groupId, dayOfWeek, slotKey) {
        return `${groupId}:${dayOfWeek}:${slotKey}`;
    }

    function visualSlotKey(slot) {
        return String(slot.timeSlotId ?? slot.timeSlotOrder ?? slot.timeSlotLabel ?? 'unknown');
    }

    function visualRuleSlotKey(slot, index) {
        return String(slot.id ?? `${visualSlotKey(slot)}:${slot.dayOfWeek}:${slot.parity}:${index}`);
    }

    function activeWeekKey(ruleId, groupId, slotKey) {
        return `${ruleId}:${groupId}:${slotKey}`;
    }

    function slotAppliesToWeek(slot, week) {
        if (!slot.parity || slot.parity === 'BOTH') return true;
        const weekParity = week % 2 === 0 ? 'EVEN' : 'ODD';
        return slot.parity === weekParity;
    }

    function maxWeeksForRule(rule) {
        const semester = semesters.find(item => String(item.id) === String(rule.semesterId));
        if (semester?.startDate && semester?.endDate) {
            const start = parseIsoDate(semester.startDate);
            const end = parseIsoDate(semester.endDate);
            const days = Math.max(1, Math.round((end - start) / 86400000) + 1);
            return Math.max(1, Math.ceil(days / 7));
        }
        return 18;
    }

    function parseIsoDate(value) {
        const [year, month, day] = String(value).split('-').map(Number);
        return new Date(year, month - 1, day);
    }

    function compactWeekRanges(weeks) {
        const uniqueWeeks = [...new Set((weeks || []).map(Number).filter(Boolean))].sort((a, b) => a - b);
        if (!uniqueWeeks.length) return '';
        return `(${weekRangeText(uniqueWeeks[0], uniqueWeeks[uniqueWeeks.length - 1])})`;
    }

    function weekRangeText(start, end) {
        return start === end
            ? `${start} нед.`
            : `с ${start} по ${end} нед.`;
    }

    function compareSlotItems(first, second) {
        return Number(first.slot.dayOfWeek || 0) - Number(second.slot.dayOfWeek || 0)
            || compareVisualSlots(slotDescriptor(first.slot), slotDescriptor(second.slot))
            || Number(first.index || 0) - Number(second.index || 0);
    }

    function slotDescriptor(slot) {
        return {
            key: visualSlotKey(slot),
            orderNumber: slot.timeSlotOrder,
            timeLabel: slot.timeSlotLabel
        };
    }

    function compareVisualSlots(first, second) {
        const firstOrder = Number(first.orderNumber || first.key);
        const secondOrder = Number(second.orderNumber || second.key);
        if (!Number.isNaN(firstOrder) && !Number.isNaN(secondOrder) && firstOrder !== secondOrder) {
            return firstOrder - secondOrder;
        }
        return naturalCompare(first.timeLabel, second.timeLabel) || naturalCompare(first.key, second.key);
    }

    function compareVisualLessons(first, second) {
        return naturalCompare(first.subjectName, second.subjectName)
            || naturalCompare(first.weekText, second.weekText)
            || naturalCompare(first.lessonTypeName, second.lessonTypeName)
            || naturalCompare(first.teacherName, second.teacherName);
    }

    function visualLessonSignature(lessons) {
        return lessons
            .map(lesson => [
                lesson.id,
                lesson.subjectName,
                lesson.weekText,
                lesson.lessonTypeName,
                lesson.teacherName,
                lesson.classroomName,
                lesson.subgroupNames.join(',')
            ].join(':'))
            .sort((a, b) => naturalCompare(a, b))
            .join('|');
    }

    function groupNameById(id) {
        return groups.find(group => String(group.id) === String(id))?.name || `Группа ${id}`;
    }

    function naturalCompare(a, b) {
        return String(a || '').localeCompare(String(b || ''), 'ru', { numeric: true, sensitivity: 'base' });
    }

    function ruleCountLabel(count) {
        const tail = count % 100;
        if (tail >= 11 && tail <= 14) return 'правил';
        if (count % 10 === 1) return 'правило';
        if ([2, 3, 4].includes(count % 10)) return 'правила';
        return 'правил';
    }

    function groupCountLabel(count) {
        const tail = count % 100;
        if (tail >= 11 && tail <= 14) return 'групп';
        if (count % 10 === 1) return 'группа';
        if ([2, 3, 4].includes(count % 10)) return 'группы';
        return 'групп';
    }

    function rowCountLabel(count) {
        const tail = count % 100;
        if (tail >= 11 && tail <= 14) return 'строк';
        if (count % 10 === 1) return 'строка';
        if ([2, 3, 4].includes(count % 10)) return 'строки';
        return 'строк';
    }
}