"""
Правила расчёта часов из планового графика смен.

Единственное место в системе, где заданы:
  * граница дня и ночи;
  * разнесение смены, переходящей через полночь, на два календарных дня;
  * вычет неоплачиваемого перерыва.

В действующих таблицах эти правила зашиты в скрипт сравнения графиков
(compareSchedule) и больше нигде не описаны. Здесь они вынесены в код,
покрыты тестами и параметризованы, а результат складывается в таблицу
schedule_plan_hours — чтобы правило не дублировалось в SQL.
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import date, datetime, time, timedelta
from typing import Container, Iterable, Sequence

#  Версия правил расчёта часов. Хранится рядом с посчитанными часами: когда
#  правило меняется, старые цифры в базе становятся неверными, и приложение
#  пересчитывает месяц само, увидев чужую версию.
#    1.0.0 — обед по календарным суткам, первое подошедшее окно;
#    1.1.0 — обед один на смену: окно ближайшее к середине смены, смены не
#            дольше 4 часов не режутся, части смены на стыке месяцев
#            склеиваются в одну.
RULE_VERSION = "1.1.0"

MINUTES_PER_DAY = 24 * 60


def _minutes(t: time) -> int:
    return t.hour * 60 + t.minute


def _overlap(a: tuple[int, int], b: tuple[int, int]) -> int:
    return max(0, min(a[1], b[1]) - max(a[0], b[0]))


def _round_to(value: float, step: float) -> float:
    if step <= 0:
        return round(value, 6)
    return round(round(value / step) * step, 6)


@dataclass(frozen=True)
class NightWindow:
    """Границы ночного времени. По умолчанию — как в действующем скрипте."""

    start: time = time(22, 0)
    end: time = time(6, 0)

    def intervals(self, days: int = 3) -> list[tuple[int, int]]:
        """Ночные интервалы в минутах от начала первых суток."""
        s, e = _minutes(self.start), _minutes(self.end)
        out: list[tuple[int, int]] = []
        for d in range(days):
            base = d * MINUTES_PER_DAY
            if s < e:
                out.append((base + s, base + e))
            else:
                out.append((base, base + e))
                out.append((base + s, base + MINUTES_PER_DAY))
        return out


@dataclass(frozen=True)
class BreakRule:
    """
    Неоплачиваемый перерыв.

    mode:
      legacy_max_bucket — как сейчас: час вычитается из наибольшего из
                          интервалов смены (день/ночь текущих и следующих суток),
                          независимо от длины смены;
      proportional      — час распределяется пропорционально длине интервалов;
      none              — перерыв не вычитается.

    min_shift_hours: порог длины смены, ниже которого перерыв не вычитается.
      None означает «вычитать всегда» — это текущее поведение, и именно оно
      требует решения владельца методики.
    """

    hours: float = 1.0
    mode: str = "legacy_max_bucket"
    min_shift_hours: float | None = None

    def minutes(self) -> int:
        return int(round(self.hours * 60))


LEGACY_BREAK = BreakRule()
NO_BREAK = BreakRule(hours=0.0, mode="none")


@dataclass(frozen=True)
class LunchRule:
    """
    Обед: один час, один раз **за смену**, по окнам.

    Конкретное время перерыва работник согласовывает с руководителем каждый
    день, поэтому в системе задан не момент, а окна, в которые перерыв
    попадает: 11:00–14:00, 16:00–19:00, 01:00–04:00. Час вычитается один раз
    на смену, даже когда смена задевает сразу два окна: обедают один раз.

    Час снимается с тех часов, в которые попал обед: окна 11:00–14:00 и
    16:00–19:00 — дневные, 01:00–04:00 — ночное. Календарные сутки — те, где
    лежит это окно: у смены с 18:00 до 06:00 обед в 01:00–04:00 приходится на
    вторые сутки, и час снимается с них, а первые остаются целыми.

    Из нескольких подошедших окон берётся **ближайшее к середине смены**:
    смена 18:00–06:00 задевает и 16:00–19:00 (первый час), и 01:00–04:00, а
    обедают посередине. Раньше бралось первое по времени окно, и у Кулевнича
    за 7 августа час снимался с первых суток, тогда как в подписанном табеле
    он снят со вторых. По правилу «ближайшее к середине» весь август депо
    сошёлся с табелем — 270 рабочих дней из 271.

    min_shift_hours — смена короче этого не обедает вовсе: перерыв положен,
    когда смена **дольше** порога. У смены ровно 4 часа обеда быть не может.

    **Обед вычитается только в табеле.** В графике стоит время присутствия:
    работа с 08:00 до 21:00 — это 13 часов графика и 12 отработанных. Так
    решил заказчик, и на этом держится сходимость графика с нормой месяца.
    """

    hours: float = 1.0
    #  (начало, конец) в часах; окна не пересекаются и заданы порядком
    windows: tuple[tuple[int, int], ...] = ((11, 14), (16, 19), (1, 4))
    #  Смена ровно такой длины обедом не режется — только дольше
    min_shift_hours: float = 4.0

    def minutes(self) -> int:
        return int(round(self.hours * 60))

    def applies_to(self, shift_minutes: int) -> bool:
        """Положен ли обед смене такой длины."""
        if self.minutes() <= 0 or not self.windows:
            return False
        return shift_minutes > int(round(self.min_shift_hours * 60))

    def intervals(self, days: int = 3) -> list[tuple[int, int]]:
        """Окна обеда в минутах от начала первых суток, по порядку времени."""
        out: list[tuple[int, int]] = []
        for d in range(days):
            base = d * MINUTES_PER_DAY
            for start, end in self.windows:
                out.append((base + start * 60, base + end * 60))
        return sorted(out)


LUNCH = LunchRule()
NO_LUNCH = LunchRule(hours=0.0, windows=())


@dataclass(frozen=True)
class PlanHours:
    """
    Часы графика, легшие на один календарный день.

    Две пары цифр по одной и той же работе:

      hours_*  — присутствие: столько стоит в графике, вместе с часом обеда;
      worked_* — к отработке: минус час обеда.

    Пустые worked_* означают «не считалось» и читаются как присутствие: так
    ведут себя старые строки, посчитанные до появления правила обеда.
    """

    work_date: date
    hours_day: float
    hours_night: float
    source_date: date
    worked_day: float | None = None
    worked_night: float | None = None

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

    @property
    def worked_total(self) -> float:
        d = self.hours_day if self.worked_day is None else self.worked_day
        n = self.hours_night if self.worked_night is None else self.worked_night
        return round(d + n, 2)


def split_shift(
    work_date: date,
    shift_start: time,
    shift_end: time,
    night: NightWindow | None = None,
    break_rule: BreakRule | None = None,
    round_to: float = 0.1,
    lunch: LunchRule | None = None,
) -> list[PlanHours]:
    """
    Разложить работу на дневные и ночные часы по календарным дням.

    Запись, у которой конец не позже начала, считается переходящей через
    полночь. Возвращает от одной до двух записей: на дату работы и на
    следующий день.

    lunch — правило обеда. Задано только там, где считаются отработанные
    часы: в графике стоит время присутствия, обед из него не вычитается.
    """
    night = night or NightWindow()
    break_rule = break_rule or LEGACY_BREAK

    start = _minutes(shift_start)
    end = _minutes(shift_end)
    if end <= start:
        end += MINUTES_PER_DAY

    shift = (start, end)
    total_minutes = end - start
    if total_minutes <= 0:
        return []

    night_iv = night.intervals(days=3)

    # buckets[(day_index, kind)] = минуты
    buckets: dict[tuple[int, str], int] = {}
    for day_index in range(2):
        window = (day_index * MINUTES_PER_DAY, (day_index + 1) * MINUTES_PER_DAY)
        seg_start = max(shift[0], window[0])
        seg_end = min(shift[1], window[1])
        seg_len = seg_end - seg_start
        if seg_len <= 0:
            continue
        seg = (seg_start, seg_end)
        night_min = sum(_overlap(seg, iv) for iv in night_iv)
        night_min = min(night_min, seg_len)
        buckets[(day_index, "night")] = night_min
        buckets[(day_index, "day")] = seg_len - night_min

    _apply_break(buckets, break_rule, total_minutes)
    if lunch is not None:
        _apply_lunch(buckets, shift, night_iv, lunch)

    hours = _rounded_hours(buckets, round_to)

    result: list[PlanHours] = []
    for day_index in range(2):
        d = hours.get((day_index, "day"), 0.0)
        n = hours.get((day_index, "night"), 0.0)
        if d <= 0 and n <= 0:
            continue
        result.append(
            PlanHours(
                work_date=work_date + timedelta(days=day_index),
                hours_day=d,
                hours_night=n,
                source_date=work_date,
            )
        )
    return result


def _rounded_hours(
    buckets: dict[tuple[int, str], int],
    round_to: float,
) -> dict[tuple[int, str], float]:
    """
    Округлить часы по интервалам так, чтобы их сумма совпала с округлённым
    итогом смены. Без этого при пропорциональном вычете перерыва из суммы
    пропадали десятые доли часа.
    """
    positive = {k: max(v, 0) for k, v in buckets.items()}
    rounded = {k: _round_to(v / 60, round_to) for k, v in positive.items()}

    target = _round_to(sum(positive.values()) / 60, round_to)
    diff = round(target - sum(rounded.values()), 6)

    if abs(diff) >= round_to / 2 and rounded:
        key = max(rounded, key=lambda k: (rounded[k], k[0], k[1]))
        rounded[key] = round(rounded[key] + diff, 6)

    return rounded


def _apply_break(
    buckets: dict[tuple[int, str], int],
    rule: BreakRule,
    total_minutes: int,
) -> None:
    if rule.mode == "none" or rule.minutes() <= 0:
        return
    if rule.min_shift_hours is not None and total_minutes / 60 < rule.min_shift_hours:
        return

    br = rule.minutes()

    if rule.mode == "legacy_max_bucket":
        # ровно то, что делает нынешний скрипт: вычесть из наибольшего интервала
        non_empty = {k: v for k, v in buckets.items() if v > 0}
        if not non_empty:
            return
        key = max(non_empty, key=lambda k: (non_empty[k], k[0], k[1]))
        buckets[key] = max(0, buckets[key] - br)
        return

    if rule.mode == "proportional":
        filled = sum(v for v in buckets.values() if v > 0)
        if filled <= 0:
            return
        br = min(br, filled)
        for key, value in list(buckets.items()):
            if value > 0:
                buckets[key] = value - int(round(br * value / filled))
        return

    raise ValueError(f"Неизвестный режим перерыва: {rule.mode}")


def lunch_bucket(
    shift: tuple[int, int],
    night_iv: list[tuple[int, int]],
    rule: LunchRule,
) -> tuple[int, str] | None:
    """
    В какие часы попал обед: (номер суток от начала работы, «day»/«night»).

    Берётся окно, **ближайшее к середине смены**: обедают один раз и обычно
    посередине. Смена 18:00–06:00 задевает 16:00–19:00 первым часом и
    01:00–04:00 серединой — обед приходится на второе окно, то есть на вторые
    сутки. Пока бралось первое по времени окно, час снимался с первых суток
    и сверка показывала «не оформлено 1 ч» там, где всё было в порядке.

    Смена, не попавшая ни в одно окно, обед всё равно получает: перерыв
    работник согласовывает с руководителем, окна — только про то, когда он
    обычно приходится. Тогда час берётся серединой смены.

    Ночное это время или дневное, определяется теми же границами ночи, что и
    всё остальное: отдельного списка «ночных окон» держать не нужно — обед в
    01:00–04:00 лежит внутри 22:00–06:00 сам.

    None означает, что обед этой смене не положен — она не дольше порога.
    """
    if not rule.applies_to(shift[1] - shift[0]):
        return None

    middle = (shift[0] + shift[1]) / 2

    def place(at: float) -> tuple[int, str]:
        minute = int(at)
        day_index = minute // MINUTES_PER_DAY
        kind = "night" if any(iv[0] <= minute < iv[1] for iv in night_iv) else "day"
        return day_index, kind

    best: tuple[float, float] | None = None      # (расстояние, середина окна)
    for window in rule.intervals():
        overlap_start = max(shift[0], window[0])
        overlap_end = min(shift[1], window[1])
        if overlap_end <= overlap_start:
            continue
        centre = (overlap_start + overlap_end) / 2
        distance = abs(centre - middle)
        if best is None or distance < best[0]:
            best = (distance, centre)
    if best is not None:
        return place(best[1])
    #  Ни одно окно не подошло — обед берётся серединой смены
    return place(middle)


def _apply_lunch(
    buckets: dict[tuple[int, str], int],
    shift: tuple[int, int],
    night_iv: list[tuple[int, int]],
    rule: LunchRule,
) -> None:
    """
    Снять час обеда с тех часов, в которые он попал.

    Если в этих часах обеда не хватает — например работа кончилась в 12:00, а
    окно 11:00–14:00 задето только на час, — остаток снимается с остальных
    часов той же работы: обед был, и в отработанное время он не идёт.
    """
    place = lunch_bucket(shift, night_iv, rule)
    if place is None:
        return
    left = rule.minutes()
    take = min(left, buckets.get(place, 0))
    if take > 0:
        buckets[place] -= take
        left -= take
    if left <= 0:
        return
    #  Порядок обхода: сначала те же сутки, потом следующие; внутри суток
    #  сначала дневные часы. Так вычет остаётся предсказуемым
    for key in sorted(buckets, key=lambda k: (k[0], k[1] != "day")):
        if key == place or buckets[key] <= 0:
            continue
        take = min(left, buckets[key])
        buckets[key] -= take
        left -= take
        if left <= 0:
            return


@dataclass(frozen=True)
class ShiftRow:
    """
    Строка планового графика — клетка одного дня.

    В клетке бывает две записи времени: рабочее время ведётся сутками, и на
    стыке месяцев работа с 20:00 до 08:00 записывается двумя частями. Если в
    тот же день человек снова выходит в ночь, в клетке стоят обе.
    """

    employment_id: int
    org_unit_id: int
    work_date: date
    shift_start: time | None = None
    shift_end: time | None = None
    day_code: str | None = None
    shift2_start: time | None = None
    shift2_end: time | None = 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 plan_hours(
    rows: Iterable[ShiftRow],
    night: NightWindow | None = None,
    break_rule: BreakRule | None = None,
    round_to: float = 0.1,
    lunch: LunchRule | None = None,
) -> list[tuple[ShiftRow, PlanHours]]:
    """
    Посчитать часы по набору строк графика.

    Записи одной клетки складываются по календарным дням: у клетки
    «00:00 - 08:00/20:00 - 08:00» часы этих суток — сумма обеих записей, и
    хранить их надо одной строкой на дату, иначе вторая перезапишет первую.

    lunch задаётся только там, где считаются отработанные часы: в графике
    стоит время присутствия, и обед из него не вычитается.
    """
    out: list[tuple[ShiftRow, PlanHours]] = []
    for row in rows:
        if not row.intervals:
            continue  # день закрыт кодом (В, О, Б...) — часов нет
        #  (дата) → часы: две записи клетки могут лечь на одни сутки
        merged: dict[date, PlanHours] = {}
        for start, end in row.intervals:
            for ph in split_shift(row.work_date, start, end, night, break_rule,
                                  round_to, lunch):
                was = merged.get(ph.work_date)
                if was is None:
                    merged[ph.work_date] = ph
                else:
                    merged[ph.work_date] = PlanHours(
                        work_date=ph.work_date,
                        hours_day=round(was.hours_day + ph.hours_day, 2),
                        hours_night=round(was.hours_night + ph.hours_night, 2),
                        source_date=was.source_date,
                    )
        for ph in sorted(merged.values(), key=lambda p: p.work_date):
            out.append((row, ph))
    return out


def shifts_of(rows: Iterable[ShiftRow]) -> dict[int, list[tuple[datetime, datetime]]]:
    """
    Собрать записи графика в смены: по назначению, в порядке времени.

    Смена — непрерывная работа, и в клетках она может лежать двумя записями.
    Так закрывается месяц: работа с 18:00 до 06:00 на стыке пишется как
    18:00–00:00 последним числом и 00:00–06:00 первым. Для табеля это две
    даты, но обед у неё один, поэтому части, у которых конец одной совпадает с
    началом другой, склеиваются обратно в одну смену.

    Без склейки у смены на стыке месяцев обед считался бы дважды: по разу на
    каждую половину.
    """
    raw: dict[int, list[tuple[datetime, datetime]]] = {}
    for row in rows:
        for start, end in row.intervals:
            begins = datetime.combine(row.work_date, start)
            ends = datetime.combine(row.work_date, end)
            if ends <= begins:
                ends += timedelta(days=1)
            raw.setdefault(row.employment_id, []).append((begins, ends))

    out: dict[int, list[tuple[datetime, datetime]]] = {}
    for employment_id, items in raw.items():
        joined: list[tuple[datetime, datetime]] = []
        for begins, ends in sorted(items):
            if joined and joined[-1][1] == begins:
                joined[-1] = (joined[-1][0], ends)
            else:
                joined.append((begins, ends))
        out[employment_id] = joined
    return out


def lunch_cuts(
    rows: Iterable[ShiftRow],
    night: NightWindow | None = None,
    lunch: LunchRule | None = None,
) -> dict[tuple[int, date, str], int]:
    """
    Сколько минут обеда снять: (назначение, сутки, «day»/«night») → минуты.

    Считается по сменам, а не по клеткам: обед один на смену, и лежит он в
    тех сутках, где окно обеда, ближайшее к середине смены.
    """
    lunch = LUNCH if lunch is None else lunch
    night = night or NightWindow()
    night_iv = night.intervals(days=3)

    cuts: dict[tuple[int, date, str], int] = {}
    for employment_id, items in shifts_of(rows).items():
        for begins, ends in items:
            #  Смену переводим в минуты от начала её первых суток: так же,
            #  как это делает split_shift
            start = begins.hour * 60 + begins.minute
            length = int(round((ends - begins).total_seconds() / 60))
            place = lunch_bucket((start, start + length), night_iv, lunch)
            if place is None:
                continue
            day_index, kind = place
            day = begins.date() + timedelta(days=day_index)
            key = (employment_id, day, kind)
            cuts[key] = cuts.get(key, 0) + lunch.minutes()
    return cuts


def plan_and_worked(
    rows: Iterable[ShiftRow],
    night: NightWindow | None = None,
    round_to: float = 0.1,
    lunch: LunchRule | None = None,
) -> list[tuple[ShiftRow, PlanHours]]:
    """
    Часы графика двумя цифрами: присутствие и к отработке.

    Присутствие — то, что стоит в графике: интервал содержит в себе час
    обеда. К отработке — минус этот час: столько работник ставит в табеле.
    Обе цифры считаются от одних и тех же интервалов, поэтому разойтись они
    не могут.

    Обед снимается не с клетки, а со смены — иначе у работы на стыке суток
    или месяцев час уходит не в те сутки, где его брали. Считается он один
    раз на смену (lunch_cuts), а потом вычитается из часов той даты и того
    вида — дневных или ночных, — куда попало окно обеда.

    Перерыв из BreakRule здесь не применяется вовсе: обед задан окнами, и
    прежнее правило «час из наибольшего интервала» его заменять не должно.
    """
    lunch = LUNCH if lunch is None else lunch
    rows = list(rows)
    presence = plan_hours(rows, night=night, break_rule=NO_BREAK,
                          round_to=round_to)
    cuts = lunch_cuts(rows, night=night, lunch=lunch)

    #  Часы одной даты могут прийти двумя строками: хвост вчерашней смены и
    #  сегодняшний выход. Обед снимается с этой даты целиком, поэтому строки
    #  собираются вместе
    worked: dict[tuple[int, date], list[float]] = {}
    for row, ph in presence:
        key = (row.employment_id, ph.work_date)
        was = worked.setdefault(key, [0.0, 0.0])
        was[0] = round(was[0] + ph.hours_day, 2)
        was[1] = round(was[1] + ph.hours_night, 2)

    for (employment_id, day, kind), minutes in cuts.items():
        bucket = worked.get((employment_id, day))
        if bucket is None:
            continue    # обед попал в сутки, которых в этом наборе строк нет
        hours = minutes / 60
        first = 1 if kind == "night" else 0
        for index in (first, 1 - first):
            take = min(hours, bucket[index])
            bucket[index] = round(bucket[index] - take, 2)
            hours = round(hours - take, 2)
            if hours <= 0:
                break

    #  Дату могли собрать две строки, а вычет один: раскладываем обратно по
    #  строкам пропорционально их присутствию, начиная с последней
    left: dict[tuple[int, date], list[float]] = {
        key: list(value) for key, value in worked.items()
    }
    out: list[tuple[ShiftRow, PlanHours]] = []
    for row, ph in presence:
        key = (row.employment_id, ph.work_date)
        bucket = left[key]
        take_day = min(ph.hours_day, bucket[0])
        take_night = min(ph.hours_night, bucket[1])
        bucket[0] = round(bucket[0] - take_day, 2)
        bucket[1] = round(bucket[1] - take_night, 2)
        out.append((row, PlanHours(
            work_date=ph.work_date,
            hours_day=ph.hours_day,
            hours_night=ph.hours_night,
            source_date=ph.source_date,
            worked_day=round(take_day, 2),
            worked_night=round(take_night, 2),
        )))
    return out


def month_bounds(period_month: date) -> tuple[date, date]:
    first = period_month.replace(day=1)
    if first.month == 12:
        nxt = first.replace(year=first.year + 1, month=1)
    else:
        nxt = first.replace(month=first.month + 1)
    return first, nxt - timedelta(days=1)


def personal_norm(
    month_norm_hours: float,
    excused_plan_hours: float,
) -> float:
    """
    Персональная норма: норма месяца минус плановые часы, приходящиеся на дни,
    когда сотрудник был освобождён (отпуск, больничный и т.п.).

    Так это описано в порядке применения расчётной нормы (постановление
    Минтруда и соцзащиты № 95 от 16.09.2025): из расчётной нормы работника
    исключается время его отсутствия в соответствии с законодательством,
    приходящееся на дни и часы по утверждённому ему графику работы.

    В действующем расчёте ЗП стоимость часа считается от ПОЛНОЙ нормы месяца,
    поэтому здесь это значение нужно для контроля переработок и недоработок.
    """
    return round(max(0.0, month_norm_hours - excused_plan_hours), 2)


#  Сколько часов даёт день производственного календаря при 40-часовой неделе.
#  Предпраздничный день короче на час (статья 116 ТК), выходной и праздник не
#  дают ничего.
CALENDAR_DAY_HOURS: dict[str, float] = {
    "work": 8.0,
    "preholiday": 7.0,
    "weekend": 0.0,
    "holiday": 0.0,
}


def schedule_norm(
    month_norm_hours: float,
    day_types: dict[date, str],
    first_day: date,
    last_day: date,
    hired_at: date | None = None,
    terminated_at: date | None = None,
) -> float:
    """
    Норма, под которую сдаётся плановый график.

    Решение заказчика от 21.09.2026: в графике закладывается **полная** норма
    месяца всем, независимо от планируемых отпусков и больничных. Отпуска в
    график не вносятся вовсе — они уменьшают норму потом, в табеле, на
    плановые часы тех дней (`personal_norm`).

    Единственное исключение — работа не весь месяц: принятым и уволенным не с
    первого числа норма уменьшается на рабочие дни вне периода работы. Дни
    считаются по производственному календарю: обычный рабочий даёт 8 часов,
    предпраздничный — 7.

    Если календарь на месяц не заполнен, доля посчитаться не может, и норма
    возвращается полной: занижать её молча нельзя.
    """
    if hired_at is None and terminated_at is None:
        return round(month_norm_hours, 2)

    whole = 0.0
    inside = 0.0
    day = first_day
    while day <= last_day:
        if day not in day_types:
            #  В календаре пробел: посчитать долю честно нельзя, а занижать
            #  норму молча нельзя тем более
            return round(month_norm_hours, 2)
        hours = CALENDAR_DAY_HOURS.get(day_types[day], 0.0)
        whole += hours
        if (hired_at is None or day >= hired_at) and (
                terminated_at is None or day <= terminated_at):
            inside += hours
        day += timedelta(days=1)

    if whole <= 0:
        return round(month_norm_hours, 2)
    return round(month_norm_hours * inside / whole, 2)


# Коды дней, на которые норма не начисляется: отсутствие по законодательству.
# Прогула и неявки по невыясненным причинам здесь нет намеренно — эти часы
# работник остался должен, и в отклонении они должны быть видны как
# недоработка. Выходных и праздников тоже нет: они уже учтены в самой
# расчётной норме месяца.
#
# «А» — отпуск без сохранения заработной платы (решение от 14.09.2026).
# Раньше это же означало «ОБ», и оно было здесь; правило не изменилось,
# сменилась буква. «ОБ» оставлено ради баз, где миграцию 31 не накатили.
NORM_EXCUSING_CODES = frozenset({
    "О", "А", "ОБ", "У", "Р", "ОЖ",     # отпуска
    "Б", "Т", "К", "Г", "ГЧ", "ПВ",  # нетрудоспособность, командировка,
                                     # госдела, военные сборы, простой
    "ОД", "ДО",                    # отгул и дополнительный свободный день
})


def excused_plan_hours(
    day_codes: dict[date, str | None],
    plan_by_date: dict[date, float],
    excusing: Container[str] = NORM_EXCUSING_CODES,
) -> float:
    """
    Сколько плановых часов приходится на дни законного отсутствия.

    day_codes    — код дня из табеля по датам месяца
    plan_by_date — плановые часы по датам (сумма всех отрезков смены на дату)

    Дни без кода и дни с кодом, который норму не уменьшает, не считаются.
    Если графика на дату нет, вычитать тоже нечего: норма для такого дня
    ничего не предполагала.
    """
    total = 0.0
    for day, code in day_codes.items():
        if code and code in excusing:
            total += plan_by_date.get(day, 0.0)
    return round(total, 2)
