"""
График трудовых отпусков на год.

Отпуска планируются заранее и утверждаются руководителем: график отпусков —
самостоятельный документ, а не пометка в табеле. Ведётся он по форме, которая
в ООУРЦ уже используется: строка на работника, столбец на месяц, в клетке
запись «11 дней с 07.01» и графа подписи об ознакомлении.

Отсюда два действия, которых нет у других справочников:

  * записанный отпуск сам ставит «О» в график и в табель — на все свои дни.
    Проставлять их руками по тридцать клеток в месяц незачем, а расходиться
    с утверждённым графиком отпусков они не должны;
  * снятый отпуск свою «О» убирает — но только там, где она и стоит. Если в
    клетке уже часы работы, отпуск их не затирает: значит человека вызвали,
    и это решает начальник депо, а не график, составленный в декабре.

Период продлевают праздники и больничный.

Государственные праздники и праздничные дни, приходящиеся на период
трудового отпуска, в число его календарных дней не включаются (статья 151
ТК): «11 дней с 07.01» при празднике 7 января — это 8–18 января. Праздники
берутся из производственного календаря, который ведётся в «Базовых
настройках»: их состав определяет организация, и в коде списка праздников
нет.

Дни временной нетрудоспособности внутри отпуска в его дни тоже не входят:
отпуск на них продлевается (статья 171 ТК). Больничный узнаётся из табеля —
по клеткам с кодом «Б», а не отдельной записью: он и так вносится в табель,
и вводить его дважды незачем. Поэтому «Б», поставленная в табель, сразу
пересчитывает отпуск: дни отпуска сдвигаются, и «О» встаёт на новые.
"""

from __future__ import annotations

import calendar
from datetime import date, timedelta
from typing import Any, Container

import psycopg

FIO_FULL = (
    "e.last_name || ' ' || e.first_name || "
    "coalesce(' ' || e.middle_name, '')"
)

#  Код дня, которым отпуск встаёт в график и табель. Трудовой отпуск — «О»,
#  социальный по беременности и родам — «Р»: так они и обозначены в
#  справочнике обозначений табеля.
#
#  Отпуска за свой счёт здесь нет намеренно. Он не планируется на год: его
#  дают по заявлению, когда обстоятельства уже случились, — и всё, что по
#  нему нужно, это отметка «А» в табеле. Заводить его записью графика значило
#  бы вести документ, которого не существует.
KIND_CODE = {"labour": "О", "social": "Р"}
KIND_RU = {
    "labour": "трудовой",
    "social": "социальный",
}

#  Код отпуска за свой счёт: он ставится в табеле руками, и подсказать это
#  надо там, где человек попробует завести такой отпуск графиком
UNPAID_CODE = "А"

#  Праздник внутри отпуска днём отпуска не считается: в клетке стоит «П» —
#  праздничный день, как его и обозначают в табеле
HOLIDAY_CODE = "П"

#  Больничный. День с этим кодом в табеле днём отпуска не считается: отпуск
#  на него продлевается (статья 171 ТК). Своей записи о больничном система не
#  держит — он вносится в табель, и это единственный его источник
SICK_CODE = "Б"


def vacation_days(
    starts_at: date,
    days: int,
    holidays: Container[date] = frozenset(),
    sick: Container[date] = frozenset(),
) -> list[date]:
    """
    Дни отпуска по записи «11 дней с 07.01».

    Без праздников и больничного это 7–17 января. Продлевают период две
    вещи, и обе — по закону:

      * **праздники.** Государственные праздники и праздничные дни,
        приходящиеся на период трудового отпуска, в число его календарных
        дней не включаются (статья 151 ТК);
      * **больничный.** Дни временной нетрудоспособности внутри отпуска в
        его дни тоже не входят: отпуск на них продлевается (статья 171 ТК).

    Поэтому дни набираются до нужного количества, а такие дни пропускаются:
    «11 дней с 07.01» при празднике 7 января — это 8–18 января.

    Праздники берутся из производственного календаря («Базовые настройки» →
    «Норма рабочего времени»), больничный — из табеля, по клеткам с «Б».
    Выходные дни в отпуск входят и его не продлевают.
    """
    out: list[date] = []
    day = starts_at
    #  Страховка от бесконечного цикла, если календарь заполнят праздниками
    #  или больничный затянется: больше двух месяцев отпуск не тянется
    limit = starts_at + timedelta(days=max(0, days) + 70)
    while len(out) < max(0, days) and day <= limit:
        if day not in holidays and day not in sick:
            out.append(day)
        day += timedelta(days=1)
    return out


def vacation_span(
    starts_at: date,
    days: int,
    holidays: Container[date] = frozenset(),
    sick: Container[date] = frozenset(),
) -> dict[str, Any]:
    """
    Период отсутствия по записи отпуска: с какого по какое и чем продлён.

    Первый день — дата из записи, даже если она сама праздничная или человек
    в этот день заболел: с этого дня работника на месте нет. Последний —
    последний день отпуска с учётом переноса. Праздники и дни больничного
    возвращаются отдельными списками: в отпуске они отмечаются по-разному, и
    объяснять продление надо тем, что его вызвало.
    """
    picked = vacation_days(starts_at, days, holidays, sick)
    if not picked:
        return {"first": starts_at, "last": starts_at, "holidays": [],
                "sick": [], "shift": 0, "days": 0}
    last = picked[-1]
    inside = [starts_at + timedelta(days=i)
              for i in range((last - starts_at).days + 1)]
    holidays_in = [d for d in inside if d in holidays]
    sick_in = [d for d in inside if d in sick and d not in holidays]
    return {
        "first": starts_at,
        "last": last,
        "holidays": holidays_in,
        "sick": sick_in,
        "shift": len(holidays_in) + len(sick_in),
        "days": len(picked),
    }


def sick_days(
    conn: psycopg.Connection, employee_id: int, first: date, last: date
) -> set[date]:
    """
    Дни временной нетрудоспособности работника из табеля — клетки с «Б».

    Отдельной записи о больничном система не ведёт: он и так вносится в
    табель, и второй источник правды здесь только разошёлся бы с первым.
    Берётся по всем назначениям человека: больничный не прерывается
    переводом внутри отдела.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT DISTINCT td.work_date
              FROM app.timesheet_day td
              JOIN app.employment em ON em.id = td.employment_id
             WHERE em.employee_id = %s
               AND td.day_code = %s
               AND td.work_date BETWEEN %s AND %s
            """,
            (employee_id, SICK_CODE, first, last),
        )
        return {r["work_date"] for r in cur.fetchall()}


#  Предел длины одной записи (02.10.2026, вычитка 3.22): трудовой — 60 дней,
#  социальный (по беременности и родам — 126, при осложнениях 140, при
#  двойне 160 календарных дней) — до 200
MAX_DAYS = {"labour": 60, "social": 200}


def holidays_for(kind_or_code: str | None, holidays: Container[date]):
    """
    Праздники, которые продлевают отпуск. Трудовой отпуск продлевается на
    праздники (статья 151 ТК); социальный считается календарными днями —
    праздники входят в него и ничего не продлевают.
    """
    if kind_or_code in ("social", KIND_CODE["social"]):
        return frozenset()
    return holidays


def holidays_of_year(conn: psycopg.Connection, year: int) -> set[date]:
    """
    Праздничные дни года из производственного календаря.

    Год берётся с запасом на месяц вперёд: отпуск, начатый в декабре,
    заканчивается в январе, и праздники января на его длину тоже влияют.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT day FROM app.calendar_day
             WHERE day_type = 'holiday'
               AND day >= make_date(%s, 1, 1)
               AND day <  make_date(%s + 1, 3, 1)
            """,
            (year, year),
        )
        return {r["day"] for r in cur.fetchall()}


def vacations(
    conn: psycopg.Connection, unit_id: int | None, year: int
) -> list[dict[str, Any]]:
    """Все записи отпусков депо за год — по людям и датам."""
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT v.id, v.employee_id, v.org_unit_id, v.starts_at, v.days,
                   v.kind, v.note, v.acknowledged,
                   e.personnel_no, {FIO_FULL} AS fio_full,
                   e.last_name, e.first_name, e.middle_name,
                   p.name AS position_name,
                   ou.name AS unit_name
            FROM app.vacation_plan v
            JOIN app.employee e ON e.id = v.employee_id
            JOIN app.org_unit ou ON ou.id = v.org_unit_id
            LEFT JOIN app.employment em
                   ON em.employee_id = e.id AND em.terminated_at IS NULL
            LEFT JOIN app.position p ON p.id = em.position_id
            WHERE v.year = %(year)s
              AND (%(unit)s::bigint IS NULL OR v.org_unit_id = %(unit)s)
            ORDER BY e.last_name, e.first_name, v.starts_at
            """,
            {"year": year, "unit": unit_id},
        )
        return cur.fetchall()


def people_for_year(
    conn: psycopg.Connection, unit_id: int | None, year: int
) -> list[dict[str, Any]]:
    """
    Кого показывать в графике отпусков: кто работал в депо в этом году.

    Уволенные в середине года остаются: отпуск у них был, и из графика он
    никуда не девается. Принятые в конце года тоже нужны — им отпуск ещё
    планировать.
    """
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT DISTINCT ON (e.id)
                   e.id AS employee_id, e.personnel_no,
                   {FIO_FULL} AS fio_full,
                   e.last_name, e.first_name, e.middle_name,
                   p.name AS position_name,
                   em.org_unit_id, ou.name AS unit_name,
                   em.terminated_at
            FROM app.employment em
            JOIN app.employee e ON e.id = em.employee_id
            JOIN app.org_unit ou ON ou.id = em.org_unit_id
            LEFT JOIN app.position p ON p.id = em.position_id
            WHERE (%(unit)s::bigint IS NULL OR em.org_unit_id = %(unit)s)
              AND em.hired_at < make_date(%(year)s + 1, 1, 1)
              AND (em.terminated_at IS NULL
                   OR em.terminated_at >= make_date(%(year)s, 1, 1))
            ORDER BY e.id, em.terminated_at NULLS FIRST, em.id DESC
            """,
            {"year": year, "unit": unit_id},
        )
        rows = cur.fetchall()
    return sorted(rows, key=lambda r: (r["last_name"] or "", r["first_name"] or ""))


def by_person_and_month(
    people: list[dict[str, Any]], records: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    """
    Сложить график в вид формы: строка человека, двенадцать столбцов месяцев.

    В клетке может быть несколько записей: отпуск часто делят на части — «11
    дней с 07.01» и «14 дней с 16.08». Поэтому в клетке список, а не запись.
    """
    out = []
    for person in people:
        months: dict[int, list[dict[str, Any]]] = {m: [] for m in range(1, 13)}
        total = 0
        acknowledged = False
        for r in records:
            if r["employee_id"] != person["employee_id"]:
                continue
            months[r["starts_at"].month].append(r)
            total += int(r["days"])
            acknowledged = acknowledged or bool(r["acknowledged"])
        out.append({
            "person": person,
            "months": months,
            "total_days": total,
            "acknowledged": acknowledged,
        })
    return out


# ---------------------------------------------------------------------------
#  Контрактный (рабочий) год
#
#  Решение заказчика от 14.09.2026: отпуск планируется в календарном году, а
#  отгуливается в пределах контрактного года, и считается этот год **от даты
#  трудоустройства**. Отпуск, вылезающий за его границу, не записывается —
#  человеку показывается предупреждение и предлагается изменить период.
#
#  Дата трудоустройства — начало непрерывной работы, а не дата последнего
#  назначения: перевод из депо в депо трудоустройство не прерывает, и
#  сдвигать из-за него рабочий год человека нельзя. Разрыв больше одного дня
#  считается новым трудоустройством: человек уволился и вернулся, и рабочий
#  год у него пошёл заново.
# ---------------------------------------------------------------------------

#  Зазор, который ещё не считается перерывом в работе: перевод оформляют
#  «уволен 31-го, принят 1-го», и это один и тот же непрерывный стаж
CONTINUITY_GAP_DAYS = 1


def hired_since(
    conn: psycopg.Connection, employee_id: int, on_day: date | None = None
) -> date | None:
    """
    Дата трудоустройства — начало непрерывного периода работы, в который
    попадает `on_day` (по умолчанию — последний период).

    Возвращает None, если назначений нет вовсе.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT hired_at, terminated_at FROM app.employment
            WHERE employee_id = %s ORDER BY hired_at, id
            """,
            (employee_id,),
        )
        rows = cur.fetchall()
    if not rows:
        return None

    #  Склеиваем назначения в непрерывные периоды работы
    spans: list[list[date | None]] = []
    for r in rows:
        start, end = r["hired_at"], r["terminated_at"]
        if spans and spans[-1][1] is not None and                 (start - spans[-1][1]).days <= CONTINUITY_GAP_DAYS:
            #  Продолжение той же работы: конец периода двигаем вперёд
            spans[-1][1] = end
        elif spans and spans[-1][1] is None:
            #  Прежнее назначение не закрыто — значит это перевод, и работа
            #  не прерывалась
            spans[-1][1] = end
        else:
            spans.append([start, end])

    if on_day is not None:
        for start, end in spans:
            if start <= on_day and (end is None or on_day <= end):
                return start
        #  День раньше первого приёма или в перерыве: берём ближайший
        #  начавшийся до него период, иначе первый вообще
        before = [start for start, _ in spans if start <= on_day]
        return before[-1] if before else spans[0][0]
    return spans[-1][0]


def contract_year(hired: date, on_day: date) -> dict[str, Any]:
    """
    Границы контрактного года, в который попадает `on_day`.

    Год отсчитывается от даты трудоустройства: принят 17.03.2023 — рабочие
    годы идут 17.03.2023–16.03.2024, 17.03.2024–16.03.2025 и так далее.
    """
    n = on_day.year - hired.year
    #  Годовщина в этом году ещё не наступила — значит идёт предыдущий год
    if (on_day.month, on_day.day) < (hired.month, hired.day):
        n -= 1
    start = _anniversary(hired, n)
    end = _anniversary(hired, n + 1) - timedelta(days=1)
    return {"no": n + 1, "hired": hired, "first": start, "last": end}


def _anniversary(hired: date, years: int) -> date:
    """
    Годовщина трудоустройства через `years` лет.

    29 февраля переносим на 1 марта: рабочий год не может исчезать раз в
    четыре года.
    """
    try:
        return hired.replace(year=hired.year + years)
    except ValueError:
        return date(hired.year + years, 3, 1)


def check_contract_year(
    conn: psycopg.Connection, employee_id: int, first: date, last: date
) -> dict[str, Any] | None:
    """
    Проверить, что отпуск укладывается в один контрактный год.

    Возвращает границы года — или поднимает ValueError с объяснением, если
    отпуск за них выходит. Решение заказчика: такую запись не делаем вовсе.
    Если даты трудоустройства нет, проверять нечего.
    """
    hired = hired_since(conn, employee_id, first)
    if hired is None:
        return None
    year = contract_year(hired, first)
    if last <= year["last"]:
        return year

    over = (last - year["last"]).days
    raise ValueError(
        f"Отпуск выходит за контрактный год. Он считается от даты "
        f"трудоустройства {hired:%d.%m.%Y}: текущий год — "
        f"{year['first']:%d.%m.%Y}—{year['last']:%d.%m.%Y}, а отпуск "
        f"кончается {last:%d.%m.%Y}, то есть на {over} дн. позже. "
        f"Дни отпуска отгуливаются внутри контрактного года — измените "
        f"период: начните раньше, сократите число дней или заведите остаток "
        f"отдельной записью в следующем контрактном году"
    )


def save_vacation(
    conn: psycopg.Connection,
    *,
    vac_id: int | None,
    employee_id: int,
    org_unit_id: int,
    starts_at: date,
    days: int,
    kind: str = "labour",
    note: str | None = None,
    user_id: int | None = None,
) -> dict[str, Any]:
    """
    Записать отпуск и проставить его «О» в график и табель.

    Проверки идут до записи, чтобы в ответ приходило понятное сообщение, а
    не текст ошибки базы.
    """
    if kind == "unpaid":
        raise ValueError(
            "Отпуск за свой счёт графиком не планируется: он даётся по "
            f"заявлению. Отметьте эти дни в табеле кодом «{UNPAID_CODE}» — "
            "больше по нему ничего не нужно"
        )
    if kind not in KIND_CODE:
        raise ValueError("Вид отпуска: трудовой или социальный")
    limit = MAX_DAYS.get(kind, 60)
    if not 1 <= days <= limit:
        raise ValueError(f"Дней отпуска — от 1 до {limit}")

    year = starts_at.year
    holidays = holidays_for(kind, holidays_of_year(conn, year))
    #  Больничный внутри отпуска его дни не занимает: берём с запасом,
    #  потому что от него же зависит, где период кончится
    sick = sick_days(conn, employee_id, starts_at,
                     starts_at + timedelta(days=days + 70))
    span = vacation_span(starts_at, days, holidays, sick)
    last = span["last"]
    if last.year != year:
        raise ValueError(
            "Отпуск переходит на следующий год: заведите его двумя записями — "
            f"по {(date(year + 1, 1, 1) - starts_at).days} дн. с "
            f"{starts_at:%d.%m} и остаток с 01.01"
        )

    #  Дни отпуска отгуливаются внутри контрактного года (решение заказчика
    #  от 14.09.2026). Проверяем до записи: такую запись не делаем вовсе
    check_contract_year(conn, employee_id, span["first"], last)

    with conn.cursor() as cur:
        #  Наложение на другой отпуск того же человека — почти всегда
        #  опечатка в дате или в числе дней
        cur.execute(
            """
            SELECT id, starts_at, days FROM app.vacation_plan
             WHERE employee_id = %s AND (%s::bigint IS NULL OR id <> %s)
               AND starts_at <= %s
               AND (starts_at + (days - 1) * interval '1 day')::date >= %s
            """,
            (employee_id, vac_id, vac_id, last, starts_at),
        )
        clash = cur.fetchone()
        if clash:
            raise ValueError(
                f"Уже есть отпуск {clash['days']} дн. с "
                f"{clash['starts_at']:%d.%m.%Y} — эти дни пересекаются"
            )

        if vac_id:
            #  Прежние дни могли быть другими: сначала снимаем старую «О»,
            #  потом ставим новую — иначе в графике остались бы лишние дни
            _drop_code(conn, cur, vac_id)
            cur.execute(
                """
                UPDATE app.vacation_plan
                   SET employee_id = %s, org_unit_id = %s, year = %s,
                       starts_at = %s, days = %s, kind = %s, note = %s,
                       updated_by = %s, updated_at = now()
                 WHERE id = %s
                RETURNING id, starts_at, days, kind
                """,
                (employee_id, org_unit_id, year, starts_at, days, kind,
                 note, user_id, vac_id),
            )
        else:
            cur.execute(
                """
                INSERT INTO app.vacation_plan
                    (employee_id, org_unit_id, year, starts_at, days, kind,
                     note, updated_by)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                RETURNING id, starts_at, days, kind
                """,
                (employee_id, org_unit_id, year, starts_at, days, kind,
                 note, user_id),
            )
        row = cur.fetchone()
        if row is None:
            raise ValueError("Запись отпуска не найдена — обновите страницу")
        placed = _put_code(conn, cur, employee_id, starts_at, int(days),
                           KIND_CODE[kind], holidays, sick)
    return {**row, "placed": placed, "span": span}


def move_vacation(
    conn: psycopg.Connection,
    *,
    vac_id: int,
    shift_days: int,
    reason: str,
    user_id: int | None = None,
) -> dict[str, Any]:
    """
    Перенести отпуск на несколько дней вперёд или назад — пункт 22 плана.

    Сотрудники просят сдвинуть отпуск, и до сих пор это делалось правкой
    даты: после неё от прежнего срока не оставалось следа. График отпусков
    утверждается приказом, и «когда было и стало» — то, что спрашивают
    первым. Поэтому перенос отдельным действием, с обязательной причиной и
    записью в `vacation_move`.

    Порядок важен: сначала снимаем прежние коды из табеля, потом двигаем
    запись, потом ставим коды на новые дни. Иначе старые «О» остались бы
    висеть на прежних числах.
    """
    if not shift_days:
        raise ValueError("Перенос на ноль дней ничего не меняет")
    if not (reason or "").strip():
        raise ValueError("Перенос отпуска требует причины: он идёт по заявлению")

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, employee_id, org_unit_id, starts_at, days, kind
            FROM app.vacation_plan WHERE id = %s
            """,
            (vac_id,),
        )
        row = cur.fetchone()
        if row is None:
            raise ValueError("Запись отпуска не найдена — обновите страницу")

        was = row["starts_at"]
        now = was + timedelta(days=shift_days)
        if now.year != was.year:
            raise ValueError(
                f"Перенос уводит отпуск в {now.year} год, а график составлен "
                f"на {was.year}. Заведите отпуск в графике нужного года"
            )

        #  Та же проверка, что при записи: перенос не должен вывести отпуск
        #  за контрактный год. Считаем до того, как что-то поменяли
        holidays_now = holidays_for(row.get("kind"), holidays_of_year(conn, now.year))
        sick_now = sick_days(conn, row["employee_id"], now,
                             now + timedelta(days=int(row["days"]) + 70))
        span_now = vacation_span(now, int(row["days"]), holidays_now, sick_now)
        check_contract_year(conn, row["employee_id"],
                            span_now["first"], span_now["last"])

        #  Снимаем прежние коды до сдвига: _drop_code читает запись из базы
        _drop_code(conn, cur, vac_id)

        cur.execute(
            "UPDATE app.vacation_plan SET starts_at = %s, updated_by = %s, "
            "updated_at = now() WHERE id = %s",
            (now, user_id, vac_id),
        )
        cur.execute(
            """
            INSERT INTO app.vacation_move
                (vacation_id, was_starts_at, now_starts_at, days, reason, moved_by)
            VALUES (%s, %s, %s, %s, %s, %s)
            """,
            (vac_id, was, now, int(row["days"]), reason.strip(), user_id),
        )

        placed = _put_code(conn, cur, row["employee_id"], now, int(row["days"]),
                           KIND_CODE[row["kind"]], holidays_now, sick_now)
        span = span_now
    conn.commit()
    return {"was": was, "now": now, "days": int(row["days"]),
            "shift": shift_days, "span": span, "placed": placed}


def moves_of(conn: psycopg.Connection, vac_ids: list[int]) -> dict[int, list[dict[str, Any]]]:
    """История переносов по записям отпусков — для отметки в таблице."""
    if not vac_ids:
        return {}
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT m.vacation_id, m.was_starts_at, m.now_starts_at, m.days,
                   m.reason, m.moved_at, u.full_name AS moved_by_name
            FROM app.vacation_move m
            LEFT JOIN app.app_user u ON u.id = m.moved_by
            WHERE m.vacation_id = ANY(%s)
            ORDER BY m.moved_at
            """,
            (vac_ids,),
        )
        out: dict[int, list[dict[str, Any]]] = {}
        for r in cur.fetchall():
            out.setdefault(r["vacation_id"], []).append(r)
    return out


def delete_vacation(conn: psycopg.Connection, vac_id: int) -> None:
    """Убрать отпуск из графика вместе с его «О» в графике и табеле."""
    with conn.cursor() as cur:
        _drop_code(conn, cur, vac_id)
        cur.execute("DELETE FROM app.vacation_plan WHERE id = %s", (vac_id,))
        if cur.rowcount == 0:
            raise ValueError("Запись отпуска не найдена — обновите страницу")


def set_acknowledged(
    conn: psycopg.Connection, employee_id: int, year: int, value: bool
) -> None:
    """Отметка «работник ознакомлен с графиком» — графа формы."""
    with conn.cursor() as cur:
        cur.execute(
            """
            UPDATE app.vacation_plan SET acknowledged = %s, updated_at = now()
             WHERE employee_id = %s AND year = %s
            """,
            (value, employee_id, year),
        )


# ---------------------------------------------------------------------------
#  «О» в графике и табеле
# ---------------------------------------------------------------------------

def _employments(cur, employee_id: int, days: list[date]) -> dict[date, int]:
    """
    Назначение человека на каждый день отпуска.

    У человека их может быть несколько — например после перевода. Отпуск
    ложится в то назначение, в границы которого попадает день.
    """
    cur.execute(
        """
        SELECT id, org_unit_id, hired_at, terminated_at
        FROM app.employment WHERE employee_id = %s ORDER BY id
        """,
        (employee_id,),
    )
    rows = cur.fetchall()
    out: dict[date, int] = {}
    for day in days:
        for r in rows:
            if r["hired_at"] and day < r["hired_at"]:
                continue
            #  02.10.2026 (вычитка 3.22): день увольнения — ещё рабочий день
            #  назначения; раньше отпуск в него не ставился
            if r["terminated_at"] and day > r["terminated_at"]:
                continue
            out[day] = r["id"]
            break
    return out


def _writable_statuses(cur) -> list[str]:
    """
    В табель каких состояний отпуск пишется (02.10.2026, вычитка 3.22).

    Сданный и проверяемый табель правит только Администрация — у депо
    запись отпуска такой месяц пропускает, а не падает целиком с ошибкой.
    Утверждённый и закрытый не правит никто.
    """
    cur.execute("SELECT app.has_perm('timesheet.approve') AS hq")
    hq = bool(cur.fetchone()["hq"])
    #  Отпуск снимает смены и в сданном графике — это своя операция
    cur.execute("SELECT set_config('app.system_op', 'vacation', true)")
    return ["open", "submitted", "in_review"] if hq else ["open"]


def _put_code(conn, cur, employee_id: int, starts_at: date, days: int,
              code: str, holidays: Container[date] = frozenset(),
              sick: Container[date] = frozenset()) -> dict[str, int]:
    """
    Поставить код отпуска в табель на все дни отпуска.

    **В плановый график отпуск не пишется** — пункт 21 плана от 14.09.2026.
    В графике стоят только плановые смены; отпуск планируется на год вперёд,
    а разносится по табелю того месяца, на который пришёлся. Так график
    остаётся тем, чем его сдают в 1С ЗУП, — расписанием смен.

    Днями отпуска не считаются две вещи, и обе продлевают период:

      * праздники (статья 151 ТК) — в их клетке стоит «П», как в табеле;
      * дни больничного (статья 171 ТК) — там уже стоит «Б», и трогать её
        нельзя: это документ, подтверждённый листком нетрудоспособности.

    Часы работы тоже не затираются: если в клетке уже стоит время, значит
    человека вызвали, и решает это начальник депо, а не график отпусков,
    составленный в декабре. Такие дни возвращаются в отчёте.
    """
    holidays = holidays_for(code, holidays)
    span = vacation_span(starts_at, days, holidays, sick)
    plan_days = vacation_days(starts_at, days, holidays, sick)
    codes = {d: code for d in plan_days}
    #  Праздники внутри периода отмечаем «П»; дни больничного не трогаем —
    #  «Б» в них уже стоит, и она главнее отпуска
    codes.update({d: HOLIDAY_CODE for d in span["holidays"]})
    by_day = _employments(cur, employee_id, sorted(codes))
    put_plan = put_fact = busy = put_holiday = 0
    statuses = _writable_statuses(cur)

    for day, employment_id in by_day.items():
        code = codes[day]
        #  В табель — только пока правка разрешена: у утверждённого и
        #  закрытого табеля график отпусков ничего не переписывает
        cur.execute(
            """
            INSERT INTO app.timesheet_day
                (timesheet_id, employment_id, work_date, day_code, updated_by,
                 updated_at)
            SELECT t.id, %s, %s, %s,
                   nullif(current_setting('app.user_id', true), '')::bigint,
                   now()
              FROM app.timesheet t
              JOIN app.employment em ON em.id = %s
             WHERE t.org_unit_id = em.org_unit_id
               AND t.period_month = date_trunc('month', %s::date)::date
               AND t.status = ANY(%s)
            ON CONFLICT (timesheet_id, employment_id, work_date) DO UPDATE
               SET day_code = EXCLUDED.day_code,
                   hours_day = 0, hours_night = 0,
                   hours_weekend = 0, hours_overtime = 0,
                   updated_by = EXCLUDED.updated_by, updated_at = now()
             WHERE app.timesheet_day.hours_day = 0
               AND app.timesheet_day.hours_night = 0
            """,
            (employment_id, day, code, employment_id, day, statuses),
        )
        if cur.rowcount:
            #  Праздники внутри отпуска считаем отдельно: в сообщении «О» и
            #  «П» смешивать нельзя, иначе дней выходит больше, чем в отпуске
            if code == HOLIDAY_CODE:
                put_holiday += 1
            else:
                put_fact += 1
        else:
            #  Клетка занята: либо в ней уже стоят часы, либо месяц закрыт
            busy += 1

    conn.commit()
    return {"plan": put_plan, "fact": put_fact, "busy": busy,
            "holiday": put_holiday}


def _drop_code(conn, cur, vac_id: int) -> None:
    """
    Убрать код отпуска, поставленный этой записью.

    Убирается только там, где он и стоит: часы работы и другие коды
    остаются. Иначе снятие отпуска стирало бы то, что после него ввели
    руками.
    """
    cur.execute(
        "SELECT employee_id, starts_at, days, kind FROM app.vacation_plan "
        " WHERE id = %s",
        (vac_id,),
    )
    row = cur.fetchone()
    if row is None:
        return
    code = KIND_CODE.get(row["kind"], "О")
    #  Праздники берём те же, что и при постановке: иначе часть дней
    #  осталась бы с кодом навсегда
    cur.execute(
        """
        SELECT day FROM app.calendar_day
         WHERE day_type = 'holiday' AND day >= %s AND day <= %s
        """,
        (row["starts_at"], row["starts_at"] + timedelta(days=int(row["days"]) + 70)),
    )
    holidays = holidays_for(code, {r["day"] for r in cur.fetchall()})
    sick = sick_days(conn, row["employee_id"], row["starts_at"],
                     row["starts_at"] + timedelta(days=int(row["days"]) + 70))
    span = vacation_span(row["starts_at"], int(row["days"]), holidays, sick)
    days = vacation_days(row["starts_at"], int(row["days"]), holidays, sick)
    codes = {d: code for d in days}
    codes.update({d: HOLIDAY_CODE for d in span["holidays"]})
    by_day = _employments(cur, row["employee_id"], sorted(codes))
    statuses = _writable_statuses(cur)

    for day, employment_id in by_day.items():
        code = codes[day]
        #  Из графика код убираем по-прежнему: в графике его больше не
        #  ставят (пункт 21), но у отпусков, записанных до этой правки, он
        #  там есть, и при отмене отпуска должен исчезнуть
        cur.execute(
            """
            DELETE FROM app.schedule_plan
             WHERE employment_id = %s AND work_date = %s AND day_code = %s
               AND shift_start IS NULL
            """,
            (employment_id, day, code),
        )
        cur.execute(
            """
            DELETE FROM app.timesheet_day td
             USING app.timesheet t
             WHERE td.timesheet_id = t.id
               AND td.employment_id = %s AND td.work_date = %s
               AND td.day_code = %s
               AND t.status = ANY(%s)
            """,
            (employment_id, day, code, statuses),
        )


def days_by_employee(
    conn: psycopg.Connection, unit_id: int, period: date
) -> dict[int, list[date]]:
    """
    На какие дни месяца у каждого работника депо приходится отпуск.

    Нужно там, где отпуск должен сойтись с плановым графиком: норма в графике
    остаётся полной (решение заказчика от 21.09.2026), а уменьшается она
    потом, в табеле — на плановые часы тех дней, которые человек отгулял.
    Значит смены на дни отпуска в графике обязаны стоять, иначе вычитать
    будет нечего и в табеле появится недоработка, которой не было.

    Отпуск считается ровно так же, как при разносе по табелю: праздники и дни
    больничного его продлевают, поэтому берутся те же поправки.
    """
    first = period.replace(day=1)
    last = date(first.year, first.month,
                calendar.monthrange(first.year, first.month)[1])
    out: dict[int, list[date]] = {}

    with conn.cursor() as cur:
        #  Отпуск мог начаться в прошлом месяце: берём с запасом назад, лишнее
        #  отсеется по датам
        cur.execute(
            """
            SELECT v.employee_id, v.starts_at, v.days, v.kind
            FROM app.vacation_plan v
            WHERE v.org_unit_id = %s
              AND v.starts_at <= %s
              AND v.starts_at + (v.days + 70) > %s
            ORDER BY v.starts_at
            """,
            (unit_id, last, first),
        )
        records = cur.fetchall()

    for row in records:
        holidays = holidays_for(row.get("kind"),
                                holidays_of_year(conn, row["starts_at"].year))
        sick = sick_days(conn, row["employee_id"], row["starts_at"],
                         row["starts_at"] + timedelta(days=int(row["days"]) + 70))
        for day in vacation_days(row["starts_at"], int(row["days"]),
                                 holidays, sick):
            if first <= day <= last:
                out.setdefault(row["employee_id"], []).append(day)

    for days in out.values():
        days.sort()
    return out


def place_for_month(
    conn: psycopg.Connection, unit_id: int, period: date
) -> dict[str, int]:
    """
    Разнести запланированные отпуска по табелю открывшегося месяца.

    Нужно из-за пункта 21: отпуск больше не пишется в плановый график, а в
    табель он попадает только в существующий документ. График отпусков
    составляют в декабре на год вперёд, табеля будущих месяцев тогда ещё
    нет — и без этого разноса «О» не появилась бы нигде вовсе.

    Поэтому при открытии месяца отпуска, которые на него пришлись,
    проставляются сами. Повторный вызов безвреден: клетки с часами и уже
    стоящие коды не трогаются.
    """
    first = period.replace(day=1)
    last = date(first.year, first.month,
                calendar.monthrange(first.year, first.month)[1])
    total = {"fact": 0, "busy": 0, "holiday": 0, "plan": 0}

    with conn.cursor() as cur:
        #  Отпуск мог начаться в прошлом месяце и продолжаться в этом:
        #  берём с запасом назад, а лишние дни отсеет сам разнос по датам
        cur.execute(
            """
            SELECT v.id, v.employee_id, v.starts_at, v.days, v.kind
            FROM app.vacation_plan v
            WHERE v.org_unit_id = %s
              AND v.starts_at <= %s
              AND v.starts_at + (v.days + 70) > %s
            ORDER BY v.starts_at
            """,
            (unit_id, last, first),
        )
        records = cur.fetchall()

        for row in records:
            holidays = holidays_for(row.get("kind"),
                                    holidays_of_year(conn, row["starts_at"].year))
            sick = sick_days(conn, row["employee_id"], row["starts_at"],
                             row["starts_at"] + timedelta(days=int(row["days"]) + 70))
            placed = _put_code(conn, cur, row["employee_id"], row["starts_at"],
                               int(row["days"]), KIND_CODE[row["kind"]],
                               holidays, sick)
            for key in total:
                total[key] += placed[key]
    total["vacations"] = len(records)
    return total


def refresh_around(
    conn: psycopg.Connection, employee_id: int, day: date
) -> list[dict[str, Any]]:
    """
    Пересчитать отпуска работника, на которые повлияла эта дата.

    Нужно, когда в табель внесли или убрали больничный: дни отпуска
    сдвигаются, и «О» должна встать на новые. Без пересчёта отпуск остался
    бы там, где его записали в декабре, а работник вернулся бы на работу
    раньше положенного — и это было бы видно только глазами.

    Пересчитываются записи, чей период мог задеть эту дату: от двух месяцев
    до неё до двух месяцев после. Больничный длиной больше двух месяцев
    отпуск и так уже прервал.

    Возвращает, что изменилось: по записи — прежний и новый последний день.
    """
    window = timedelta(days=70)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, employee_id, org_unit_id, starts_at, days, kind
              FROM app.vacation_plan
             WHERE employee_id = %s
               AND starts_at BETWEEN %s AND %s
             ORDER BY starts_at
            """,
            (employee_id, day - window, day + window),
        )
        rows = cur.fetchall()

    changed: list[dict[str, Any]] = []
    for row in rows:
        holidays = holidays_for(row.get("kind"),
                                holidays_of_year(conn, row["starts_at"].year))
        with conn.cursor() as cur:
            #  Каким период был до правки табеля — по прежним больничным
            #  судить нельзя, поэтому сравниваем с тем, что стоит в графике
            cur.execute(
                """
                SELECT max(sp.work_date) AS last_day
                  FROM app.schedule_plan sp
                  JOIN app.employment em ON em.id = sp.employment_id
                 WHERE em.employee_id = %s AND sp.day_code = %s
                   AND sp.work_date BETWEEN %s AND %s
                """,
                (row["employee_id"], KIND_CODE.get(row["kind"], "О"),
                 row["starts_at"], row["starts_at"] + timedelta(days=int(row["days"]) + 70)),
            )
            was = cur.fetchone()["last_day"]

            _drop_code(conn, cur, row["id"])
            sick = sick_days(conn, row["employee_id"], row["starts_at"],
                             row["starts_at"] + timedelta(days=int(row["days"]) + 70))
            span = vacation_span(row["starts_at"], int(row["days"]),
                                 holidays, sick)
            _put_code(conn, cur, row["employee_id"], row["starts_at"],
                      int(row["days"]), KIND_CODE.get(row["kind"], "О"),
                      holidays, sick)
        if was != span["last"]:
            changed.append({
                "id": row["id"],
                "starts_at": row["starts_at"],
                "days": int(row["days"]),
                "was_last": was,
                "last": span["last"],
                "sick": span["sick"],
                "holidays": span["holidays"],
            })
    conn.commit()
    return changed
