сделал просмотр загруженности конкретной аудитории

frontend/admin/js/views/auditorium-workload.js

@@ -2,6 +2,9 @@ import { api } from '../api.js';
 import { escapeHtml, initMultiSelect, showAlert, hideAlert } from '../utils.js';
 
 const NO_BUILDING = '__no_building__';
+const DISPLAY_ALL = 'all';
+const ROOM_PREFIX = 'room:';
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
 const DAY_SHORT_LABELS = {
     1: 'Пн',
@@ -13,6 +16,23 @@ const DAY_SHORT_LABELS = {
     7: 'Вс'
 };
 
+const DAY_FULL_LABELS = {
+    1: 'Понедельник',
+    2: 'Вторник',
+    3: 'Среда',
+    4: 'Четверг',
+    5: 'Пятница',
+    6: 'Суббота',
+    7: 'Воскресенье'
+};
+
+const DAY_ORDER = [1, 2, 3, 4, 5, 6, 7];
+
+const CELL_PARITY_LAYOUT = [
+    { parity: 'ODD', label: 'Нечётная' },
+    { parity: 'EVEN', label: 'Чётная' }
+];
+
 const CAPACITY_BUCKETS = [
     { id: 'small', name: 'До 30 мест', match: capacity => Number(capacity || 0) < 30 },
     { id: 'medium', name: '30 - 60 мест', match: capacity => Number(capacity || 0) >= 30 && Number(capacity || 0) <= 60 },
@@ -23,16 +43,26 @@ const CAPACITY_BUCKETS = [
 export async function initAuditoriumWorkload() {
     const dateInput = document.getElementById('workload-date');
     const refreshButton = document.getElementById('workload-refresh');
+    const displaySelect = document.getElementById('workload-display-select');
     const headerRow = document.getElementById('workload-header-row');
     const tbody = document.getElementById('workload-tbody');
     const summary = document.getElementById('workload-summary');
+    const overviewBlock = document.getElementById('workload-overview-block');
+    const roomBlock = document.getElementById('room-workload-block');
+    const roomSummary = document.getElementById('room-workload-summary');
+    const roomTables = document.getElementById('room-workload-tables');
+    const overviewFilters = Array.from(document.querySelectorAll('.workload-overview-filter'));
+    const dateLabel = dateInput?.closest('.form-group')?.querySelector('label');
 
     let classrooms = [];
     let timeSlots = [];
     let equipments = [];
     let groups = [];
+    let semesters = [];
     let lessonsByRoomSlot = new Map();
     let failedGroupLoads = 0;
+    let currentView = DISPLAY_ALL;
+    let selectedRoomId = null;
 
     setDefaultDate();
     initFilters();
@@ -42,11 +72,7 @@ export async function initAuditoriumWorkload() {
     function setDefaultDate() {
         if (!dateInput || dateInput.value) return;
         const today = new Date();
-        dateInput.value = [
-            today.getFullYear(),
-            String(today.getMonth() + 1).padStart(2, '0'),
-            String(today.getDate()).padStart(2, '0')
-        ].join('-');
+        dateInput.value = formatIsoDate(today);
     }
 
     function initFilters() {
@@ -56,8 +82,13 @@ export async function initAuditoriumWorkload() {
     }
 
     function bindEvents() {
-        refreshButton?.addEventListener('click', loadScheduleForSelectedDate);
-        dateInput?.addEventListener('change', loadScheduleForSelectedDate);
+        refreshButton?.addEventListener('click', loadCurrentView);
+        dateInput?.addEventListener('change', loadCurrentView);
+        displaySelect?.addEventListener('change', () => {
+            applyDisplaySelection();
+            syncDisplayMode();
+            loadCurrentView();
+        });
 
         [
             ['building-checkboxes', 'building-text', 'Все корпуса'],
@@ -67,7 +98,9 @@ export async function initAuditoriumWorkload() {
             const container = document.getElementById(containerId);
             container?.addEventListener('change', () => {
                 updateFilterText(containerId, textId, emptyText);
-                renderGrid();
+                if (currentView === DISPLAY_ALL) {
+                    renderGrid();
+                }
             });
         });
     }
@@ -75,16 +108,44 @@ export async function initAuditoriumWorkload() {
     async function loadInitialData() {
         setTableLoading('Загрузка аудиторий и расписания...');
         try {
-            [classrooms, equipments, groups] = await Promise.all([
+            const [loadedClassrooms, loadedEquipments, loadedGroups, academicYears] = await Promise.all([
                 api.get('/api/classrooms'),
                 api.get('/api/equipments'),
-                api.get('/api/groups')
+                api.get('/api/groups'),
+                api.get('/api/admin/calendar/years').catch(() => [])
             ]);
-            classrooms = [...classrooms].sort((a, b) => naturalCompare(a.name, b.name));
+            classrooms = [...loadedClassrooms].sort((a, b) => naturalCompare(a.name, b.name));
+            equipments = loadedEquipments;
+            groups = loadedGroups;
+            semesters = (academicYears || []).flatMap(year => year.semesters || []);
             populateFilters();
-            await loadScheduleForSelectedDate();
+            populateDisplayOptions();
+            applyDisplaySelection();
+            syncDisplayMode();
+            await loadCurrentView();
         } catch (error) {
-            setTableError(error.message || 'Ошибка загрузки данных загруженности аудиторий');
+            const message = error.message || 'Ошибка загрузки данных загруженности аудиторий';
+            setTableError(message);
+            setRoomError(message);
+        }
+    }
+
+    async function loadCurrentView() {
+        applyDisplaySelection();
+        syncDisplayMode();
+        try {
+            if (currentView === DISPLAY_ALL) {
+                await loadScheduleForSelectedDate();
+            } else {
+                await loadRoomWorkload();
+            }
+        } catch (error) {
+            const message = error.message || 'Ошибка загрузки загруженности аудиторий';
+            if (currentView === DISPLAY_ALL) {
+                setTableError(message);
+            } else {
+                setRoomError(message);
+            }
         }
     }
 
@@ -96,6 +157,7 @@ export async function initAuditoriumWorkload() {
         }
 
         hideAlert('workload-alert');
+        failedGroupLoads = 0;
         setTableLoading('Загрузка расписания на выбранную дату...');
         timeSlots = await api.get(`/api/admin/time-slots/effective?date=${encodeURIComponent(date)}`);
 
@@ -106,21 +168,15 @@ export async function initAuditoriumWorkload() {
             return;
         }
 
-        const params = group => new URLSearchParams({
-            groupId: String(group.id),
-            startDate: date,
-            endDate: date
-        }).toString();
-
         const responses = await Promise.allSettled(
-            groups.map(group => api.get(`/api/schedule?${params(group)}`))
+            groups.map(group => api.get(`/api/schedule?${scheduleParams(group, date, date)}`))
         );
         failedGroupLoads = responses.filter(response => response.status === 'rejected').length;
         const lessons = responses
             .filter(response => response.status === 'fulfilled')
             .flatMap(response => response.value || []);
 
-        lessonsByRoomSlot = groupLessons(lessons);
+        lessonsByRoomSlot = groupLessonsByRoomSlot(lessons);
         renderGrid();
 
         if (failedGroupLoads > 0) {
@@ -128,6 +184,105 @@ export async function initAuditoriumWorkload() {
         }
     }
 
+    async function loadRoomWorkload() {
+        const date = dateInput?.value;
+        const room = selectedRoom();
+        if (!date) {
+            showAlert('workload-alert', 'Выберите дату', 'error');
+            setRoomError('Выберите дату для расчёта двухнедельного периода');
+            return;
+        }
+        if (!room) {
+            showAlert('workload-alert', 'Выберите аудиторию', 'error');
+            setRoomError('Выберите аудиторию в поле «Отображение»');
+            return;
+        }
+
+        hideAlert('workload-alert');
+        setRoomLoading('Загрузка расписания аудитории на две недели...');
+        const range = twoWeekRange(date);
+        const dates = datesBetween(range.startDate, range.endDate);
+        const [slotLoad, lessonLoad] = await Promise.all([
+            loadSlotsForDates(dates),
+            loadRoomLessons(range, room.id)
+        ]);
+
+        renderRoomWorkload(room, range, dates, slotLoad.slotsByDate, lessonLoad.lessons, lessonLoad.lessonsByDateSlot, {
+            failedSlotLoads: slotLoad.failedLoads,
+            failedGroupLoads: lessonLoad.failedLoads,
+            parityLessons: lessonLoad.parityLessons
+        });
+
+        const warnings = [];
+        if (lessonLoad.failedLoads > 0) warnings.push(`групп не загрузилось: ${lessonLoad.failedLoads}`);
+        if (slotLoad.failedLoads > 0) warnings.push(`сеток времени не загрузилось: ${slotLoad.failedLoads}`);
+        if (warnings.length) {
+            showAlert('workload-alert', `Часть данных не загрузилась (${warnings.join(', ')}). Показаны доступные данные.`, 'error');
+        }
+    }
+
+    async function loadSlotsForDates(dates) {
+        const responses = await Promise.allSettled(
+            dates.map(date => api.get(`/api/admin/time-slots/effective?date=${encodeURIComponent(date)}`))
+        );
+        const slotsByDate = new Map();
+        responses.forEach((response, index) => {
+            const slots = response.status === 'fulfilled' ? response.value || [] : [];
+            slotsByDate.set(dates[index], [...slots].sort(compareSlots));
+        });
+        return {
+            slotsByDate,
+            failedLoads: responses.filter(response => response.status === 'rejected').length
+        };
+    }
+
+    async function loadRoomLessons(range, roomId) {
+        if (!groups.length) {
+            return {
+                lessons: [],
+                lessonsByDateSlot: new Map(),
+                parityLessons: [],
+                failedLoads: 0
+            };
+        }
+
+        const responses = await Promise.allSettled(
+            groups.map(group => api.get(`/api/schedule?${scheduleParams(group, range.startDate, range.endDate)}`))
+        );
+        const parityLessons = responses
+            .filter(response => response.status === 'fulfilled')
+            .flatMap(response => response.value || []);
+        const lessons = uniqueLessons(
+            parityLessons.filter(lesson => sameId(lesson.classroomId, roomId))
+        );
+        const lessonsByDateSlot = new Map();
+        lessons.forEach(lesson => {
+            const slotKey = lessonSlotKey(lesson);
+            if (!lesson.date || slotKey == null) return;
+            const key = dateSlotKey(lesson.date, slotKey);
+            if (!lessonsByDateSlot.has(key)) lessonsByDateSlot.set(key, []);
+            lessonsByDateSlot.get(key).push(lesson);
+        });
+        lessonsByDateSlot.forEach(items => {
+            items.sort((a, b) => naturalCompare(a.subjectName, b.subjectName));
+        });
+
+        return {
+            lessons,
+            lessonsByDateSlot,
+            parityLessons,
+            failedLoads: responses.filter(response => response.status === 'rejected').length
+        };
+    }
+
+    function scheduleParams(group, startDate, endDate) {
+        return new URLSearchParams({
+            groupId: String(group.id),
+            startDate,
+            endDate
+        }).toString();
+    }
+
     function populateFilters() {
         renderCheckboxes(
             'building-checkboxes',
@@ -153,6 +308,49 @@ export async function initAuditoriumWorkload() {
         updateFilterText('equipment-checkboxes', 'equipment-text', 'Любое оборудование');
     }
 
+    function populateDisplayOptions() {
+        if (!displaySelect) return;
+        const selectedValue = displaySelect.value;
+        displaySelect.innerHTML = '';
+        displaySelect.append(new Option('Все аудитории', DISPLAY_ALL));
+        classrooms.forEach(room => {
+            const details = [room.building, room.floor ? `${room.floor} этаж` : null].filter(Boolean).join(', ');
+            const suffix = details ? ` · ${details}` : '';
+            displaySelect.append(new Option(`${room.name}${suffix}`, `${ROOM_PREFIX}${room.id}`));
+        });
+        if (selectedValue && Array.from(displaySelect.options).some(option => option.value === selectedValue)) {
+            displaySelect.value = selectedValue;
+        }
+    }
+
+    function applyDisplaySelection() {
+        const value = displaySelect?.value || DISPLAY_ALL;
+        if (value.startsWith(ROOM_PREFIX)) {
+            currentView = 'room';
+            selectedRoomId = value.slice(ROOM_PREFIX.length);
+            return;
+        }
+        currentView = DISPLAY_ALL;
+        selectedRoomId = null;
+    }
+
+    function syncDisplayMode() {
+        const roomMode = currentView !== DISPLAY_ALL;
+        overviewFilters.forEach(filter => {
+            filter.hidden = roomMode;
+        });
+        if (overviewBlock) overviewBlock.hidden = roomMode;
+        if (roomBlock) roomBlock.hidden = !roomMode;
+        if (dateLabel) {
+            dateLabel.textContent = roomMode ? 'Дата в периоде' : 'Дата';
+        }
+    }
+
+    function selectedRoom() {
+        if (!selectedRoomId) return null;
+        return classrooms.find(room => sameId(room.id, selectedRoomId)) || null;
+    }
+
     function buildingOptions() {
         const values = new Map();
         classrooms.forEach(room => {
@@ -193,7 +391,7 @@ export async function initAuditoriumWorkload() {
         `).join('');
     }
 
-    function groupLessons(lessons) {
+    function uniqueLessons(lessons) {
         const unique = new Map();
         lessons.forEach(lesson => {
             if (!lesson.classroomId || !lesson.timeSlotId) return;
@@ -209,17 +407,24 @@ export async function initAuditoriumWorkload() {
             if (existing) {
                 existing.groupNames = mergeNames(existing.groupNames, lesson.groupNames);
                 existing.groupIds = mergeIds(existing.groupIds, lesson.groupIds);
+                existing.subgroupNames = mergeNames(existing.subgroupNames, lesson.subgroupNames);
+                existing.subgroupIds = mergeIds(existing.subgroupIds, lesson.subgroupIds);
                 return;
             }
             unique.set(key, {
                 ...lesson,
                 groupNames: [...(lesson.groupNames || [])],
-                groupIds: [...(lesson.groupIds || [])]
+                groupIds: [...(lesson.groupIds || [])],
+                subgroupNames: [...(lesson.subgroupNames || [])],
+                subgroupIds: [...(lesson.subgroupIds || [])]
             });
         });
+        return Array.from(unique.values());
+    }
 
+    function groupLessonsByRoomSlot(lessons) {
         const grouped = new Map();
-        unique.forEach(lesson => {
+        uniqueLessons(lessons).forEach(lesson => {
             const key = roomSlotKey(lesson.classroomId, lesson.timeSlotId);
             if (!grouped.has(key)) grouped.set(key, []);
             grouped.get(key).push(lesson);
@@ -288,11 +493,298 @@ export async function initAuditoriumWorkload() {
         });
     }
 
+    function renderRoomWorkload(room, range, dates, slotsByDate, lessons, lessonsByDateSlot, failures) {
+        const slotRows = buildSlotRows(dates, slotsByDate, lessons);
+        const dateGrid = buildDateGridByDay(dates, failures.parityLessons || lessons);
+        renderRoomSummary(room, range, dates, slotsByDate, lessonsByDateSlot, failures, dateGrid.unknownParityDates);
+
+        if (!slotRows.length) {
+            roomTables.innerHTML = '<div class="loading-row room-workload-state">За выбранный период нет временных слотов</div>';
+            return;
+        }
+
+        roomTables.innerHTML = renderRoomCombinedWeekTable(dateGrid.datesByDay, slotRows, slotsByDate, lessonsByDateSlot);
+    }
+
+    function renderRoomSummary(room, range, dates, slotsByDate, lessonsByDateSlot, failures, unknownParityDates) {
+        if (!roomSummary) return;
+        const totalCells = countAvailableRoomCells(dates, slotsByDate, lessonsByDateSlot);
+        const occupiedCells = countOccupiedRoomCells(lessonsByDateSlot);
+        const percent = totalCells ? Math.round((occupiedCells / totalCells) * 100) : 0;
+        const roomMeta = [
+            room.capacity ? `${room.capacity} мест` : null,
+            room.building || null,
+            room.floor ? `${room.floor} этаж` : null
+        ].filter(Boolean).join(', ');
+        const warnings = [];
+        if (failures.failedGroupLoads) warnings.push(`ошибок групп: ${failures.failedGroupLoads}`);
+        if (failures.failedSlotLoads) warnings.push(`ошибок сеток: ${failures.failedSlotLoads}`);
+        if (unknownParityDates) warnings.push('часть дат вне семестра');
+
+        roomSummary.innerHTML = `
+            <div class="room-summary-main">
+                <strong>${escapeHtml(room.name)}</strong>
+                ${roomMeta ? `<span>${escapeHtml(roomMeta)}</span>` : ''}
+            </div>
+            <span class="room-summary-chip">${escapeHtml(formatDate(range.startDate))} - ${escapeHtml(formatDate(range.endDate))}</span>
+            <span class="room-summary-chip">Занято: ${occupiedCells} из ${totalCells} (${percent}%)</span>
+            ${warnings.length ? `<span class="room-summary-warning">${escapeHtml(warnings.join(', '))}</span>` : ''}
+        `;
+    }
+
+    function renderRoomCombinedWeekTable(datesByDay, slotRows, slotsByDate, lessonsByDateSlot) {
+        const dayHeaders = DAY_ORDER.map(day => `
+            <th class="room-day-cell">
+                <strong>${escapeHtml(dayShort(day))}</strong>
+                <span>${escapeHtml(DAY_FULL_LABELS[day] || '')}</span>
+                <div class="room-day-parity-dates">
+                    ${CELL_PARITY_LAYOUT.map(({ parity, label }) => renderDayParityDate(datesByDay[day]?.[parity], label)).join('')}
+                </div>
+            </th>
+        `).join('');
+        const rows = slotRows.map(row => `
+            <tr>
+                <td class="room-time-cell">
+                    <strong>${escapeHtml(row.orderLabel)}</strong>
+                    <span>${escapeHtml(row.timeLabel)}</span>
+                </td>
+                ${DAY_ORDER.map(day => renderRoomCombinedSlotCell(datesByDay[day] || {}, row, slotsByDate, lessonsByDateSlot)).join('')}
+            </tr>
+        `).join('');
+
+        return `
+            <section class="room-week-panel">
+                <div class="room-week-heading">
+                    <h3>Нагрузка аудитории по неделям</h3>
+                    <span>${escapeHtml(roomWeekCaption(datesByDay))}</span>
+                </div>
+                <div class="workload-grid-container room-grid-container">
+                    <table class="workload-table room-week-table">
+                        <thead>
+                            <tr>
+                                <th class="room-time-heading">Время</th>
+                                ${dayHeaders}
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${rows}
+                        </tbody>
+                    </table>
+                </div>
+            </section>
+        `;
+    }
+
+    function renderDayParityDate(date, label) {
+        return `<span>${escapeHtml(label)}: ${date ? escapeHtml(formatDateShort(date)) : '-'}</span>`;
+    }
+
+    function renderRoomCombinedSlotCell(datesByParity, row, slotsByDate, lessonsByDateSlot) {
+        const states = CELL_PARITY_LAYOUT.map(({ parity, label }) => ({
+            parity,
+            label,
+            state: roomSlotState(datesByParity[parity], row, slotsByDate, lessonsByDateSlot)
+        }));
+
+        if (roomSlotStatesEqual(states[0].state, states[1].state)) {
+            return `<td class="room-combined-cell room-single-cell">${renderRoomUnifiedSlot(states[0].state)}</td>`;
+        }
+
+        const halves = states.map(({ parity, label, state }) =>
+            renderRoomSlotHalf(state, parity, label)
+        ).join('');
+        return `<td class="room-combined-cell">${halves}</td>`;
+    }
+
+    function roomSlotState(date, row, slotsByDate, lessonsByDateSlot) {
+        if (!date) {
+            return { kind: 'empty', lessons: [] };
+        }
+
+        const key = dateSlotKey(date, row.key);
+        const lessons = lessonsByDateSlot.get(key) || [];
+        const slotExists = hasSlotForDate(date, row.key, slotsByDate) || lessons.length > 0;
+        if (lessons.length) {
+            return { kind: 'busy', lessons };
+        }
+        if (!slotExists) {
+            return { kind: 'missing', lessons: [] };
+        }
+        return { kind: 'free', lessons: [] };
+    }
+
+    function renderRoomUnifiedSlot(state) {
+        if (state.kind === 'busy') {
+            return `<div class="room-week-unified room-week-unified-busy">${state.lessons.map(renderLessonCard).join('')}</div>`;
+        }
+        if (state.kind === 'missing') {
+            return '<div class="room-week-unified room-week-unified-missing"><span class="slot-unavailable">Нет слота</span></div>';
+        }
+        if (state.kind === 'empty') {
+            return '<div class="room-week-unified room-week-unified-empty"><span class="slot-unavailable">Нет даты</span></div>';
+        }
+        return '<div class="room-week-unified room-week-unified-free"><span class="free-slot">Свободно</span></div>';
+    }
+
+    function renderRoomSlotHalf(state, parity, label) {
+        if (state.kind === 'busy') {
+            return `
+                <div class="room-week-half room-week-half-${parity.toLowerCase()} room-week-half-busy">
+                    <span class="room-half-marker">${escapeHtml(label)}</span>
+                    ${state.lessons.map(renderLessonCard).join('')}
+                </div>
+            `;
+        }
+        if (state.kind === 'missing') {
+            return `
+                <div class="room-week-half room-week-half-${parity.toLowerCase()} room-week-half-missing">
+                    <span class="room-half-marker">${escapeHtml(label)}</span>
+                    <span class="slot-unavailable">Нет слота</span>
+                </div>
+            `;
+        }
+        if (state.kind === 'empty') {
+            return `
+                <div class="room-week-half room-week-half-${parity.toLowerCase()} room-week-half-empty">
+                    <span class="room-half-marker">${escapeHtml(label)}</span>
+                    <span class="slot-unavailable">Нет даты</span>
+                </div>
+            `;
+        }
+        return `
+            <div class="room-week-half room-week-half-${parity.toLowerCase()} room-week-half-free">
+                <span class="room-half-marker">${escapeHtml(label)}</span>
+                <span class="free-slot">Свободно</span>
+            </div>
+        `;
+    }
+
+    function roomSlotStatesEqual(first, second) {
+        if (first.kind !== second.kind) return false;
+        if (first.kind !== 'busy') return true;
+        return lessonSetSignature(first.lessons) === lessonSetSignature(second.lessons);
+    }
+
+    function lessonSetSignature(lessons) {
+        return lessons
+            .map(lessonContentSignature)
+            .sort((a, b) => naturalCompare(a, b))
+            .join('|');
+    }
+
+    function lessonContentSignature(lesson) {
+        return [
+            lesson.scheduleRuleSlotId || lesson.scheduleRuleId || '',
+            lesson.subjectId || lesson.subjectName || '',
+            lesson.teacherId || lesson.teacherName || '',
+            lesson.lessonTypeId || lesson.lessonTypeName || '',
+            lesson.lessonFormat || '',
+            valueListSignature(lesson.groupIds, lesson.groupNames),
+            valueListSignature(lesson.subgroupIds, lesson.subgroupNames)
+        ].join(':');
+    }
+
+    function valueListSignature(primary = [], fallback = []) {
+        const primaryList = Array.isArray(primary) ? primary : [];
+        const fallbackList = Array.isArray(fallback) ? fallback : [];
+        const source = primaryList.length ? primaryList : fallbackList;
+        return [...source]
+            .map(value => String(value))
+            .sort((a, b) => naturalCompare(a, b))
+            .join(',');
+    }
+
+    function buildSlotRows(dates, slotsByDate, lessons) {
+        const rows = new Map();
+        dates.forEach(date => {
+            (slotsByDate.get(date) || []).forEach(slot => {
+                const key = slotOrderKey(slot);
+                if (key == null) return;
+                putSlotRow(rows, key, slot.orderNumber, slot.startTime, slot.endTime);
+            });
+        });
+        lessons.forEach(lesson => {
+            const key = lessonSlotKey(lesson);
+            if (key == null) return;
+            putSlotRow(rows, key, lesson.timeSlotOrder, lesson.startTime, lesson.endTime);
+        });
+        return Array.from(rows.values()).sort(compareSlotRows);
+    }
+
+    function putSlotRow(rows, key, orderNumber, startTime, endTime) {
+        const existing = rows.get(key);
+        const next = {
+            key,
+            orderNumber,
+            startTime,
+            endTime,
+            orderLabel: orderNumber ? `${orderNumber} пара` : 'Пара',
+            timeLabel: startTime || endTime ? `${trimTime(startTime)}-${trimTime(endTime)}` : 'Время не указано'
+        };
+        if (!existing || existing.timeLabel === 'Время не указано') {
+            rows.set(key, next);
+        }
+    }
+
+    function buildDateGridByDay(dates, lessons) {
+        const datesByDay = {};
+        let unknownParityDates = 0;
+        dates.forEach((date, index) => {
+            let parity = parityForDate(date, lessons);
+            if (!parity) {
+                unknownParityDates += 1;
+                parity = index < 7 ? 'ODD' : 'EVEN';
+            }
+            const day = isoDay(date);
+            if (!datesByDay[day]) datesByDay[day] = {};
+            datesByDay[day][parity] = date;
+        });
+        return { datesByDay, unknownParityDates };
+    }
+
+    function parityForDate(date, lessons) {
+        const lessonParity = lessons.find(lesson => lesson.date === date && ['ODD', 'EVEN'].includes(lesson.parity))?.parity;
+        if (lessonParity) return lessonParity;
+        const weekNumber = weekNumberForDate(date);
+        if (!weekNumber) return null;
+        return weekNumber % 2 === 0 ? 'EVEN' : 'ODD';
+    }
+
+    function weekNumberForDate(date) {
+        const semester = semesters.find(item => item.startDate <= date && item.endDate >= date);
+        if (!semester) return null;
+        const days = Math.floor((parseIsoDate(date) - parseIsoDate(semester.startDate)) / MS_PER_DAY);
+        return Math.floor(days / 7) + 1;
+    }
+
+    function uniqueWeekNumbers(dates) {
+        return Array.from(new Set(dates.map(weekNumberForDate).filter(Boolean)))
+            .sort((a, b) => a - b);
+    }
+
+    function roomWeekCaption(datesByDay) {
+        return CELL_PARITY_LAYOUT
+            .map(({ parity, label }) => {
+                const dates = DAY_ORDER.map(day => datesByDay[day]?.[parity]).filter(Boolean);
+                const weeks = uniqueWeekNumbers(dates);
+                const weekText = weeks.length ? `учебная неделя ${weeks.join(', ')}` : 'неделя вне семестра';
+                const positionText = parity === 'ODD' ? 'сверху' : 'снизу';
+                return `${label} ${positionText}, ${weekText}`;
+            })
+            .join('; ');
+    }
+
+    function hasSlotForDate(date, key, slotsByDate) {
+        return (slotsByDate.get(date) || []).some(slot => slotOrderKey(slot) === key);
+    }
+
     function renderLessonCard(lesson) {
+        const subgroupText = (lesson.subgroupNames || []).join(', ');
         return `
             <div class="lesson-card">
                 <div class="lesson-subject">${escapeHtml(lesson.subjectName || 'Без дисциплины')}</div>
                 <div class="lesson-group">${escapeHtml((lesson.groupNames || []).join(', ') || 'Группа не указана')}</div>
+                ${subgroupText ? `<div class="lesson-subgroup">${escapeHtml(subgroupText)}</div>` : ''}
                 <div class="lesson-teacher">${escapeHtml(lesson.teacherName || 'Преподаватель не указан')}</div>
                 <div class="lesson-meta">${escapeHtml([lesson.lessonTypeName, lesson.lessonFormat].filter(Boolean).join(' · '))}</div>
             </div>
@@ -349,6 +841,17 @@ export async function initAuditoriumWorkload() {
         showAlert('workload-alert', message, 'error');
     }
 
+    function setRoomLoading(message) {
+        if (roomSummary) roomSummary.textContent = '';
+        if (roomTables) roomTables.innerHTML = `<div class="loading-row room-workload-state">${escapeHtml(message)}</div>`;
+    }
+
+    function setRoomError(message) {
+        if (roomSummary) roomSummary.textContent = '';
+        if (roomTables) roomTables.innerHTML = `<div class="loading-row room-workload-state">${escapeHtml(message)}</div>`;
+        showAlert('workload-alert', message, 'error');
+    }
+
     function renderSummary(roomCount, occupiedCells, totalCells) {
         if (!summary) return;
         const percent = totalCells ? Math.round((occupiedCells / totalCells) * 100) : 0;
@@ -364,10 +867,40 @@ export async function initAuditoriumWorkload() {
         ).length, 0);
     }
 
+    function countAvailableRoomCells(dates, slotsByDate, lessonsByDateSlot) {
+        return dates.reduce((count, date) => {
+            const keys = new Set((slotsByDate.get(date) || []).map(slotOrderKey).filter(key => key != null));
+            lessonsByDateSlot.forEach((items, key) => {
+                if (items.length && key.startsWith(`${date}:`)) {
+                    keys.add(key.slice(date.length + 1));
+                }
+            });
+            return count + keys.size;
+        }, 0);
+    }
+
+    function countOccupiedRoomCells(lessonsByDateSlot) {
+        return Array.from(lessonsByDateSlot.values()).filter(items => items.length > 0).length;
+    }
+
     function roomSlotKey(roomId, timeSlotId) {
         return `${roomId}:${timeSlotId}`;
     }
 
+    function dateSlotKey(date, slotKey) {
+        return `${date}:${slotKey}`;
+    }
+
+    function slotOrderKey(slot) {
+        const value = slot?.orderNumber ?? slot?.timeSlotOrder ?? slot?.id;
+        return value == null ? null : String(value);
+    }
+
+    function lessonSlotKey(lesson) {
+        const value = lesson?.timeSlotOrder ?? lesson?.timeSlotId;
+        return value == null ? null : String(value);
+    }
+
     function buildingKey(room) {
         return room.building ? String(room.building) : NO_BUILDING;
     }
@@ -386,9 +919,7 @@ export async function initAuditoriumWorkload() {
 
     function selectedIsoDay() {
         if (!dateInput?.value) return null;
-        const date = new Date(`${dateInput.value}T00:00:00`);
-        const day = date.getDay();
-        return day === 0 ? 7 : day;
+        return isoDay(dateInput.value);
     }
 
     function scopeShort(slot) {
@@ -402,15 +933,81 @@ export async function initAuditoriumWorkload() {
         return DAY_SHORT_LABELS[Number(dayOfWeek)] || '-';
     }
 
+    function isoDay(value) {
+        const day = parseIsoDate(value).getDay();
+        return day === 0 ? 7 : day;
+    }
+
+    function twoWeekRange(value) {
+        const selected = parseIsoDate(value);
+        const start = addDays(selected, 1 - isoDay(value));
+        const end = addDays(start, 13);
+        return {
+            startDate: formatIsoDate(start),
+            endDate: formatIsoDate(end)
+        };
+    }
+
+    function datesBetween(startDate, endDate) {
+        const dates = [];
+        for (let date = parseIsoDate(startDate); date <= parseIsoDate(endDate); date = addDays(date, 1)) {
+            dates.push(formatIsoDate(date));
+        }
+        return dates;
+    }
+
+    function parseIsoDate(value) {
+        const [year, month, day] = String(value).split('-').map(Number);
+        return new Date(year, month - 1, day);
+    }
+
+    function addDays(date, days) {
+        const next = new Date(date);
+        next.setDate(next.getDate() + days);
+        return next;
+    }
+
     function trimTime(value) {
         return value ? String(value).slice(0, 5) : '';
     }
 
+    function formatIsoDate(date) {
+        return [
+            date.getFullYear(),
+            String(date.getMonth() + 1).padStart(2, '0'),
+            String(date.getDate()).padStart(2, '0')
+        ].join('-');
+    }
+
     function formatDate(value) {
         const [year, month, day] = String(value).split('-');
         return `${day}.${month}.${year}`;
     }
 
+    function formatDateShort(value) {
+        const [, month, day] = String(value).split('-');
+        return `${day}.${month}`;
+    }
+
+    function compareSlots(a, b) {
+        return Number(a.orderNumber || 0) - Number(b.orderNumber || 0)
+            || naturalCompare(a.startTime, b.startTime);
+    }
+
+    function compareSlotRows(a, b) {
+        const first = Number(a.orderNumber || a.key);
+        const second = Number(b.orderNumber || b.key);
+        if (!Number.isNaN(first) && !Number.isNaN(second) && first !== second) {
+            return first - second;
+        }
+        return naturalCompare(a.startTime, b.startTime)
+            || naturalCompare(a.key, b.key);
+    }
+
+    function sameId(first, second) {
+        return String(first) === String(second);
+    }
+
     function naturalCompare(a, b) {
         return String(a || '').localeCompare(String(b || ''), 'ru', { numeric: true, sensitivity: 'base' });
     }