"""
Канбан начальника РЦ — пункт 24 плана от 14.09.2026.

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

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

* подходит срок медосмотра, инструктажа, удостоверения, контракта;
* СИЗ пора менять;
* табель месяца не сдан, график не сдан;
* у принятого не заполнена карточка — нет медосмотра, инструктажа или СИЗ;
* открыта заявка на ремонт, подошло ТО;
* кадровая заявка депо ждёт решения.

Как это живёт
-------------

Задачи недели один раз материализуются (`refresh`), дальше у каждой своя
судьба: закрыта руками, закрыта сама или осталась в работе. «Как только внёс
— задача закрыта успешно» из задания — это `auto_done`: причина исчезла,
данные появились в карточке, и отмечать ничего не нужно.

Вычислять задачи на лету было бы проще, но тогда нечего показать в
«результате работы»: исчезнувшая причина неотличима от сделанной работы.
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import date, timedelta
from typing import Any
from uuid import uuid4

import psycopg

#  За сколько дней до срока задача появляется на доске. Две недели — чтобы
#  успеть записать человека на медосмотр и дождаться очереди
LEAD_DAYS = 14
#  Повторный инструктаж — за неделю до срока (вычитка 2.25, 02.10.2026)
BRIEFING_LEAD_DAYS = 7

STATUS_RU = {
    "open": "В работе",
    #  Вычитка LOGIKA_PROSTO 30.09.2026 (п. 6.1): состояния «Сделано» больше
    #  нет — и отмеченное кнопкой, и закрывшееся сами данными читаются
    #  одинаково: «Выполнено». Код оставлен прежним — по нему видно, чем
    #  задача закрыта: отметкой или самой работой (у отметки есть
    #  «Вернуть в работу», у закрывшейся самой — нет)
    "done": "Выполнено",
    #  Уточнение заказчика от 15.09.2026: «закрыто само — это когда сотрудник
    #  исправил дату и выполнил действие, значит это статус выполнено».
    #  Название было неточным и обесценивало работу: задача исчезла не сама
    #  по себе, а потому что человек внёс данные. Код оставлен прежним —
    #  по нему видно, чем задача закрыта: отметкой или самой работой
    "auto_done": "Выполнено",
    "skipped": "Отложено",
    #  Вычитка 30.09.2026 (п. 6.1): новое состояние «Просрочено» — срок
    #  задачи прошёл, а она всё ещё не закрыта. И «вернувшееся» из переноса:
    #  в день переноса задача снова видна наверху доски как «Отложено»,
    #  на следующий день становится «Просрочено». Оба состояния вычисляются
    #  на лету — в таблице они не хранятся, потому что «просроченность»
    #  зависит от сегодняшнего дня, а не от недели строки
    "overdue": "Просрочено",
    "returned": "Отложено",
}

#  Порядок состояний на доске (вычитка 30.09.2026, п. 6.2): вернувшиеся из
#  переноса — в самом вверху (их день настал), дальше просроченные, работа,
#  отложенные, выполненные. Действует во всех режимах времени и состава
STATUS_ORDER = ("returned", "overdue", "open", "skipped", "done", "auto_done")

#  Что считается выполненной работой. Обе отметки — про сделанное, и в
#  сводке начальника они складываются
DONE_STATUSES = ("done", "auto_done")


def effective_status(task: dict[str, Any], today: date | None = None) -> str:
    """
    Состояние задачи на экране — каким его видит доска (вычитка 30.09.2026).

    «Просрочено» — открытая задача, чей срок уже прошёл, или отложенная, у
    которой истёк перенос: на следующий день после даты переноса она
    просрочена так же, как и незамеченный срок. «Вернувшееся» — отложенная,
    у которой дата переноса наступила сегодня: стоит наверху доски как
    «Отложено», без даты переноса и «кто отложил», но с причиной.

    Состояния вычисляются от сегодняшнего дня, а не хранятся в строке:
    вчерашняя «в работе» сегодня утром — уже «просрочено», и для этого
    никому не надо открывать доску.
    """
    today = today or date.today()
    status = task["status"]
    if status in DONE_STATUSES:
        return status
    if status == "skipped":
        until = task.get("postponed_to")
        if until is None:
            #  Отложенной без переноса не бывает: строку вернули в работу
            #  или стёрли запись переноса — показываем как открытую
            return "open"
        if until > today:
            return "skipped"
        if until == today:
            return "returned"
        return "overdue"
    if status == "open" and task.get("due_at") and task["due_at"] < today:
        return "overdue"
    return "open"


def board_order(task: dict[str, Any], today: date | None = None) -> tuple:
    """Ключ сортировки строки доски: иерархия состояний, затем срок."""
    rank = STATUS_ORDER.index(effective_status(task, today))
    return (rank, task.get("due_at") is None,
            task.get("due_at") or date.max, task.get("kind") or "",
            task.get("subject") or "")

#  Задачи, которые видят не все в депо. Право — то же, что на правку графика:
#  им обладают начальник депо и заместитель, а мастер и кладовщик нет
RESTRICTED_KINDS = {"timesheet_day": "schedule.write",
                    #  Финансы (24.09.2026) — только тем, кто ведёт раздел
                    "fin_contract_end": "finance.read",
                    "fin_payment": "finance.read",
                    "fin_rate": "finance.read",
                    #  02.10.2026: поставки — тем, кто принимает на складе
                    "space_update": "supply.receive",
                    "supply_queue": "supply.receive"}

#  Виды задач и то, как они называются на доске. Порядок — порядок колонок в
#  сводке: сначала люди и их допуски, потом документы месяца, потом техника
KIND_RU = {
    "card": "Карточка нового сотрудника",
    "medical": "Медосмотр",
    "briefing": "Инструктаж",
    "certificate": "Удостоверение",
    "contract": "Контракт",
    "ppe": "СИЗ",
    "timesheet": "Табель",
    #  Решение заказчика от 21.09.2026: «если табель за прошедшие сутки не
    #  заполнен, появляется задача». Видят её только начальник и заместители
    "timesheet_day": "Табель за сутки",
    "schedule": "График",
    "request": "Кадровая заявка",
    "repair": "Ремонт техники",
    "maintenance": "Техобслуживание",
    #  Поверка алкотестера и лабораторных весов (22.09.2026). Не ТО: её не
    #  проводят своими силами и не считают по наработке — везут в поверочную
    #  организацию, и если срок вышел, работать прибором нельзя
    "verification": "Поверка",
    #  Очереди администрации — «дополнительно дублировать список
    #  задач на доску в Администрацию ООУРЦ» (16.09.2026)
    "password": "Смена пароля",
    "hiring": "Проверка трудоустройства",
    #  Увольнение порождает три задачи (подтверждение 15 от 16.09.2026):
    #  сдача СИЗ и возврат техники — на начальника РЦ, окончательный расчёт —
    #  на администрацию
    "ppe_return": "Возврат СИЗ",
    "asset_return": "Возврат техники",
    "settlement": "Окончательный расчёт",
    #  Карточка ТУ, которую администрация вернула депо (22.09.2026):
    #  «отражения на доске задач кандидатов, возвращённых на доработку».
    #  Без неё замечание видно только тому, кто откроет вкладку кандидатов
    "hire_draft": "Карточка ТУ на доработке",
    #  Доска «Минск» (24.09.2026): очередь Администрации ООУРЦ — всё, что
    #  пришло из городов и ждёт её подтверждения, одобрения, согласования
    "hq_request": "Кадровая заявка",
    "hq_hiring": "Проверка трудоустройства",
    "hq_settlement": "Окончательный расчёт",
    "hq_timesheet": "Табель на утверждение",
    "hq_adjustment": "Вычеты и доплаты",
    "hq_headcount": "Заявка на численность",
    #  06.10.2026 (правка заказчика): заявка депо на недостающий комплект СИЗ
    "hq_ppe_request": "Заявка на комплект СИЗ",
    #  06.10.2026 (вечер): предложение по доработке из коробки погрузчика
    "hq_suggestion": "Предложение по доработке",
    "hq_repair": "Ремонт: шаг Минска",
    #  ТО со специалистом и ремонт по ролям (24.09.2026, TO_PROCESS п. 7.4.1)
    "maint_request": "Заявка на ТО",
    "maint_visit": "ТО со специалистом",
    "hq_maint": "Заявка на ТО: сформировать",
    "hq_specialist": "Ремонт: вызвать специалиста",
    #  Финансы (24.09.2026): договоры аренды и услуг связи
    "fin_contract_end": "Договор заканчивается",
    "fin_payment": "Оплата по договору",
    "fin_rate": "Курс НБРБ",
    #  Персональная задача (вычитка 30.09.2026, п. 6.4.1): ставит Администрация
    #  из «Результата по депо», выполняет начальник РЦ с примечанием. Это
    #  единственный вид, который рождается не правилом, а человеком
    "personal": "Персональная",
    #  Свободное место на складе (волна 4б): пн и чт до 10:00, кабинет ОЗ
    #  видит наличие по всем депо
    "space_update": "Свободное место",
    #  02.10.2026: поставка ждёт решения депо или приёмки сегодня
    "supply_queue": "Поставки",
}

#  Задачи, у которых вместо «Выполнено» — кнопка действия (24.09.2026):
#  «заменить кнопку Выполнено на кнопку Заполнить заявку» и т. д. Кнопка
#  ведёт туда, где действие делается, — в карточку машины
ACTION_LABEL = {
    "maint_request": "Заполнить заявку",
    "hq_maint": "Сформировать заявку",
    "maint_visit": "Пройти ТО",
    "hq_specialist": "Вызвать специалиста",
    "fin_contract_end": "Открыть договор",
    "fin_payment": "Отметить оплату",
    "fin_rate": "Внести курс",
}


def asset_subject(inventory_no: str, name: str, model: str | None = None,
                  unit: str | None = None) -> str:
    """
    «Кого касается» у задач по технике (24.09.2026): инвентарный номер, вид
    техники, депо — и второй строкой производитель/модель. Доска делит
    строки по переводу строки: первая — ссылка, вторая — серым под ней.
    """
    head = f"{inventory_no} · {name}" + (f" · {unit}" if unit else "")
    return head + (f"\n{model}" if model else "")


def action_label(kind: str, title: str) -> str | None:
    """Надпись кнопки действия для задачи или None — тогда «Выполнено»."""
    if kind == "maint_visit":
        #  «Провести ТО-2 — …» → «Пройти ТО-2»
        parts = (title or "").split()
        return f"Пройти {parts[1]}" if len(parts) > 1 else ACTION_LABEL[kind]
    if kind == "repair" and (title or "").startswith("Приезд специалиста"):
        return "Произведён ремонт"
    return ACTION_LABEL.get(kind)

#  Фильтры доски (24.09.2026): «задачи, которые относятся к людям, и
#  задачи, которые относятся к технике». Остальное — документы месяца
#  (табель, график, расчёт) — видно в «Все»
PEOPLE_KINDS = ("card", "medical", "briefing", "certificate", "contract",
                "ppe", "ppe_return", "settlement", "request", "hiring",
                "hire_draft", "password", "hq_request", "hq_hiring",
                "hq_settlement")
TECH_KINDS = ("maintenance", "verification", "repair", "asset_return",
              "hq_repair", "maint_request", "maint_visit", "hq_maint",
              "hq_specialist")

#  Код подразделения «Минск» — Администрация ООУРЦ. Его доска собирает не
#  сроки одного депо, а очередь согласований со всех двенадцати
HQ_KIND = "hq"
#  Виды задач доски «Минск»: они видны в «Сегодня» целиком, не дожидаясь
#  срока, — это очередь, которую разбирают по мере поступления
HQ_KINDS = ("hq_request", "hq_hiring", "hq_settlement", "hq_timesheet",
            "hq_adjustment", "hq_headcount", "hq_repair", "password",
            "hq_maint", "hq_specialist",
            "fin_contract_end", "fin_payment", "fin_rate")
#  Задачи раздела «Финансы» — только у тех, кто его ведёт
FINANCE_KINDS = ("fin_contract_end", "fin_payment", "fin_rate")


def week_start(day: date | None = None) -> date:
    """Понедельник недели, в которую попадает день."""
    today = day or date.today()
    return today - timedelta(days=today.weekday())


def has_kanban(conn: psycopg.Connection) -> bool:
    """Накатана ли миграция 35. Без неё доска открывается пустой, а не 500."""
    with conn.cursor() as cur:
        cur.execute("SELECT to_regclass('app.kanban_task') IS NOT NULL AS ok")
        return bool(cur.fetchone()["ok"])


@dataclass(frozen=True)
class Task:
    """Задача, порождённая правилом. Ключ устойчив между обновлениями доски."""

    key: str
    kind: str
    title: str
    subject: str | None = None
    due_at: date | None = None


# ---------------------------------------------------------------------------
#  Правила: что система считает работой на эту неделю
# ---------------------------------------------------------------------------

def _people_deadlines(conn, unit_id: int, edge: date) -> list[Task]:
    """
    Сроки по людям: медосмотр, инструктаж, удостоверение, контракт.

    Всё в одном запросе одной формы — это четыре одинаковых по смыслу
    вопроса «у кого что заканчивается», и писать их четырьмя способами
    значило бы четыре раза ошибиться по-разному.
    """
    sources = [
        ("medical", "Медосмотр заканчивается",
         """SELECT e.id AS employee_id, m.valid_until AS due, t.name AS what
              FROM app.employee_medical_exam m
              JOIN app.employee e ON e.id = m.employee_id
              JOIN app.medical_exam_type t ON t.id = m.type_id
             WHERE m.valid_until IS NOT NULL"""),
        #  02.10.2026 (вычитка 2.25): первый повторный — через 6 месяцев
        #  после первичного на рабочем месте; дальше — от последнего
        #  повторного. Задача появляется за неделю (BRIEFING_LEAD_DAYS)
        ("briefing", "Инструктаж заканчивается",
         """SELECT e.id AS employee_id, b.valid_until AS due, t.name AS what
              FROM app.safety_briefing b
              JOIN app.employee e ON e.id = b.employee_id
              LEFT JOIN app.briefing_type t ON t.id = b.type_id
             WHERE b.valid_until IS NOT NULL
               AND b.held_at >= app.employee_current_since(b.employee_id)
            UNION ALL
            SELECT e.id, (p.held_at + (rt.period_months || ' months')::interval)::date,
                   rt.name
              FROM app.safety_briefing p
              JOIN app.briefing_type pt ON pt.id = p.type_id AND pt.code = 'primary'
              JOIN app.employee e ON e.id = p.employee_id
              JOIN app.briefing_type rt ON rt.code = 'repeat' AND rt.is_active
             WHERE p.held_at >= app.employee_current_since(p.employee_id)
               AND NOT EXISTS (
                   SELECT 1 FROM app.safety_briefing r
                    WHERE r.employee_id = p.employee_id AND r.type_id = rt.id
                      AND r.held_at >= app.employee_current_since(p.employee_id))"""),
        ("certificate", "Удостоверение заканчивается",
         """SELECT e.id AS employee_id, c.valid_until AS due, t.name AS what
              FROM app.employee_certificate c
              JOIN app.employee e ON e.id = c.employee_id
              JOIN app.certificate_type t ON t.id = c.type_id
             WHERE c.valid_until IS NOT NULL"""),
        ("contract", "Контракт заканчивается",
         """SELECT e.id AS employee_id, k.ends_at AS due, NULL AS what
              FROM app.employee_contract k
              JOIN app.employee e ON e.id = k.employee_id"""),
    ]

    out: list[Task] = []
    with conn.cursor() as cur:
        for kind, title, sql in sources:
            #  Сначала берём последнюю запись по человеку и виду, и только
            #  потом смотрим, истекает ли она. Раньше порядок был обратный:
            #  условие «срок подходит» стояло до выбора последней записи,
            #  поэтому свежая запись в отбор не попадала, DISTINCT ON
            #  выбирал из одних просроченных — и задача оставалась на доске
            #  навсегда. Инструктаж провели 18.09 до 17.03.2027, а доска
            #  по-прежнему требовала его провести.
            #
            #  Касается всех четырёх видов: прежние записи хранятся и по
            #  медосмотрам, и по удостоверениям, и по контрактам.
            cur.execute(
                f"""
                WITH src AS ({sql}),
                     latest AS (
                         SELECT DISTINCT ON (s.employee_id, s.what)
                                s.employee_id, s.due, s.what
                           FROM src s
                          ORDER BY s.employee_id, s.what, s.due DESC
                     )
                SELECT l.employee_id, l.due, l.what,
                       e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                           coalesce(left(e.middle_name, 1) || '.', '') AS fio
                FROM latest l
                JOIN app.employee e   ON e.id = l.employee_id
                JOIN app.employment em ON em.employee_id = e.id
                                      AND em.terminated_at IS NULL
                WHERE em.org_unit_id = %(unit)s AND l.due <= %(edge)s
                ORDER BY l.employee_id, l.what
                """,
                {"unit": unit_id,
                 "edge": (edge - timedelta(days=LEAD_DAYS - BRIEFING_LEAD_DAYS)
                          if kind == "briefing" else edge)},
            )
            for r in cur.fetchall():
                what = f" — {r['what']}" if r["what"] else ""
                out.append(Task(
                    key=f"{kind}:{r['employee_id']}:{r['what'] or ''}",
                    kind=kind,
                    title=f"{title}{what}: внести новые данные в карточку",
                    subject=r["fio"],
                    due_at=r["due"],
                ))
    return out


def _new_cards(conn, unit_id: int, today: date) -> list[Task]:
    """
    У принятого не заполнена карточка.

    Из задания: «администратор произвёл трудоустройство, заполнил первичный
    учёт — ФИО, табельный, должность. А вот потом вступает в работу канбан:
    заполнить карточку, выдать СИЗ, провести инструктажи».

    Смотрим тех, кого приняли за последние два месяца, и считаем их пробелы
    функцией базы — тем же списком, что показывает карточка.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT e.id AS employee_id, em.hired_at,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio
            FROM app.employment em
            JOIN app.employee e ON e.id = em.employee_id
            WHERE em.org_unit_id = %s AND em.terminated_at IS NULL
              AND em.hired_at >= %s
            """,
            (unit_id, today - timedelta(days=60)),
        )
        rows = cur.fetchall()

    #  Какие обобщённые задачи уже закрыты. Решение заказчика от 15.09.2026:
    #  «задача „Заполнить карточку“ остаётся обобщённой; после её закрытия
    #  оставшиеся пробелы выводятся на доску отдельным списком».
    #
    #  То есть пока человека оформляют, на доске одна строка — не двадцать;
    #  а когда оформляющий сказал «сделал», доска показывает, что всё-таки
    #  осталось, поимённо.
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT DISTINCT task_key FROM app.kanban_task
             WHERE org_unit_id = %s AND kind = 'card'
               AND status IN ('done', 'auto_done')
            """,
            (unit_id,),
        )
        finished = {r["task_key"] for r in cur.fetchall()}

    out: list[Task] = []
    for r in rows:
        key = f"card:{r['employee_id']}"
        #  Пробелы считает база: тот же список, что показывает карточка.
        #  Два списка «чего не хватает» неминуемо разошлись бы
        with conn.cursor() as cur:
            cur.execute("SELECT kind, title FROM app.card_gaps(%s)",
                        (r["employee_id"],))
            gaps = cur.fetchall()
        if not gaps:
            continue

        if key in finished:
            for n, g in enumerate(gaps, start=1):
                out.append(Task(
                    key=f"{key}:{g['kind']}:{n}",
                    kind="card",
                    title=g["title"],
                    subject=r["fio"],
                    due_at=r["hired_at"] + timedelta(days=7),
                ))
        else:
            out.append(Task(
                key=key,
                kind="card",
                title=f"Заполнить карточку принятого: не хватает {len(gaps)}",
                subject=r["fio"],
                #  Неделя с даты приёма — столько обычно и занимает оформление
                due_at=r["hired_at"] + timedelta(days=7),
            ))
    return out


def _unfilled_yesterday(conn, unit_id: int, today: date) -> Task | None:
    """
    Табель за прошедшие сутки: заполнен или нет.

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

    Считаем по данным: у кого по графику на вчера была смена, а клетки в
    табеле за этот день нет. Задача гаснет сама, как только их заполнят.
    """
    day = today - timedelta(days=1)
    if day.day == 1:
        #  Первое число закрывается вместе со сдачей месяца — своей задачей
        #  «свести и сдать табель», дублировать её незачем. 02.10.2026:
        #  прежнее условие «и месяц вчера другой» не срабатывало никогда —
        #  вчера первое число значит сегодня второе того же месяца
        return None
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT count(*) AS n
              FROM app.schedule_plan sp
              JOIN app.employment em ON em.id = sp.employment_id
             WHERE sp.org_unit_id = %(unit)s
               AND sp.work_date = %(day)s
               AND sp.shift_start IS NOT NULL
               AND (em.terminated_at IS NULL OR em.terminated_at >= %(day)s)
               AND NOT EXISTS (
                   SELECT 1 FROM app.timesheet_day td
                     JOIN app.timesheet t ON t.id = td.timesheet_id
                    WHERE td.employment_id = sp.employment_id
                      AND td.work_date = sp.work_date
                      AND t.org_unit_id = %(unit)s)
            """,
            {"unit": unit_id, "day": day},
        )
        missing = int(cur.fetchone()["n"])
    if not missing:
        return None
    return Task(
        key=f"timesheet_day:{day:%Y-%m-%d}", kind="timesheet_day",
        title=f"Заполнить табель за {day:%d.%m.%Y}: не закрыто смен — {missing}",
        subject=f"{day:%d.%m}",
        due_at=today,
    )


def _documents(conn, unit_id: int, today: date) -> list[Task]:
    """
    Табель и график: сданы или нет.

    02.10.2026 (вычитка 3.22):
      * табель прошлого месяца — задача до сдачи, срок 5-е число: с 1 по 5
        сдаётся именно он, а раньше задачи по нему не было вовсе;
      * табель текущего месяца — как прежде, задача весь месяц;
      * график текущего месяца — до сдачи; график следующего месяца — с
        20-го числа, срок — последний день месяца: сдают его до начала;
      * табель, который ещё не открыт, — тоже «не сдан». Раньше задача
        исчезала и считалась «выполненной», пока месяц никто не открывал.
    """
    out: list[Task] = []
    month = today.replace(day=1)
    prev = (month - timedelta(days=1)).replace(day=1)
    nxt = (month + timedelta(days=32)).replace(day=1)
    last_day = nxt - timedelta(days=1)
    day_task = _unfilled_yesterday(conn, unit_id, today)
    if day_task:
        out.append(day_task)
    with conn.cursor() as cur:
        def staffed(p: date) -> bool:
            cur.execute(
                """
                SELECT EXISTS (
                    SELECT 1 FROM app.employment em
                     WHERE em.org_unit_id = %s
                       AND em.hired_at < (%s::date + interval '1 month')
                       AND (em.terminated_at IS NULL OR em.terminated_at >= %s))
                       AS ok
                """, (unit_id, p, p))
            return bool(cur.fetchone()["ok"])

        def ts_task(p: date, due: date | None) -> None:
            cur.execute(
                "SELECT status, return_reason FROM app.timesheet "
                "WHERE org_unit_id = %s AND period_month = %s",
                (unit_id, p),
            )
            row = cur.fetchone()
            if row and row["status"] != "open":
                return
            if not row and not staffed(p):
                return
            reason = ((row or {}).get("return_reason") or "").strip()
            out.append(Task(
                key=f"timesheet:{p:%Y-%m}", kind="timesheet",
                title=(f"Поправить и сдать табель заново: {reason}" if reason
                       else "Свести и сдать табель месяца"),
                subject=f"{p:%m.%Y}", due_at=due,
            ))

        ts_task(prev, month.replace(day=5))
        ts_task(month, None)

        cur.execute("SELECT to_regclass('app.schedule_status') IS NOT NULL AS ok")
        if cur.fetchone()["ok"]:
            def sched_task(p: date, due: date | None) -> None:
                cur.execute(
                    "SELECT status FROM app.schedule_status WHERE org_unit_id = %s "
                    "AND period_month = %s",
                    (unit_id, p),
                )
                sched = cur.fetchone()
                if sched and sched["status"] == "submitted":
                    return
                if not staffed(p):
                    return
                out.append(Task(
                    key=f"schedule:{p:%Y-%m}", kind="schedule",
                    title="Сдать плановый график месяца",
                    subject=f"{p:%m.%Y}", due_at=due,
                ))

            sched_task(month, None)
            if today.day >= 20:
                sched_task(nxt, last_day)

        #  Кадровые заявки, заявки на пароль и проверка трудоустройства
        #  уехали на доску «Минск» (24.09.2026): решает их администрация, а
        #  на доске депо они висели задачей, которую депо выполнить не может
    return out

def _equipment(conn, unit_id: int, today: date) -> list[Task]:
    """СИЗ к замене, открытые заявки на ремонт, подошедшее ТО."""
    out: list[Task] = []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT i.id, i.replace_at, it.name AS item_name,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio
            FROM app.ppe_issue i
            JOIN app.ppe_item it ON it.id = i.ppe_item_id
            JOIN app.employee e  ON e.id = i.employee_id
            WHERE i.org_unit_id = %s AND i.status = 'issued'
              AND i.replace_at IS NOT NULL AND i.replace_at <= %s
            """,
            (unit_id, today + timedelta(days=LEAD_DAYS)),
        )
        for r in cur.fetchall():
            out.append(Task(
                key=f"ppe:{r['id']}", kind="ppe",
                title=f"Заменить СИЗ: {r['item_name']}",
                subject=r["fio"], due_at=r["replace_at"],
            ))

        cur.execute("SELECT to_regclass('app.repair_request') IS NOT NULL AS ok")
        if cur.fetchone()["ok"]:
            cur.execute(
                """
                SELECT r.id, r.status, r.route, a.inventory_no, a.name, a.model,
                       r.specialist_date
                FROM app.repair_request r
                JOIN app.asset a ON a.id = r.asset_id
                WHERE r.org_unit_id = %s
                  AND r.status NOT IN ('received', 'fixed', 'cancelled')
                """,
                (unit_id,),
            )
            for r in cur.fetchall():
                #  Ремонт вызовом специалиста по ролям (24.09.2026):
                #  специалиста вызывает Администрация и назначает дату, депо
                #  видит дату приезда и отмечает «Произведён ремонт»
                if r.get("route") == "specialist":
                    if r["status"] == "new":
                        continue            # ждёт Администрацию, задача у неё
                    when = r.get("specialist_date")
                    out.append(Task(
                        key=f"repair:{r['id']}", kind="repair",
                        title=(f"Приезд специалиста {when:%d.%m.%Y} — отметить ремонт"
                               if when else "Приезд специалиста — отметить ремонт"),
                        subject=asset_subject(r['inventory_no'], r['name'], r.get('model')),
                        due_at=when,
                    ))
                    continue
                out.append(Task(
                    key=f"repair:{r['id']}", kind="repair",
                    title="Довести заявку на ремонт до получения депо",
                    subject=asset_subject(r['inventory_no'], r['name'], r.get('model')),
                ))

    out.extend(_maintenance(conn, unit_id, today))
    out.extend(_verification(conn, unit_id, today))
    return out


#  Когда какое ТО показывать. Правило заказчика от 15.09.2026:
#  «ТО-1 появляется в списке задач день в день. ТО-2 появляется в начале
#  недели за 7 дней до окончания ТО-2».
#
#  Разница не в придирчивости, а в том, кто и как их делает. ТО-1 проводят
#  своими силами за полчаса — предупреждать заранее незачем, к сроку и
#  напомним. ТО-2 делает сторонний специалист: его надо вызвать, а значит
#  узнать о сроке в начале недели, а не в день, когда уже поздно.
MAINTENANCE_LEAD = {
    "ТО-1": 0,   # день в день
    "ТО-2": 7,   # прежнее правило; с 24.09.2026 ТО-2 объявляется 25-го
}

#  ТО со специалистом объявляются 25-го числа на весь следующий месяц
#  (24.09.2026). Список держит база (maintenance_type.announce); здесь —
#  значения по умолчанию, если миграция 79 ещё не накатана
ANNOUNCE_MONTH25 = {"ТО-2", "ПОПГ", "ЧТО"}


def month25_horizon(today: date) -> date:
    """
    До какого дня показывать ТО со специалистом.

    С 25-го — до конца следующего месяца, до 25-го — до конца текущего.
    """
    first = today.replace(day=1)
    months = 2 if today.day >= 25 else 1
    y, m = first.year, first.month + months
    while m > 12:
        y, m = y + 1, m - 12
    return date(y, m, 1) - timedelta(days=1)


def maintenance_is_due(type_code: str, due_date: date | None,
                       left_hours: float | None, today: date,
                       monday: date | None = None,
                       announce: str | None = None) -> bool:
    """
    Пора ли показывать это ТО на доске недели.

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

    ТО-1 — день в день: `due_date <= today`. ТО-2 — от понедельника недели,
    за семь дней до срока: `due_date <= monday + 7`. Человек видит его в
    начале недели и успевает вызвать специалиста.

    Наработка считается наравне с календарём: 50 моточасов могут набежать за
    три дня, и ждать седьмого дня в этом случае нельзя.
    """
    #  02.10.2026 (вычитка 5.20, 6.11): правило берётся из справочника
    #  видов ТО (announce), а не из списка названий — новый вид ТО со
    #  специалистом сразу объявляется 25-го, а своими силами — день в день
    if announce == "month25" or (announce is None and type_code in ANNOUNCE_MONTH25):
        #  24.09.2026: «появляется 25 числа каждого месяца, в нём все ТО-2,
        #  которые запланированы на следующий месяц». До 25-го видно то, что
        #  приходится на текущий месяц (и просроченное)
        if left_hours is not None and left_hours <= 0:
            return True
        if due_date is None:
            return False
        return due_date <= month25_horizon(today)
    lead = MAINTENANCE_LEAD.get(type_code)
    if lead is None:
        if announce != "day":
            return False
        lead = 0
    if left_hours is not None and left_hours <= 0:
        return True
    if due_date is None:
        return False
    if lead == 0:
        return due_date <= today
    return due_date <= (monday or week_start(today)) + timedelta(days=lead)


def _maintenance(conn, unit_id: int, today: date) -> list[Task]:
    """
    Подошедшее техобслуживание.

    Срок считается не здесь: берётся готовым из `supplydb.maintenance_due` —
    тем же расчётом, что показывает вкладка «Техническое обслуживание» и
    столбцы «ТО-1 до» / «ТО-2 до» в списке техники. Два способа ответить на
    вопрос «когда следующее ТО» однажды разошлись бы, и доска начала бы
    спорить с карточкой.

    Срок по наработке учитывается наравне с календарным: 50 моточасов могут
    набежать за три дня, и ждать седьмого дня в этом случае нельзя.
    """
    from . import supplydb

    monday = week_start(today)
    out: list[Task] = []
    try:
        due = supplydb.maintenance_due(conn, unit_id, today)
    except psycopg.Error:
        #  Нет миграции обеспечения — доска работает и без ТО
        conn.rollback()
        return out

    for d in due:
        if d["status"] in ("written_off", "needs_replacement"):
            continue
        month25 = (d.get("announce") == "month25"
                   or (d.get("announce") is None and d["type_code"] in ANNOUNCE_MONTH25))
        req = d.get("request")
        if month25 and req:
            #  Заявка уже есть: заполнена — ждёт Администрацию (задача у
            #  неё), сформирована — депо проводит ТО к назначенной дате
            if req["status"] == "scheduled":
                out.append(Task(
                    key=f"maint_visit:{req['id']}", kind="maint_visit",
                    title=(f"Провести {d['type_code']} — "
                           f"{req.get('contractor_name') or 'специалист'}, "
                           f"{req['planned_date']:%d.%m.%Y}"),
                    subject=asset_subject(d['inventory_no'], d['name'], d.get('model')),
                    due_at=req["planned_date"],
                ))
            continue
        if not maintenance_is_due(d["type_code"], d["due_date"],
                                  d["left_hours"], today, monday,
                                  announce=d.get("announce")):
            continue
        if month25:
            out.append(Task(
                key=f"maint_request:{d['asset_id']}:{d['type_code']}",
                kind="maint_request",
                title=f"{d['type_code']} — заполнить заявку на специалиста",
                subject=asset_subject(d['inventory_no'], d['name'], d.get('model')),
                due_at=d["due_date"],
            ))
            continue

        by_hours = d["left_hours"] is not None and d["left_hours"] <= 0
        by_date = d["due_date"] is not None and d["due_date"] <= today
        why = "по наработке" if by_hours and not by_date else "по сроку"
        out.append(Task(
            key=f"maintenance:{d['asset_id']}:{d['type_code']}",
            kind="maintenance",
            title=(f"Провести {d['type_code']} — "
                   f"{'своими силами' if d['is_self_service'] else 'вызвать специалиста'}"
                   f", {why}"),
            subject=asset_subject(d['inventory_no'], d['name'], d.get('model')),
            due_at=d["due_date"],
        ))
    return out


#  За сколько предупреждать о поверке. Месяц, а не десять дней, как у
#  медосмотров: прибор надо отвезти в поверочную организацию, дождаться и
#  забрать, и всё это время им нельзя работать
VERIFICATION_LEAD = 30


def _verification(conn, unit_id: int, today: date) -> list[Task]:
    """
    Поверка, срок которой подходит или уже вышел.

    Показывается по сроку из карточки — тому же, что стоит в столбце
    «Годна до» на вкладке «Поверенная техника». Незаполненный срок задачи не
    порождает: приложение не знает, просрочен он или нет, и выдумывать за
    депо не станет. Пустые сроки видно на самой вкладке — они внизу списка.
    """
    out: list[Task] = []
    edge = today + timedelta(days=VERIFICATION_LEAD)
    try:
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT a.id, a.inventory_no, a.name, a.model, a.verified_until
                  FROM app.asset a
                  JOIN app.asset_category k ON k.id = a.category_id
                 WHERE a.org_unit_id = %s
                   AND k.group_code = 'verification'
                   AND a.status <> 'written_off'
                   AND a.verified_until IS NOT NULL
                   AND a.verified_until <= %s
                 ORDER BY a.verified_until
                """,
                (unit_id, edge),
            )
            rows = cur.fetchall()
    except psycopg.Error:
        #  Нет миграции 64 — доска работает и без поверок
        conn.rollback()
        return out

    for r in rows:
        overdue = r["verified_until"] < today
        out.append(Task(
            key=f"verification:{r['id']}",
            kind="verification",
            title=("Поверка просрочена — прибором работать нельзя"
                   if overdue else "Отправить на поверку: срок подходит"),
            subject=asset_subject(r['inventory_no'], r['name'], r.get('model')),
            due_at=r["verified_until"],
        ))
    return out


def _dismissals(conn, unit_id: int, today: date) -> list[Task]:
    """
    Что осталось за уволенным: СИЗ на руках, закреплённая техника, расчёт.

    Считаем по состоянию данных, а не по факту «уволили — создали задачу».
    Тогда задача гаснет сама, как только человек сдал СИЗ: отмечать её
    отдельно не нужно, и «сделано» нельзя нажать, ничего не сделав.

    Горизонт — квартал: через три месяца после увольнения не вернувшийся
    комбинезон списывают, а не ищут доской задач.
    """
    with conn.cursor() as cur:
        cur.execute("SELECT * FROM app.dismissal_todo(%s, %s)",
                    (unit_id, today - timedelta(days=90)))
        rows = cur.fetchall()

    out: list[Task] = []
    for r in rows:
        out.append(Task(
            key=f"{r['kind']}:{r['employment_id']}",
            kind=r["kind"],
            title=r["title"],
            subject=r["fio"],
            #  Две недели с даты увольнения: столько занимает обходной лист
            due_at=r["terminated_at"] + timedelta(days=14),
        ))
    return out


def _returned_drafts(conn, unit_id: int, today: date) -> list[Task]:
    """
    Карточки трудоустройства, возвращённые администрацией на доработку.

    Задача гаснет сама, как только замечание снято: правка карточки очищает
    `return_reason`, и причины задачи больше нет. Отмечать её не нужно — как
    и все остальные задачи этой доски.

    Срок — три дня: пока человек не подтверждён, он не входит в приложение,
    и тянуть с этим нельзя.
    """
    out: list[Task] = []
    try:
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT em.id, em.return_reason, em.returned_at,
                       e.last_name || ' ' || e.first_name AS fio
                  FROM app.employment em
                  JOIN app.employee e ON e.id = em.employee_id
                 WHERE em.org_unit_id = %s
                   AND em.confirmed_at IS NULL
                   AND em.terminated_at IS NULL
                   AND em.return_reason IS NOT NULL
                 ORDER BY em.returned_at
                """,
                (unit_id,),
            )
            rows = cur.fetchall()
    except psycopg.Error:
        #  Нет миграции 48 — доска работает и без очереди проверки
        conn.rollback()
        return out

    for r in rows:
        out.append(Task(
            key=f"hire_draft:{r['id']}",
            kind="hire_draft",
            title=f"Поправить карточку ТУ: {r['return_reason']}",
            subject=r["fio"],
            due_at=((r["returned_at"].date() if r["returned_at"] else today)
                    + timedelta(days=3)),
        ))
    return out


def hq_unit(conn: psycopg.Connection) -> dict[str, Any] | None:
    """Подразделение «Минск» — Администрация ООУРЦ."""
    with conn.cursor() as cur:
        cur.execute("SELECT id, code, name, full_name FROM app.org_unit "
                    "WHERE kind = %s AND is_active ORDER BY id LIMIT 1",
                    (HQ_KIND,))
        return cur.fetchone()


def _is_hq(conn, unit_id: int) -> bool:
    with conn.cursor() as cur:
        cur.execute("SELECT kind FROM app.org_unit WHERE id = %s", (unit_id,))
        row = cur.fetchone()
    return bool(row and row["kind"] == HQ_KIND)


def _hq_queue(conn, today: date) -> list[Task]:
    """
    Доска «Минск»: что ждёт решения Администрации ООУРЦ (24.09.2026).

    «Минск — это где будут отображаться все задачи, подтверждения, одобрения,
    согласования, которые касаются администрации ООУРЦ. Это запросы,
    поступающие от разных городов».

    Каждая задача гаснет сама, как только решение принято: заявку рассмотрели,
    трудоустройство подтвердили, расчёт приняли — причины больше нет.
    Каждый блок читается отдельно: не накатана миграция — нет и блока, а
    доска остальное показывает.
    """
    out: list[Task] = []

    def block(sql: str, args: tuple = ()) -> list[dict[str, Any]]:
        try:
            with conn.transaction(), conn.cursor() as cur:
                cur.execute(sql, args)
                return cur.fetchall()
        except psycopg.Error:
            return []

    #  Кадровые заявки депо: увольнение, перевод, запрос сверки ЗП
    for r in block("""
            SELECT ou.code, ou.name, count(*) AS n, min(sr.created_at) AS since
              FROM app.staff_request sr JOIN app.org_unit ou ON ou.id = sr.org_unit_id
             WHERE sr.status = 'new' GROUP BY ou.code, ou.name ORDER BY ou.name"""):
        out.append(Task(key=f"hq_request:{r['code']}", kind="hq_request",
                        title=f"Рассмотреть кадровые заявки: {r['n']}",
                        subject=r["name"],
                        due_at=r["since"].date() + timedelta(days=2)))

    #  Трудоустройства, оформленные депо, — ждут проверки. Возвращённые на
    #  доработку сейчас у депо, их здесь нет
    for r in block("""
            SELECT ou.code, ou.name, count(*) AS n, min(em.created_at) AS since
              FROM app.employment em JOIN app.org_unit ou ON ou.id = em.org_unit_id
             WHERE em.terminated_at IS NULL AND em.confirmed_at IS NULL
               AND em.return_reason IS NULL
             GROUP BY ou.code, ou.name ORDER BY ou.name"""):
        out.append(Task(key=f"hq_hiring:{r['code']}", kind="hq_hiring",
                        title=f"Проверить и подтвердить трудоустройство: {r['n']}",
                        subject=r["name"],
                        due_at=r["since"].date() + timedelta(days=1)))

    #  Окончательный расчёт, отправленный депо, — принять
    for r in block("""
            SELECT em.id, ou.name AS unit, em.settlement_sent_at,
                   e.last_name || ' ' || e.first_name AS fio
              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
             WHERE em.settlement_state = 'submitted'
             ORDER BY em.settlement_sent_at"""):
        sent = r["settlement_sent_at"].date() if r["settlement_sent_at"] else today
        out.append(Task(key=f"hq_settlement:{r['id']}", kind="hq_settlement",
                        title="Посчитать и принять окончательный расчёт",
                        subject=f"{r['fio']} · {r['unit']}",
                        due_at=sent + timedelta(days=2)))

    #  Табели, сданные депо, — утвердить или вернуть
    for r in block("""
            SELECT ou.code, ou.name, t.period_month, t.submitted_at
              FROM app.timesheet t JOIN app.org_unit ou ON ou.id = t.org_unit_id
             WHERE t.status IN ('submitted', 'in_review')
             ORDER BY t.period_month, ou.name"""):
        sent = r["submitted_at"].date() if r["submitted_at"] else today
        out.append(Task(key=f"hq_timesheet:{r['code']}:{r['period_month']:%Y-%m}",
                        kind="hq_timesheet",
                        title=f"Утвердить или вернуть табель за "
                              f"{r['period_month']:%m.%Y}",
                        subject=r["name"], due_at=sent + timedelta(days=2)))

    #  Вычеты и доплаты, поданные депо, — согласовать
    for r in block("""
            SELECT ou.code, ou.name, a.period_month, count(*) AS n
              FROM app.adjustment a JOIN app.org_unit ou ON ou.id = a.org_unit_id
             WHERE a.status = 'pending'
             GROUP BY ou.code, ou.name, a.period_month
             ORDER BY a.period_month, ou.name"""):
        out.append(Task(key=f"hq_adjustment:{r['code']}:{r['period_month']:%Y-%m}",
                        kind="hq_adjustment",
                        title=f"Согласовать вычеты и доплаты: {r['n']}",
                        subject=f"{r['name']} · {r['period_month']:%m.%Y}"))

    #  Заявки на численность
    for r in block("""
            SELECT ou.code, ou.name, count(*) AS n, min(h.created_at) AS since
              FROM app.headcount_request h JOIN app.org_unit ou ON ou.id = h.org_unit_id
             WHERE h.status = 'new' GROUP BY ou.code, ou.name ORDER BY ou.name"""):
        out.append(Task(key=f"hq_headcount:{r['code']}", kind="hq_headcount",
                        title=f"Рассмотреть заявку на численность: {r['n']}",
                        subject=r["name"],
                        due_at=r["since"].date() + timedelta(days=3)))

    #  Ремонт по маршруту «Отправить в Минск»: шаги на стороне Минска
    steps = {"sent_to_hq": "Подтвердить получение техники из депо",
             "hq_received": "Отправить технику в ремонт",
             "in_repair": "Принять технику из ремонта",
             "repaired": "Отправить технику в депо"}
    for r in block("""
            SELECT r.id, r.status, ou.code, ou.name, a.inventory_no, a.name AS asset, a.model
              FROM app.repair_request r
              JOIN app.org_unit ou ON ou.id = r.org_unit_id
              JOIN app.asset a ON a.id = r.asset_id
             WHERE coalesce(r.route, 'minsk') = 'minsk'
               AND r.status IN ('sent_to_hq', 'hq_received', 'in_repair', 'repaired')
             ORDER BY r.opened_at"""):
        out.append(Task(key=f"hq_repair:{r['id']}", kind="hq_repair",
                        title=steps[r["status"]],
                        subject=asset_subject(r['inventory_no'], r['asset'], r.get('model'), r['name'])))

    #  ТО со специалистом: депо заполнило заявку — сформировать (24.09.2026)
    for r in block("""
            SELECT q.id, q.due_date, t.code, ou.name, a.inventory_no, a.name AS asset, a.model
              FROM app.maintenance_request q
              JOIN app.maintenance_type t ON t.id = q.maintenance_type_id
              JOIN app.org_unit ou ON ou.id = q.org_unit_id
              JOIN app.asset a ON a.id = q.asset_id
             WHERE q.status = 'filled'
             ORDER BY q.due_date NULLS LAST, q.filled_at"""):
        out.append(Task(key=f"hq_maint:{r['id']}", kind="hq_maint",
                        title=f"Сформировать заявку на {r['code']}",
                        subject=asset_subject(r['inventory_no'], r['asset'], r.get('model'), r['name']),
                        due_at=r["due_date"]))

    #  Ремонт вызовом специалиста: депо открыло заявку — вызвать
    #  специалиста и назначить дату приезда (24.09.2026)
    for r in block("""
            SELECT r.id, r.opened_at, ou.name, a.inventory_no, a.name AS asset, a.model
              FROM app.repair_request r
              JOIN app.org_unit ou ON ou.id = r.org_unit_id
              JOIN app.asset a ON a.id = r.asset_id
             WHERE r.route = 'specialist' AND r.status = 'new'
             ORDER BY r.opened_at"""):
        out.append(Task(key=f"hq_specialist:{r['id']}", kind="hq_specialist",
                        title="Вызвать специалиста на ремонт",
                        subject=asset_subject(r['inventory_no'], r['asset'], r.get('model'), r['name'])))

    #  Заявки депо на недостающие комплекты СИЗ (06.10.2026, правка
    #  заказчика): заводятся из окна выдачи в карточке сотрудника, гаснут
    #  сами, когда комплект выдан
    for r in block("""
            SELECT rq.id, rq.size, rq.note, rq.created_at,
                   e.last_name || ' ' || e.first_name AS fio,
                   it.name AS item,
                   (SELECT ou.name FROM app.employment em2
                      JOIN app.org_unit ou ON ou.id = em2.org_unit_id
                     WHERE em2.employee_id = e.id
                       AND em2.terminated_at IS NULL
                     LIMIT 1) AS unit
              FROM app.ppe_request rq
              JOIN app.employee e ON e.id = rq.employee_id
              LEFT JOIN app.ppe_item it ON it.id = rq.ppe_item_id
             WHERE rq.closed_at IS NULL
             ORDER BY rq.created_at"""):
        subject = f"{r['fio']} · {r['unit'] or '—'} · {r['item'] or r['note']}"
        if r["size"]:
            subject += f" ({r['size']})"
        out.append(Task(key=f"hq_ppe_request:{r['id']}", kind="hq_ppe_request",
                        title="Выдать недостающий комплект СИЗ",
                        subject=subject,
                        due_at=r["created_at"].date()))

    #  Предложения по доработке из коробки погрузчика (06.10.2026, вечер,
    #  правка заказчика): сотрудник отправил — здесь ждёт проработки.
    #  «Выполнить» гасит предложение в таблице, и задача исчезает
    for r in block("""
            SELECT s.id, s.body, s.created_at, u.full_name AS author,
                   (SELECT ou.name
                      FROM app.employment em
                      JOIN app.org_unit ou ON ou.id = em.org_unit_id
                     WHERE em.employee_id = (
                           SELECT au.employee_id FROM app.app_user au
                            WHERE au.id = s.user_id)
                       AND em.terminated_at IS NULL
                     LIMIT 1) AS unit
              FROM app.improvement_suggestion s
              JOIN app.app_user u ON u.id = s.user_id
             WHERE s.handled_at IS NULL
             ORDER BY s.created_at"""):
        subject = f"{r['author']}"
        if r["unit"]:
            subject += f" · {r['unit']}"
        subject += f": {r['body']}"
        out.append(Task(key=f"hq_suggestion:{r['id']}", kind="hq_suggestion",
                        title="Проработать предложение по доработке",
                        subject=subject,
                        due_at=r["created_at"].date()))

    #  Финансы (24.09.2026): договор заканчивается через 30 дней, прошёл
    #  день оплаты без оплаты, нет курса НБРБ для валютного начисления.
    #  Перед чтением начисления приводятся в порядок — иначе новый месяц
    #  появился бы только после открытия раздела
    try:
        from . import financedb
        with conn.transaction():
            if financedb.has_finance(conn):
                with conn.cursor() as cur:
                    cur.execute("SELECT app.has_perm('finance.write') AS ok")
                    if cur.fetchone()["ok"]:
                        #  Доска строит и будущие недели (прогноз) с «сегодня»
                        #  в будущем. Начисления и пролонгацию — только по
                        #  настоящей дате: иначе прогноз завёл бы начисление
                        #  за месяц, который ещё не наступил
                        financedb.ensure(conn, min(today, date.today()), commit=False)
                fin = financedb.board_items(conn, today)
            else:
                fin = {"ending": [], "unpaid": [], "rates": []}
    except psycopg.Error:
        fin = {"ending": [], "unpaid": [], "rates": []}
    for r in fin["ending"]:
        out.append(Task(key=f"fin_contract_end:{r['id']}", kind="fin_contract_end",
                        title=("Договор продлится автоматически — проверить условия"
                               if r["auto_renew"] else
                               "Договор заканчивается — продлить или закрыть"),
                        subject=f"{financedb.KIND_RU[r['kind']]}: {r['counterparty']}, "
                                f"№{r['contract_no']} · {r['unit_name']}",
                        due_at=r["ends_on"]))
    for r in fin["unpaid"]:
        out.append(Task(key=f"fin_payment:{r['contract_id']}:{r['id']}", kind="fin_payment",
                        title=f"Оплатить за {r['period_month']:%m.%Y}",
                        subject=f"{financedb.KIND_RU[r['kind']]}: {r['counterparty']}, "
                                f"№{r['contract_no']} · {r['unit_name']}",
                        due_at=r["due_date"]))
    for r in fin["rates"]:
        out.append(Task(key=f"fin_rate:{r['currency']}:{r['rate_date']:%Y-%m-%d}",
                        kind="fin_rate",
                        title=f"Внести курс {r['currency']} на {r['rate_date']:%d.%m.%Y}",
                        subject=f"валютных начислений: {r['n']}",
                        due_at=r["rate_date"]))

    #  Заявки на смену пароля со страницы входа
    for r in block("SELECT count(*) AS n FROM app.password_reset_request "
                   "WHERE status = 'new'"):
        if r["n"]:
            out.append(Task(key="password:new", kind="password",
                            title=f"Заявок на смену пароля: {r['n']}",
                            subject="страница входа"))
    return out


def _space_freshness(conn, unit_id: int, today: date) -> list[Task]:
    """
    Свободное место на складе (вычитка 30.09.2026, волна 4б): депо
    обновляет его в понедельник и четверг до 10:00. В эти дни задача
    стоит на доске со сроком «сегодня» и гаснет, как только место
    обновлено в «Приёмке».
    """
    if today.weekday() not in (0, 3):        # 0 — понедельник, 3 — четверг
        return []
    try:
        from . import purchasedb
        if purchasedb.has_tables(conn) and purchasedb.space_fresh(conn, unit_id):
            return []
    except psycopg.Error:
        return []                            # миграция 99 ещё не накатана
    return [Task(key=f"space_update:{today:%Y-%m-%d}", kind="space_update",
                 title="Обновить свободное место на складе",
                 subject="приёмка · до 10:00", due_at=today)]


def _supply_queue(conn, unit_id: int, today: date) -> list[Task]:
    """
    Поставки, которые ждут депо (02.10.2026): запросы ОЗ на согласовании и
    поставки, которые сегодня или раньше нужно принять. Задача гаснет, как
    только депо приняло решение или подтвердило приёмку.
    """
    try:
        from . import purchasedb
        if not purchasedb.has_tables(conn):
            return []
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT count(*) FILTER (WHERE status = 'approval') AS ask,
                       count(*) FILTER (WHERE status IN ('approved', 'arrival')
                                          AND exact_date <= %s) AS take
                FROM app.supply_order WHERE org_unit_id = %s
                """, (today, unit_id))
            r = cur.fetchone()
    except psycopg.Error:
        return []
    out: list[Task] = []
    if r and r["ask"]:
        out.append(Task(key="supply_queue:ask", kind="supply_queue",
                        title=f"Согласовать поставки отдела закупок: {r['ask']}",
                        subject="приёмка", due_at=today))
    if r and r["take"]:
        out.append(Task(key=f"supply_queue:take:{today:%Y-%m-%d}",
                        kind="supply_queue",
                        title=f"Принять поставки и подтвердить приёмку: {r['take']}",
                        subject="приёмка", due_at=today))
    return out


def collect(conn: psycopg.Connection, unit_id: int,
            today: date | None = None) -> list[Task]:
    """Все задачи, которые система видит на сегодня."""
    day = today or date.today()
    if _is_hq(conn, unit_id):
        return _hq_queue(conn, day)
    edge = day + timedelta(days=LEAD_DAYS)
    return (_people_deadlines(conn, unit_id, edge)
            + _new_cards(conn, unit_id, day)
            + _documents(conn, unit_id, day)
            + _equipment(conn, unit_id, day)
            + _returned_drafts(conn, unit_id, day)
            + _dismissals(conn, unit_id, day)
            + _space_freshness(conn, unit_id, day)
            + _supply_queue(conn, unit_id, day))


# ---------------------------------------------------------------------------
#  Доска недели
# ---------------------------------------------------------------------------

def refresh(conn: psycopg.Connection, unit_id: int,
            today: date | None = None,
            week: date | None = None) -> dict[str, int]:
    """
    Обновить доску недели: добавить новые задачи и закрыть исчезнувшие.

    Задача, причины которой больше нет, закрывается сама — это и есть «внёс
    данные, задача закрыта успешно» из задания. Закрытые руками не трогаем:
    человек уже отчитался, и переписывать его отметку нельзя.

    `today` — на какой день смотрим, `week` — на чью доску кладём результат.
    Обычно это одно и то же, и второй аргумент не нужен. Разводятся они для
    будущих недель: неделя 21–27 сентября показывается по своему последнему
    дню («что за неё предстоит»), но задачи ложатся на её понедельник, а не
    на понедельник той недели, в которой лежит 27 сентября.
    """
    day = today or date.today()
    monday = week or week_start(day)
    tasks = collect(conn, unit_id, day)
    keys = [t.key for t in tasks]

    added = 0
    refreshed = 0
    with conn.cursor() as cur:
        #  Куда отложены задачи этого депо — по последней отметке на ключ.
        #  Перенос переживает смену недели: отложили до 25-го, значит до
        #  25-го задача не поднимается, даже если наступил новый понедельник
        #  24.09.2026: перенос — одна запись на задачу депо (kanban_postpone),
        #  а не отметка в строке одной недели. Раньше новая неделя искала
        #  «последнюю отметку Отложено», и перенос терялся, если строка
        #  недели уже была создана прогнозом, или воскресал после «Вернуть
        #  в работу»
        parked = postpones(conn, unit_id)

        #  Исполнитель по умолчанию — начальник этого депо (подтверждение 16
        #  от 16.09.2026). Если начальника в приложении ещё нет, поле
        #  остаётся пустым: назначить можно и потом
        cur.execute("SELECT app.default_assignee(%s) AS uid", (unit_id,))
        assignee = cur.fetchone()["uid"]

        for t in tasks:
            wait = parked.get(t.key)
            #  Ещё не срок — заводим задачу сразу отложенной, с той же датой
            #  и причиной. Иначе она всплыла бы в понедельник как новая, и
            #  перенос пришлось бы делать заново каждую неделю
            if wait and wait["postponed_to"] > day:
                #  Строка недели могла уже быть — прогнозом, «в работе».
                #  Тогда перенос на неё накладывается; выполненную не трогаем
                cur.execute(
                    """
                    INSERT INTO app.kanban_task AS k
                        (org_unit_id, week_start, task_key, kind, title,
                         subject, due_at, status, note, postponed_to, done_at,
                         done_by, assignee_id)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, 'skipped', %s, %s,
                            %s, %s, %s)
                    ON CONFLICT (org_unit_id, week_start, task_key) DO UPDATE
                       SET status = 'skipped', note = EXCLUDED.note,
                           postponed_to = EXCLUDED.postponed_to,
                           done_at = EXCLUDED.done_at, done_by = EXCLUDED.done_by,
                           title = EXCLUDED.title, subject = EXCLUDED.subject,
                           due_at = EXCLUDED.due_at
                     WHERE k.status IN ('open', 'skipped')
                       AND (k.status, k.postponed_to, k.note, k.title, k.subject, k.due_at)
                           IS DISTINCT FROM
                           ('skipped', EXCLUDED.postponed_to, EXCLUDED.note,
                            EXCLUDED.title, EXCLUDED.subject, EXCLUDED.due_at)
                    RETURNING (xmax = 0) AS inserted
                    """,
                    (unit_id, monday, t.key, t.kind, t.title, t.subject,
                     t.due_at, wait["note"], wait["postponed_to"], wait["at"],
                     wait["by_user"], assignee),
                )
                row = cur.fetchone()
                if row and row["inserted"]:
                    added += 1
                continue

            #  Задача, которая уже на доске, пересчитывается вместе с
            #  причиной (24.09.2026): срок, заголовок и «кого касается»
            #  берутся свежими. Раньше строка писалась один раз за неделю, и
            #  после отметки ТО задача показывала старый срок — 22.06 при
            #  «ТО-1 до 22.09» в карточке машины. Пустой исполнитель тоже
            #  подтягивается: учётка начальника могла появиться позже задачи.
            #  Трогаем только открытые — отложенные и выполненные остаются
            #  такими, какими их закрыли, это история
            cur.execute(
                """
                INSERT INTO app.kanban_task AS k
                    (org_unit_id, week_start, task_key, kind, title, subject,
                     due_at, assignee_id)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                ON CONFLICT (org_unit_id, week_start, task_key) DO UPDATE
                   SET title       = EXCLUDED.title,
                       subject     = EXCLUDED.subject,
                       due_at      = EXCLUDED.due_at,
                       assignee_id = coalesce(k.assignee_id,
                                              EXCLUDED.assignee_id)
                 WHERE k.status = 'open'
                   AND (k.title, k.subject, k.due_at, k.assignee_id)
                       IS DISTINCT FROM
                       (EXCLUDED.title, EXCLUDED.subject, EXCLUDED.due_at,
                        coalesce(k.assignee_id, EXCLUDED.assignee_id))
                RETURNING (xmax = 0) AS inserted
                """,
                (unit_id, monday, t.key, t.kind, t.title, t.subject, t.due_at,
                 assignee),
            )
            row = cur.fetchone()
            if row and row["inserted"]:
                added += 1
            elif row:
                refreshed += 1

        #  Срок переноса наступил (вычитка 30.09.2026, п. 6.2): задача
        #  возвращается на доску, но не «в работу», а остаётся «Отложено» —
        #  стоит в самом вверху с причиной, без даты переноса и «кто отложил»
        #  (то и другое экран больше не показывает). На следующий день она
        #  читается «Просрочено». Поэтому строки не трогаем вовсе: статус
        #  'skipped' и прошедший postponed_to — это и есть сигнал для
        #  effective_status. Прежняя логика возвращала их в 'open' — теперь
        #  перенос, сделанный и не выполненный, не прячется среди рабочих задач
        #
        #  Истёкшие записи переноса больше не нужны — сама строка остаётся
        cur.execute("DELETE FROM app.kanban_postpone "
                    " WHERE org_unit_id = %s AND postponed_to <= %s",
                    (unit_id, day))
        returned = 0

        #  Прогноз будущих недель: перенос, закончившийся до понедельника
        #  этой недели, к ней уже не относится — «на новых неделях до даты
        #  переноса задача появляется отложенной», а после даты переноса —
        #  обычной работой (вычитка 30.09.2026, п. 6.2). Текущую неделю не
        #  трогаем: у вернувшегося переноса своя судьба — «Отложено» наверху
        #  в день возврата, «Просрочено» на следующий день
        if monday > week_start(date.today()):
            cur.execute(
                """
                UPDATE app.kanban_task
                   SET status = 'open', postponed_to = NULL,
                       done_at = NULL, done_by = NULL
                 WHERE org_unit_id = %s AND week_start = %s
                   AND status = 'skipped'
                   AND (postponed_to IS NULL OR postponed_to < %s)
                """,
                (unit_id, monday, monday),
            )

        #  Исчезла причина — задача закрыта внесением данных. Но только на
        #  неделе, которая уже идёт: будущая неделя это прогноз, её
        #  пересобирают при каждом взгляде. Отметить там «выполнено» значило
        #  бы записать сделанную сегодня работу на будущую неделю и раздуть
        #  её отчёт. В прогнозе задача просто исчезает — её там ещё не выдавали.
        #
        #  Вычитка 30.09.2026 (п. 6.2): сверка идёт и по отложенным — «когда
        #  задача выполнится через карточку человека или техники, автоматом
        #  переводить в Выполнено». Раньше отложенная с исчезнувшей причиной
        #  висела до дня переноса. Персональные задачи (is_manual) правила не
        #  порождают — их свери не с чем, закрывает их человек
        if monday > week_start(date.today()):
            cur.execute(
                """
                DELETE FROM app.kanban_task
                 WHERE org_unit_id = %s AND week_start = %s
                   AND status IN ('open', 'skipped')
                   AND NOT is_manual
                   AND NOT (task_key = ANY(%s))
                """,
                (unit_id, monday, keys),
            )
        else:
            cur.execute(
                """
                UPDATE app.kanban_task
                   SET status = 'auto_done', done_at = now()
                 WHERE org_unit_id = %s AND week_start = %s
                   AND status IN ('open', 'skipped')
                   AND NOT is_manual
                   AND NOT (task_key = ANY(%s))
                """,
                (unit_id, monday, keys),
            )
        closed = cur.rowcount
    conn.commit()
    return {"added": added, "auto_closed": closed, "returned": returned,
            "refreshed": refreshed, "total": len(tasks)}


#  Виды задач, у которых в ключе стоит номер сотрудника: `briefing:41:...`.
#  По нему в списке задач ставится ссылка на карточку (ДЗ-6, 21.09.2026).
#  Виды задач, чей ключ держит номер СОТРУДНИКА (а не назначения). Список
#  остаётся для тестов и для чтения: сама раскладка ссылок — в subject_urls
SUBJECT_KINDS = ("medical", "briefing", "certificate", "contract", "card")


#  Куда ведёт задача по человеку: вкладка карточки и блок на ней. Пустая
#  строка — просто карточка
PERSON_TABS = {
    "medical": "?tab=docs#exams",
    "briefing": "?tab=docs#briefings",
    "certificate": "?tab=docs#certificates",
    "contract": "?tab=main#contract",
    "card": "",
    "ppe": "?tab=ppe",
    #  Увольнение: сдача СИЗ, возврат техники и окончательный расчёт
    "ppe_return": "?tab=ppe",
    "asset_return": "?tab=ppe",
    "settlement": "?tab=payslips",
}

#  Виды, чей ключ держит номер СОТРУДНИКА. У остальных задач по людям
#  (увольнение) в ключе сразу номер назначения
BY_EMPLOYEE = ("medical", "briefing", "certificate", "contract", "card")


def subject_urls(conn: psycopg.Connection, unit_id: int, unit_code: str,
                 period: date, rows: list[dict[str, Any]]) -> dict[str, str]:
    """
    Задача → куда ведёт столбец «Кого касается».

    Требование заказчика от 22.09.2026: «сделать весь столбец кликабельным в
    соответствии с задачи: если это ТО-1 или ТО-2 — переходить в карточку
    данной техники; если подходит срок выдачи СИЗ — переходить в карточку
    сотрудника и во вкладку СИЗ».

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

    Номера объектов уже лежат в ключах задач, поэтому запросов ровно два:
    выдачи СИЗ перевести в сотрудников, заявки на ремонт — в технику.
    """
    month = f"{period:%Y-%m}"
    out: dict[str, str] = {}
    #  ключ → номер, который ещё предстоит превратить в ссылку
    issues: dict[str, int] = {}     # выдача СИЗ → сотрудник
    repairs: dict[str, int] = {}    # заявка на ремонт → техника
    mreqs: dict[str, int] = {}      # заявка на ТО → техника
    people: dict[str, tuple[str, int]] = {}   # ключ → (вид, номер сотрудника)

    for r in rows:
        key = r.get("task_key") or ""
        kind = r.get("kind") or ""
        tail = key.partition(":")[2]

        #  02.10.2026: месяц — из ключа задачи: табель прошлого месяца и
        #  график следующего ведут в свой месяц, а не в текущий
        own = tail[:7] if len(tail) >= 7 and tail[4:5] == "-" else month
        if kind == "timesheet":
            out[key] = f"/review?unit={unit_code}&period={own}"
        elif kind == "timesheet_day":
            out[key] = f"/timesheet?unit={unit_code}&period={own}"
        elif kind == "schedule":
            out[key] = f"/schedule?unit={unit_code}&period={own}"
        #  Свободное место (волна 4б): ведёт в «Приёмку» — обновляется там
        elif kind in ("space_update", "supply_queue"):
            out[key] = f"/purchase?unit={unit_code}"
        elif kind == "request":
            out[key] = "/staff?tab=requests"
        elif kind == "hiring":
            #  Вкладка очереди проверки называется «pending» — ссылка на
            #  «hiring» открывала общий список (исправлено 24.09.2026)
            out[key] = "/staff?tab=pending"
        elif kind == "password":
            out[key] = "/staff?tab=passwords"
        #  Доска «Минск»: каждая задача ведёт туда, где решение принимается
        elif kind == "hq_request":
            out[key] = f"/staff?tab=requests&unit={tail}"
        elif kind == "hq_hiring":
            out[key] = "/staff?tab=pending"
        elif kind == "hq_settlement" and tail.isdigit():
            out[key] = f"/settlement/{tail}"
        elif kind == "hq_timesheet":
            code, _, per = tail.partition(":")
            out[key] = f"/review?unit={code}&period={per}"
        elif kind == "hq_adjustment":
            code, _, per = tail.partition(":")
            out[key] = f"/adjustments?unit={code}&period={per}"
        elif kind == "hq_headcount":
            out[key] = "/budget"
        #  06.10.2026 (правка заказчика): заявка на недостающий комплект —
        #  в карточку сотрудника, на подвкладку «Выдано (на руках)»
        elif kind == "hq_ppe_request" and tail.isdigit():
            with conn.cursor() as cur:
                cur.execute(
                    """
                    SELECT em.id FROM app.ppe_request rq
                      JOIN app.employment em
                        ON em.employee_id = rq.employee_id
                       AND em.terminated_at IS NULL
                     WHERE rq.id = %s LIMIT 1
                    """,
                    (int(tail),))
                row = cur.fetchone()
            if row:
                out[key] = f"/staff/{row['id']}?tab=ppe&siz=issued"
        #  06.10.2026 (вечер): предложение по доработке прорабатывается
        #  на самой доске — клик ведёт на «Минск»
        elif kind == "hq_suggestion":
            out[key] = "/kanban?unit=hq"
        #  Финансы: договор — в карточку, оплата — к начислениям, курс — во
        #  вкладку курсов
        elif kind == "fin_contract_end" and tail.isdigit():
            out[key] = f"/finance/contract/{tail}"
        elif kind == "fin_payment":
            cid = tail.partition(":")[0]
            if cid.isdigit():
                out[key] = f"/finance/contract/{cid}#accruals"
        elif kind == "fin_rate":
            out[key] = "/finance?tab=rates"
        elif kind in ("hq_repair", "hq_specialist") and tail.isdigit():
            repairs[key] = int(tail)
        elif kind == "maint_request":
            asset = tail.partition(":")[0]
            if asset.isdigit():
                out[key] = f"/supply/asset/{asset}"
        elif kind in ("maint_visit", "hq_maint") and tail.isdigit():
            mreqs[key] = int(tail)
        elif kind == "hire_draft":
            #  Правится карточка там же, где депо её и заполняло: в подборе,
            #  подвкладка «На проверке»
            out[key] = f"/staff?tab=candidates&unit={unit_code}&cand=review"
        elif kind == "verification":
            #  «verification:{номер техники}» — ведёт в карточку прибора
            if tail.isdigit():
                out[key] = f"/supply/asset/{tail}"
        elif kind == "maintenance":
            #  «maintenance:{номер техники}:{ТО-1}»
            asset = tail.partition(":")[0]
            if asset.isdigit():
                out[key] = f"/supply/asset/{asset}"
        elif kind == "repair" and tail.isdigit():
            repairs[key] = int(tail)
        elif kind == "ppe" and tail.isdigit():
            issues[key] = int(tail)
        elif kind in PERSON_TABS:
            #  22.09.2026: фамилии перестали быть кликабельными. Ключ задачи
            #  по документу — «briefing:{сотрудник}:{вид инструктажа}», а
            #  номер брался из всего хвоста сразу: «17:Повторный» не число,
            #  и ссылки не выходило. Номер — всегда первый отрезок хвоста,
            #  что бы за ним ни стояло
            ident = tail.partition(":")[0]
            if ident.isdigit():
                people[key] = (kind, int(ident))

    if repairs:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT r.id, r.asset_id, ou.code FROM app.repair_request r "
                "  JOIN app.org_unit ou ON ou.id = r.org_unit_id "
                " WHERE r.id = ANY(%s)",
                (sorted(set(repairs.values())),),
            )
            by_request = {r["id"]: r for r in cur.fetchall()}
        for key, request_id in repairs.items():
            r = by_request.get(request_id)
            if not r:
                continue
            #  Вызов специалиста и «Произведён ремонт» делаются в заявке
            #  (24.09.2026) — туда и ведём, прямо на её строку
            if key.startswith(("hq_specialist:", "repair:")):
                out[key] = f"/supply?unit={r['code']}&tab=repairs#r{request_id}"
            else:
                out[key] = f"/supply/asset/{r['asset_id']}"

    if mreqs:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT id, asset_id FROM app.maintenance_request WHERE id = ANY(%s)",
                (sorted(set(mreqs.values())),),
            )
            by_mreq = {r["id"]: r["asset_id"] for r in cur.fetchall()}
        for key, rid in mreqs.items():
            if by_mreq.get(rid):
                out[key] = f"/supply/asset/{by_mreq[rid]}"

    if issues:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT id, employee_id FROM app.ppe_issue WHERE id = ANY(%s)",
                (sorted(set(issues.values())),),
            )
            by_issue = {r["id"]: r["employee_id"] for r in cur.fetchall()}
        for key, issue_id in issues.items():
            if by_issue.get(issue_id):
                people[key] = ("ppe", by_issue[issue_id])

        #  23.09.2026: «Асіповіч М.Ю.» в задаче по СИЗ не открывался. Задача
        #  уже выполнена, а выдачу, по которой она заводилась, с тех пор
        #  удалили (заменили вещь или исправили ошибочную запись) — искать
        #  человека стало не по чему. Ключ задачи менять нельзя: по нему доска
        #  узнаёт задачу между обновлениями. Поэтому для таких строк человек
        #  находится по фамилии с инициалами среди сотрудников депо — это та
        #  самая строка, что стоит в столбце. Совпадений больше одного —
        #  ссылки нет: вести не к тому человеку хуже, чем никуда
        lost = {key: r.get("subject") for r in rows
                for key in [r.get("task_key") or ""]
                if key in issues and key not in people and r.get("subject")}
        if lost:
            with conn.cursor() as cur:
                cur.execute(
                    """
                    SELECT e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                               coalesce(left(e.middle_name, 1) || '.', '') AS fio,
                           array_agg(DISTINCT e.id) AS ids
                    FROM app.employment em
                    JOIN app.employee e ON e.id = em.employee_id
                    WHERE em.org_unit_id = %s
                    GROUP BY 1
                    """,
                    (unit_id,),
                )
                by_fio = {r["fio"]: r["ids"] for r in cur.fetchall()}
            for key, fio in lost.items():
                ids = by_fio.get(fio) or []
                if len(ids) == 1:
                    people[key] = ("ppe", ids[0])

    #  Сотрудники → их действующие назначения: карточка открывается по
    #  назначению, а в ключах задач стоит номер человека
    need = sorted({num for kind, num in people.values()
                   if kind in BY_EMPLOYEE or kind == "ppe"})
    by_employee: dict[int, int] = {}
    if need:
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT DISTINCT ON (employee_id) employee_id, id
                  FROM app.employment
                 WHERE org_unit_id = %s AND employee_id = ANY(%s)
                 --  Действующее назначение первым; если человек уже уволен,
                 --  карточка у него всё равно есть — ведём в последнюю
                 ORDER BY employee_id, (terminated_at IS NULL) DESC,
                          hired_at DESC
                """,
                (unit_id, need),
            )
            by_employee = {r["employee_id"]: r["id"] for r in cur.fetchall()}

    for key, (kind, num) in people.items():
        employment = (by_employee.get(num)
                      if kind in BY_EMPLOYEE or kind == "ppe" else num)
        if employment:
            out[key] = f"/staff/{employment}{PERSON_TABS.get(kind, '')}"
    return out

def board(conn: psycopg.Connection, unit_id: int,
          monday: date) -> list[dict[str, Any]]:
    """Задачи недели — то, что рисует доска."""
    if not has_kanban(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT k.*, u.full_name AS done_by_name,
                   a.full_name AS assignee_name
            FROM app.kanban_task k
            LEFT JOIN app.app_user u ON u.id = k.done_by
            LEFT JOIN app.app_user a ON a.id = k.assignee_id
            WHERE k.org_unit_id = %s AND k.week_start = %s
            ORDER BY (k.status <> 'open'), k.due_at NULLS LAST, k.kind, k.subject
            """,
            (unit_id, monday),
        )
        return cur.fetchall()


def _check_really_done(conn: psycopg.Connection, task_id: int,
                       note: str | None) -> None:
    """
    Можно ли отметить задачу выполненной.

    Ручную — можно, но с комментарием. Остальные система проверяет сама:
    пересчитывает свои правила и смотрит, порождается ли эта задача до сих
    пор. Порождается — значит причина на месте и работа не сделана.
    """
    with conn.cursor() as cur:
        cur.execute(
            "SELECT org_unit_id, task_key, title, is_manual, week_start "
            "FROM app.kanban_task WHERE id = %s",
            (task_id,),
        )
        task = cur.fetchone()
    if not task:
        raise ValueError("Задача не найдена — обновите страницу")

    if task["is_manual"]:
        if not (note or "").strip():
            raise ValueError(
                "Напишите, что сделано: у ручной задачи это единственное "
                "свидетельство работы")
        return

    still = {t.key for t in collect(conn, task["org_unit_id"])}
    if task["task_key"] in still:
        raise ValueError(
            "Задача ещё не выполнена: данные в документе не исправлены. "
            "Внесите их — задача закроется сама, — либо отложите её с "
            "указанием причины")


def task_kind(conn: psycopg.Connection, task_id: int) -> str | None:
    with conn.cursor() as cur:
        cur.execute("SELECT kind FROM app.kanban_task WHERE id = %s", (task_id,))
        row = cur.fetchone()
    return row["kind"] if row else None


def suggestion_settle(conn: psycopg.Connection, task_id: int,
                      user_id: int | None) -> None:
    """
    «Выполнить» на задаче-предложении по доработке: вопрос проработан,
    предложение гаснет в таблице (handled_at). После этого проверка
    «реально ли сделано» перестаёт находить причину, и задача закрывается.
    Отложенная задача предложение не гасит — оно вернётся на доску.
    """
    with conn.cursor() as cur:
        cur.execute(
            "SELECT task_key FROM app.kanban_task WHERE id = %s", (task_id,))
        row = cur.fetchone()
        if not row or not row["task_key"].startswith("hq_suggestion:"):
            return
        tail = row["task_key"].split(":", 1)[1]
        if not tail.isdigit():
            return
        cur.execute(
            """
            UPDATE app.improvement_suggestion
               SET handled_at = now(), handled_by = %s
             WHERE id = %s AND handled_at IS NULL
            """,
            (user_id, int(tail)))


def close_task(conn: psycopg.Connection, task_id: int, status: str,
               note: str | None, user_id: int | None,
               postponed_to: date | None = None,
               result_link: str | None = None,
               result_file: str | None = None,
               result_file_name: str | None = None) -> None:
    """
    Отложить задачу или вернуть её в работу.

    Кнопка «Выполнено» вернулась 16.09.2026 — вместе с проверкой, которую
    просил заказчик: «если дата не исправлена и задача не выполнена, то
    невозможно закрыть её нажав кнопку выполнено. Только если отложить с
    указанием причины».

    Поэтому «Выполнено» здесь не отметка о намерении, а запрос на проверку:
    система заново считает свои правила и смотрит, исчезла ли причина задачи.
    Исчезла — задача закрывается; нет — отказ с объяснением. Нажать её, не
    сделав работу, по-прежнему нельзя.

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

    «Отложить» требует двух вещей: когда вернёмся и почему. Без даты
    «отложено» означало бы «забыли навсегда», без причины — «прячем
    несделанное». Пример заказчика: надо выдать СИЗ, а человек на больничном.
    """
    if status not in ("skipped", "open", "done"):
        raise ValueError(f"Неизвестная отметка: {status}")

    if status == "done":
        _check_really_done(conn, task_id, note)

    if status == "skipped":
        if not (note or "").strip():
            raise ValueError("Отложенную задачу поясните: почему не сделана")
        if postponed_to is None:
            raise ValueError("Укажите дату, на которую переносите задачу")
        if postponed_to <= date.today():
            raise ValueError(
                "Дата переноса должна быть в будущем: отложить на вчера "
                "или на сегодня значит не отложить вовсе")

    with conn.cursor() as cur:
        cur.execute(
            """
            UPDATE app.kanban_task
               SET status = %(status)s,
                   note = %(note)s,
                   postponed_to = %(until)s,
                   done_at = CASE WHEN %(status)s = 'open' THEN NULL ELSE now() END,
                   done_by = CASE WHEN %(status)s = 'open' THEN NULL
                                  ELSE %(user)s END,
                   result_link = %(rlink)s,
                   result_file = %(rfile)s,
                   result_file_name = %(rfname)s
             WHERE id = %(id)s
            """,
            {"status": status, "note": (note or "").strip() or None,
             "until": postponed_to if status == "skipped" else None,
             "user": user_id, "id": task_id,
             #  Отчёт о выполнении персональной задачи (6.4.1): ссылка и
             #  файл прикладываются один раз при закрытии; «Вернуть в
             #  работу» их стирает — отчёта больше нет
             "rlink": result_link if status == "done" else None,
             "rfile": result_file if status == "done" else None,
             "rfname": result_file_name if status == "done" else None},
        )
        if cur.rowcount == 0:
            raise ValueError("Задача не найдена — обновите страницу")
        cur.execute("SELECT org_unit_id, task_key, title, week_start "
                    "  FROM app.kanban_task WHERE id = %s", (task_id,))
        task = cur.fetchone()
        this_week = week_start(date.today())
        if status == "skipped":
            #  Перенос — одной записью на задачу (24.09.2026) и сразу на все
            #  уже созданные строки недель от текущей и дальше
            cur.execute(
                """
                INSERT INTO app.kanban_postpone
                    (org_unit_id, task_key, postponed_to, note, by_user)
                VALUES (%s, %s, %s, %s, %s)
                ON CONFLICT (org_unit_id, task_key) DO UPDATE
                   SET postponed_to = EXCLUDED.postponed_to, note = EXCLUDED.note,
                       by_user = EXCLUDED.by_user, at = now()
                """,
                (task["org_unit_id"], task["task_key"], postponed_to,
                 note.strip(), user_id))
            cur.execute(
                """
                UPDATE app.kanban_task
                   SET status = 'skipped', note = %s, postponed_to = %s,
                       done_at = now(), done_by = %s
                 WHERE org_unit_id = %s AND task_key = %s AND id <> %s
                   AND week_start >= %s AND status = 'open'
                """,
                (note.strip(), postponed_to, user_id, task["org_unit_id"],
                 task["task_key"], task_id, this_week))
            _log(cur, user_id, task["org_unit_id"], "kanban_postpone",
                 f"«{task['title']}» отложена до {postponed_to:%d.%m.%Y}: {note.strip()}")
        elif status == "open":
            #  «Вернуть в работу» снимает перенос совсем — задача больше
            #  нигде не всплывает отложенной
            cur.execute("DELETE FROM app.kanban_postpone "
                        " WHERE org_unit_id = %s AND task_key = %s",
                        (task["org_unit_id"], task["task_key"]))
            cur.execute(
                """
                UPDATE app.kanban_task
                   SET status = 'open', postponed_to = NULL, done_at = NULL,
                       done_by = NULL
                 WHERE org_unit_id = %s AND task_key = %s AND id <> %s
                   AND week_start >= %s AND status = 'skipped'
                """,
                (task["org_unit_id"], task["task_key"], task_id, this_week))
            _log(cur, user_id, task["org_unit_id"], "kanban_return",
                 f"«{task['title']}» возвращена в работу")
    conn.commit()


def personal_create(conn: psycopg.Connection, unit_id: int,
                    title: str, subject: str, kind_label: str,
                    due_at: date, user_id: int | None) -> int:
    """
    Поставить персональную задачу (вычитка 30.09.2026, п. 6.4.1).

    Задачу ставит Администрация ООУРЦ из «Результата по депо»: кого касается,
    срок, что сделать, вид. Живёт она на доске выбранного депо текущей
    недели, исполнитель — начальник этого депо. Ключ с датой и случайным
    хвостом: двух одинаковых поручений в день быть может сколько угодно.

    is_manual = true: правила доски такую задачу не пересчитывают и не
    закрывают — закрывает её начальник РЦ кнопкой «ВЫПОЛНИТЬ» с отчётом.
    """
    key = f"personal:{date.today():%Y%m%d}:{uuid4().hex[:8]}"
    with conn.cursor() as cur:
        cur.execute("SELECT app.default_assignee(%s) AS uid", (unit_id,))
        assignee = cur.fetchone()["uid"]
        cur.execute(
            """
            INSERT INTO app.kanban_task
                (org_unit_id, week_start, task_key, kind, kind_label, title,
                 subject, due_at, status, is_manual, assignee_id)
            VALUES (%s, %s, %s, 'personal', %s, %s, %s, %s, 'open', true, %s)
            RETURNING id
            """,
            (unit_id, week_start(), key, kind_label.strip(), title.strip(),
             subject.strip(), due_at, assignee),
        )
        task_id = cur.fetchone()["id"]
        _log(cur, user_id, unit_id, "kanban_personal",
             f"«{title.strip()}» — {subject.strip()}, срок "
             f"{due_at:%d.%m.%Y} (вид: {kind_label.strip()})")
    conn.commit()
    return task_id


def personal_tasks(conn: psycopg.Connection,
                   weeks: list[date]) -> list[dict[str, Any]]:
    """
    Персональные задачи всех депо за недели — копия для доски «Минск».

    Трансляция (п. 6.4.1): Администрация видит поставленные ею задачи и их
    состояние на своей доске, не открывая двенадцать депо. Сами строки лежат
    в депо и меняются там — здесь только чтение.
    """
    if not weeks or not has_kanban(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT k.*, ou.code AS unit_code, ou.name AS unit_name,
                   u.full_name AS done_by_name,
                   a.full_name AS assignee_name
            FROM app.kanban_task k
            JOIN app.org_unit ou ON ou.id = k.org_unit_id
            LEFT JOIN app.app_user u ON u.id = k.done_by
            LEFT JOIN app.app_user a ON a.id = k.assignee_id
            WHERE k.kind = 'personal' AND k.week_start = ANY(%s)
            """,
            (weeks,),
        )
        return cur.fetchall()


def postpones(conn: psycopg.Connection, unit_id: int) -> dict[str, dict[str, Any]]:
    """Действующие переносы депо: ключ задачи → дата, причина, кто, когда."""
    try:
        with conn.transaction(), conn.cursor() as cur:
            cur.execute("SELECT task_key, postponed_to, note, by_user, at "
                        "  FROM app.kanban_postpone WHERE org_unit_id = %s",
                        (unit_id,))
            return {r["task_key"]: r for r in cur.fetchall()}
    except psycopg.Error:
        return {}                       # миграция 83 ещё не накатана


def _log(cur, user_id, unit_id, operation: str, message: str) -> None:
    """Перенос и возврат — в журнал операций: история переносов (24.09.2026)."""
    cur.execute(
        "INSERT INTO app.operation_log (user_id, operation, org_unit_id, status,"
        " rows_affected, message) VALUES (%s, %s, %s, 'ok', 1, %s)",
        (user_id, operation, unit_id, message[:500]))


def summary(conn: psycopg.Connection, unit_ids: list[int],
            monday: date) -> list[dict[str, Any]]:
    """
    Сводка по депо за неделю — центральное окно администратора.

    «Оцифровка проделанной работы»: сколько задач выдано, сколько отмечено
    руками, сколько выполнено внесением данных и сколько осталось.

    Обе отметки — выполненная работа: «нам важно фиксировать выполненные
    задачи». Складываются они в `closed`, но по отдельности тоже видны —
    по ним понятно, отчитывается человек кнопкой или просто делает дело.
    """
    if not unit_ids or not has_kanban(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT ou.id, ou.code, ou.name,
                   count(k.id)                                        AS total,
                   count(*) FILTER (WHERE k.status = 'open')          AS open,
                   count(*) FILTER (WHERE k.status = 'done')          AS done,
                   count(*) FILTER (WHERE k.status = 'auto_done')     AS auto_done,
                   count(*) FILTER (WHERE k.status = 'skipped')       AS skipped,
                   count(*) FILTER (WHERE k.status = 'open'
                                      AND k.due_at < %(monday)s)      AS overdue
            FROM app.org_unit ou
            LEFT JOIN app.kanban_task k
                   ON k.org_unit_id = ou.id AND k.week_start = %(monday)s
            WHERE ou.id = ANY(%(units)s)
            GROUP BY ou.id, ou.code, ou.name
            ORDER BY ou.name
            """,
            {"units": unit_ids, "monday": monday},
        )
        rows = cur.fetchall()
    for r in rows:
        closed = int(r["done"]) + int(r["auto_done"])
        total = int(r["total"])
        #  Доля закрытого — то, что смотрят первым. Без задач доля не
        #  считается: ноль из нуля это не «ничего не сделано»
        r["share"] = round(closed / total * 100) if total else None
        r["closed"] = closed
    return rows
