"""
Разбор и вывод содержимого клетки табеля и графика.

Смысл: начальник РЦ печатает в клетке то же, что печатал в таблице, а система
раскладывает это на структурированные поля. Поддерживаются оба привычных
формата и новые, которых в таблице выразить было нельзя.

Табель, дневная половина клетки:
    11          11 часов днём
    4/7         4 часа днём и 7 ночью
    В О Б К     код дня, полный список — на странице табеля
    РВ 4        4 часа, всё — работа в выходной
    4 С         4 часа, всё — сверхурочные
    10 С 3      10 часов, из них 3 сверхурочные
    РВ 2 1      2 часа, из них 1 — работа в выходной
    Я9 Н5 С4    итог дня как в старой программе: явка 9 часов,
                из них 5 ночных и 4 сверхурочных
    (пусто)     день не заполнен

Табель, ночная половина клетки:
    7           7 часов ночью
    РВ 5        5 ночных часов, и все они — работа в выходной
    С 4         4 ночных часа, и все они — сверхурочные

Сверхурочные и работа в выходной — признаки СУТОК, а не половины клетки:
вызов на ночь даёт «4 С 8» в дневной колонке при восьми ночных часах, то есть
12 отработанных за сутки, из них 8 сверхурочных.

График:
    09:00-21:00 смена
    9-21        то же короткой записью
    20:00-08:00 ночная смена, переходящая через полночь
    В О Б       код дня
"""

from __future__ import annotations

import re
from dataclasses import dataclass
from datetime import time

# Коды, которые можно поставить в клетку. Часы работы (Я, Н, С, РВ) сюда не
# входят: они вводятся числами — «11», «4/7», «РВ 4», «4 С». Полный справочник
# с пояснениями — в таблице app.day_code и на странице табеля.
#
# Сравнение точное, целиком по клетке, поэтому «О» и «ОБ» не конфликтуют.
DAY_CODES = (
    "В", "П", "ОД", "ДО",
    "А", "ОЖ", "О", "У", "Р",
    "Б", "Т", "К", "Г", "ГЧ", "ПВ", "ПР", "НН",
    #  «ОБ» означало то же, что «А». Решением от 14.09.2026 в ООУРЦ пишут
    #  «А», а «ОБ» убрано из справочника (миграция 31). Разбор его всё ещё
    #  понимает: в базе, где миграцию не накатили, дни с «ОБ» должны
    #  читаться, а не падать
    "ОБ",
)

_NUM = r"\d+(?:[.,]\d+)?"
_RE_WEEKEND = re.compile(rf"^РВ\s*({_NUM})$", re.IGNORECASE)
_RE_OVERTIME = re.compile(rf"^({_NUM})\s*С$", re.IGNORECASE)
#  «С 4» — буква впереди, как «РВ 4» (23.09.2026). Раньше принималось только
#  «4 С», и привычная запись отклонялась с ошибкой
_RE_OVERTIME_LEAD = re.compile(rf"^С\s*({_NUM})$", re.IGNORECASE)
# «10 С 3» — всего 10 часов, из них 3 сверхурочных. Так записывают смену со
# сверхурочкой: 06:00–14:00 по графику (7 часов за вычетом перерыва) плюс
# 3 часа сверх — в клетке 10, из них 3 сверхурочные.
_RE_OVERTIME_PART = re.compile(rf"^({_NUM})\s*С\s*({_NUM})$", re.IGNORECASE)
# «РВ 2 1» — 2 часа, из них 1 работа в выходной. Встречается реже, но
# записывается по тому же правилу, что и сверхурочные.
_RE_WEEKEND_PART = re.compile(rf"^РВ\s*({_NUM})\s+({_NUM})$", re.IGNORECASE)
#  «8 РВ3» — так клетка показывается, когда в выходной пришлась часть часов
#  (23.09.2026). Показанное должно приниматься обратно как есть: иначе
#  открыл клетку, ничего не поменял, ушёл — и получил ошибку
_RE_WEEKEND_TAIL = re.compile(rf"^({_NUM})\s*РВ\s*({_NUM})$", re.IGNORECASE)
# «Я9 Н5 С4» — так итог дня показывает старая программа: явка 9 часов, из них
# 5 ночных и 4 сверхурочных. Разбираем и это: удобно перенести день как есть.
_RE_PROGRAM_TOKEN = re.compile(rf"(Я|Н|С|РВ)\s*({_NUM})", re.IGNORECASE)
_RE_PAIR = re.compile(rf"^({_NUM})\s*/\s*({_NUM})$")
_RE_SINGLE = re.compile(rf"^({_NUM})$")
_RE_SHIFT = re.compile(
    r"^(\d{1,2})(?::(\d{2}))?\s*[-–—]\s*(\d{1,2})(?::(\d{2}))?$"
)


class CellError(ValueError):
    """Клетку не удалось разобрать."""


@dataclass(frozen=True)
class FactCell:
    """Разобранная клетка фактического табеля."""

    day_code: str | None = None
    hours_day: float = 0.0
    hours_night: float = 0.0
    hours_weekend: float = 0.0
    hours_overtime: float = 0.0

    @property
    def is_empty(self) -> bool:
        return self.day_code is None and self.hours_day == 0 and self.hours_night == 0

    @property
    def worked(self) -> float:
        return round(self.hours_day + self.hours_night, 2)


@dataclass(frozen=True)
class PlanCell:
    """
    Разобранная клетка планового графика.

    В клетке бывает две записи времени. Рабочее время ведётся сутками, и на
    стыке месяцев работа с 20:00 до 08:00 записывается двумя частями: «20:00
    - 24:00» в закрываемом месяце и «00:00 - 08:00» в новом. Если в этот же
    день человек снова выходит в ночь, в клетке стоят обе записи —
    «00:00 - 08:00/20:00 - 08:00»: сначала то, что дорабатывается с прошлых
    суток, потом то, что начинается в эти.

    Третьей записи быть не может: сутки закончатся раньше.
    """

    day_code: str | None = None
    shift_start: time | None = None
    shift_end: time | None = None
    shift2_start: time | None = None
    shift2_end: time | None = None

    @property
    def is_empty(self) -> bool:
        return self.day_code is None and self.shift_start is None

    @property
    def intervals(self) -> list[tuple[time, time]]:
        """Записи времени клетки по порядку — одна или две."""
        out = []
        if self.shift_start is not None and self.shift_end is not None:
            out.append((self.shift_start, self.shift_end))
        if self.shift2_start is not None and self.shift2_end is not None:
            out.append((self.shift2_start, self.shift2_end))
        return out


def _num(text: str) -> float:
    return float(text.replace(",", "."))


def _normalize_code(text: str) -> str | None:
    upper = text.upper().replace("Ё", "Е").strip()
    for code in DAY_CODES:
        if upper == code.upper().replace("Ё", "Е"):
            return code
    return None


def parse_fact_cell(raw: str | None) -> FactCell:
    """Разобрать клетку табеля. Пустая строка означает «день не заполнен»."""
    if raw is None:
        return FactCell()
    text = " ".join(str(raw).split())
    if not text:
        return FactCell()

    code = _normalize_code(text)
    if code:
        return FactCell(day_code=code)

    program = _parse_program_cell(text)
    if program is not None:
        return program

    m = _RE_OVERTIME_PART.match(text)
    if m:
        hours, overtime = _num(m.group(1)), _num(m.group(2))
        _check_hours(hours)
        # Сверхурочные могут быть больше дневных часов: они относятся ко всем
        # суткам, а в дневной колонке стоит только дневная их часть. Так и
        # записывают вызов на ночь: «4 С 8» днём и 8 часов в ночной колонке.
        _check_hours(overtime)
        return FactCell(hours_day=hours, hours_overtime=overtime)

    m = _RE_WEEKEND_PART.match(text) or _RE_WEEKEND_TAIL.match(text)
    if m:
        hours, weekend = _num(m.group(1)), _num(m.group(2))
        _check_hours(hours)
        _check_hours(weekend)
        return FactCell(hours_day=hours, hours_weekend=weekend)

    m = _RE_WEEKEND.match(text)
    if m:
        hours = _num(m.group(1))
        _check_hours(hours)
        return FactCell(hours_day=hours, hours_weekend=hours)

    m = _RE_OVERTIME.match(text) or _RE_OVERTIME_LEAD.match(text)
    if m:
        hours = _num(m.group(1))
        _check_hours(hours)
        return FactCell(hours_day=hours, hours_overtime=hours)

    m = _RE_PAIR.match(text)
    if m:
        d, n = _num(m.group(1)), _num(m.group(2))
        _check_hours(d + n)
        return FactCell(hours_day=d, hours_night=n)

    m = _RE_SINGLE.match(text)
    if m:
        hours = _num(m.group(1))
        _check_hours(hours)
        return FactCell(hours_day=hours)

    # Полный список кодов не перечисляем: их два десятка, в сообщение об
    # ошибке они не помещаются. Весь справочник — на странице табеля.
    raise CellError(
        f"Не понял «{raw}». Ожидается число часов («11», «4/7»), "
        f"«РВ 4», «4 С», «10 С 3», «Я9 Н5 С4» или код дня — "
        f"В, П, О, Б, К и другие из списка «Обозначения»"
    )


def _parse_program_cell(text: str) -> FactCell | None:
    """
    Запись итога дня из старой программы: «Я9 Н5 С4».

    Я — явка, всего отработанных часов; Н — сколько из них ночных; С —
    сколько сверхурочных; РВ — сколько работы в выходной. Дневные часы
    получаются вычитанием: Я минус Н.

    Возвращает None, если запись не в этом виде — тогда её разберут обычные
    правила. Без Я не берёмся: «Н5» само по себе двусмысленно.
    """
    if "Я" not in text.upper():
        return None
    found = {}
    consumed = 0
    for m in _RE_PROGRAM_TOKEN.finditer(text):
        key = m.group(1).upper()
        if key in found:
            raise CellError(f"В записи «{text}» дважды указано «{key}»")
        found[key] = _num(m.group(2))
        # Пробелы внутри токена не считаем: «Я 9 Н 5 С 4» — та же запись
        consumed += len(m.group(0).replace(" ", ""))
    # В строке не должно остаться ничего, кроме разобранных токенов и пробелов
    if not found or consumed != len(text.replace(" ", "")):
        return None

    total = found.get("Я", 0.0)
    night = found.get("Н", 0.0)
    _check_hours(total)
    if night > total + 1e-9:
        raise CellError(
            f"Ночных часов ({_fmt(night)}) больше отработанных ({_fmt(total)})"
        )
    return FactCell(
        hours_day=round(total - night, 2),
        hours_night=night,
        hours_weekend=found.get("РВ", 0.0),
        hours_overtime=found.get("С", 0.0),
    )


def build_fact_cell(
    day_code: str | None = None,
    hours_day: float | str | None = 0,
    hours_night: float | str | None = 0,
    hours_weekend: float | str | None = 0,
    hours_overtime: float | str | None = 0,
) -> FactCell:
    """
    Собрать клетку из отдельных полей — так вводит начальник РЦ на экране смены.

    В отличие от текстовой записи здесь работа в выходной и сверхурочные могут
    быть частью смены, а не всей сменой: 11 часов, из которых 3 сверхурочных.
    Проверки повторяют ограничения таблицы timesheet_day, чтобы человек видел
    понятную ошибку рядом с полем, а не отказ базы.
    """
    code = None
    if day_code:
        code = _normalize_code(str(day_code))
        if not code:
            raise CellError(
                f"Неизвестный код дня «{day_code}». Допустимы: {', '.join(DAY_CODES)}"
            )

    d = _field("Часы днём", hours_day)
    n = _field("Часы ночью", hours_night)
    w = _field("Работа в выходной", hours_weekend)
    o = _field("Сверхурочные", hours_overtime)
    total = round(d + n, 2)

    if code and (total > 0 or w > 0 or o > 0):
        raise CellError(
            f"День закрыт кодом «{code}» — часы в этот день не ставятся. "
            f"Уберите код или очистите часы"
        )
    if code:
        return FactCell(day_code=code)

    if total == 0:
        if w > 0 or o > 0:
            raise CellError("Указаны часы без отработанного времени")
        return FactCell()

    if total > 24:
        raise CellError(f"Больше 24 часов в сутки не бывает, получилось {_fmt(total)}")
    for name, value in (("работы в выходной", w), ("сверхурочных", o)):
        if value > total:
            raise CellError(
                f"Часов {name} ({_fmt(value)}) больше отработанных ({_fmt(total)})"
            )
    if round(w + o, 2) > total:
        raise CellError(
            f"Работа в выходной и сверхурочные вместе ({_fmt(w + o)}) "
            f"больше отработанных часов ({_fmt(total)})"
        )

    return FactCell(hours_day=d, hours_night=n, hours_weekend=w, hours_overtime=o)


def fact_cell_parts(cell: FactCell | None) -> dict[str, str]:
    """
    Клетка табеля половинами: что показать в дневной колонке и что в ночной.

    В дневной колонке либо код дня, либо число дневных часов. Признаки
    «работа в выходной» и «сверхурочные» числом не показываются — они
    отражаются цветом клетки и подсказкой, иначе в узкую колонку не влезет.

    Код дня и часы в одной клетке — не ошибка, а обычное дело на стыке суток:
    смена с 22:00 отдаёт хвост следующим сутками, а сами эти сутки человек
    может быть уже в отпуске. В подписанном табеле депо это записано двумя
    половинами — «О» слева и «2» справа, — и прятать эти часы за кодом нельзя:
    они входят в отработанные часы месяца и в отклонение.
    """
    if cell is None:
        return {"day": "", "night": "", "title": ""}
    if cell.day_code:
        note = [cell.day_code]
        if cell.hours_night:
            note.append(f"ночные {_fmt(cell.hours_night)} ч")
        if cell.hours_day:
            note.append(f"дневные {_fmt(cell.hours_day)} ч")
        return {
            "day": cell.day_code,
            "night": _fmt(cell.hours_night) if cell.hours_night else "",
            "title": ", ".join(note),
        }

    parts = []
    if cell.hours_weekend:
        parts.append(f"работа в выходной {_fmt(cell.hours_weekend)} ч")
    if cell.hours_overtime:
        parts.append(f"сверхурочные {_fmt(cell.hours_overtime)} ч")
    if cell.hours_night:
        parts.append(f"ночные {_fmt(cell.hours_night)} ч")

    return {
        "day": _day_text(cell),
        "night": _fmt(cell.hours_night) if cell.hours_night else "",
        "title": ", ".join(parts),
    }


def _day_text(cell: FactCell) -> str:
    """
    Дневная половина клетки — с буквой, если она есть (23.09.2026).

    «Когда ставятся часы с буквенным обозначением, обозначение не должно
    пропадать». Раньше «РВ 11» после ввода превращалось в «11», а признак
    оставался только цветом и подсказкой — и по экрану нельзя было понять,
    вызов это или обычная смена. Теперь буква видна:

      * «РВ 11» — все часы суток работа в выходной;
      * «11 С» — все часы сверхурочные;
      * «8 С3», «8 РВ3» — из восьми часов сверхурочных или в выходной три.
    """
    if not cell.hours_day and not (cell.hours_weekend or cell.hours_overtime):
        return ""
    hours = _fmt(cell.hours_day) if cell.hours_day else "0"
    worked = cell.worked
    if cell.hours_weekend:
        if abs(cell.hours_weekend - worked) < 0.01:
            return f"РВ {hours}"
        return f"{hours} РВ{_fmt(cell.hours_weekend)}"
    if cell.hours_overtime:
        if abs(cell.hours_overtime - worked) < 0.01:
            return f"{hours} С"
        return f"{hours} С{_fmt(cell.hours_overtime)}"
    return hours


def merge_fact_part(existing: FactCell | None, part: str, raw: str | None) -> FactCell:
    """
    Заменить одну половину клетки, сохранив другую.

    Дневная половина принимает число, код дня или привычные записи «РВ 4» и
    «4 С» — тогда часы попадают и в признак работы в выходной или
    сверхурочных. Ночная половина принимает только число.

    Правила, которые здесь удерживаются:
      * код дня закрывает весь день — ночные часы при этом обнуляются;
      * ночные часы нельзя поставить в день, закрытый кодом;
      * работа в выходной и сверхурочные — подмножества отработанного, и при
        уменьшении часов они не должны оказаться больше него.
    """
    base = existing or FactCell()
    text = " ".join(str(raw or "").split())

    if part == "night":
        if base.day_code and text:
            raise CellError(
                f"День закрыт кодом «{base.day_code}» — ночные часы в этот день "
                f"не ставятся. Сначала очистите код в дневной колонке"
            )
        # В ночной колонке тоже пишут «РВ 5» или «С 4»: в докладной на вызов в
        # выходной признак ставится и в дневную, и в ночную клетку. Такая
        # запись означает «эти ночные часы — тоже работа в выходной», поэтому
        # признак складывается с дневной частью, а не заменяет её.
        night, add_weekend, add_overtime = _parse_night_part(text)
        explicit_w, explicit_o = add_weekend > 0, add_overtime > 0
        merged = FactCell(
            hours_day=base.hours_day,
            hours_night=night,
            hours_weekend=round(base.hours_weekend + add_weekend, 2),
            hours_overtime=round(base.hours_overtime + add_overtime, 2),
        )

    elif part == "day":
        explicit_w = explicit_o = False
        if not text:
            # Очистили дневную половину: ночная остаётся, признаки — нет,
            # они относились к прежним дневным часам
            merged = FactCell(hours_night=base.hours_night)
        else:
            fresh = parse_fact_cell(text)
            if fresh.day_code:
                # Код закрывает сутки целиком, ночные часы теряют смысл
                return fresh
            explicit_w, explicit_o = fresh.hours_weekend > 0, fresh.hours_overtime > 0
            #  «РВ 7» и «7 С» в дневной колонке значат «дневные часы — работа
            #  в выходной (сверхурочные)». Если ночные часы у этого признака
            #  уже были, они остаются: иначе повторный ввод того, что клетка
            #  сама показывает, срезал бы ночную часть признака (23.09.2026)
            night_w = max(0.0, round(base.hours_weekend - base.hours_day, 2))
            night_o = max(0.0, round(base.hours_overtime - base.hours_day, 2))
            if explicit_w and abs(fresh.hours_weekend - fresh.hours_day) < 0.01 \
                    and night_w and base.hours_night:
                fresh = FactCell(hours_day=fresh.hours_day,
                                 hours_night=fresh.hours_night,
                                 hours_weekend=round(fresh.hours_weekend + night_w, 2),
                                 hours_overtime=fresh.hours_overtime)
            if explicit_o and abs(fresh.hours_overtime - fresh.hours_day) < 0.01 \
                    and night_o and base.hours_night:
                fresh = FactCell(hours_day=fresh.hours_day,
                                 hours_night=fresh.hours_night,
                                 hours_weekend=fresh.hours_weekend,
                                 hours_overtime=round(fresh.hours_overtime + night_o, 2))
            merged = FactCell(
                hours_day=fresh.hours_day,
                # «4/7» в дневной колонке задаёт сразу обе половины —
                # привычная запись, отбирать её незачем
                hours_night=fresh.hours_night or base.hours_night,
                # если в записи были «РВ 4» или «4 С» — берём их, иначе
                # оставляем прежние признаки
                hours_weekend=fresh.hours_weekend or base.hours_weekend,
                hours_overtime=fresh.hours_overtime or base.hours_overtime,
            )
    else:
        raise CellError(f"Неизвестная половина клетки: {part}")

    total = merged.worked
    if total == 0:
        return FactCell()
    if total > 24:
        raise CellError(f"Больше 24 часов в сутки не бывает, получилось {_fmt(total)}")

    # Признак, названный прямо в этой записи, молча не обрезаем: «4 С 8» при
    # четырёх отработанных часах значит, что ночные ещё не введены, а не что
    # сверхурочных четыре. Молчаливое обрезание дало бы в табеле неверное
    # число, и никто бы этого не заметил.
    for label, value, explicit, hint in (
        ("Работы в выходной", merged.hours_weekend, explicit_w,
         "«РВ 5» в ночной колонке пометит ночные часы отдельно"),
        ("Сверхурочных", merged.hours_overtime, explicit_o,
         "если сверхурочные пришлись и на ночь, сначала впишите ночные часы"),
    ):
        if explicit and value > total + 1e-9:
            raise CellError(
                f"{label} ({_fmt(value)} ч) больше отработанных за сутки "
                f"({_fmt(total)} ч): {hint}"
            )

    # А вот признаки, оставшиеся от прежних — больших — часов, подрезаем
    weekend = min(merged.hours_weekend, total)
    overtime = min(merged.hours_overtime, total)
    if round(weekend + overtime, 2) > total:
        overtime = round(max(0.0, total - weekend), 2)

    return FactCell(
        hours_day=merged.hours_day,
        hours_night=merged.hours_night,
        hours_weekend=weekend,
        hours_overtime=overtime,
    )


_RE_NIGHT_WEEKEND = re.compile(rf"^РВ\s*({_NUM})$", re.IGNORECASE)
_RE_NIGHT_OVERTIME = re.compile(rf"^(?:С\s*({_NUM})|({_NUM})\s*С)$", re.IGNORECASE)


def _parse_night_part(text: str) -> tuple[float, float, float]:
    """
    Ночная половина клетки: часы и, если указан, признак этих часов.

    Понимает «5», «РВ 5», «С 4» и «4 С». Возвращает (часы, работа в выходной,
    сверхурочные) — признак равен часам, потому что относится ко всей ночной
    половине: половину нельзя пометить частично, для этого есть экран смены.
    """
    if not text:
        return 0.0, 0.0, 0.0

    m = _RE_NIGHT_WEEKEND.match(text)
    if m:
        hours = _num(m.group(1))
        _check_hours(hours)
        return hours, hours, 0.0

    m = _RE_NIGHT_OVERTIME.match(text)
    if m:
        hours = _num(m.group(1) or m.group(2))
        _check_hours(hours)
        return hours, 0.0, hours

    return _field("Ночные часы", text), 0.0, 0.0


def _field(name: str, raw: float | str | None) -> float:
    """Одно числовое поле формы: пусто значит ноль, запятая допустима."""
    if raw is None or raw == "":
        return 0.0
    try:
        value = float(str(raw).replace(",", ".").strip())
    except ValueError as exc:
        raise CellError(f"{name}: «{raw}» — это не число") from exc
    if value < 0:
        raise CellError(f"{name} не может быть отрицательным")
    if value > 24:
        raise CellError(f"{name}: больше 24 часов в сутки не бывает")
    return round(value, 2)


def _check_hours(total: float) -> None:
    if total <= 0:
        raise CellError("Часы должны быть больше нуля")
    if total > 24:
        raise CellError("Больше 24 часов в сутки не бывает")


def _parse_interval(text: str, raw: str) -> tuple[time, time]:
    """Одна запись времени: «06:00-18:00», «6-18», «22:00 -24:00»."""
    #  «24:00» — это конец суток: время суток заканчивается на 00:00, и без
    #  замены такая запись не разобралась бы вовсе. В графике на стыке
    #  месяцев она встречается постоянно: «20:00 - 24:00» за 31-е число
    m = _RE_SHIFT.match(text.replace(" ", "").replace("24:00", "00:00"))
    if not m:
        raise CellError(
            f"Не понял «{raw}». Ожидается время работы вида «09:00-21:00», "
            f"две записи через косую черту «00:00-08:00/20:00-08:00» "
            f"или код дня — В, П, О, Б, К и другие из списка «Обозначения»"
        )
    sh, sm, eh, em = m.group(1), m.group(2) or "00", m.group(3), m.group(4) or "00"
    try:
        start = time(int(sh), int(sm))
        end = time(int(eh), int(em))
    except ValueError as exc:
        raise CellError(f"Неверное время: {raw}") from exc
    if start == end:
        raise CellError("Начало и конец работы совпадают")
    return start, end


def parse_plan_cell(raw: str | None) -> PlanCell:
    """
    Разобрать клетку планового графика.

    В клетке бывает две записи через косую черту: рабочее время ведётся
    сутками, и на стыке месяцев работа с 20:00 до 08:00 записывается двумя
    частями. Если в тот же день человек снова выходит в ночь, в клетке стоят
    обе записи — «00:00 - 08:00/20:00 - 08:00».
    """
    if raw is None:
        return PlanCell()
    text = " ".join(str(raw).split())
    if not text:
        return PlanCell()

    code = _normalize_code(text)
    if code:
        return PlanCell(day_code=code)

    parts = [p.strip() for p in text.split("/") if p.strip()]
    if len(parts) > 2:
        raise CellError(
            "В клетке не больше двух записей времени: сутки закончатся раньше"
        )
    if not parts:
        return PlanCell()

    start, end = _parse_interval(parts[0], raw)
    if len(parts) == 1:
        return PlanCell(shift_start=start, shift_end=end)

    start2, end2 = _parse_interval(parts[1], raw)
    #  Порядок записей смысловой: сначала то, что дорабатывается с прошлых
    #  суток, потом начатое в эти. Если запись перепутали местами, часы
    #  посчитались бы верно, а прочесть клетку было бы нельзя
    if _minutes_of(start2) < _minutes_of(start):
        raise CellError(
            "Первой записью идёт то, что дорабатывается с прошлых суток: "
            f"«{start2:%H:%M}» начинается раньше «{start:%H:%M}»"
        )
    return PlanCell(shift_start=start, shift_end=end,
                    shift2_start=start2, shift2_end=end2)


def _minutes_of(value: time) -> int:
    return value.hour * 60 + value.minute


def _fmt(value: float) -> str:
    rounded = round(float(value), 2)
    if abs(rounded - int(rounded)) < 1e-9:
        return str(int(rounded))
    return f"{rounded:g}".replace(".", ",")


def format_fact_cell(cell: FactCell) -> str:
    """Собрать клетку обратно в текст — то, что видно в сетке."""
    if cell.day_code:
        return cell.day_code
    if cell.worked <= 0:
        return ""

    if cell.hours_weekend > 0 and abs(cell.hours_weekend - cell.worked) < 0.01:
        base = f"РВ {_fmt(cell.worked)}"
    elif cell.hours_overtime > 0 and abs(cell.hours_overtime - cell.worked) < 0.01:
        base = f"{_fmt(cell.worked)} С"
    elif cell.hours_night > 0:
        base = f"{_fmt(cell.hours_day)}/{_fmt(cell.hours_night)}"
    else:
        base = _fmt(cell.hours_day)

    return base


def format_plan_cell(cell: PlanCell) -> str:
    """Клетка обратно в текст — то, что стоит в поле ввода сетки."""
    if cell.day_code:
        return cell.day_code
    return "/".join(f"{s:%H:%M}-{e:%H:%M}" for s, e in cell.intervals)


def format_plan_cell_short(cell: PlanCell) -> str:
    """
    Компактная запись для сетки: 9–21 вместо 09:00-21:00.
    Минуты показываются только если они не нулевые.
    """
    if cell.day_code:
        return cell.day_code

    def t(v: time) -> str:
        return str(v.hour) if v.minute == 0 else f"{v.hour}:{v.minute:02d}"

    return "/".join(f"{t(s)}–{t(e)}" for s, e in cell.intervals)


def plan_cell_lines(cell: PlanCell) -> list[str]:
    """
    Смена двумя строками: «09:00 -» и «18:00».

    Так проще читать столбец сверху вниз: начала смен выстраиваются друг под
    другом, концы — под ними. В одну строку глаз каждый раз ищет, где дефис.
    Код дня остаётся одной строкой.
    """
    if cell.day_code:
        return [cell.day_code]
    intervals = cell.intervals
    if not intervals:
        return []
    if len(intervals) == 1:
        start, end = intervals[0]
        return [f"{start:%H:%M} -", f"{end:%H:%M}"]
    #  Две записи — по строке на каждую, компактно: иначе четыре строки не
    #  влезут в клетку дня, а важно видеть, что записей в этих сутках две
    return [f"{s:%H:%M}-{e:%H:%M}" for s, e in intervals]


def fact_cell_kind(cell: FactCell) -> str:
    """Смысловой тип клетки табеля — от него зависит цвет в сетке."""
    if cell.day_code:
        return CODE_KIND.get(cell.day_code, "other")
    if cell.worked <= 0:
        return "empty"
    if cell.hours_night > 0:
        return "night"
    if cell.hours_weekend > 0:
        return "weekend"
    if cell.hours_overtime > 0:
        return "overtime"
    return "shift"


def plan_cell_kind(cell: PlanCell, night_from: int = 22, night_to: int = 6) -> str:
    if cell.day_code:
        return CODE_KIND.get(cell.day_code, "other")
    intervals = cell.intervals
    if not intervals:
        return "empty"
    #  Клетка красится ночной, если ночные часы есть хоть в одной записи:
    #  на стыке месяцев первая запись как раз ночная («00:00 - 08:00»)
    for start_t, end_t in intervals:
        start, end = start_t.hour, end_t.hour
        crosses_midnight = end <= start
        if (crosses_midnight or end > night_from
                or start >= night_from or start < night_to):
            return "night"
    return "shift"


# Справочник обозначений на случай, когда таблица app.day_code ещё не
# заполнена — например миграция 05 не накатилась. Без него страница табеля
# оставалась вообще без легенды и без кнопки «Обозначения», и человек не мог
# узнать, какие буквы вводить.
#
# Источник правды — таблица в базе: там организация может поправить
# формулировки. Этот список нужен только как запасной, и тест проверяет, что
# он покрывает все вводимые коды.
DAY_CODE_REFERENCE = [
    # code, название, раздел, вид, можно ли вводить, примечание
    ("Я",  "Явка, отработанные часы", "Работа", "shift", False,
     "В клетке — число часов в колонках «д» и «н»"),
    ("Н",  "Часы ночной работы", "Работа", "night", False,
     "Колонка «н»: часы, попавшие в 22:00–06:00"),
    ("С",  "Сверхурочная работа", "Работа", "overtime", False,
     "Запись «4 С» в дневной колонке"),
    ("РВ", "Работа в выходной или праздничный день", "Работа", "weekend", False,
     "Запись «РВ 4» в дневной колонке"),

    ("В",  "Выходной день", "Отдых", "off", True, None),
    ("П",  "Государственный праздник, праздничный день", "Отдых", "holiday", True,
     "Нерабочие дни по статье 147 ТК"),
    ("ОД", "День отдыха за работу в выходной, отгул", "Отдых", "off", True, None),
    ("ДО", "Дополнительный свободный день от работы", "Отдых", "off", True,
     "Например, свободный день многодетной матери"),

    ("О",  "Трудовой отпуск", "Отпуска", "vacation", True, None),
    ("А",  "Отпуск без сохранения заработной платы", "Отпуска", "other", True, None),
    ("У",  "Отпуск в связи с обучением", "Отпуска", "vacation", True, None),
    ("Р",  "Отпуск по беременности и родам", "Отпуска", "other", True, None),
    ("ОЖ", "Отпуск по уходу за ребёнком до трёх лет", "Отпуска", "other", True, None),

    ("Б",  "Временная нетрудоспособность, больничный", "Отсутствие", "sick", True,
     "С назначением пособия"),
    ("Т",  "Нетрудоспособность без назначения пособия", "Отсутствие", "sick", True, None),
    ("К",  "Служебная командировка", "Отсутствие", "trip", True, None),
    ("Г",  "Выполнение государственных обязанностей", "Отсутствие", "other", True,
     "Военкомат, суд, донорство и подобное"),
    ("ГЧ", "Военно-учебные сборы", "Отсутствие", "other", True,
     "Отдельно от «Г»: там государственные обязанности"),
    ("ПВ", "Простой не по вине работника", "Отсутствие", "other", True, None),
    ("ПР", "Прогул", "Отсутствие", "other", True,
     "Отсутствие без уважительной причины"),
    ("НН", "Неявка по невыясненным причинам", "Отсутствие", "other", True,
     "До выяснения; потом заменить на нужный код"),

    #  Строки «Устаревшие» здесь больше нет: «А» вернулось в строй решением
    #  от 14.09.2026 и стоит выше, в группе «Отпуска», а «ОБ» убрано
    #  миграцией 31. В справочник оно не входит, но разбор клетки его
    #  по-прежнему понимает — см. DAY_CODES.
]


def day_code_reference_fallback() -> list[dict[str, object]]:
    """Тот же вид, что отдаёт запрос к app.day_code."""
    return [
        {
            "code": code, "name": name, "group_name": group, "kind": kind,
            "entry": entry, "note": note,
            # признаки оплаты в запасном списке не показываем: они зависят от
            # решений организации и живут только в базе
            "counts_as_worked": None, "counts_in_norm": None,
        }
        for code, name, group, kind, entry, note in DAY_CODE_REFERENCE
    ]


# Как красить клетку с кодом. Держится в паре с полем kind в app.day_code:
# там тот же смысл, но для справочника на странице табеля.
CODE_KIND = {
    "В": "off",
    "П": "holiday",
    "ОД": "off",
    "ДО": "off",
    "О": "vacation",
    "У": "vacation",
    "А": "other",
    #  Прежнее обозначение того же отпуска: цвет нужен, пока в какой-нибудь
    #  базе остались непереведённые дни
    "ОБ": "other",
    "Р": "other",
    "ОЖ": "other",
    "Б": "sick",
    "Т": "sick",
    "К": "trip",
    "Г": "other",
    #  Военно-учебные сборы: отсутствие законное, цвет тот же, что у «Г»
    "ГЧ": "other",
    "ПВ": "other",
    "ПР": "other",
    "НН": "other",
}
