"""
Веб-интерфейс приложения «Управление ООУРЦ».

Запуск:
    uvicorn timesheet.webapp:app --host 127.0.0.1 --port 8000

Экраны:
    /login      вход
    /timesheet  сетка фактического табеля
    /schedule   сетка планового графика
    /review     сверка плана и факта, сдача табеля, выгрузка табеля
"""

from __future__ import annotations

import calendar
import os
import re
import secrets
from contextlib import asynccontextmanager, contextmanager
from datetime import date, datetime, time, timedelta
from decimal import Decimal, InvalidOperation
from pathlib import Path
from typing import Any, Iterator
from urllib.parse import quote, urlencode

import psycopg
from fastapi import FastAPI, File, Form, HTTPException, Query, Request, UploadFile
from fastapi.responses import (
    FileResponse,
    HTMLResponse,
    JSONResponse,
    RedirectResponse,
    Response,
)
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from markupsafe import Markup, escape
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from starlette.middleware.sessions import SessionMiddleware

from . import (budgetdb, cabinetdb, defectdb, discountdb, discountreport, financedb, kanbandb, mail, opsimport,
               orderdb, payroll, payrolldb, penaltydb, purchasedb, repo,
               rmbdb, rmbimages, productimages, settingsdb, staffdb, supplydb, vacationdb, webdb)
from .cells import (
    DAY_CODES,
    CellError,
    day_code_reference_fallback,
    FactCell,
    build_fact_cell,
    fact_cell_kind,
    fact_cell_parts,
    merge_fact_part,
    format_fact_cell,
    format_plan_cell,
    parse_fact_cell,
    parse_plan_cell,
    plan_cell_kind,
    plan_cell_lines,
)
from . import security
from .compare import compare, month_row, summarize
from .schedule_print import build_rows as build_sched_rows, export_schedule
from .totals import SUMMARY_CODES
from .rules import (
    RULE_VERSION,
    BreakRule,
    LunchRule,
    NightWindow,
    PlanHours,
    ShiftRow,
    excused_plan_hours,
    month_bounds,
    personal_norm,
    plan_and_worked,
    plan_hours,
    schedule_norm,
)
from .ppe_print import StatementLine as PpeLine
from .ppe_print import export_statement
from .vacation_print import VacationRow, export_vacations
from .vacation_print import record_text as vacation_record_text
from .tabel_print import TabelDay, TabelRow, export_tabel
#  `order_print` ввозится не здесь, а внутри самого обработчика печати.
#
#  Причина конкретная (22.09.2026). Модуль печати приказа держится на
#  python-docx; пакет в окружении не оказался, и приложение не поднялось
#  целиком: человек увидел не «печать недоступна», а трассировку вместо
#  табеля. Одна печатная форма не должна уносить с собой весь табель, график
#  и расчёт зарплаты.
#
#  Так же поступать с остальными импортами незачем: openpyxl и psycopg нужны
#  приложению всегда, и без них ему всё равно нечего показывать.
from .totals import compare_with_norm, compute_totals

BASE_DIR = Path(__file__).parent
OUT_DIR = Path(os.environ.get("OUT_DIR", "/out"))

# Название приложения. Одно место на всё: заголовок окна браузера, шапка,
# имя сервиса, страница входа.
#
# Полное наименование отдела — «Отдел операционного управления
# распределительными центрами». Оно официальное: так отдел называется в
# документах, и в приложении расходиться с ними нельзя. Раньше в разных
# местах стояла расшифровка «отдел обеспечения управления региональными
# центрами» — неверная; теперь наименование задано здесь одной строкой и
# подставляется всюду, чтобы второй такой правки не потребовалось.
#
# Пункт 28 плана от 14.09.2026: приложение называется «Управление ООУРЦ», а
# не «табель». Табель — один из документов внутри него, и называть систему
# по одному её экрану значит обещать меньше, чем она делает: здесь и график,
# и кадры, и мотивация, и бюджет.
APP_NAME = "Управление ООУРЦ"
APP_FULL_NAME = "Отдел операционного управления распределительными центрами"

# Обозначение валюты. Все суммы в системе — белорусские рубли; знак задаётся
# здесь, чтобы не разъезжался по страницам и выгрузкам.
CURRENCY = os.environ.get("CURRENCY", "руб.")

MONTHS_RU = [
    "январь", "февраль", "март", "апрель", "май", "июнь",
    "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь",
]
WEEKDAYS_RU = ["пн", "вт", "ср", "чт", "пт", "сб", "вс"]

#  Состояний табеля пять. «Принят на проверку» появился 16.09.2026: без него
#  не выразить решение «депо отзывает свою сдачу, пока администрация не взяла
#  табель в работу» — между «сдан» и «утверждён» не было момента, в который
#  решается, поздно отзывать или ещё нет.
STATUS_RU = {
    "open": "Открыт",
    "submitted": "Сдан депо",
    "in_review": "На проверке",
    "approved": "Утверждён",
    "closed": "Закрыт",
}

#  У графика состояний два: пока составляется — правится молча, после сдачи
#  (выгрузки в 1С ЗУП) правится по-прежнему, но каждая правка идёт в журнал
SCHEDULE_STATUS_RU = {
    "draft": "Составляется",
    "submitted": "Сдан",
}

#  Значение в списке депо, означающее «все сразу». Не код подразделения:
#  подразделения с таким кодом не бывает, и спутать их нельзя
ALL_UNITS = "all"

#  До какого года приложение готово вести учёт (пункт 20 плана от
#  14.09.2026). Раньше в списках годов стояли только текущий и следующий, и
#  завести производственный календарь на 2027-й было некуда: год в списке не
#  появлялся, пока в нём не окажется хотя бы одна строка календаря, а строку
#  неоткуда было взять. Теперь годы перечисляются вперёд до этой границы.
LAST_WORK_YEAR = 2030


def work_years(*known: int) -> list[int]:
    """
    Годы для выпадающих списков: от прошлого до LAST_WORK_YEAR.

    Прошлый год нужен, чтобы можно было открыть уже закрытый декабрь и
    посмотреть, как считали. Всё, что пришло из базы (`known`), добавляется:
    в старых данных попадаются годы и раньше.
    """
    first = min([date.today().year - 1, *known]) if known else date.today().year - 1
    return sorted(set(range(first, LAST_WORK_YEAR + 1)) | set(known), reverse=True)

#  Журнал операций свой в каждом блоке работ (пункт 16). Отбор идёт по
#  образцам имени операции, а не по перечню кодов: новая операция блока
#  попадает в его журнал сама, без правки списка в двух местах.
JOURNAL_BLOCKS: dict[str, tuple[str, ...]] = {
    "timesheet": ("timesheet%", "month_open"),
    "schedule": ("schedule%", "plan%"),
    #  24.09.2026: и подтверждение трудоустройства, и окончательный расчёт —
    #  тоже события по людям; раньше они в журнал «Сотрудников» не попадали
    "staff": ("staff%", "hire%", "dismissal%", "transfer%",
              "ppe%", "briefing%", "medical%", "vacation%",
              "employment%", "settlement%", "password%"),
    "payroll": ("payroll%", "kpi%", "adjustment%", "operations%", "fuel%"),
    #  Шаги заявок на ремонт — отдельной страницы журнала нет, но название
    #  операции должно куда-то относиться, иначе её не увидит никто
    #  02.10.2026 (вычитка 9.6): журнал раздела виден на вкладке
    #  «Обеспечение» → «Журнал»
    "supply": ("repair%", "maintenance%", "supply%", "asset%",
               "verification%", "ppe_base%"),
    #  Переносы задач доски (24.09.2026)
    "kanban": ("kanban%",),
    #  Финансы: договоры, начисления, оплаты, курсы (24.09.2026)
    "finance": ("finance%",),
}

#  Названия операций по-русски. Код операции остаётся в базе, а в журнале
#  человек читает слова: «timesheet_reopen» ему ничего не говорит.
OPERATION_RU = {
    "month_open": "Месяц открыт",
    "timesheet_submit": "Табель сдан",
    "timesheet_approve": "Табель утверждён",
    "timesheet_reopen": "Табель возвращён на доработку",
    "timesheet_close": "Табель закрыт",
    "timesheet_clear": "Табель очищен",
    "timesheet_fill": "Табель заполнен по графику",
    "timesheet_import": "Табель загружен из файла",
    "schedule_submit": "График сдан",
    "schedule_reopen": "График возвращён в работу",
    "schedule_edit": "Правка сданного графика",
    "schedule_import": "График загружен из файла",
    "schedule_copy": "График заполнен по прошлому месяцу",
    "schedule_clear": "График очищен",
    "plan_recalc": "Плановые часы пересчитаны",
    "payroll_calc": "Расчёт выполнен",
    "payroll_confirm": "Расчёт подтверждён",
    "payroll_close": "Расчёт закрыт",
    "payroll_recalc": "Перерасчёт новой версией",
    "kpi_entry": "Показатель внесён",
    "adjustment": "Вычет или доплата",
    "operations_load": "Загрузка операций",
    "hire": "Приём на работу",
    "dismissal": "Увольнение",
    #  24.09.2026: «что показывает столбец Операция?» — показывал служебный
    #  код («staff.terminate»). Теперь слова
    "staff.hire": "Приём на работу",
    "staff.terminate": "Увольнение или перевод",
    "staff.transfer": "Перевод",
    #  02.10.2026: новые операции без словаря показывались кодом
    "staff.fio_fix": "Исправление ФИО",
    "staff.hire_cancel": "Отмена неподтверждённого приёма",
    "staff.undo_close": "Отмена увольнения",
    "staff.undo_close": "Отмена увольнения",
    "employment_confirm": "Трудоустройство подтверждено",
    "employment_return": "Карточка ТУ возвращена депо",
    "employment_redraft": "Карточка ТУ исправлена депо",
    "settlement.submit": "Расчёт отправлен администрации",
    "settlement.accept": "Окончательный расчёт принят",
    "settlement.return": "Расчёт возвращён депо",
    "settlement.tsd": "Подтверждена сдача ТСД",
    "adjustment_approve": "Вычет или доплата согласованы",
    "adjustment_reject": "Вычет или доплата отклонены",
    "adjustment_delete": "Вычет или доплата удалены",
    "timesheet_review": "Табель взят на проверку",
    "timesheet_withdraw": "Табель отозван депо",
    "repair_move": "Шаг заявки на ремонт",
    #  Кабинет ОЗ (волна 4б): путь поставки от запроса до приёмки
    "supply_create": "Поставка запрошена",
    "supply_decide": "Решение по поставке",
    "supply_exact": "Точная дата поставки",
    "supply_arrival": "Запрошена приёмка",
    "supply_received": "Приёмка подтверждена",
    "kanban_postpone": "Задача доски отложена",
    "kanban_return": "Задача доски возвращена в работу",
    #  Персональная задача (вычитка 30.09.2026, п. 6.4.1): постановку — в
    #  журнал, чтобы было видно, кто и что поручил; отчёт о выполнении
    #  начальником РЦ — как обычная отметка задачи, без записи
    "kanban_personal": "Персональная задача поставлена",
    "ppe_annul": "Выдача СИЗ аннулирована",
    "ppe_extend": "Срок носки СИЗ продлён актом",
    "ppe_extend_annul": "Акт продления СИЗ аннулирован",
    "ppe_statement_annul": "Ведомость СИЗ аннулирована",
    "maintenance_request": "Заявка на ТО заполнена",
    "maintenance_schedule": "Заявка на ТО сформирована",
    "maintenance_cancel": "Заявка на ТО отменена",
    "maintenance_fix": "Отметка ТО исправлена",
    "maintenance_drop": "Отметка ТО удалена",
    "password_mail": "Письмо с паролем",
}
#  Финансы (24.09.2026): операции раздела описаны рядом с его кодом
OPERATION_RU.update(financedb.OPERATION_RU)


def journal_text(text: str | None) -> str:
    """
    «Что именно» в журнале — человеческими словами (24.09.2026).

    Сообщения пишет база, и в них оставались служебные слова и даты в
    машинном виде: «закрыто 2026-09-23, направление dismissal».
    """
    if not text:
        return ""
    out = re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3.\2.\1", text)
    for code, ru in (("transfer_internal", "перевод в другой РЦ"),
                     ("transfer_company", "перевод внутри компании"),
                     ("dismissal", "увольнение"), ("transfer", "перевод")):
        out = re.sub(rf"\b{code}\b", ru, out)
    return out


def journal_of(conn, block: str, unit_id: int | None,
               period: date | None,
               patterns: tuple[str, ...] | None = None) -> list[dict[str, Any]]:
    """
    Журнал блока, собранный по месяцам — в том виде, в каком его рисует
    шаблон: список месяцев, внутри каждого записи сверху вниз по времени.

    30.09.2026 (вычитка 1.24): сведения об отправке паролей — «Пароль
    выслан на …», «Письмо на … не ушло» — видит только Администратор.
    Раньше их читало любое депо: кому по всей компании высылались пароли
    и тексты ошибок почтового сервера.

    patterns (02.10.2026): свой набор образцов вместо блочного — так
    вкладка «Журнал» в «Сотрудниках» фильтрует историю по вкладкам.
    """
    patterns = patterns or JOURNAL_BLOCKS[block]
    #  без соединения (тесты журнала) состав блока не пересобираем
    if conn is not None and "password%" in patterns \
            and not webdb.is_admin(conn):
        patterns = tuple(p for p in patterns if p != "password%")
    rows = webdb.journal(conn, patterns, unit_id, period)
    months: list[dict[str, Any]] = []
    for r in rows:
        m = r["month"]
        if not months or months[-1]["month"] != m:
            months.append({
                "month": m,
                "label": f"{MONTHS_RU[m.month - 1]} {m.year}" if m else "Без месяца",
                "rows": [],
            })
        months[-1]["rows"].append(r)
    return months

def dsn() -> str:
    """Строка подключения. Своей копии нет намеренно — см. `repo.dsn`."""
    return repo.dsn()


_pool: ConnectionPool | None = None


def pool() -> ConnectionPool:
    """
    Пул соединений с базой.

    Раньше каждый запрос страницы открывал своё соединение и нигде их число
    не ограничивалось. При перезапуске сервера (а с --reload он перезапускается
    на каждую правку кода) старый процесс убивался, а его соединения оставались
    висеть на стороне PostgreSQL. Набиралось столько, что постмастер перестаёт
    обслуживать новые — и любая страница падала с ConnectionTimeout.

    Пул держит ограниченное число соединений и закрывается при остановке
    приложения, поэтому висящих больше не остаётся.
    """
    global _pool
    if _pool is None:
        _pool = ConnectionPool(
            dsn(),
            min_size=1,
            max_size=int(os.environ.get("DB_POOL_MAX", "8")),
            timeout=15,                    # сколько ждать свободного соединения
            max_lifetime=30 * 60,
            kwargs={"row_factory": dict_row, "connect_timeout": 10},
            # База на этом же ПК её и перезапускают руками. Без проверки пул
            # выдал бы соединение, умершее вместе с прошлым запуском базы.
            check=ConnectionPool.check_connection,
            reset=_reset_connection,
            name="ooucr",
            open=True,
        )
    return _pool


def _reset_connection(conn: psycopg.Connection) -> None:
    """Соединение уходит обратно в пул — стереть пользователя сессии."""
    webdb.clear_session_user(conn)
    conn.commit()


@asynccontextmanager
async def lifespan(_app: FastAPI):
    yield
    global _pool
    if _pool is not None:
        _pool.close()
        _pool = None


app = FastAPI(title=APP_NAME, docs_url=None, redoc_url=None,
              lifespan=lifespan)
app.add_middleware(
    SessionMiddleware,
    secret_key=os.environ.get("SESSION_SECRET") or secrets.token_hex(32),
    #  v1.1: собственное имя cookie. Браузер не разделяет cookie по портам,
    #  и две копии приложения на 127.0.0.1:8000 и :8001 перезаписывали бы
    #  сессии друг друга, выкидывая из системы.
    session_cookie="ooucr_session_v11",
    same_site="lax",
    #  Внешний контур (23.09.2026): за HTTPS cookie уходит только по
    #  защищённому каналу. Включается настройкой COOKIE_SECURE=1 — без HTTPS
    #  этот флаг сломал бы вход, браузер перестал бы отдавать cookie
    https_only=security.COOKIE_SECURE,
    max_age=12 * 3600,
)
#  Заголовки безопасности и проверка источника запроса — см. security.py.
#  Добавляется после сессии, значит выполняется раньше неё: запрос с чужого
#  сайта отсекается до того, как до него дойдёт чья-то сессия
app.add_middleware(security.SecurityHeaders)
app.mount("/static", StaticFiles(directory=BASE_DIR / "static"), name="static")


@app.get("/favicon.ico", include_in_schema=False)
def favicon():
    """Браузер спрашивает значок по старому адресу — отдаём погрузчик."""
    return RedirectResponse("/static/img/favicon.svg", status_code=301)


from fastapi.exception_handlers import http_exception_handler as _default_http_handler  # noqa: E402
from starlette.exceptions import HTTPException as StarletteHTTPException  # noqa: E402


@app.exception_handler(StarletteHTTPException)
async def _auth_redirect(request: Request, exc: StarletteHTTPException):
    """
    «Требуется вход» из браузера — на страницу входа, а не голым текстом.

    Сюда же попадает учётка, которую отключили, пока человек работал
    (23.09.2026): сессия у него ещё есть, а права — нет. Сессию стираем,
    чтобы следующий запрос не пришёл с ней снова.
    """
    if exc.status_code == 401:
        request.session.clear()
        if request.method == "GET" and "text/html" in request.headers.get("accept", ""):
            return RedirectResponse("/login", status_code=303)
    return await _default_http_handler(request, exc)


DB_DOWN_HTML = """<!doctype html>
<meta charset="utf-8">
<title>База не отвечает</title>
<style>
 body {{ font: 15px/1.5 -apple-system, "Segoe UI", Roboto, Arial, sans-serif;
        margin: 12vh auto; max-width: 46em; padding: 0 24px; color: #16181d; }}
 h1 {{ font-size: 20px; }}
 code {{ background: #eceef2; padding: 2px 6px; border-radius: 4px; }}
 li {{ margin-bottom: 6px; }}
 .why {{ color: #6b7280; font-size: 13px; margin-top: 24px; }}
</style>
<h1>База данных не отвечает</h1>
<p>Приложение работает, но не может обратиться к PostgreSQL. Данные не потеряны.</p>
<ol>
  <li>Закройте окно сервера или запустите <code>stop_app.cmd</code></li>
  <li>Запустите <code>start_app.cmd</code> — он проверит базу и при необходимости
      перезапустит её сам</li>
</ol>
<p>Если не помогло, посмотрите журнал базы:
   <code>%LOCALAPPDATA%\\ooucr\\postgres.log</code></p>
<p class="why">Техническая причина: {reason}</p>
"""


@app.exception_handler(psycopg.OperationalError)
@app.exception_handler(PoolTimeout)
def db_unavailable(request: Request, exc: Exception):
    """
    База недоступна — это не ошибка страницы, а состояние окружения.
    Трассировка на пол-экрана тут ничего не объясняет, поэтому отдаём
    страницу с тем, что надо сделать.
    """
    return HTMLResponse(
        DB_DOWN_HTML.format(reason=str(exc) or type(exc).__name__),
        status_code=503,
    )


DB_STALE_HTML = """<!doctype html>
<meta charset="utf-8">
<title>База отстала от кода</title>
<style>
 body {{ font: 15px/1.5 -apple-system, "Segoe UI", Roboto, Arial, sans-serif;
        margin: 12vh auto; max-width: 48em; padding: 0 24px; color: #16181d; }}
 h1 {{ font-size: 20px; }}
 code {{ background: #eceef2; padding: 2px 6px; border-radius: 4px; }}
 li {{ margin-bottom: 8px; }}
 .why {{ color: #6b7280; font-size: 13px; margin-top: 24px; }}
 .back {{ margin-top: 18px; }}
</style>
<h1>База отстала от кода</h1>
<p>Страница просит из базы то, чего в ней ещё нет. Данные целы: обновление
   кода и обновление базы — два разных действия, и второе не сделано.</p>
<ol>
  <li>Закройте окно сервера или запустите <code>stop_app.cmd</code></li>
  <li>Запустите <code>start_app.cmd</code> — при запуске он накатывает
      новые миграции сам. Или отдельно <code>update_db.cmd</code>, если сервер
      трогать не хочется</li>
  <li>Обновите страницу</li>
</ol>
<p class="back"><a href="/">Вернуться на главную</a></p>
<p class="why">Техническая причина: {reason}</p>
"""


@app.exception_handler(psycopg.errors.UndefinedColumn)
@app.exception_handler(psycopg.errors.UndefinedTable)
@app.exception_handler(psycopg.errors.UndefinedFunction)
def db_stale(request: Request, exc: Exception):
    """
    Код обновился, а база нет.

    Такое бывает при каждом обновлении: uvicorn перечитывает код сам, а
    миграции накатываются только при запуске start_app.cmd. Раньше это
    выглядело как «Internal Server Error» — сообщение, из которого ничего не
    следует. Теперь страница прямо говорит, что запустить; и это работает для
    любой будущей миграции, а не только для той, из-за которой я это писал.
    """
    reason = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
    return HTMLResponse(
        DB_STALE_HTML.format(reason=reason or type(exc).__name__),
        status_code=503,
    )

templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.globals["MONTHS_RU"] = MONTHS_RU
templates.env.globals["CALLS_YEAR_LIMIT"] = webdb.CALLS_YEAR_LIMIT
templates.env.globals["OVERTIME_YEAR_LIMIT"] = webdb.OVERTIME_YEAR_LIMIT
templates.env.globals["STATUS_RU"] = STATUS_RU
#  02.10.2026 (вычитка 2.25): один порог подсветки сроков в списке и в
#  карточке — за 30 дней. Раньше список подсвечивал за 30, карточка — за 60
#  (контракт, медосмотр, свидетельство) и за 30 (инструктаж)
DUE_WARN_DAYS = 30
templates.env.globals["DUE_WARN_DAYS"] = DUE_WARN_DAYS
templates.env.globals["SCHEDULE_STATUS_RU"] = SCHEDULE_STATUS_RU
templates.env.globals["OPERATION_RU"] = OPERATION_RU
templates.env.filters["journal_text"] = journal_text
templates.env.globals["REPAIR_STATUS_RU"] = supplydb.REPAIR_STATUS_RU
templates.env.globals["REPAIR_FLOW"] = supplydb.REPAIR_FLOW
#  Два маршрута ремонта (23.09.2026): вызов специалиста и отправка в Минск
templates.env.globals["REPAIR_FLOWS"] = supplydb.REPAIR_FLOWS
templates.env.globals["REPAIR_ROUTES"] = supplydb.REPAIR_ROUTES
templates.env.globals["REPAIR_ROUTE_RU"] = supplydb.REPAIR_ROUTE_RU
templates.env.globals["REPAIR_OUTCOMES"] = list(supplydb.REPAIR_OUTCOME_RU.items())
templates.env.globals["ASSET_STATUS_RU"] = supplydb.ASSET_STATUS_RU
templates.env.globals["ASSET_TRACKING_RU"] = supplydb.ASSET_TRACKING_RU
templates.env.globals["ASSET_TRACKING_SHORT"] = supplydb.ASSET_TRACKING_SHORT
#  Какая группа реестра в какую вкладку попадает: связь показывается прямо в
#  «Видах ТМЦ и техники», а не держится в голове (22.09.2026)
templates.env.globals["GROUP_TAB"] = supplydb.group_tab
templates.env.globals["TASK_STATUS_RU"] = kanbandb.STATUS_RU
templates.env.globals["TASK_KIND_RU"] = kanbandb.KIND_RU
templates.env.globals["APP_NAME"] = APP_NAME
templates.env.globals["APP_FULL_NAME"] = APP_FULL_NAME
templates.env.globals["CURRENCY"] = CURRENCY


#  Версия сборки. Лежит файлом в корне приложения, а не строкой в коде:
#  обновление на чужом ПК копирует файлы, и по этой строке человек видит,
#  какая сборка у него стоит. Нет файла — значит собрано из исходников.
def _app_version() -> str:
    root = BASE_DIR.parent.parent
    for path in (root / "VERSION", root / "app" / "VERSION"):
        try:
            return path.read_text(encoding="utf-8").strip()
        except OSError:
            continue
    return ""


APP_VERSION = _app_version()
templates.env.globals["APP_VERSION"] = APP_VERSION


def md_bold(text: str) -> Markup:
    """**Жирный** и `моноширинный` в списке изменений — больше там ничего."""
    safe = str(escape(text))
    safe = re.sub(r"[*][*]([^*]+)[*][*]", lambda m: "<b>" + m.group(1) + "</b>", safe)
    safe = re.sub(r"`([^`]+)`", lambda m: "<code>" + m.group(1) + "</code>", safe)
    return Markup(safe)


templates.env.filters["md_bold"] = md_bold


def money(value: object, with_currency: bool = True) -> str:
    """
    Денежная сумма по-русски: «1 234,56 руб.»

    Разряды разделяются узким неразрывным пробелом, копейки — запятой. Точка
    и запятая в этих ролях местами не путаются: сумма читается так же, как в
    платёжке и в приказе.
    """
    if value is None or value == "":
        return ""
    try:
        amount = float(value)
    except (TypeError, ValueError):
        return str(value)
    whole, cents = divmod(round(abs(amount) * 100), 100)
    groups = f"{whole:,}".replace(",", " ")
    sign = "−" if amount < 0 else ""
    out = f"{sign}{groups},{cents:02d}"
    return f"{out} {CURRENCY}" if with_currency else out


def rate_money(value: object) -> str:
    """
    Ставка за операцию: копеек мало, там значимы доли копейки.
    «0,0520 руб.» — четыре знака, лишние нули с конца убираются.
    """
    if value is None or value == "":
        return ""
    try:
        amount = float(value)
    except (TypeError, ValueError):
        return str(value)
    text = f"{amount:.4f}".rstrip("0")
    if text.endswith("."):
        text += "00"
    return f"{text.replace('.', ',')} {CURRENCY}"


def num(value: object, digits: int = 4) -> str:
    """
    Обычное число по-русски: «0,07», «0,8», «1». Не деньги — ни знака валюты,
    ни обязательных копеек: незначащие нули с конца убираются, десятичный
    разделитель — запятая. Так пишутся пороги и коэффициенты в приказе.
    """
    if value is None or value == "":
        return ""
    try:
        amount = float(value)
    except (TypeError, ValueError):
        return str(value)
    text = f"{amount:.{digits}f}"
    #  Незначащие нули убираем только после запятой. Раньше `rstrip` шёл по
    #  всей строке, и при digits=0 дробной части не было вовсе — обрезались
    #  настоящие цифры: 120 моточасов показывались как «12», численность
    #  200 человек — как «2». Портились ровно те числа, что кончаются нулём,
    #  поэтому на глаз это долго не замечали.
    if "." in text:
        text = text.rstrip("0").rstrip(".")
    return (text or "0").replace(".", ",")


#  Сокращения ссылок на приложения и пункты. Порядок важен: длинные
#  выражения раньше коротких, иначе «1 раз в 2 года» не совпадёт.
NOTE_SHORTS = (
    ("Приложение", "прил."),
    ("приложение", "прил."),
    ("Пункты", "пп."),
    ("пункты", "пп."),
    ("Пункт", "п."),
    ("пункт", "п."),
    ("1 раз в 2 года", "1 р/2 года"),
    ("1 раз в два года", "1 р/2 года"),
    ("1 раз в год", "1 р/год"),
    ("раза в", "р/"),
    ("раз в", "р/"),
    ("месяцев", "мес"),
    ("месяца", "мес"),
    ("периодичность", ""),
)

#  Из пояснения в шапку столбца выносим только то, где есть цифры: ссылку на
#  пункт и периодичность. Остальной текст пояснения виден по наведению.
REF_DIGITS_RE = re.compile(
    r"прил\.\s*\d+(?:\.\d+)*"
    r"|пп?\.\s*\d+(?:\.\d+)*"
    r"|\d+\s*р/\s*\d*\s*(?:года?|лет|мес|год)",
    re.IGNORECASE,
)


def ref_short(value: object) -> str:
    """
    Ссылка на пункт приложения — коротко, чтобы влезла в шапку столбца.

    «Приложение 3, пункт 3; 1 раз в 2 года» → «прил. 3, п. 3 · 1 р/2 года».
    Цифры остаются как есть: по ним и сверяются с приказом. Незнакомый текст
    возвращается как есть — выдумывать сокращения не наше дело.
    """
    if not value:
        return ""
    out = str(value)
    for long, short in NOTE_SHORTS:
        out = out.replace(long, short)
    out = " ".join(out.replace(";", " ·").split())
    #  «1 раза в 6 месяцев» после замен даёт «1 р/ 6 мес» — пробел лишний
    return out.replace("р/ ", "р/")


templates.env.filters["money"] = money
templates.env.filters["rate_money"] = rate_money
templates.env.filters["num"] = num


def money_fmt(value: object) -> str:
    """Деньги в разделе «Финансы»: 9 880,00 — всегда две цифры после запятой."""
    if value is None or value == "":
        return "—"
    try:
        d = Decimal(str(value)).quantize(Decimal("0.01"))
    except (InvalidOperation, ValueError):
        return str(value)
    text = f"{abs(d):,.2f}".replace(",", "\u00a0").replace(".", ",")
    return ("−" if d < 0 else "") + text


templates.env.filters["fmoney"] = money_fmt
def ref_digits(value: object) -> str:
    """
    Только цифровая часть пояснения: пункт приложения и периодичность.

    В шапке столбца места на предложение нет, а «п. 2» и «1 р/6 мес» — то,
    по чему сверяются с порядком. Полное пояснение остаётся в подсказке.
    Если цифр в пояснении нет (внеплановый и целевой инструктаж), строка
    пустая — и лишней строки в шапке не будет.
    """
    found: list[str] = []
    for m in REF_DIGITS_RE.finditer(ref_short(value)):
        piece = " ".join(m.group(0).split())
        if piece not in found:
            found.append(piece)
    return " · ".join(found)


templates.env.filters["ref_digits"] = ref_digits


def static_url(name: str) -> str:
    """
    Адрес статики с отметкой времени файла. Без неё браузер держит старый
    app.css до принудительного обновления страницы — и новая вёрстка
    выглядит сломанной, хотя на диске всё верно.
    """
    try:
        version = int((BASE_DIR / "static" / name).stat().st_mtime)
    except OSError:
        version = 0
    return f"/static/{name}?v={version}"


templates.env.globals["static_url"] = static_url
templates.env.globals["defect_image_code"] = productimages.defect_code
templates.env.globals["discount_image_code"] = productimages.discount_code
templates.env.globals["product_image_code"] = productimages.code


@contextmanager
def db(user_id: int | None = None) -> Iterator[psycopg.Connection]:
    """
    Соединение из пула на время запроса.

    Пользователь сессии выставляется явно при каждой выдаче — и явно
    стирается, если запрос идёт без пользователя (вход, healthz). Иначе
    переиспользованное соединение принесло бы чужой app.user_id, а от него
    зависит, чьи данные покажет RLS.
    """
    with pool().connection() as conn:
        if user_id:
            webdb.set_session_user(conn, user_id)
            #  Учётка могла быть отключена, пока человек работал: уволили,
            #  отозвали доступ. Права база и так уже не даст, но сессию
            #  закрываем здесь же — на каждом запросе (23.09.2026)
            if not webdb.user_is_active(conn, user_id):
                webdb.clear_session_user(conn)
                raise HTTPException(401, "Учётная запись отключена")
        else:
            webdb.clear_session_user(conn)
        yield conn


def sticky_period(request: Request, text: str | None) -> date:
    """
    Выбранный месяц живёт до тех пор, пока его не сменят сами.

    Раньше каждая вкладка начинала с текущего месяца: выбрал август, перешёл
    в «Сверку» — и там снова сентябрь. Теперь пришедший в запросе период
    запоминается в сессии, а вкладка без периода в адресе берёт запомненный.
    Текущий месяц остаётся последним запасным вариантом — для первого входа.
    """
    if text:
        p = parse_period(text)
        request.session["period"] = p.strftime("%Y-%m")
        return p
    saved = request.session.get("period")
    if saved:
        try:
            return parse_period(saved)
        except HTTPException:
            # В сессии мусор — забываем его и показываем текущий месяц
            request.session.pop("period", None)
    return date.today().replace(day=1)


def parse_period(text: str | None) -> date:
    if not text:
        today = date.today()
        return today.replace(day=1)
    for fmt in ("%Y-%m", "%m.%Y", "%Y-%m-%d"):
        try:
            return datetime.strptime(text, fmt).date().replace(day=1)
        except ValueError:
            continue
    raise HTTPException(400, f"Не понял период: {text}")


def require_user(request: Request) -> int:
    uid = request.session.get("uid")
    if not uid:
        raise HTTPException(401, "Требуется вход")
    #  30.09.2026 (вычитка 1.24): пароль сменили после того, как человек
    #  вошёл, — сессия больше не действует, войти надо заново. Раньше
    #  вошедший по старому паролю работал до конца своих 12 часов.
    #  Отметка времени пароля лежит в учётке (миграция 89), копия на
    #  момент входа — в сессии. База недоступна — не наша забота: дальше
    #  страницу откроет своя проверка и покажет своё сообщение
    pwd_at = request.session.get("pwd_at")
    try:
        with pool().connection() as conn:
            #  app_user под RLS: без контекста строки не видны и проверка
            #  молча пропускалась. Контекст = сам вошедший (uid из сессии)
            webdb.set_session_user(conn, int(uid))
            try:
                with conn.cursor() as cur:
                    cur.execute(
                        "SELECT password_changed_at FROM app.app_user "
                        "WHERE id = %s AND is_active", (uid,))
                    row = cur.fetchone()
            finally:
                webdb.clear_session_user(conn)
    except Exception:
        row = None
    if row and (pwd_at is None
                or row["password_changed_at"].timestamp() > float(pwd_at) + 1):
        request.session.clear()
        raise HTTPException(401, "Пароль был сменён — войдите заново")
    return int(uid)


def unit_or_403(conn, code: str) -> dict[str, Any]:
    """
    Подразделение из запроса — с проверкой доступа. Без неё RLS всё равно
    не даст записать чужое депо, но пользователь получил бы невнятную ошибку.
    """
    unit = webdb.unit_by_code(conn, code)
    if not unit:
        raise HTTPException(404, "Подразделение не найдено")
    if not webdb.can_access_unit(conn, unit["id"]):
        raise HTTPException(403, "Нет доступа к этому подразделению")
    return unit


def month_days(period: date) -> list[date]:
    n = calendar.monthrange(period.year, period.month)[1]
    return [date(period.year, period.month, d) for d in range(1, n + 1)]


def lunch_rule_from_env() -> LunchRule:
    """
    Обед: час и окна. Меняется переменными окружения, а не правкой кода.

    LUNCH_HOURS — сколько вычитать (по умолчанию 1);
    LUNCH_WINDOWS — окна через запятую, «11-14,16-19,1-4».
    """
    raw = os.environ.get("LUNCH_WINDOWS", "")
    windows = []
    for part in raw.replace(";", ",").split(","):
        part = part.strip()
        if not part:
            continue
        left, _, right = part.partition("-")
        try:
            windows.append((int(left), int(right)))
        except ValueError:
            continue
    return LunchRule(
        hours=float(os.environ.get("LUNCH_HOURS", "1")),
        windows=tuple(windows) or LunchRule().windows,
    )


def break_rule_from_env() -> BreakRule:
    threshold = os.environ.get("BREAK_MIN_SHIFT_HOURS")
    return BreakRule(
        hours=float(os.environ.get("BREAK_HOURS", "1")),
        mode=os.environ.get("BREAK_MODE", "legacy_max_bucket"),
        min_shift_hours=float(threshold) if threshold else None,
    )


# ---------------------------------------------------------------------------
#  Вход
# ---------------------------------------------------------------------------

_FORKLIFT_CACHE: dict[str, Any] = {"at": 0.0, "mode": "auto"}


def header_forklift_mode() -> str:
    """
    Режим погрузчика в шапке (24.09.2026). Шапка рисуется на каждой
    странице, поэтому значение держится в памяти минуту, а после сохранения
    системных настроек сбрасывается сразу. База недоступна — «по настройке
    системы», как у заставки входа.
    """
    import time
    now = time.monotonic()
    if now - _FORKLIFT_CACHE["at"] > 60:
        try:
            with db() as conn:
                _FORKLIFT_CACHE["mode"] = settingsdb.app_settings(conn).get(
                    "header_forklift", "auto")
        except psycopg.Error:
            _FORKLIFT_CACHE["mode"] = "auto"
        _FORKLIFT_CACHE["at"] = now
    return _FORKLIFT_CACHE["mode"]


templates.env.globals["header_forklift"] = header_forklift_mode


def _login_context(error: str | None = None) -> dict[str, Any]:
    """
    Контекст экрана входа. Поведение заставки задаётся в базовых настройках
    (вкладка «Системные»), поэтому читается из базы, а не решается скриптом.

    База может быть недоступна — на экране входа это как раз возможно.
    Тогда берутся значения по умолчанию: показать форму входа важнее, чем
    точно попасть в настройку заставки.
    """
    try:
        with db() as conn:
            settings = settingsdb.app_settings(conn)
    except psycopg.Error:
        settings = dict(settingsdb.APP_SETTING_DEFAULTS)
    return {"error": error, "app_settings": settings, "forgot_done": False}


#  Стартовая страница (23.09.2026): «при первом запуске приложения всегда
#  открывается доска задач, с фильтром "Сегодня"». И после входа, и при
#  открытии корня адреса — человек начинает день с того, что сделать сегодня
START_PAGE = "/kanban?span=day"


@app.get("/login", response_class=HTMLResponse)
def login_form(request: Request, error: str | None = None):
    return templates.TemplateResponse(
        request, "login.html", _login_context(error)
    )


@app.post("/login")
def login_submit(request: Request, email: str = Form(...), password: str = Form(...)):
    #  Ограничение частоты по адресу (23.09.2026): блокировка по учётке
    #  защищает одну учётку, а перебор по многим с одного адреса — нет
    if not security.LOGIN_LIMIT.allow(security.client_ip(request)):
        return templates.TemplateResponse(
            request, "login.html",
            _login_context("Слишком много попыток входа. Подождите несколько "
                           "минут и попробуйте снова"),
            status_code=429,
        )
    with db() as conn:
        uid = webdb.authenticate(conn, email, password)
    if not uid:
        return templates.TemplateResponse(
            request, "login.html",
            _login_context("Неверная почта или пароль"),
            status_code=401,
        )
    request.session["uid"] = uid
    #  30.09.2026: копия отметки пароля на момент входа — с ней require_user
    #  узнает, что пароль сменили, и закроет сессию (вычитка 1.24).
    #  Важно: app_user под RLS — без пользовательского контекста строки
    #  не видны, поэтому сначала выставляем вошедшего (аутентификация
    #  уже прошла), потом читаем и снимаем контекст
    with db() as conn:
        webdb.set_session_user(conn, uid)
        user = webdb.current_user(conn, uid)
        rmb_roles = rmbdb.user_roles(conn, uid)
        with conn.cursor() as cur:
            cur.execute("SELECT password_changed_at FROM app.app_user "
                        "WHERE id = %s", (uid,))
            epoch = cur.fetchone()
        webdb.clear_session_user(conn)
    if epoch and epoch["password_changed_at"]:
        request.session["pwd_at"] = epoch["password_changed_at"].timestamp()
    #  Наблюдателю доска не показывается — стартовая страница для него
    #  «Сотрудники», иначе вход падал бы в 403
    #  02.10.2026: службам (ОЗ, ОТ, Руководство) — свой кабинет, а не доска
    if user and not (user.get("roles") or []) and "specialist" in rmb_roles:
        start = "/defects/rmb?view=specialist"
    else:
        start = user["start_page"] if user else START_PAGE
    return RedirectResponse(start, status_code=303)


@app.post("/forgot")
def forgot_password(request: Request, email: str = Form(...)):
    """
    Заявка «Забыли пароль?» со страницы входа.

    Отвечаем одинаково, нашёлся такой логин или нет: страница входа не должна
    работать справочником о том, кто в приложении есть. Сама заявка пишется
    функцией базы — пользователя сессии здесь нет и быть не может.
    """
    #  Не больше пяти заявок в час с адреса: без ограничения очередь
    #  администрации можно завалить заявками. Ответ при этом тот же, что и
    #  всегда, — страница входа не подсказывает, сработало ли ограничение
    if not security.RESET_LIMIT.allow(security.client_ip(request)):
        ctx = _login_context()
        ctx["forgot_done"] = True
        return templates.TemplateResponse(request, "login.html", ctx)
    try:
        with db() as conn:
            staffdb.ask_password_reset(conn, email)
    except psycopg.Error:
        #  Недоступная база на экране входа — не повод показывать ошибку
        #  человеку, который и так не может войти
        pass
    ctx = _login_context()
    ctx["forgot_done"] = True
    return templates.TemplateResponse(request, "login.html", ctx)


@app.get("/logout")
def logout(request: Request):
    request.session.clear()
    return RedirectResponse("/login", status_code=303)


# ---------------------------------------------------------------------------
#  Главная
# ---------------------------------------------------------------------------

@app.get("/")
def index(request: Request):
    if not request.session.get("uid"):
        return RedirectResponse("/login", status_code=303)
    return RedirectResponse(START_PAGE, status_code=303)


# ---------------------------------------------------------------------------
#  Общий контекст сетки
# ---------------------------------------------------------------------------

def _fact_editable(conn, ts: dict[str, Any]) -> bool:
    """Может ли вошедший править клетки табеля этого месяца."""
    if not webdb.has_perm(conn, "timesheet.write"):
        return False
    if ts["status"] == "open":
        return True
    if ts["status"] in ("submitted", "in_review"):
        return webdb.has_perm(conn, "timesheet.approve")
    return False


def _schedule_cells_editable(conn, unit_id: int, period: date) -> bool:
    """Может ли вошедший править клетки графика этого месяца."""
    if not webdb.has_perm(conn, "schedule.write"):
        return False
    state = webdb.schedule_status(conn, unit_id, period)
    if state and state.get("status") == "submitted":
        return webdb.has_perm(conn, "schedule.reopen")
    return True


def grid_context(conn, uid: int, unit_code: str | None, period: date) -> dict[str, Any]:
    user = webdb.current_user(conn, uid)
    units = webdb.accessible_units(conn)
    if not units:
        raise HTTPException(403, "Нет доступа ни к одному подразделению")

    unit = None
    if unit_code:
        unit = next((u for u in units if u["code"] == unit_code), None)
    unit = unit or units[0]

    ts = webdb.ensure_timesheet(conn, unit["id"], period)
    norm = webdb.month_norm(conn, period)
    day_types = webdb.calendar_days(conn, period)
    days = month_days(period)

    return {
        "user": user,
        "units": units,
        "unit": unit,
        "period": period,
        "period_label": f"{MONTHS_RU[period.month - 1]} {period.year}",
        "period_iso": f"{period:%Y-%m}",
        "timesheet": ts,
        "norm": norm,
        "days": days,
        "day_meta": [
            {
                "date": d,
                "iso": d.isoformat(),
                "num": d.day,
                "wd": WEEKDAYS_RU[d.weekday()],
                "is_off": day_types.get(d, "work") in ("weekend", "holiday"),
                "is_today": d == date.today(),
            }
            for d in days
        ],
        #  02.10.2026 (вычитка 3.22): «править табель» = есть право и табель
        #  открыт; сданный и проверяемый правит только Администрация,
        #  утверждённый — никто. Тот же замок стоит в базе
        "locked": not _fact_editable(conn, ts),
        "fact_status": ts["status"],
        #  График живёт своим состоянием: «составляется» и «сдан». Сданный
        #  правится, но каждая правка идёт в журнал (пункт 17)
        "schedule_state": webdb.schedule_status(conn, unit["id"], period),
        "can_submit_schedule": webdb.has_perm(conn, "schedule.submit"),
        "can_reopen_schedule": webdb.has_perm(conn, "schedule.reopen"),
        "can_edit_schedule": _schedule_cells_editable(conn, unit["id"], period),
        "open_requests": webdb.open_staff_requests(conn),
        "can_reference": webdb.has_perm(conn, "reference.write"),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
        # Значок на вкладке «Сверка и сдача» — по состоянию на последнюю сверку
        "open_discrepancies": webdb.open_discrepancies(conn, unit["id"], period),
    }


def plan_by_date(conn, unit_id: int, period: date) -> dict[int, dict[date, float]]:
    """
    Часы графика месяца по датам для каждого сотрудника.

    Работа через полночь даёт на одну дату несколько отрезков, поэтому часы
    складываем: иначе у ночников на дату оставался бы только последний.

    Часы — к отработке, без обеда: по ним уменьшается персональная норма за
    дни законного отсутствия. Отпускной день должен снимать с нормы столько,
    сколько человек в этот день отработал бы, а обед он бы не отработал.
    """
    out: dict[int, dict[date, float]] = {}
    for emp_id, hours in plan_hours_fresh(conn, unit_id, period).items():
        per_day: dict[date, float] = {}
        for h in hours:
            per_day[h.work_date] = round(
                per_day.get(h.work_date, 0.0) + h.worked_total, 2)
        out[emp_id] = per_day
    return out


def person_month_norm(conn, month_norm: float, period: date,
                      hired: date | None, fired: date | None,
                      day_types: dict[date, str] | None = None) -> float:
    """
    Норма месяца для человека, работавшего не весь месяц (02.10.2026,
    вычитка 3.22). График сдаётся под уменьшенную норму, а табель считал
    отклонение от полной — у принятого 15-го при точно выполненном графике
    выходила «недоработка» в половину нормы. Теперь обе стороны считают
    одинаково: доля рабочих дней периода работы по производственному
    календарю.
    """
    first = period.replace(day=1)
    last = date(period.year, period.month,
                calendar.monthrange(period.year, period.month)[1])
    if not ((hired and hired > first) or (fired and fired < last)):
        return month_norm
    if day_types is None:
        day_types = webdb.calendar_days(conn, period)
    return schedule_norm(month_norm, day_types, first, last,
                         hired if hired and hired > first else None,
                         fired if fired and fired < last else None)


def personal_norm_for(
    month_norm: float,
    fact_days: list[Any],
    plan_days: dict[date, float],
    excusing: Any = None,
) -> tuple[float, float]:
    """
    Персональная норма сотрудника и сколько часов из неё исключено.

    Правило — из порядка применения расчётной нормы (постановление Минтруда
    № 95 от 16.09.2025): из нормы работника исключается время отсутствия по
    законодательству, приходящееся на дни по его графику. То есть отпуск на
    смену 11 часов снимает с нормы 11 часов, а не 8: считаем по графику, а не
    по пятидневке.

    Какие именно обозначения норму уменьшают — берётся из справочника
    обозначений («Базовые настройки»), потому что уважительность отсутствия
    определяет приказ нанимателя, а не код в клетке.
    """
    codes = {f.work_date: f.day_code for f in fact_days}
    if excusing is None:
        excused = excused_plan_hours(codes, plan_days)
    else:
        excused = excused_plan_hours(codes, plan_days, excusing)
    return personal_norm(month_norm, excused), excused


@app.get("/timesheet", response_class=HTMLResponse)
def timesheet_grid(request: Request, unit: str | None = None, period: str | None = None):
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = grid_context(conn, uid, unit, p)
        rows = webdb.people(conn, ctx["unit"]["id"], p)
        cells = webdb.fact_cells(conn, ctx["timesheet"]["id"])
        facts = webdb.fact_days(conn, ctx["timesheet"]["id"])
        # Норма привязана к месяцу, но у каждого своя: отпуск и больничный
        # снимают с неё плановые часы этих дней
        plans = plan_by_date(conn, ctx["unit"]["id"], p)
        month_norm = float(ctx["norm"] or 0)
        excusing = webdb.norm_excusing_codes(conn)

        #  Вызовы и сверхурочные за год с 1 января по конец месяца
        #  (23.09.2026): «1/12», «6/180»
        month_end = date(p.year, p.month, calendar.monthrange(p.year, p.month)[1])
        limits = webdb.year_limits(conn, [r["employment_id"] for r in rows],
                                   month_end)

        day_types = webdb.calendar_days(conn, p)
        grid = []
        for r in rows:
            emp = r["employment_id"]
            totals = compute_totals(facts.get(emp, []))
            pnorm, excused = personal_norm_for(
                person_month_norm(conn, month_norm, p, r["hired_at"],
                                  r["terminated_at"], day_types),
                facts.get(emp, []), plans.get(emp, {}), excusing
            )
            cmpn = compare_with_norm(totals, pnorm)
            grid.append({
                "person": r,
                "norm": pnorm,
                "norm_excused": excused,
                # Клетка табеля разложена на половины: дневные часы и ночные.
                # Ночные — это 22:00–06:00, дневные — 06:00–22:00.
                "cells": {
                    d.isoformat(): {
                        **fact_cell_parts(cells[(emp, d)]),
                        "kind": fact_cell_kind(cells[(emp, d)]),
                    }
                    for d in ctx["days"] if (emp, d) in cells
                },
                "totals": totals,
                "deviation": cmpn.deviation,
                "limits": limits.get(emp, {"calls": 0, "overtime": 0.0}),
                **{"limits_text": webdb.limits_text(
                    limits.get(emp, {"calls": 0, "overtime": 0.0}))},
            })

        day_totals = fact_day_totals(cells)

        codes = webdb.day_code_reference(conn)
        #  Журнал табеля — свой, а не общий на всё приложение (пункт 16)
        ctx["journal"] = journal_of(conn, "timesheet", ctx["unit"]["id"], p)

        #  Оформление привлечения к работе (решение от 22.09.2026). Окно
        #  живёт здесь, потому что оформление кончается тем, что часы встают
        #  в клетки табеля — и смотреть на них человек будет тут же
        ctx["can_workorder"] = webdb.has_perm(conn, "workorder.write")
        if ctx["can_workorder"]:
            ctx["wo_people"] = orderdb.people(conn, ctx["unit"]["id"], p)
            ctx["wo_addressed"] = orderdb.addressed_default(conn)
            ctx["wo_list"] = orderdb.listing(conn, ctx["unit"]["id"], p)
            ctx["wo_kinds"] = orderdb.KIND_RU
            ctx["today_iso"] = date.today().isoformat()
        #  Кнопки заполнения по графику видит только администрация (ответ О7
        #  от 21.09.2026): депо ведёт табель по ходу месяца
        may_fill = webdb.has_perm(conn, "timesheet.fill")

    # Справочник в базе может быть ещё не заполнен — тогда берём встроенный.
    # Без этого страница оставалась совсем без легенды, и кнопка
    # «Обозначения» не появлялась вовсе.
    if not codes:
        codes = day_code_reference_fallback()

    fill_date = last_fillable_day(p)

    ctx.update({
        "mode": "fact",
        "grid": grid,
        "title": "Табель учёта рабочего времени",
        "day_totals": day_totals,
        "grand_total": round(sum(day_totals.values()), 2),
        # Справочник обозначений: группируем по разделам справочника
        "code_groups": _group_codes(codes),
        "codes": codes,
        # Заполнять можно не дальше чем на сутки вперёд
        "fill_date": fill_date,
        "fill_date_iso": fill_date.isoformat(),
        "fill_min": f"{p:%Y-%m-%d}",
        "fill_max": last_fillable_day(p).isoformat(),
        "fill_available": fill_date >= p and may_fill,
        #  Право заполнять по графику — отдельно от «месяц начался»: у кого
        #  права нет (депо, ответ О7), не должно быть ни кнопки, ни надписи
        #  «месяц ещё не начался» — она врала посреди месяца (24.09.2026)
        "may_fill": may_fill,
    })
    return templates.TemplateResponse(request, "grid.html", ctx)


#  На сколько вперёд разрешено заполнять табель. Решение заказчика от
#  21.09.2026: «табель можно заполнить только на 24 часа вперёд». Прежнее
#  правило — «только прошедшие сутки» — не давало закрыть месяц человеку,
#  которого увольняют последним числом.
FILL_AHEAD_DAYS = 1


def last_fillable_day(period: date) -> date:
    """
    Последние сутки, которые можно заполнить: не дальше чем на сутки вперёд и
    в пределах открытого месяца. Если месяц целиком в будущем, вернётся дата
    раньше его начала — заполнять нечего.
    """
    last_of_month = date(
        period.year, period.month,
        calendar.monthrange(period.year, period.month)[1],
    )
    return min(date.today() + timedelta(days=FILL_AHEAD_DAYS), last_of_month)


def _group_codes(codes: list[dict[str, Any]]) -> list[tuple[str, list[dict]]]:
    """Обозначения по разделам, порядок разделов — как в справочнике."""
    groups: list[tuple[str, list[dict]]] = []
    for c in codes:
        name = c.get("group_name") or "Прочее"
        if not groups or groups[-1][0] != name:
            groups.append((name, []))
        groups[-1][1].append(c)
    return groups


def fact_day_totals(cells: dict) -> dict[str, float]:
    """Сумма отработанных часов по каждому дню месяца."""
    out: dict[str, float] = {}
    for (_, day), cell in cells.items():
        out[day.isoformat()] = round(out.get(day.isoformat(), 0.0) + cell.worked, 2)
    return out


def plan_day_totals(cells: dict) -> dict[str, int]:
    """Сколько человек в смене в каждый день."""
    out: dict[str, int] = {}
    for (_, day), cell in cells.items():
        if cell.shift_start is not None:
            out[day.isoformat()] = out.get(day.isoformat(), 0) + 1
    return out


#  Допуск при сравнении графика с нормой. Решение заказчика от 21.09.2026 —
#  точное совпадение, поэтому здесь только защита от копеечной погрешности
#  сложения дробных часов, а не поблажка в полсмены.
NORM_EPSILON = 0.005


def schedule_norm_gaps(
    conn: psycopg.Connection, unit_id: int, period: date
) -> list[dict[str, Any]]:
    """
    У кого график не сходится с нормой месяца.

    Норма в графике полная у всех: отпуска и больничные её не уменьшают —
    они снимут своё потом, в табеле, с плановых часов тех же дней
    (`personal_norm`). Значит смены на дни будущего отпуска в графике обязаны
    стоять, иначе в табеле вычитать будет нечего и у человека появится
    недоработка, которой не было.

    Отсюда и проверка: сравниваем не отдельные клетки, а сумму часов к
    отработке за месяц. Пропуск смен под отпуском она ловит не хуже, но не
    ругается на выходные по ротации, которые внутри отпуска пустые совершенно
    законно.

    Уменьшается норма только у работавших не весь месяц — принятых или
    уволенных не с первого числа (решение от 21.09.2026, симметрично для
    обоих случаев).
    """
    month_norm = float(webdb.month_norm(conn, period) or 0)
    if month_norm <= 0:
        #  Норма месяца не заполнена — сравнивать не с чем. Это отдельная
        #  ошибка, и говорить о ней должен тот, кто её проверяет
        return []

    first, last = month_bounds(period)
    day_types = webdb.calendar_days(conn, period)
    ph = plan_hours_fresh(conn, unit_id, period)
    vacations = vacationdb.days_by_employee(conn, unit_id, period)

    out: list[dict[str, Any]] = []
    for r in webdb.people(conn, unit_id, period):
        hired = r["hired_at"] if r["hired_at"] and r["hired_at"] > first else None
        fired = (r["terminated_at"]
                 if r["terminated_at"] and r["terminated_at"] < last else None)
        norm = schedule_norm(month_norm, day_types, first, last, hired, fired)
        worked = round(
            sum(h.worked_total for h in ph.get(r["employment_id"], [])), 2)
        diff = round(worked - norm, 2)
        if abs(diff) < NORM_EPSILON:
            continue
        out.append({
            "person": r,
            "plan_worked": worked,
            "norm": norm,
            "diff": diff,
            #  Подсказка, где искать: недобор часов у человека с отпуском в
            #  этом месяце — почти всегда непроставленные смены под отпуском
            "vacation_days": len(vacations.get(r["employee_id"], [])),
        })
    return out


def schedule_norm_message(gaps: list[dict[str, Any]]) -> str:
    """Текст отказа в сдаче графика: по человеку — часы, норма и разница."""
    lines = []
    for g in gaps[:12]:
        who = g["person"]["fio_short"]
        sign = "+" if g["diff"] > 0 else "−"
        line = (f"{who}: {g['plan_worked']:g} ч при норме {g['norm']:g} "
                f"({sign}{abs(g['diff']):g})")
        if g["diff"] < 0 and g["vacation_days"]:
            line += f", в месяце отпуск {g['vacation_days']} дн."
        lines.append(line)
    if len(gaps) > 12:
        lines.append(f"…и ещё {len(gaps) - 12}")
    return ("График не сходится с нормой месяца — "
            f"человек: {len(gaps)}.\n" + "\n".join(lines)
            + "\n\nС нормой сверяются часы «К отраб.» — смены без часа обеда. "
              "Столбец «С обедом» — время присутствия, с нормой он не "
              "сверяется: смена 08:00–16:00 даёт 8 ч присутствия и 7 ч к "
              "отработке."
            + "\n\nНорма в графике полная у всех: отпуск снимет своё в табеле, "
              "поэтому смены на дни отпуска должны стоять и здесь.")


@app.get("/schedule", response_class=HTMLResponse)
def schedule_grid(request: Request, unit: str | None = None, period: str | None = None):
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = grid_context(conn, uid, unit, p)
        rows = webdb.people(conn, ctx["unit"]["id"], p)
        cells = webdb.plan_cells(conn, ctx["unit"]["id"], p)
        #  Часы считаются сами: при первом заходе в месяц и после смены
        #  правила расчёта — иначе в колонках «План», «К отраб.» и «Ночь»
        #  остались бы нули или цифры прежнего правила
        ph = plan_hours_fresh(conn, ctx["unit"]["id"], p)
        #  Норма, под которую график сдаётся: полная у всех, усечённая у
        #  работавших не весь месяц. Отпуск её не трогает — он снимет своё в
        #  табеле, поэтому смены на его дни должны стоять и здесь
        first_day, last_day = month_bounds(p)
        day_types = webdb.calendar_days(conn, p)
        month_norm = float(ctx["norm"] or 0)
        vacations = vacationdb.days_by_employee(conn, ctx["unit"]["id"], p)

        grid = []
        total_hours = 0.0
        total_worked = 0.0
        for r in rows:
            emp = r["employment_id"]
            hours = ph.get(emp, [])
            #  Две цифры по месяцу: присутствие — то, что стоит в клетках
            #  вместе с часом обеда; к отработке — минус этот час, то есть
            #  столько работник поставит в табеле
            plan_total = round(sum(h.total for h in hours), 2)
            plan_worked = round(sum(h.worked_total for h in hours), 2)
            total_hours += plan_total
            total_worked += plan_worked
            plan_norm = schedule_norm(
                month_norm, day_types, first_day, last_day,
                r["hired_at"] if r["hired_at"] and r["hired_at"] > first_day else None,
                r["terminated_at"]
                if r["terminated_at"] and r["terminated_at"] < last_day else None,
            )
            grid.append({
                "person": r,
                # Время показываем полностью и двумя строками: «09:00 -» и
                # «18:00». Правится по-прежнему одной строкой «09:00-18:00».
                "cells": {
                    d.isoformat(): {
                        "short": format_plan_cell(cells[(emp, d)]),
                        "full": format_plan_cell(cells[(emp, d)]),
                        "lines": plan_cell_lines(cells[(emp, d)]),
                        "kind": plan_cell_kind(cells[(emp, d)]),
                    }
                    for d in ctx["days"] if (emp, d) in cells
                },
                "plan_total": plan_total,
                "plan_worked": plan_worked,
                "plan_night": round(sum(h.hours_night for h in hours), 2),
                "plan_norm": plan_norm,
                "plan_diff": round(plan_worked - plan_norm, 2),
                "vacation_days": len(vacations.get(r["employee_id"], [])),
            })

        #  Журнал графика: сдача, возврат в работу и все правки после сдачи
        ctx["journal"] = journal_of(conn, "schedule", ctx["unit"]["id"], p)

    ctx.update({
        "mode": "plan",
        "grid": grid,
        "title": "Плановый график работ",
        "day_totals": plan_day_totals(cells),
        "grand_total": round(total_hours, 2),
        "grand_worked": round(total_worked, 2),
    })
    return templates.TemplateResponse(request, "grid.html", ctx)


# ---------------------------------------------------------------------------
#  Сотрудники: база, карточка, заявки депо
#
#  Администрация Минска заводит, правит и увольняет. Начальник РЦ видит своих
#  и подаёт заявку — она ни на что не влияет, пока администрация не решит.
# ---------------------------------------------------------------------------

#  Вкладки списка сотрудников. «На проверке» и «Смена пароля» появились
#  16.09.2026: начальник РЦ может провести трудоустройство в срочном случае, а
#  администрация обязана его проверить; заявки «Забыли пароль?» тоже приходят
#  сюда — «добавить вкладку в сотрудниках смена пароля».
#
#  Обе видны только тем, кто с ними работает: администрации. Депо показывать
#  очередь, в которой оно ничего не может сделать, незачем.
#  05.10.2026 (правка заказчика): порядок вкладок — по процессу:
#  подбор -> проверка -> работают -> уволены -> заявки -> удержания -> журнал.
#  «Трудоустроенные» при этом остаются вкладкой, открывающейся по умолчанию.
#  Смена пароля — внутри «Заявок»: это тоже заявка Администрации.
STAFF_TABS = [
    ("candidates", "Кандидаты"),
    ("pending", "На проверке"),
    ("employed", "Трудоустроенные"),
    ("dismissed", "Уволенные"),
    ("requests", "Заявки"),
    #  Журнал приказов о депремировании и удержаниях (23.09.2026). Видят
    #  администрация и депо (своё), правит администрация
    ("penalties", "Удержания"),
    #  02.10.2026 (правка заказчика): вся история раздела — в одной вкладке,
    #  с фильтрами по остальным вкладкам и свёрнутыми месяцами. Раньше
    #  «Журнал по сотрудникам» висел хвостом под каждой вкладкой
    ("journal", "Журнал"),
]

#  Фильтры вкладки «Журнал» (02.10.2026): история группируется по вкладкам,
#  на которых она фиксируется. «Трудоустроенные» — приёмы, переводы, правки;
#  «Уволенные» — закрытия назначений, увольнения, окончательные расчёты.
#  Отбор по образцам, как в самом журнале: новая операция попадает в свой
#  фильтр сама
STAFF_JOURNAL_FILTERS: dict[str, tuple[str, tuple[str, ...]]] = {
    "all": ("Все", JOURNAL_BLOCKS["staff"]),
    "hired": ("Трудоустроенные", ("hire%", "staff.hire", "staff.undo_close",
                                  "staff.fio_fix", "transfer%")),
    "fired": ("Уволенные", ("staff.terminate", "dismissal%", "settlement%")),
    "review": ("На проверке", ("employment%",)),
    "requests": ("Заявки", ("staff.request%",)),
    "penalties": ("Удержание", ("penalty%",)),
    "passwords": ("Смена пароля", ("password%",)),
}

DIRECTION_RU = {
    "dismissal": "увольнение",
    "transfer": "перевод",                       # прежнее значение, в истории
    "transfer_internal": "перевод в другой РЦ",
    "transfer_company": "перевод внутри компании",
}
REQUEST_KIND_RU = {"dismissal": "Увольнение или перевод",
                   "contact": "Правка телефона",
                   "fix": "Исправление данных",
                   #  Подаёт сам сотрудник из личного кабинета (23.09.2026)
                   "payroll_query": "Сверка заработной платы"}

# Что начальник РЦ может попросить исправить. Порядок — как в карточке.
# Значение: подпись и вид поля ввода, чтобы форма не заставляла печатать
# дату руками, а должность — кодом.
FIX_FIELDS = [
    ("phone",        "Телефон",             "tel"),
    ("work_email",   "Рабочая почта",       "email"),
    ("birth_date",   "Дата рождения",       "date"),
    ("last_name",    "Фамилия",             "text"),
    ("first_name",   "Имя",                 "text"),
    ("middle_name",  "Отчество",            "text"),
    ("personnel_no", "Табельный номер",     "personnel"),
    ("position",     "Должность",           "position"),
    ("tsd_login",    "Логин ТСД",           "text"),
    ("other",        "Другое — опишу словами", "text"),
]
FIX_FIELDS_RU = {code: label for code, label, _ in FIX_FIELDS}
REQUEST_STATUS_RU = {"new": "Ждёт решения", "approved": "Подтверждена",
                     "rejected": "Отклонена"}

PPE_STATUS_RU = {"issued": "выдано", "returned": "возвращено",
                 "written_off": "списано", "annulled": "аннулировано"}
PPE_KIND_RU = {"summer": "летняя", "winter": "зимняя",
               "footwear": "обувь", "other": "прочее"}

templates.env.globals["DIRECTION_RU"] = DIRECTION_RU
templates.env.globals["PPE_STATUS_RU"] = PPE_STATUS_RU
templates.env.globals["PPE_KIND_RU"] = PPE_KIND_RU
templates.env.globals["REQUEST_KIND_RU"] = REQUEST_KIND_RU
templates.env.globals["REQUEST_STATUS_RU"] = REQUEST_STATUS_RU
templates.env.globals["FIX_FIELDS"] = FIX_FIELDS
templates.env.globals["FIX_FIELDS_RU"] = FIX_FIELDS_RU


def staff_context(conn, uid: int) -> dict[str, Any]:
    user = webdb.current_user(conn, uid)
    units = webdb.accessible_units(conn)
    if not units:
        raise HTTPException(403, "Нет доступа ни к одному подразделению")
    today = date.today()
    return {
        "user": user,
        "units": units,
        "unit": None,
        "period_iso": f"{today:%Y-%m}",
        "mode": "staff",
        "can_write": webdb.has_perm(conn, "employee.write"),
        #  «Оформить ТУ» — отдельное право (22.09.2026): «дать доступ к
        #  "оформить ТУ" для учёток депо (начальник, заместитель)». Не
        #  `employee.write`: оно открыло бы депо заодно увольнение, перевод и
        #  откат, которые по договорённости идут заявкой
        "can_draft": (webdb.has_perm(conn, "hiring.draft")
                      or webdb.has_perm(conn, "employee.write")),
        #  Документы и допуски — своё право (таблица заказчика от 16.09.2026).
        #  У начальника РЦ по ней есть документы, но нет кадровых решений:
        #  `employee.write` открыло бы ему увольнение и перевод
        "can_card": webdb.has_perm(conn, "card.write"),
        #  02.10.2026: топливную карту ведёт только админская учётка
        "can_fuel": webdb.has_perm(conn, "hiring.confirm"),
        "can_request": webdb.has_perm(conn, "staff_request.write"),
        "can_personal": webdb.has_perm(conn, "personal_data.read"),
        #  «Удержание» (23.09.2026): смотреть — администрация, начальник и
        #  заместитель депо; вносить, править и удалять — администрация
        "can_penalty_read": webdb.has_perm(conn, "penalty.read"),
        "can_penalty": webdb.has_perm(conn, "penalty.write"),
        #  Учётная запись ТСД живёт своими правами (ответ О5 от 21.09.2026):
        #  видят начальник, заместители и мастера, правят начальник и
        #  заместители. Отдельно от `personal_data.read`, которое открыло бы
        #  мастеру заодно дату рождения и личный номер
        "can_tsd": (webdb.has_perm(conn, "tsd.read")
                    or webdb.has_perm(conn, "personal_data.read")),
        "can_tsd_write": (webdb.has_perm(conn, "tsd.write")
                          or webdb.has_perm(conn, "personal_data.read")),
        "open_requests": webdb.open_staff_requests(conn),
        "all_units": len(units) > 1,
        "can_reference": webdb.has_perm(conn, "reference.write"),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
        # Нужен списку сотрудников: по нему считается, просрочен ли допуск
        "today": today,
    }


def _selected_unit(units: list[dict], code: str | None) -> dict | None:
    """None означает «все доступные депо» — так смотрит администрация."""
    if not code or code == "all":
        return None if len(units) > 1 else units[0]
    return next((u for u in units if u["code"] == code), None)


# ---------------------------------------------------------------------------
#  Отпуска: график трудовых отпусков на год
#
#  Отпуск планируется заранее и утверждается руководителем, поэтому это
#  отдельный документ, а не пометка в табеле. Записанный отпуск сам ставит
#  «О» в график и табель на все свои дни, а снятый — свою «О» убирает.
# ---------------------------------------------------------------------------

def _contract_years(conn, people: list[dict[str, Any]],
                    year: int) -> dict[int, dict[str, Any]]:
    """
    Контрактный год каждого человека на этот календарный год.

    Считается от даты трудоустройства. Год берём по 1 июля — середина
    календарного года: так в подсказке окажется тот контрактный год, в
    котором человек проводит бо́льшую часть планируемого.
    """
    middle = date(year, 7, 1)
    out: dict[int, dict[str, Any]] = {}
    for person in people:
        hired = vacationdb.hired_since(conn, person["employee_id"], middle)
        if hired:
            out[person["employee_id"]] = vacationdb.contract_year(hired, middle)
    return out


@app.get("/vacations", response_class=HTMLResponse)
def vacations_page(
    request: Request,
    unit: str | None = None,
    year: int | None = None,
    edit: int | None = None,
    msg: str | None = None,
    error: str | None = None,
):
    uid = require_user(request)
    y = year or date.today().year
    #  Вкладки раздела живут месяцем, а отпуска — годом. Раньше здесь брался
    #  январь, и он уезжал в ссылки вкладок: зашёл в «Отпуска», вернулся в
    #  «График» — а там январь вместо августа. Берём запомненный месяц, а год
    #  — тот, который смотрят в отпусках.
    remembered = sticky_period(request, None)
    with db(uid) as conn:
        ctx = grid_context(conn, uid, unit, date(y, remembered.month, 1))
        unit_id = ctx["unit"]["id"]
        people = vacationdb.people_for_year(conn, unit_id, y)
        records = vacationdb.vacations(conn, unit_id, y)
        #  Период каждой записи: праздники внутри отпуска в его дни не входят
        #  и отпуск продлевают (статья 151 ТК), поэтому «по какое число» —
        #  расчёт, а не дата из записи
        holidays = vacationdb.holidays_of_year(conn, y)
        for r in records:
            #  Больничный внутри отпуска его дни тоже не занимает, а берётся
            #  он из табеля — по клеткам с «Б»
            sick = vacationdb.sick_days(
                conn, r["employee_id"], r["starts_at"],
                r["starts_at"] + timedelta(days=int(r["days"]) + 70))
            r["span"] = vacationdb.vacation_span(
                r["starts_at"], int(r["days"]), holidays, sick)
        ctx.update({
            "mode": "vacations",
            "title": f"График трудовых отпусков на {y} год",
            "year": y,
            "years": work_years(y),
            "rows": vacationdb.by_person_and_month(people, records),
            #  История переносов: график утверждается приказом, и прежний
            #  срок должен оставаться видимым (пункт 22)
            "moves": vacationdb.moves_of(conn, [r["id"] for r in records]),
            #  Границы контрактного года по каждому: предел должен быть виден
            #  до того, как запись отклонят (пункт 22)
            "contract": _contract_years(conn, people, y),
            "people": people,
            "months_ru": MONTHS_RU,
            "kind_ru": vacationdb.KIND_RU,
            "kind_code": vacationdb.KIND_CODE,
            #  Отпуск за свой счёт графиком не планируется: подсказать, каким
            #  кодом он ставится в табеле, надо там же, где заводят остальные
            "unpaid_code": vacationdb.UNPAID_CODE,
            "edit_id": edit,
            "editing": next((r for r in records if r["id"] == edit), None),
            "records_total": len(records),
            "holidays_count": len([d for d in holidays if d.year == y]),
            "shifted": sum(1 for r in records if r["span"]["shift"]),
            "sick_shifted": sum(1 for r in records if r["span"]["sick"]),
            "sick_code": vacationdb.SICK_CODE,
            "msg": msg,
            "error": error,
            "can_write": webdb.has_perm(conn, "employee.write"),
            "can_card": webdb.has_perm(conn, "card.write"),
            #  23.09.2026: «в учётке начальника нет возможности заполнить
            #  отпуска». Форма показывалась по праву кадров (employee.write),
            #  которого у депо нет, — хотя сами запись, перенос и удаление с
            #  16.09 проверяют отдельное право на отпуска, и оно у начальника
            #  и заместителя есть. Экран и обработчики спрашивали разное
            "can_vacation": webdb.has_perm(conn, "vacation.write"),
        })
    return templates.TemplateResponse(request, "vacations.html", ctx)


def _vacations_back(unit: str, year: int, msg: str = "", error: str = ""):
    tail = f"/vacations?unit={unit}&year={year}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


#  Отпуск: запись, перенос и удаление — под одним правом (подтверждение 13
#  от 16.09.2026). До этого перенос требовал права на табель, а запись и
#  удаление не требовали ничего: удалить отпуск было легче, чем перенести.
VACATION_DENIED = ("График отпусков ведут начальник депо, заместитель и "
                   "администрация")


@app.post("/vacations/save")
def vacations_save(
    request: Request,
    unit: str = Form(...),
    year: int = Form(...),
    vac_id: str = Form(""),
    employee_id: int = Form(...),
    starts_at: str = Form(...),
    days: str = Form(...),
    kind: str = Form("labour"),
    note: str = Form(""),
):
    """
    Записать отпуск — и сразу проставить «О» в график и табель.

    Часы работы при этом не затираются: если в клетке уже стоит время,
    значит человека вызвали, и решает это начальник депо, а не график
    отпусков, составленный в декабре. Такие дни попадают в сообщение.
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "vacation.write"):
            raise HTTPException(403, VACATION_DENIED)
        try:
            made = vacationdb.save_vacation(
                conn,
                vac_id=int(vac_id) if vac_id else None,
                employee_id=employee_id,
                org_unit_id=u["id"],
                starts_at=parse_day(starts_at),
                days=int(days),
                kind=kind,
                note=note.strip() or None,
                user_id=uid,
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _vacations_back(unit, year, error=text)

    placed = made["placed"]
    span = made["span"]
    tail = ""
    #  Праздник и больничный внутри отпуска в его дни не входят: отпуск
    #  продлевается, и человек возвращается позже. Об этом надо сказать сразу
    if span["holidays"]:
        days_ru = ", ".join(f"{d:%d.%m}" for d in span["holidays"])
        tail += (f". Праздники внутри периода ({days_ru}) в дни отпуска не "
                 f"вошли — отпуск продлён на {len(span['holidays'])} дн., в "
                 f"табеле они помечены «{vacationdb.HOLIDAY_CODE}»")
    if span["sick"]:
        days_ru = ", ".join(f"{d:%d.%m}" for d in span["sick"])
        tail += (f". Дни больничного внутри периода ({days_ru}) в дни отпуска "
                 f"не вошли — отпуск продлён ещё на {len(span['sick'])} дн.")
    if placed["busy"]:
        tail += f"; дней с введёнными часами не тронуто: {placed['busy']}"
    return _vacations_back(
        unit, year,
        #  В график отпуск больше не разносится (пункт 21): там только
        #  плановые смены. Сообщение говорит про табель — то, что на самом
        #  деле изменилось
        msg=(f"Отпуск {made['days']} дн. с {made['starts_at']:%d.%m.%Y} записан: "
             f"по {span['last']:%d.%m.%Y} включительно, "
             f"«{vacationdb.KIND_CODE[made['kind']]}» встало в табель "
             f"({placed['fact']} дн.){tail}"),
    )


@app.post("/vacations/move")
def vacations_move(
    request: Request,
    unit: str = Form(...),
    year: int = Form(...),
    vac_id: int = Form(...),
    shift_days: int = Form(...),
    reason: str = Form(""),
):
    """
    Перенести отпуск на несколько дней — пункт 22 плана.

    Не правка даты, а отдельное действие: график отпусков утверждается
    приказом, и прежний срок должен остаться видимым. Причина обязательна —
    перенос идёт по заявлению работника.
    """
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "vacation.write"):
            raise HTTPException(403, VACATION_DENIED)
        try:
            moved = vacationdb.move_vacation(
                conn, vac_id=vac_id, shift_days=shift_days,
                reason=reason, user_id=uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _vacations_back(unit, year, error=text)

    where = "вперёд" if moved["shift"] > 0 else "назад"
    return _vacations_back(
        unit, year,
        msg=(f"Отпуск {moved['days']} дн. перенесён {where} на "
             f"{abs(moved['shift'])} дн.: было с {moved['was']:%d.%m.%Y}, "
             f"стало с {moved['now']:%d.%m.%Y} по "
             f"{moved['span']['last']:%d.%m.%Y} включительно. "
             f"В табеле переставлено дней: {moved['placed']['fact']}"))


@app.post("/vacations/delete")
def vacations_delete(
    request: Request,
    unit: str = Form(...),
    year: int = Form(...),
    vac_id: int = Form(...),
):
    """Убрать отпуск вместе с его «О» в графике и табеле."""
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "vacation.write"):
            raise HTTPException(403, VACATION_DENIED)
        try:
            vacationdb.delete_vacation(conn, vac_id)
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _vacations_back(unit, year, error=text)
    return _vacations_back(unit, year, msg="Отпуск убран из графика")


@app.post("/vacations/ack")
def vacations_ack(
    request: Request,
    unit: str = Form(...),
    year: int = Form(...),
    employee_id: int = Form(...),
    value: str = Form("1"),
):
    """Отметка «работник ознакомлен с графиком» — графа формы."""
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "vacation.write"):
            raise HTTPException(403, VACATION_DENIED)
        try:
            vacationdb.set_acknowledged(conn, employee_id, year, value == "1")
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _vacations_back(unit, year, error=text)
    return _vacations_back(unit, year, msg="Отметка об ознакомлении сохранена")


@app.get("/api/vacations/print")
def download_vacations(request: Request, unit: str, year: int):
    """
    Выгрузить график отпусков по форме, которую утверждает управляющий.

    Это та же форма, что ведут сейчас в файле «График отпусков 2026 Гродно»:
    строка на работника, столбец на месяц, в клетке «11 дней с 07.01».
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        people = vacationdb.people_for_year(conn, u["id"], year)
        records = vacationdb.vacations(conn, u["id"], year)
        rows = []
        for group in vacationdb.by_person_and_month(people, records):
            person = group["person"]
            rows.append(VacationRow(
                personnel_no=person["personnel_no"] or "",
                fio=(person["fio_full"] or "").strip(),
                position=person["position_name"] or "",
                by_month={
                    m: [vacation_record_text(r["starts_at"], int(r["days"]))
                        for r in recs]
                    for m, recs in group["months"].items() if recs
                },
            ))
        unit_full = u["full_name"] or u["name"]

    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = f"otpuska_{u['code']}_{year}.xlsx"
    path = OUT_DIR / filename
    export_vacations(
        str(path),
        organization=os.environ.get(
            "ORGANIZATION_FULL",
            'Общество с ограниченной ответственностью "Триовист"'),
        org_unit=unit_full,
        year=year,
        rows=rows,
        head_name=os.environ.get("ORG_HEAD_NAME", ""),
    )
    return FileResponse(
        path,
        filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )


@app.get("/staff", response_class=HTMLResponse)
def staff_page(
    request: Request,
    unit: str | None = None,
    tab: str = "employed",
    q: str | None = None,
    #  Какой срез кандидатов смотрим: в подборе, трудоустроенные, в архиве
    cand: str | None = None,
    #  02.10.2026: фильтр вкладки «Журнал» — по вкладкам раздела
    jf: str = "all",
    msg: str | None = None,
    #  «Удержание»: какую запись правим и что не понравилось в форме
    edit: int | None = None,
    error: str | None = None,
):
    uid = require_user(request)
    if tab not in dict(STAFF_TABS):
        tab = "employed"
    if jf not in STAFF_JOURNAL_FILTERS:
        jf = "all"

    with db(uid) as conn:
        ctx = staff_context(conn, uid)
        sel = _selected_unit(ctx["units"], unit)
        unit_id = sel["id"] if sel else None

        ctx.update({
            "sel_unit": sel,
            "unit_param": (sel["code"] if sel else "all"),
            "tab": tab,
            "tabs": STAFF_TABS,
            "q": q or "",
            "counts": staffdb.staff_counts(conn, unit_id),
            "msg": msg,
            #  30.09.2026: ошибка кандидатов приходит параметром error и
            #  показывается красной плашкой сверху (раньше ездила в msg)
            "error": error,
        })
        #  02.10.2026: история живёт только во вкладке «Журнал» — раньше
        #  «Журнал по сотрудникам» тянулся хвостом под каждой вкладкой
        if tab == "journal":
            ctx["journal"] = journal_of(
                conn, "staff", unit_id, None,
                patterns=STAFF_JOURNAL_FILTERS[jf][1])
            ctx["journal_filters"] = [
                (code, title) for code, (title, _) in STAFF_JOURNAL_FILTERS.items()
            ]
            ctx["jf"] = jf
        ctx["can_confirm"] = webdb.has_perm(conn, "hiring.confirm")
        ctx["can_users"] = webdb.has_perm(conn, "user.manage")
        #  Счётчики на вкладках: очередь, о которой не знаешь, не разбирается
        ctx["pending_count"] = (len(staffdb.unconfirmed(conn))
                                if ctx["can_confirm"] else 0)
        ctx["reset_count"] = (staffdb.reset_requests_count(conn)
                              if ctx["can_users"] else 0)
        ctx["can_candidates"] = webdb.has_perm(conn, "candidate.write")
        ctx["settlements"] = []
        ctx["penalty_count"] = (penaltydb.penalty_count(conn, unit_id)
                                if ctx["can_penalty_read"] else 0)
        if ctx["can_candidates"]:
            _cc = staffdb.candidate_counts(conn, unit_id)
            #  Кандидат, чья карточка ТУ ушла на проверку, из подбора не
            #  уходит: «пока сотрудник не подтверждён… он остаётся во вкладке
            #  Кандидаты». Значит, и в счётчике вкладки он остаётся тоже
            ctx["cand_count"] = _cc.get("active", 0) + _cc.get("review", 0)
        else:
            ctx["cand_count"] = 0

        if tab == "requests":
            #  05.10.2026 (правка заказчика): смена пароля — часть «Заявок»,
            #  отдельной вкладки больше нет
            ctx["resets"] = (staffdb.open_reset_requests(conn)
                             if ctx["can_users"] else [])
            ctx["requests"] = staffdb.requests(conn, unit_id)
            #  Увольнение теперь кончается не датой, а принятым расчётом
            #  (22.09.2026). До этого мига человек живёт здесь, а не в
            #  «Уволенных»: место, где о нём вспомнят, должно быть одно
            ctx["settlements"] = staffdb.settlements(conn, unit_id)
            ctx["rows"] = []
        elif tab == "pending":
            ctx["pending"] = staffdb.unconfirmed(conn) if ctx["can_confirm"] else []
            ctx["requests"] = []
            ctx["rows"] = []
        elif tab == "candidates":
            ctx["can_candidates"] = webdb.has_perm(conn, "candidate.write")
            ctx["cand_status"] = cand or "active"
            ctx["candidates"] = (
                staffdb.candidates(conn, unit_id, ctx["cand_status"])
                if ctx["can_candidates"] else [])
            ctx["cand_counts"] = (staffdb.candidate_counts(conn, unit_id)
                                  if ctx["can_candidates"] else {})
            ctx["cand_stages"] = staffdb.CANDIDATE_STAGES
            ctx["positions"] = staffdb.positions(conn)
            ctx["requests"] = []
            ctx["rows"] = []
        elif tab == "penalties":
            ctx.update(_penalty_ctx(conn, ctx, unit_id, q, edit, error))
            ctx["requests"] = []
            ctx["rows"] = []
        else:
            ctx["rows"] = staffdb.staff_list(conn, unit_id, tab, q)
            ctx["requests"] = []
            # Столбцов со сроками столько, сколько видов в справочниках:
            # добавили вид медосмотра — появился столбец, ничего не правя
            ctx["exam_types"] = [
                t for t in settingsdb.ref_types(conn, "medical") if t["is_active"]
            ]
            ctx["cert_types"] = [
                t for t in settingsdb.ref_types(conn, "certificate") if t["is_active"]
            ]
            ctx["brief_types"] = staffdb.briefing_types(conn)
            # Кому какой инструктаж требуется: клетка «не требуется» — это
            # ответ, а не пробел, и красить её как незаполненную нельзя
            ctx["brief_matrix"] = settingsdb.briefing_matrix(conn)
            ctx["exams"] = staffdb.due_by_type(conn, "medical")
            ctx["certs"] = staffdb.due_by_type(conn, "certificate")
            ctx["briefs"] = staffdb.briefing_by_type(conn)
            #  СИЗ: по столбцу на каждый вид, за которым следят, и в клетке
            #  дата окончания срока носки последней выданной позиции
            ctx["ppe_groups"] = staffdb.PPE_GROUPS
            ctx["ppe_due"] = staffdb.ppe_due_by_group(conn)

    return templates.TemplateResponse(request, "staff.html", ctx)


def _penalty_ctx(conn, ctx: dict[str, Any], unit_id: int | None,
                 q: str | None, edit: int | None,
                 error: str | None) -> dict[str, Any]:
    """
    Вкладка «Удержание» в «Сотрудниках»: журнал приказов и форма записи.

    Только журнал: в расчёт заработной платы записи не идут (ответ заказчика
    от 23.09.2026). В списке — те, кто сейчас работает; уволенный уходит
    отсюда, а в карточке его записи остаются.
    """
    if not ctx["can_penalty_read"]:
        return {"penalties": [], "penalty_edit": None}
    out: dict[str, Any] = {
        "penalties": penaltydb.penalties(conn, unit_id, q),
        "penalty_kinds": penaltydb.PENALTY_KINDS,
        "penalty_kind_ru": penaltydb.PENALTY_KIND_RU,
        "penalty_edit": None,
        "error": error,
    }
    if ctx["can_penalty"]:
        out["penalty_people"] = penaltydb.people_by_unit(conn)
        if edit:
            out["penalty_edit"] = penaltydb.penalty(conn, edit)
            if out["penalty_edit"] and out["penalty_edit"]["employee_id"] not in {
                    x["id"] for x in out["penalty_people"].get(
                        out["penalty_edit"]["unit_code"], [])}:
                #  Правим запись уволенного: в каскаде его нет, а выбор
                #  должен показать, кто в записи сейчас
                out["penalty_people"].setdefault(
                    out["penalty_edit"]["unit_code"], []).insert(0, {
                        "id": out["penalty_edit"]["employee_id"],
                        "name": out["penalty_edit"]["full_name"],
                        "no": (out["penalty_edit"]["personnel_no"] or "").strip(),
                    })
    return out


def _penalty_back(back: str | None, **params: str) -> RedirectResponse:
    url = security.safe_back(back, "/staff?tab=penalties")
    extra = "&".join(f"{k}={quote(v)}" for k, v in params.items() if v)
    if extra:
        url += ("&" if "?" in url else "?") + extra
    return RedirectResponse(url, status_code=303)


def _penalty_form(order_date: str, kind: str, amount: str,
                  order_no: str) -> tuple[date, Any]:
    value = penaltydb.parse_amount(amount)
    day = penaltydb.check_fields(kind, value, order_no, order_date)
    return day, value


@app.post("/staff/penalties")
def penalty_add(
    request: Request,
    order_date: str = Form(""),
    unit_code: str = Form(""),
    employee_id: str = Form(""),
    kind: str = Form(""),
    amount: str = Form(""),
    order_no: str = Form(""),
    comment: str = Form(""),
    back: str = Form(""),
):
    """«Записать»: новая строка журнала."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "penalty.write"):
            raise HTTPException(403, "Вносить удержания может Администрация ООУРЦ")
        try:
            if not employee_id.isdigit():
                raise ValueError("Выберите сотрудника")
            day, value = _penalty_form(order_date, kind, amount, order_no)
            penaltydb.add_penalty(
                conn, order_date=day, unit_code=unit_code,
                employee_id=int(employee_id), kind=kind, amount=value,
                order_no=order_no, comment=comment)
        except ValueError as e:
            return _penalty_back(back, error=str(e))
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _penalty_back(back, error=msg)
    return _penalty_back(back, msg="Записано")


@app.post("/staff/penalties/{penalty_id}")
def penalty_update(
    request: Request,
    penalty_id: int,
    order_date: str = Form(""),
    unit_code: str = Form(""),
    employee_id: str = Form(""),
    kind: str = Form(""),
    amount: str = Form(""),
    order_no: str = Form(""),
    comment: str = Form(""),
    back: str = Form(""),
):
    """Правка записи — только администрация."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "penalty.write"):
            raise HTTPException(403, "Править удержания может Администрация ООУРЦ")
        try:
            if not employee_id.isdigit():
                raise ValueError("Выберите сотрудника")
            day, value = _penalty_form(order_date, kind, amount, order_no)
            if not penaltydb.update_penalty(
                    conn, penalty_id, order_date=day, unit_code=unit_code,
                    employee_id=int(employee_id), kind=kind, amount=value,
                    order_no=order_no, comment=comment):
                raise HTTPException(404, "Запись не найдена")
        except ValueError as e:
            return _penalty_back(back, error=str(e), edit=str(penalty_id))
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _penalty_back(back, error=msg, edit=str(penalty_id))
    return _penalty_back(back, msg="Изменено")


@app.post("/staff/penalties/{penalty_id}/delete")
def penalty_delete(request: Request, penalty_id: int, back: str = Form("")):
    """«Удалить»: строка уходит и из журнала, и из карточки — она одна."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "penalty.write"):
            raise HTTPException(403, "Удалять удержания может Администрация ООУРЦ")
        if not penaltydb.delete_penalty(conn, penalty_id):
            raise HTTPException(404, "Запись не найдена")
    return _penalty_back(back, msg="Запись удалена")


@app.get("/staff/new", response_class=HTMLResponse)
def staff_new_form(request: Request, unit: str | None = None,
                   candidate: int | None = None,
                   error: str | None = None):
    uid = require_user(request)
    with db(uid) as conn:
        ctx = staff_context(conn, uid)
        if not ctx["can_draft"]:
            raise HTTPException(
                403, "Оформить трудоустройство может администрация, "
                     "начальник депо и заместитель")
        ctx.update({
            "positions": staffdb.positions(conn),
            "preset_unit": unit,
            "error": error,
            "today": date.today().isoformat(),
            #  02.10.2026 (вопрос 2.2): приём сверх численности подтверждает
            #  только тот, кто подтверждает трудоустройства
            "can_confirm": webdb.has_perm(conn, "hiring.confirm"),
        })
        #  Приём из подбора: ФИО и должность уже известны, набирать их заново
        #  значит переписать то, что вводили на собеседовании
        ctx["candidate"] = (staffdb.candidate(conn, candidate)
                            if candidate else None)
    return templates.TemplateResponse(request, "staff_new.html", ctx)


@app.post("/staff/new")
def staff_new_submit(
    request: Request,
    last_name: str = Form(...),
    first_name: str = Form(...),
    middle_name: str = Form(""),
    personnel_no: str = Form(...),
    unit_code: str = Form(...),
    position_code: str = Form(...),
    hired_at: str = Form(...),
    birth_date: str = Form(""),
    phone: str = Form(""),
    work_email: str = Form(""),
    tsd_login: str = Form(""),
    tsd_password: str = Form(""),
    candidate_id: str = Form(""),
    gender: str = Form("male"),
    #  02.10.2026 (правка заказчика, вопрос 2.2): приём сверх численности
    #  Администрация подтверждает явно
    confirm_headcount: str = Form(""),
):
    uid = require_user(request)
    personnel_no = personnel_no.strip()

    with db(uid) as conn:
        try:
            if not personnel_no.isdigit() or len(personnel_no) != 10:
                raise ValueError("Табельный номер — ровно 10 цифр")
            #  Численность (вопрос 2.2): занятость категории должности
            #  на дату приёма против согласованного плана месяца.
            #  «Увольнение 20-го и приём 18-го» превышением не считается:
            #  занятость считается на дату приёма
            d_hired = parse_day(hired_at)
            hc = staffdb.headcount_on(conn, unit_code, position_code, d_hired)
            over = hc["has_plan"] and hc["occupied"] + 1 > hc["plan"]
            can_confirm = webdb.has_perm(conn, "hiring.confirm")
            if over and can_confirm and confirm_headcount != "yes":
                raise ValueError(
                    f"Численность по должности исчерпана: план {hc['plan']}, "
                    f"на {d_hired:%d.%m.%Y} занято {hc['occupied']}. "
                    f"Подтвердите приём сверх численности или откажите "
                    f"кандидату")
            #  02.10.2026: на отключённую должность не принимаем
            if not staffdb.position_active(conn, position_code):
                raise ValueError("Эта должность отключена в справочнике — "
                                 "выберите действующую")
            #  02.10.2026 (вычитка 2.25): приём, пометка, пол и отметка
            #  кандидата — одной транзакцией. Раньше сбой на втором шаге
            #  оставлял сотрудника принятым, а кандидата «в подборе», и
            #  повтор давал «уже трудоустроен»
            emp_id = staffdb.hire(
                conn, commit=False,
                last_name=last_name, first_name=first_name,
                middle_name=middle_name or None,
                personnel_no=personnel_no,
                unit_code=unit_code, position_code=position_code,
                hired_at=d_hired,
                birth_date=parse_day(birth_date) if birth_date else None,
                phone=phone or None, work_email=work_email or None,
                tsd_login=tsd_login or None, tsd_password=tsd_password or None,
            )
            if over:
                #  Превышение — запрос Администрации: пометка видна во
                #  вкладке «На проверке» (у депо приём и так идёт туда;
                #  Администрация уже подтвердила галочкой выше)
                staffdb.mark_headcount_over(
                    conn, emp_id, commit=False, note=
                    f"Сверх численности: план {hc['plan']}, "
                    f"на {d_hired:%d.%m.%Y} занято {hc['occupied']}")
            #  «Доработка 2» (25.09.2026): пол. По умолчанию в базе «Мужской» —
            #  записываем только выбор «Женский»
            if gender == "female":
                staffdb.set_gender(conn, emp_id, "female", commit=False)
            #  Кандидат уходит из подбора в «Трудоустроены» той же операцией,
            #  которая завела назначение: отдельной кнопкой оба списка
            #  однажды разошлись бы
            if candidate_id.strip():
                staffdb.candidate_hired(conn, int(candidate_id), emp_id,
                                        commit=False)
            #  Оформила администрация — проверка не нужна и человек принят.
            #  Оформило депо — карточка ушла на проверку, и говорить «принят»
            #  было бы неправдой: в приложение он пока не войдёт
            checked = webdb.has_perm(conn, "hiring.confirm")
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/staff/new?unit={unit_code}&error={quote(msg)}", status_code=303
            )

    if checked:
        msg = "Сотрудник принят"
        if over:
            msg += ". Приём сверх численности — помечен в журнале"
        return RedirectResponse(
            f"/staff/{emp_id}?msg={quote(msg)}", status_code=303
        )
    tail = (" Приём сверх численности — подтвердит Администрация ООУРЦ."
            if over else "")
    return RedirectResponse(
        "/staff?tab=candidates&unit=" + quote(unit_code) + "&msg=" + quote(
            "Карточка отправлена на проверку администрации. Кандидат остаётся "
            "в подборе, пока её не подтвердят." + tail),
        status_code=303,
    )


# Вкладки карточки. В карточке десяток разделов, и в две колонки на одной
# странице они не помещались — таблицы с полями ввода вылезали за края блока.
# Вкладками каждый раздел получает всю ширину.
#  «История» — отдельной вкладкой, решение заказчика от 16.09.2026: «кто,
#  когда, что изменил, с чего на что — по всему сотруднику». Внутри блоков
#  остаётся только строка «последнюю правку внёс такой-то тогда-то».
#  Из каких таблиц складывается история карточки. Порядок — как вкладки:
#  сначала человек, потом документы и допуски, потом обеспечение
HISTORY_BLOCKS = [
    ("employee", "Личные данные"),
    ("employment", "Назначение"),
    ("employee_contract", "Контракт"),
    ("safety_briefing", "Инструктаж"),
    ("employee_medical_exam", "Медосмотр"),
    ("employee_certificate", "Свидетельство"),
    ("employee_fuel_norm", "Топливо"),
    ("ppe_issue", "СИЗ"),
    #  Строки расчёта тоже попадают в историю карточки — под своим
    #  табличным именем они читались как ошибка
    ("payroll_line", "Расчётный листок"),
    ("employee_photo", "Фотография"),
    ("user_role", "Роль в приложении"),
    ("app_user", "Учётная запись"),
]
HISTORY_BLOCK_RU = dict(HISTORY_BLOCKS)
HISTORY_ACTION_RU = {"insert": "добавлено", "update": "изменено",
                     "delete": "удалено"}

#  Поля, которые в истории показывать нечего: они меняются при каждой записи
#  и только заслоняют то, ради чего в историю пришли. `employee_id` и его
#  родня — про то, чья это запись: в карточке этого человека и так понятно.
HISTORY_SKIP = {"id", "updated_at", "updated_by", "set_at", "set_by",
                "created_at", "password_hash", "granted_at", "revoked_at",
                "employee_id", "employment_id", "asset_id", "user_id",
                "last_login_at", "failed_logins", "locked_until", "run_id"}

#  Названия полей по-русски. До разбора 21.09.2026 (КР-12) в истории стояло
#  `number: 53453453; type_id: 1; issued_at: 2026-09-17; valid_until:
#  2026-09-30` — верно по существу и нечитаемо.
HISTORY_FIELD_RU = {
    "last_name": "Фамилия", "first_name": "Имя", "middle_name": "Отчество",
    "birth_date": "Дата рождения", "phone": "Телефон",
    "work_email": "Рабочая почта", "personal_email": "Личная почта",
    "personnel_no": "Табельный номер",
    "position_id": "Должность", "category_id": "Категория",
    "org_unit_id": "Депо",
    "hired_at": "Дата приёма", "terminated_at": "Дата увольнения",
    "direction": "Направление", "reason": "Причина",
    "confirmed_at": "Проверено", "return_reason": "Причина возврата",
    "type_id": "Вид",
    "held_at": "Проведён", "held_by": "Ответственный",
    "passed_at": "Пройден", "valid_until": "Действует до",
    "issued_at": "Выдано", "number": "Номер",
    "ends_at": "Действует до", "extended_at": "Дата продления",
    "months": "Срок, мес.", "note": "Примечание",
    "ppe_item_id": "Позиция", "replace_at": "Заменить до",
    "qty": "Количество", "size": "Размер", "status": "Состояние",
    "liters": "Литров", "amount": "Сумма", "price": "Цена",
    "login": "Логин", "email": "Логин", "is_active": "Доступ включён",
    "role_id": "Роль", "full_name": "Имя в приложении",
    "returned_at": "Сдано", "done_at": "Проведено",
    "done_hours": "Наработка", "performed_by": "Кто отметил",
    "hours_day": "Часы дневные", "hours_night": "Часы ночные",
    "norm_hours": "Норма месяца", "net_total": "К выплате",
    "amount_kpi": "Премия", "amount_fuel": "Топливо",
    "amount_salary": "Оклад", "amount_piece": "Сделка",
    "amount_night": "Ночные", "amount_extra": "Доплаты",
    "amount_deduct": "Вычеты",
}

#  Значения, у которых свой словарь
HISTORY_VALUE_RU = {
    "is_active": {True: "да", False: "нет"},
    "direction": DIRECTION_RU,
    "status": {"issued": "на руках", "returned": "сдано",
               "written_off": "списано", "done": "проведено"},
}


def audit_diff(row: dict[str, Any],
               names: dict[str, str] | None = None) -> str:
    """
    «С чего на что» одной строкой.

    Показываем только поля, которые действительно поменялись: запись целиком
    читать никто не станет, а разница — ровно то, за чем в историю приходят.

    `names` — названия справочников, собранные `staffdb.history_names`. Без
    них строка остаётся читаемой, но со ссылкой на номер: словарь готовится
    в обработчике, где есть соединение с базой.
    """
    names = names or {}
    before = row.get("before_data") or {}
    after = row.get("after_data") or {}
    keys = [k for k in (after or before)
            if k not in HISTORY_SKIP and before.get(k) != after.get(k)]
    if not keys:
        return "—"

    entity = row.get("entity")

    def show(col, value):
        if value is None or value == "":
            return "пусто"
        #  Ссылка на справочник — показываем название, а не номер
        table = staffdb.HISTORY_REF_TABLE.get(col)
        if col == "type_id":
            table = staffdb.HISTORY_TYPE_TABLE.get(entity)
        if table:
            name = names.get(f"{table}:{value}")
            if name:
                return name
        if col in HISTORY_VALUE_RU:
            got = HISTORY_VALUE_RU[col].get(value)
            if got:
                return got
        #  Даты и отметки времени в журнале лежат строками ISO
        if isinstance(value, str) and len(value) >= 10 and value[4:5] == "-":
            try:
                if len(value) == 10:
                    return date.fromisoformat(value).strftime("%d.%m.%Y")
                return datetime.fromisoformat(value).strftime("%d.%m.%Y %H:%M")
            except ValueError:
                pass
        return str(value)

    def label(col):
        return HISTORY_FIELD_RU.get(col, col)

    parts = []
    for k in keys[:6]:
        if row.get("action") == "insert":
            parts.append(f"{label(k)}: {show(k, after.get(k))}")
        elif row.get("action") == "delete":
            parts.append(f"{label(k)}: было {show(k, before.get(k))}")
        else:
            parts.append(f"{label(k)}: {show(k, before.get(k))} → "
                         f"{show(k, after.get(k))}")
    if len(keys) > 6:
        parts.append(f"и ещё {len(keys) - 6}")
    return "; ".join(parts)


#  Справочники истории отдаём шаблонам здесь, а не наверху файла:
#  наверху их ещё нет
templates.env.globals["HISTORY_BLOCKS"] = HISTORY_BLOCKS
templates.env.globals["HISTORY_BLOCK_RU"] = HISTORY_BLOCK_RU
templates.env.globals["HISTORY_ACTION_RU"] = HISTORY_ACTION_RU
templates.env.filters["audit_diff"] = audit_diff

#  Виды инструктажа, которые проводят по событию, а не по расписанию:
#  изменился НПА, случилась авария, идут работы по наряду-допуску. В карточке
#  они свёрнуты в блок «Дополнительно» — стоять в общем списке постоянно им
#  незачем (разбор 21.09.2026, КР-10).
BRIEF_BY_EVENT = ("unplanned", "target")
templates.env.globals["BRIEF_BY_EVENT"] = BRIEF_BY_EVENT

CARD_TABS = [
    ("main", "Личное"),
    #  КР-2 (21.09.2026): фотография и топливная карта — своя вкладка.
    #  Оба блока высокие, с формами, а трогают их раз в год: на «Личном»
    #  из-за них до контактов приходилось прокручивать.
    ("extra", "Фото и топливо"),
    #  Переименования от 21.09.2026: вкладка про то, к чему человек
    #  допущен, а не про папку с бумагами
    ("docs", "Допуски к работе"),
    ("stats", "Показатели"),
    #  Пункт 26: расчётные листки закреплены в карточке — история, к которой
    #  можно вернуться и посмотреть, что было начислено и из чего
    ("payslips", "Расчётные листки"),
    #  06.10.2026 (правка заказчика): прежняя общая вкладка разделена —
    #  СИЗ с двумя подвкладками (норма / выданное), закреплённые ТМЦ —
    #  отдельной вкладкой ниже
    ("ppe", "СИЗ"),
    #  Приказы о депремировании и удержаниях (23.09.2026). Вкладка есть
    #  только у тех, кому журнал открыт, — см. `staff_card`
    ("penalties", "Удержание"),
    ("hr", "Кадровое"),
    #  ТМЦ — своей вкладкой: закреплённые терминалы и техника не про одежду
    ("tmc", "ТМЦ"),
    ("history", "История"),
]


def hr_subtabs(person: dict[str, Any], can_write: bool, can_request: bool):
    """
    Вкладки внутри «Кадрового» — по состоянию назначения и правам.

    Закрытому назначению переводить и увольнять уже нечего, поэтому там
    остаётся только история с кнопкой отката. У начальника РЦ прав на
    кадровые действия нет — у него история и заявка.
    """
    tabs = [("history", "История")]
    if person["terminated_at"]:
        return tabs
    if can_write:
        tabs += [("transfer", "Перевод"), ("dismissal", "Увольнение"),
                 ("fix", "Исправление")]
    elif can_request:
        tabs += [("request", "Заявка администрации")]
    return tabs


@app.get("/staff/{employment_id}", response_class=HTMLResponse)
def staff_card(request: Request, employment_id: int, tab: str = "main",
               sub: str | None = None, modal: int = 0,
               hist: str | None = None,
               #  06.10.2026: подвкладка «СИЗ» — норма или выданное
               siz: str = "norm",
               msg: str | None = None, error: str | None = None,
               note: str | None = None):
    """
    Карточка сотрудника.

    `modal=1` — карточка открыта окном поверх списка. Меняется только каркас:
    шапка и меню не рисуются, потому что они уже есть на странице, из которой
    окно открыли. Содержимое, права и формы те же самые — это одна и та же
    страница, а не вторая её версия.
    """
    uid = require_user(request)
    if tab not in dict(CARD_TABS):
        tab = "main"
    #  Признак окна берём ещё и из заголовка запроса: браузер сам помечает
    #  им всё, что грузится в рамку, — переходы по ссылкам, отправку форм и
    #  переадресацию после них. Тащить `modal=1` через каждую ссылку и каждый
    #  ответ пришлось бы вручную, и первая же забытая ссылка вернула бы шапку
    #  внутрь окна. Параметр остаётся запасным путём для браузеров, которые
    #  заголовок не шлют.
    in_frame = request.headers.get("sec-fetch-dest") == "iframe"

    with db(uid) as conn:
        ctx = staff_context(conn, uid)
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        emp = person["employee_id"]
        if tab == "penalties" and not ctx["can_penalty_read"]:
            tab = "main"
        #  Пароль, выданный без почты, приходит одноразовой запиской, а не
        #  в адресе страницы (24.09.2026)
        secret_note = _note_take(conn, note) if note else None
        if siz not in ("norm", "issued", "returned"):
            siz = "norm"
        ctx.update({
            "secret_note": secret_note,
            "person": person,
            "card_tab": tab,
            "siz": siz,
            "card_tabs": [t for t in CARD_TABS
                          if t[0] != "penalties" or ctx["can_penalty_read"]],
            "msg": msg,
            "error": error,
            "today": date.today().isoformat(),
            "today_date": date.today(),
        })

        # Шапка карточки одна на все вкладки, остальное грузим по надобности:
        # запрашивать десять наборов данных, чтобы показать один, незачем.
        # Шапка карточки с фотографией одна на все вкладки
        ctx["photo"] = staffdb.photo_meta(conn, emp)

        #  Чего не хватает в карточке — на всех вкладках: это ответ на вопрос
        #  «что ещё сделать», и прятать его за вкладкой незачем
        ctx["gaps"] = staffdb.card_gaps(conn, emp)

        if tab == "history":
            rows = staffdb.card_history(conn, emp)
            ctx["history_rows"] = rows
            #  Названия справочников — чтобы в истории стояло «Повторный», а
            #  не «type_id: 3». Собираются одним запросом на справочник
            ctx["history_names"] = staffdb.history_names(conn, rows)
            ctx["hist"] = hist
        elif tab == "main":
            ctx["tsd"] = staffdb.tsd(conn, emp)
            #  30.09.2026: контракт нужен и на «Личном» — блок переехал сюда
            #  из «Допусков» (КР-8), а данные оставались в старой ветке, и
            #  на «Личном» всегда писалось «Контракт не заведён»
            ctx["contract"] = staffdb.contract(conn, emp)
            ctx["contracts"] = staffdb.contract_history(conn, emp)
            ctx["fuel"] = staffdb.fuel_norm(conn, emp)
            ctx["provisions"] = staffdb.provisions(conn, emp)
            ctx["fuel_allowed"] = staffdb.provision_allowed(
                conn, person.get("category_code") or "", "fuel")
            #  Учётная запись приложения — рядом с учёткой ТСД: оба логина
            #  этого человека в одном месте, искать их по разным вкладкам
            #  незачем
            ctx["account"] = staffdb.app_account(conn, emp)
            ctx["can_users"] = webdb.has_perm(conn, "user.manage")
            if ctx["can_users"]:
                ctx["account_roles"] = staffdb.roles_for_grant(conn)
                ctx["account_units"] = webdb.accessible_units(conn)
                if ctx["account"]:
                    ctx["account_history"] = staffdb.role_history(
                        conn, ctx["account"]["id"])
            else:
                #  02.10.2026 (вопрос 2.3): учётку новому сотруднику заводит
                #  начальник/заместитель — она лежит отключённой,
                #  подтверждение трудоустройства её включает. Админским
                #  учёткам (user.manage) здесь нечего делать: у них свой
                #  блок выдачи доступа с ролями
                if ctx["can_draft"] and person["confirmed_at"] is None \
                        and person["terminated_at"] is None:
                    try:
                        ctx["depot_account"] = staffdb.depot_account_of(
                            conn, employment_id)
                    except psycopg.Error:
                        ctx["depot_account"] = None
        elif tab == "docs":
            ctx["contract"] = staffdb.contract(conn, emp)
            ctx["contracts"] = staffdb.contract_history(conn, emp)
            # Инструктажи — по видам: у каждого вида свой смысл и своя
            # последняя дата, одного списка «инструктаж» уже мало
            ctx["brief_types"] = staffdb.briefing_types(conn)
            ctx["brief_matrix"] = settingsdb.briefing_matrix(conn)
            ctx["briefings"] = staffdb.briefings(conn, emp)
            #  Кто мог проводить инструктаж в этом депо: начальник и
            #  заместители (ответ О6 от 21.09.2026). По умолчанию в списке
            #  стоит тот, кто вносит запись, — если он сам из этого списка
            ctx["conductors"] = staffdb.briefing_conductors(
                conn, person["unit_id"])
            ctx["briefs_by_type"] = _briefings_by_type(
                ctx["brief_types"], ctx["briefings"])
            ctx["exams"] = staffdb.medical_exams(conn, emp)
            ctx["certificates"] = staffdb.certificates(conn, emp)
            ctx["provisions"] = staffdb.provisions(conn, emp)
            ctx["cert_allowed"] = staffdb.provision_allowed(
                conn, person.get("category_code") or "", "certificate")
        elif tab == "extra":
            #  02.10.2026: вкладка «Фото и топливо» (КР-2) — данные топлива
            #  грузились только для «Личного», и здесь у любой должности
            #  писалось «топливная карта не предусмотрена»
            ctx["fuel"] = staffdb.fuel_norm(conn, emp)
            ctx["provisions"] = staffdb.provisions(conn, emp)
            ctx["fuel_allowed"] = staffdb.provision_allowed(
                conn, person.get("category_code") or "", "fuel")
        elif tab == "stats":
            ctx["months"] = staffdb.timesheet_summary(conn, employment_id)
        elif tab == "payslips":
            ctx["payslips"] = payrolldb.payslips_of(conn, emp)
            ctx["can_payroll"] = webdb.has_perm(conn, "payroll.read")
            ctx["can_supply"] = webdb.has_perm(conn, "asset.read")
        elif tab == "penalties":
            ctx["penalties"] = penaltydb.penalties_of(conn, emp)
            ctx["penalty_kinds"] = penaltydb.PENALTY_KIND_RU
        elif tab == "ppe":
            issued_all = staffdb.ppe_issued(conn, emp)
            #  06.10.2026 (правка заказчика): сданное — отдельная подвкладка
            #  «Возвращено»; в «Выдано (на руках)» остаются только те, что
            #  числятся за работником (аннулированные тоже здесь)
            ctx["ppe_issued"] = [i for i in issued_all if not i["returned_at"]]
            ctx["ppe_returned"] = [i for i in issued_all if i["returned_at"]]
            ctx["ppe_norms"] = staffdb.ppe_norms(conn, employment_id)
            #  Выдача из «Базы СИЗ» (вычитка 30.09.2026): у каждой нормы —
            #  какие размеры есть в наличии у депо; вместо поля «размер»
            #  шаблон показывает список имеющихся
            ctx["ppe_variants"] = staffdb.ppe_base_variants(
                conn, person["unit_id"], ctx["ppe_norms"])
            ctx["ppe_catalog"] = staffdb.ppe_catalog(conn)
            ctx["ppe_kinds"] = settingsdb.PPE_KINDS
            ctx["statements"] = staffdb.ppe_statements(conn, emp)
            #  «Доработка 2» (25.09.2026): акты продления срока носки
            ctx["ext_acts"] = staffdb.extension_acts(conn, emp)
            ctx["ext_max"] = staffdb.add_one_year(date.today()).isoformat()
            ctx["can_ppe"] = webdb.has_perm(conn, "ppe.write")
            #  06.10.2026 (правка заказчика): окно «Ведомость на выдачу» —
            #  остатки «Базы СИЗ» этого депо из 1С УТ
            ctx["depot_stock"] = staffdb.depot_ppe_stock(
                conn, person["unit_id"])
            #  06.10.2026 (правка заказчика): в окне выдачи выбирают, кто
            #  выдал СИЗ физически, — из трудоустроенных этого депо
            ctx["staff_choices"] = staffdb.staff_list(
                conn, person["unit_id"], "employed")
            #  07.10.2026 (№2 «Путь СИЗ»): позиции заявки — карточки Базы СИЗ
            ctx["ppe_cards"] = settingsdb.ppe_size_cards(conn)
        elif tab == "tmc":
            #  06.10.2026 (правка заказчика): закреплённые ТМЦ — своя
            #  вкладка карточки, из «СИЗ» переехали. При увольнении их
            #  по-прежнему спрашивают вместе с СИЗ
            ctx["assigned"] = staffdb.assigned_assets(conn, emp)
            ctx["can_assets"] = webdb.has_perm(conn, "asset.write")
            if ctx["can_assets"]:
                ctx["free_assets"] = staffdb.assignable_assets(
                    conn, person["unit_id"])
        else:
            subs = hr_subtabs(person, ctx["can_write"], ctx["can_request"])
            if sub not in dict(subs):
                sub = subs[0][0]
            ctx["hr_subtabs"] = subs
            ctx["hr_sub"] = sub

            if sub == "history":
                ctx["history"] = staffdb.history(conn, emp)
                ctx["requests"] = staffdb.requests(conn, employment_id=employment_id)
            elif sub == "transfer":
                ctx["transfer_units"] = staffdb.units_for_transfer(conn)
                ctx["positions"] = staffdb.positions(conn)
            elif sub == "fix":
                ctx["positions"] = staffdb.positions(conn)
            else:                                  # dismissal, request
                ctx["reasons"] = staffdb.termination_reasons(conn)
                #  30.09.2026: заявке-переводу нужен список РЦ (вычитка 2.25)
                if sub == "request":
                    ctx["transfer_units"] = staffdb.units_for_transfer(conn)
                #  Причины непродления — вторым списком, он появляется после
                #  «Окончания контракта» (22.09.2026)
                ctx["non_renewal_reasons"] = staffdb.termination_reasons(
                    conn, non_renewal=True)
                if sub == "request":
                    # для заявки на исправление должности нужен их список
                    ctx["positions"] = staffdb.positions(conn)

    ctx["modal"] = bool(modal) or in_frame
    resp = templates.TemplateResponse(request, "staff_card.html", ctx)
    if ctx.get("secret_note"):
        #  Страница с паролем не кешируется: кнопка «Назад» его не вернёт
        resp.headers["Cache-Control"] = "no-store"
    return resp


def _briefings_by_type(
    types: list[dict[str, Any]], rows: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    """
    Инструктажи по видам: на каждый вид — последний и прежние.

    Виды идут все, даже те, которых у человека нет: пустая строка «Целевой —
    не проводился» и есть ответ на вопрос, а отсутствие строки заставило бы
    гадать, забыли записать или инструктажа не было.
    """
    out = []
    for kind in types:
        mine = [r for r in rows if r["type_id"] == kind["id"]]
        out.append({
            "type": kind,
            "last": mine[0] if mine else None,
            "older": mine[1:],
        })
    unknown = [r for r in rows if r["type_id"] is None]
    if unknown:
        out.append({"type": None, "last": unknown[0], "older": unknown[1:]})
    return out


def _back_to_card(employment_id: int, msg: str = "", error: str = "",
                  tab: str = "main", sub: str = "", note: str | None = None,
                  siz: str = ""):
    """
    Назад в карточку — на ту вкладку, где действие и делали: иначе после
    сохранения контракта человек оказывался бы на «Личном» и искал, что
    изменилось.

    sub — вкладка второго уровня внутри «Кадрового». При ошибке возвращаем на
    форму, чтобы её можно было поправить; при успехе — в историю, где виден
    результат.

    siz — подвкладка «СИЗ» (норма / выданное), 06.10.2026.
    """
    parts = [f"tab={tab}"]
    if sub:
        parts.append(f"sub={sub}")
    if siz:
        parts.append(f"siz={siz}")
    if msg:
        parts.append(f"msg={quote(msg)}")
    elif error:
        parts.append(f"error={quote(error)}")
    if note:
        #  Только номер одноразовой записки — сам пароль в адрес не попадает
        parts.append(f"note={quote(note)}")
    return RedirectResponse(
        f"/staff/{employment_id}?{'&'.join(parts)}", status_code=303
    )


@app.post("/staff/{employment_id}/terminate")
def staff_terminate(
    request: Request,
    employment_id: int,
    effective_date: str = Form(...),
    reason_id: int = Form(...),
    #  Почему не продлили контракт: спрашивается и здесь, и в заявке депо
    #  (22.09.2026). Требует поле сама база — одной проверкой на оба пути
    non_renewal_id: str = Form(""),
    direction: str = Form("dismissal"),
    comment: str = Form(""),
):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.terminate(conn, employment_id, parse_day(effective_date),
                              reason_id, direction, comment or None,
                              int(non_renewal_id) if non_renewal_id else None)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="hr", sub="dismissal")
    what = DIRECTION_RU.get(direction, direction)
    return _back_to_card(employment_id, msg=f"Оформлено: {what}", tab="hr", sub="history")


@app.get("/staff/photo/{employee_id}")
def staff_photo(request: Request, employee_id: int, v: str | None = None):
    """
    Отдать фотографию сотрудника.

    Адрес отдельный, а не data: в разметке — снимок кладётся в кеш браузера и
    при переходе по вкладкам карточки заново не качается. В адресе есть
    отметка времени (v), поэтому замена фотографии видна сразу, а не после
    сброса кеша.

    Доступ ограничивает RLS: если человек не из доступного подразделения,
    запрос вернёт пусто, а не чужое лицо.
    """
    uid = require_user(request)
    with db(uid) as conn:
        row = staffdb.photo_bytes(conn, employee_id)
    if not row:
        raise HTTPException(404, "Фотографии нет")

    return Response(
        content=bytes(row["data"]),
        media_type=row["mime_type"],
        headers={
            # Снимок меняется редко, а адрес меняется вместе с ним, поэтому
            # кешировать можно надолго. private — это персональные данные,
            # промежуточным кешам его хранить нельзя.
            "Cache-Control": "private, max-age=86400",
            "Content-Disposition": f'inline; filename="photo-{employee_id}.jpg"',
        },
    )


@app.post("/staff/{employment_id}/photo")
async def staff_photo_upload(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    photo: UploadFile = File(...),
):
    """
    Загрузить или заменить фотографию.

    Тип определяется по первым байтам файла, а не по расширению: расширение
    переименовывается, и вместо снимка в базу попало бы что угодно.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        #  30.09.2026 (вычитка 2.25): загружать фотографию могут и учётки
        #  депо (card.write) — раньше ссылка была видна, а загрузка
        #  отказывала «Фотографию загружает администрация». Удаление
        #  фотографии осталось за администрацией
        try:
            data = await photo.read()
            mime, size = staffdb.save_photo(conn, employee_id, data)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="main")
    # Маленький файл не должен выглядеть как «0 КБ» — это читается как сбой
    shown = f"{size // 1024} КБ" if size >= 1024 else f"{size} байт"
    return _back_to_card(
        employment_id, msg=f"Фотография загружена, {shown}", tab="main"
    )


@app.post("/staff/{employment_id}/photo/delete")
def staff_photo_delete(
    request: Request, employment_id: int, employee_id: int = Form(...)
):
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        if not webdb.has_perm(conn, "employee.write"):
            raise HTTPException(403, "Фотографию удаляет администрация")
        removed = staffdb.delete_photo(conn, employee_id)
    return _back_to_card(
        employment_id,
        msg="Фотография удалена" if removed else "Фотографии и не было",
        tab="main",
    )


@app.post("/staff/{employment_id}/transfer")
def staff_transfer(
    request: Request,
    employment_id: int,
    kind: str = Form(...),               # internal | company
    effective_date: str = Form(...),
    to_unit: str = Form(""),
    to_position: str = Form(""),
    to_text: str = Form(""),
    comment: str = Form(""),
):
    """
    Перевод сотрудника — двух видов.

    internal — внутри отдела, в другой РЦ: назначение здесь закрывается днём
    раньше даты перевода, в целевом РЦ открывается новое, и человек сразу
    попадает в его график и табель.

    company — внутри компании, но за пределы отдела: нового назначения нет,
    записываем только, куда именно ушёл человек.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            if kind == "internal":
                if not to_unit:
                    raise ValueError("Не выбран РЦ, куда переводится сотрудник")
                new_id = staffdb.transfer(
                    conn, employment_id, parse_day(effective_date),
                    to_unit_code=to_unit,
                    to_position=to_position or None,
                    comment=comment or None,
                )
            elif kind == "company":
                if not to_text.strip():
                    raise ValueError("Не указано, куда переведён сотрудник")
                new_id = staffdb.transfer(
                    conn, employment_id, parse_day(effective_date),
                    to_unit_code=None,
                    to_text=to_text,
                    comment=comment or None,
                )
            else:
                raise ValueError(f"Неизвестный вид перевода: {kind}")
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="hr", sub="transfer")

    # После перевода внутри отдела смотреть надо уже новое назначение
    if new_id:
        return _back_to_card(new_id, msg="Перевод оформлен, назначение открыто", tab="hr", sub="history")
    return _back_to_card(employment_id, msg="Перевод оформлен", tab="hr", sub="history")


@app.post("/staff/{employment_id}/undo")
def staff_undo(request: Request, employment_id: int):
    """
    Откатить увольнение или перевод.

    Кадровое действие проводит человек, и человек же может ошибиться. Откат
    возвращает назначение в работу; запись, открытую переводом, база удалит
    только если в ней ещё нет табеля — иначе это уже не исправление ошибки,
    а стирание учтённых часов, и база откажет.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            what = staffdb.undo_close(conn, employment_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="hr", sub="history")
    return _back_to_card(employment_id, msg=f"Отменено: {what}", tab="hr", sub="history")


@app.post("/staff/{employment_id}/position")
def staff_position(
    request: Request,
    employment_id: int,
    position_code: str = Form(...),
):
    """
    Исправить должность в действующем назначении — без истории.

    Это про опечатку при приёме. Настоящий перевод на другую должность
    оформляется переводом с датой: иначе прошлые месяцы задним числом
    пересчитаются по новой должности.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.set_position(conn, employment_id, position_code)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="hr", sub="fix")
    return _back_to_card(employment_id, msg="Должность исправлена", tab="hr", sub="fix")


# ---------------------------------------------------------------------------
#  Допуск к работе и выплаты: контракт, инструктаж, медосмотры, свидетельства
# ---------------------------------------------------------------------------

#  Документы и допуски карточки — контракт, инструктажи, медосмотры,
#  свидетельства, топливо и фотография. До 16.09.2026 они не спрашивали права
#  вовсе: записать инструктаж мог любой, у кого есть доступ к депо.
CARD_DENIED = ("Допуски к работе ведут начальник депо, заместитель и "
               "администрация")


@app.post("/staff/{employment_id}/contract")
def staff_contract(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    extended_at: str = Form(...),
    term_months: int = Form(...),
    note: str = Form(""),
):
    """Продление контракта: дата продления и срок, окончание считается."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        try:
            ends = staffdb.save_contract(
                conn, employee_id=employee_id,
                extended_at=parse_day(extended_at),
                term_months=int(term_months),
                note=note or None,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="main")
    #  30.09.2026: назад на «Личное» — блок контракта живёт там (КР-8),
    #  а редирект ещё уходил на «Допуски», где блока уже нет
    return _back_to_card(
        employment_id, msg=f"Контракт продлён до {ends:%d.%m.%Y}", tab="main"
    )


@app.post("/staff/{employment_id}/briefing")
def staff_briefing(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    type_id: int = Form(...),
    held_at: str = Form(...),
    held_by: str = Form(""),
):
    """
    Инструктаж по охране труда: вид, дата проведения и кто провёл.

    «Действует до» в форме нет — разбор 21.09.2026 (СК-5): дату вводили
    руками, хотя она однозначно считается от периодичности вида. Два
    источника одной даты рано или поздно разойдутся, и правой окажется
    бумага, а не приложение.

    А вот «кто провёл» вернулось выпадающим списком (ответ О6 от 21.09.2026):
    «начальник может заполнить данные, но сам инструктаж проводил другой
    человек». В списке начальник и заместители депо, мастеров в нём нет. Тот,
    кто нажал «Записать», сохраняется отдельной колонкой — в журнале видны
    оба.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        me = webdb.current_user(conn, uid)
        try:
            staffdb.save_briefing(
                conn, employee_id=employee_id, type_id=type_id,
                held_at=parse_day(held_at),
                valid_until=None,
                #  Список пуст (начальник и замы не заведены) — остаётся тот,
                #  кто вносит: пустой столбец хуже приблизительного ответа
                held_by=held_by.strip() or me["full_name"],
                recorded_by=uid,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="docs")
    return _back_to_card(employment_id, msg="Инструктаж записан", tab="docs")


@app.post("/staff/{employment_id}/briefing/{briefing_id}/fix")
def staff_briefing_fix(
    request: Request,
    employment_id: int,
    briefing_id: int,
    held_at: str = Form(...),
    held_by: str = Form(""),
):
    """
    Исправить последнюю запись об инструктаже.

    Требование от 21.09.2026: «перезапись инструктажа, медосмотра и
    свидетельства при ошибке ввода — с записью в журнал». У медосмотра и
    свидетельства по одной записи на вид, и повторное сохранение её
    перезаписывает. У инструктажа записей много, и ошибочную дату было нечем
    поправить: оставалось завести вторую запись рядом с неверной.

    Правка попадает в журнал сама: на таблице стоит аудит (миграция 49), и на
    вкладке «История» видно прежнее значение и новое.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        try:
            staffdb.update_briefing(
                conn, briefing_id=briefing_id,
                held_at=parse_day(held_at),
                held_by=held_by.strip() or None,
                recorded_by=uid,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="docs")
    return _back_to_card(employment_id, msg="Запись исправлена", tab="docs")


@app.post("/staff/{employment_id}/briefing/{briefing_id}/drop")
def staff_briefing_drop(request: Request, employment_id: int, briefing_id: int):
    """
    Убрать задвоенную запись об инструктаже.

    Разбор 22.09.2026: у человека оказалось два вводных — верный от даты
    приёма и второй, появившийся при попытке поправить первый. Повторяться
    это больше не будет, но уже заведённые записи надо чем-то убрать.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        try:
            staffdb.drop_briefing(conn, briefing_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="docs")
    return _back_to_card(employment_id, msg="Запись удалена", tab="docs")


@app.post("/staff/{employment_id}/exam")
def staff_exam(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    type_id: int = Form(...),
    passed_at: str = Form(""),
    valid_until: str = Form(...),
    note: str = Form(""),
):
    """Медосмотр по виду работ: дата прохождения и до какого числа действует."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        try:
            staffdb.save_medical_exam(
                conn, employee_id=employee_id, type_id=type_id,
                passed_at=parse_day(passed_at) if passed_at else None,
                valid_until=parse_day(valid_until),
                note=note or None,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="docs")
    return _back_to_card(employment_id, msg="Медосмотр сохранён", tab="docs")


@app.post("/staff/{employment_id}/certificate")
def staff_certificate(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    type_id: int = Form(...),
    number: str = Form(""),
    issued_at: str = Form(...),
    valid_until: str = Form(""),
    note: str = Form(""),
):
    """Свидетельство: номер, дата выдачи и срок действия, если он есть."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "card.write"):
            raise HTTPException(403, CARD_DENIED)
        try:
            staffdb.save_certificate(
                conn, employee_id=employee_id, type_id=type_id,
                number=number or None,
                issued_at=parse_day(issued_at),
                valid_until=parse_day(valid_until) if valid_until else None,
                note=note or None,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="docs")
    return _back_to_card(employment_id, msg="Свидетельство сохранено", tab="docs")


@app.post("/staff/{employment_id}/fuel")
def staff_fuel(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    card_number: str = Form(""),
    liters_month: str = Form("0"),
    amount_month: str = Form("0"),
    valid_from: str = Form(...),
    note: str = Form(""),
):
    """
    Месячная норма компенсации топливом — литры и рубли.

    Норма историчная: новая открывается с даты, прежняя закрывается ею же.
    Расчёт зарплаты за прошлый месяц должен считаться по той норме, которая
    тогда действовала.
    """
    uid = require_user(request)
    with db(uid) as conn:
        #  02.10.2026 (вычитка 2.25): топливную карту заполняет только
        #  админская учётка — Администратор и Администрация ООУРЦ
        if not webdb.has_perm(conn, "hiring.confirm"):
            raise HTTPException(403, "Топливную карту заполняет Администрация ООУРЦ")
        try:
            staffdb.save_fuel_norm(
                conn, employee_id=employee_id,
                card_number=card_number or None,
                liters_month=float((liters_month or "0").replace(",", ".")),
                amount_month=float((amount_month or "0").replace(",", ".")),
                valid_from=parse_day(valid_from),
                note=note or None,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="extra")
    return _back_to_card(employment_id, msg="Норма топлива сохранена", tab="extra")


PPE_DENIED = ("СИЗ выдают начальник, заместитель, мастер и Администрация "
              "ООУРЦ — у вашей учётки только просмотр")


@app.post("/staff/{employment_id}/ppe")
def staff_ppe_issue(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    org_unit_id: int = Form(...),
    item_id: str = Form(""),
    item_name: str = Form(""),
    code: str = Form(""),
    ppe_kind: str = Form("other"),
    size: str = Form(""),
    classification: str = Form(""),
    qty: str = Form("1"),
    issued_at: str = Form(...),
    replace_at: str = Form(""),
    wear_period_months: str = Form(""),
    from_base: int = Form(0),
):
    """
    Выдача СИЗ работнику: позиция из справочника или новая.

    «Заменить до» можно не вводить: если у нормы есть срок носки, дата
    считается от даты выдачи. Пусто и там и там — выдано до износа.

    Выдача из «Базы СИЗ» (вычитка 30.09.2026): размер берётся из строки
    базы, один экземпляр списывается с остатка. Наименование остаётся
    наименованием нормы — по нему норма считает «на руках».
    """
    uid = require_user(request)
    with db(uid) as conn:
        #  02.10.2026 (вычитка 2.25, 5.20): СИЗ ведут начальник, заместитель,
        #  мастер и Администрация; наблюдатель и кладовщик только смотрят
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, PPE_DENIED)
        taken = False
        try:
            size_use = size
            if from_base:
                with conn.cursor() as cur:
                    cur.execute(
                        "SELECT size FROM app.ppe_base_stock "
                        " WHERE id = %s AND org_unit_id = %s",
                        (from_base, org_unit_id))
                    row = cur.fetchone()
                if row is None:
                    raise ValueError(
                        "Строка базы не найдена — обновите страницу")
                size_use = row["size"]
            staffdb.add_ppe_issue(
                conn,
                employee_id=employee_id,
                org_unit_id=org_unit_id,
                item_id=int(item_id) if item_id else None,
                name=item_name,
                code=code,
                kind=ppe_kind,
                size=size_use,
                classification=classification,
                qty=float((qty or "1").replace(",", ".")),
                issued_at=parse_day(issued_at),
                replace_at=parse_day(replace_at) if replace_at else None,
                wear_period_months=(
                    int(wear_period_months) if wear_period_months.strip() else None
                ),
            )
            if from_base:
                supplydb.take_ppe_from_base(conn, from_base, org_unit_id)
                taken = True
            #  Заявка на недостающий комплект гаснет сама, когда комплект
            #  выдан: совпали сотрудник и позиция номенклатуры
            if item_id:
                staffdb.ppe_requests_close_for(conn, employee_id, int(item_id))
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    note = "Выдача записана — списана из базы" if taken else "Выдача записана"
    return _back_to_card(employment_id, msg=note, tab="ppe", siz="issued")


@app.post("/staff/{employment_id}/ppe/issue-batch")
def staff_ppe_issue_batch(request: Request, employment_id: int,
                          employee_id: int = Form(...),
                          org_unit_id: int = Form(...),
                          stock_ids: list[str] = Form([]),
                          issued_at: str = Form(...),
                          issuer_employee_id: int = Form(0)):
    """Выдача пачкой из окна «Ведомость на выдачу» (06.10.2026, правка
    заказчика): кладовщик отмечает позиции остатков 1С УТ, внизу жмёт
    «Выдать», указывает дату выдачи и того, кто выдал физически, и
    подтверждает формирование — каждая выбранная строка записывается
    сотруднику и списывается с остатка, ведомость сохраняется.
    «Заменить до» не вводится: срок берётся из нормы (Базовые настройки),
    пустой срок — «до износа». Печать — из «Ведомостей», сама она после
    выдачи не открывается (вторая правка 06.10.2026)."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, PPE_DENIED)
        if not issuer_employee_id:
            return _back_to_card(employment_id, tab="ppe", siz="issued",
                                 error="Укажите, кто выдал СИЗ")
        #  06.10.2026 (правка заказчика): «заменить до» считается само
        #  по сроку носки из нормы этого сотрудника (по наименованию,
        #  как в «Положены по норме»); нет срока — «до износа»
        period_by_name = {
            n["item_name"]: n["wear_period_months"]
            for n in staffdb.ppe_norms(conn, employment_id)
            if n["wear_period_months"]
        }
        ids = []
        for v in stock_ids:
            if str(v).isdigit():
                ids.append(int(v))
        if not ids:
            return _back_to_card(employment_id, tab="ppe", siz="issued",
                                 error="Не выбрано ни одной позиции")
        n = 0
        issued_ids: list[int] = []
        try:
            for sid in ids:
                with conn.cursor() as cur:
                    cur.execute(
                        """
                        SELECT s.size, i.id AS item_id, i.name
                          FROM app.ppe_base_stock s
                          JOIN app.ppe_item i ON i.id = s.ppe_item_id
                         WHERE s.id = %s AND s.org_unit_id = %s
                        """,
                        (sid, org_unit_id))
                    row = cur.fetchone()
                if row is None:
                    continue
                issued_ids.append(staffdb.add_ppe_issue(
                    conn,
                    employee_id=employee_id,
                    org_unit_id=org_unit_id,
                    item_id=row["item_id"],
                    name=row["name"],
                    code="",
                    kind="other",
                    size=row["size"],
                    classification=None,
                    qty=1,
                    issued_at=parse_day(issued_at),
                    replace_at=None,
                    wear_period_months=period_by_name.get(row["name"]),
                ))
                supplydb.take_ppe_from_base(conn, sid, org_unit_id)
                staffdb.ppe_requests_close_for(conn, employee_id,
                                               row["item_id"])
                n += 1
            #  06.10.2026 (правка заказчика, вторая): после подтверждения
            #  ведомость только записывается — печать запускают из
            #  «Ведомостей», сама она не открывается
            made = staffdb.create_ppe_statement(
                conn,
                employee_id=employee_id,
                org_unit_id=org_unit_id,
                issue_ids=issued_ids,
                statement_date=parse_day(issued_at),
                kind="issue",
                user_id=uid,
                issuer_employee_id=issuer_employee_id,
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe",
                                 siz="issued")
    return _back_to_card(
        employment_id, tab="ppe", siz="issued",
        msg=f"Ведомость {made['number']} записана — "
            f"позиций: {n}. Распечатать — в «Ведомостях»")


@app.post("/staff/{employment_id}/ppe-request")
async def staff_ppe_request(request: Request, employment_id: int):
    """Заявка на недостающие комплекты СИЗ (07.10.2026, №2 «Путь СИЗ»).

    Позиции выбирают из всей Базы СИЗ — семи карточек типоразмеров,
    — несколько позиций сразу; строки «Размер» нет: размер уточнится при
    выдаче. По каждой выбранной позиции — своя открытая заявка, то есть
    своя задача на доске Администрации ООУРЦ."""
    uid = require_user(request)
    form = await request.form()
    cards = [str(v).strip() for v in form.getlist("card") if str(v).strip()]
    note = str(form.get("note") or "").strip()
    with db(uid) as conn:
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, PPE_DENIED)
        if not cards:
            return _back_to_card(
                employment_id, tab="ppe", siz="issued",
                error="Выберите хотя бы одну позицию из Базы СИЗ")
        known = {c["code"]: (c["title"] or c["subtitle"] or c["code"])
                 for c in settingsdb.ppe_size_cards(conn)}
        try:
            for code in dict.fromkeys(cards):
                title = known.get(code)
                if title is None:
                    raise ValueError(
                        "Позиция не найдена в Базе СИЗ — обновите окно")
                staffdb.ppe_request_add(conn, person["employee_id"],
                                        None, title, None,
                                        note or None)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe",
                                 siz="issued")
        conn.commit()
    return _back_to_card(
        employment_id, tab="ppe", siz="issued",
        msg=f"Заявка отправлена — позиций: {len(cards)}. "
            f"Задачи появились на доске Администрации ООУРЦ")


@app.post("/staff/{employment_id}/ppe/drop")
def staff_ppe_drop(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    issue_id: int = Form(...),
):
    """Убрать ошибочную выдачу — пока она не попала в ведомость."""
    uid = require_user(request)
    with db(uid) as conn:
        #  02.10.2026 (вычитка 2.25, 5.20): СИЗ ведут начальник, заместитель,
        #  мастер и Администрация; наблюдатель и кладовщик только смотрят
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, PPE_DENIED)
        try:
            staffdb.drop_ppe_issue(conn, issue_id, employee_id)
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    return _back_to_card(employment_id, msg="Выдача убрана", tab="ppe", siz="issued")


@app.post("/staff/{employment_id}/ppe/annul")
async def staff_ppe_annul(request: Request, employment_id: int):
    """Аннулировать выданную позицию — с причиной (24.09.2026)."""
    uid = require_user(request)
    form = await request.form()
    issue_id = int(form.get("annul_id") or 0)
    reason = str(form.get(f"annul_reason_{issue_id}") or "")
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, "СИЗ ведут начальник депо, заместитель и мастер")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        try:
            staffdb.annul_ppe_issue(conn, issue_id, person["employee_id"], reason, uid)
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    return _back_to_card(employment_id, msg="Позиция аннулирована", tab="ppe", siz="issued")


@app.post("/staff/{employment_id}/ppe/extend")
async def staff_ppe_extend(request: Request, employment_id: int):
    """
    Акт осмотра СИЗ на продление срока носки (25.09.2026, «Доработка 2»):
    отмеченные «На продление» позиции продлеваются до даты — не дальше года
    от даты составления. Срок «Заменить до» переносится, акт сохраняется в
    карточке; печать — из списка актов, сама она не открывается
    (06.10.2026, вторая правка заказчика).
    """
    uid = require_user(request)
    form = await request.form()
    #  06.10.2026 (правка заказчика): один столбец галочек — что отмечено,
    #  то и продлевается
    ids = [int(x) for x in form.getlist("picked") if str(x).isdigit()]
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, "СИЗ ведут начальник депо, заместитель и мастер")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        try:
            act_date = financedb.parse_day(str(form.get("act_date") or ""))
            ext_raw = str(form.get("extended_to") or "")
            if not ext_raw:
                raise ValueError("Укажите, до какого числа продлевается срок носки")
            act_id = staffdb.create_extension_act(
                conn, employee_id=person["employee_id"], org_unit_id=person["unit_id"],
                issue_ids=ids, act_date=act_date,
                extended_to=financedb.parse_day(ext_raw), user_id=uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    #  06.10.2026 (правка заказчика, вторая): акт только записывается —
    #  печать запускают из списка актов, сама она не открывается
    return _back_to_card(
        employment_id, tab="ppe", siz="issued",
        msg=f"Акт записан — позиций: {len(ids)}. "
            f"Распечатать — в «Актах на продление»")


@app.get("/staff/{employment_id}/ppe/extension/{act_id}/print",
         response_class=HTMLResponse)
def print_extension_act(request: Request, employment_id: int, act_id: int):
    """Печатная форма акта продления (06.10.2026, правка заказчика):
    та же форма, что в docx «Скачать акт», но HTML — открывается в новой
    вкладке и сразу вызывает печать."""
    uid = require_user(request)
    with db(uid) as conn:
        act = staffdb.extension_act_for_print(conn, act_id)
        if not act:
            raise HTTPException(404, "Акт не найден")
        com = settingsdb.ppe_commission_of(conn, act["org_unit_id"]) or \
            {"chair": "", "members": ""}
    return templates.TemplateResponse(
        request, "ppe_act_print.html",
        {"act": act, "com": com, "employment_id": employment_id})


@app.post("/staff/{employment_id}/ppe/extension/{act_id}/annul")
def staff_ppe_extension_annul(request: Request, employment_id: int, act_id: int,
                              reason: str = Form("")):
    """Аннулировать акт продления: сроки замены возвращаются к прежним."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, "СИЗ ведут начальник депо, заместитель и мастер")
        try:
            staffdb.annul_extension_act(conn, act_id, reason, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    return _back_to_card(employment_id, tab="ppe", siz="issued",
                         msg="Акт аннулирован, сроки замены возвращены")


@app.get("/api/ppe/extension/{act_id}")
def download_extension_act(request: Request, act_id: int):
    """Акт осмотра СИЗ на продление — по шаблону заказчика (25.09.2026)."""
    from .ppe_act_print import export_act

    uid = require_user(request)
    with db(uid) as conn:
        act = staffdb.extension_act_for_print(conn, act_id)
        if not act:
            raise HTTPException(404, "Акт не найден")
        if act["annulled_at"]:
            raise HTTPException(409, "Акт аннулирован")
        com = settingsdb.ppe_commission_of(conn, act["org_unit_id"])
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = f"akt_siz_{act['personnel_no']}_{act['act_date']:%d%m%Y}.docx"
    path = OUT_DIR / filename
    export_act(str(path), act_date=act["act_date"], unit_name=act["unit_name"],
               chair=com["chair"], members=com["members"], fio=act["fio_full"],
               lines=act["lines"], extended_to=act["extended_to"])
    return FileResponse(
        path, filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document")


@app.post("/staff/{employment_id}/ppe/statement/{statement_id}/annul")
def staff_ppe_statement_annul(request: Request, employment_id: int,
                              statement_id: int, reason: str = Form("")):
    """Аннулировать ведомость: позиции освобождаются для новой (24.09.2026)."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, "СИЗ ведут начальник депо, заместитель и мастер")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        try:
            n = staffdb.annul_ppe_statement(conn, statement_id,
                                            person["employee_id"], reason, uid)
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    return _back_to_card(employment_id, tab="ppe", siz="issued",
                         msg=f"Ведомость аннулирована, позиций освобождено: {n}")


@app.post("/staff/{employment_id}/ppe/return")
async def staff_ppe_return(request: Request, employment_id: int):
    """
    Провести сдачу СИЗ — без ведомости.

    Заказчик 22.09.2026: «после нажатия саму ведомость формировать не нужно.
    Система должна понять и отметить, что сотрудник это сдал, сам бланк
    печатается 1 раз, в нём уже есть столбец с отметкой даты сдачи…
    при проведении сдачи должно запрашивать дату и подтверждение проведения».

    Дата приходит из формы, подтверждение спрашивает браузер: действие
    меняет состояние имущества, и промахнуться мимо кнопки не должно быть
    достаточно.
    """
    uid = require_user(request)
    form = await request.form()
    picked = [int(v) for v in form.getlist("picked") if str(v).isdigit()]
    with db(uid) as conn:
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, "СИЗ ведут начальник депо, заместитель "
                                     "и мастер")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        try:
            done = staffdb.mark_returned(
                conn, employee_id=person["employee_id"], issue_ids=picked,
                returned_at=parse_day(form.get("returned_at")), user_id=uid,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    return _back_to_card(
        employment_id, tab="ppe", siz="issued",
        msg=f"Сдача проведена, позиций: {done}")


@app.post("/staff/{employment_id}/ppe/statement")
async def staff_ppe_statement(request: Request, employment_id: int):
    """
    Собрать ведомость из отмеченных позиций — на выдачу или на сдачу.

    У каждого вида своя колонка галочек, и вид приходит нажатой кнопкой.
    Одним списком это не сделать: сдают то, что уже выдано и подписано, то
    есть ровно те строки, которые для выдачи отмечать уже нельзя.
    """
    uid = require_user(request)
    form = await request.form()
    kind = str(form.get("kind") or "issue")
    #  Ведомости на сдачу больше нет (22.09.2026): бланк на выдачу печатается
    #  один раз, и графа для даты возврата в нём уже есть. Сдача проводится
    #  отметкой — обработчик выше. Здесь остаётся защита от старой ссылки
    if kind == "return":
        return _back_to_card(
            employment_id, tab="ppe", siz="issued",
            error="Ведомость на сдачу больше не оформляется: нажмите "
                  "«Провести сдачу» — дата отметится в самой выдаче")
    group = "issue"
    picked = [int(v) for v in form.getlist(group) if str(v).isdigit()]

    with db(uid) as conn:
        #  02.10.2026 (вычитка 2.25, 5.20): СИЗ ведут начальник, заместитель,
        #  мастер и Администрация; наблюдатель и кладовщик только смотрят
        if not webdb.has_perm(conn, "ppe.write"):
            raise HTTPException(403, PPE_DENIED)
        try:
            made = staffdb.create_ppe_statement(
                conn,
                employee_id=int(form["employee_id"]),
                org_unit_id=int(form["org_unit_id"]),
                issue_ids=picked,
                statement_date=parse_day(str(form.get("statement_date") or "")),
                kind=kind,
                user_id=uid,
            )
            conn.commit()
        except (ValueError, psycopg.Error, KeyError) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="ppe", siz="issued")
    what = "на сдачу" if kind == "return" else "на выдачу"
    return _back_to_card(
        employment_id,
        msg=f"Ведомость {what} № {made['number']} сформирована", tab="ppe", siz="issued",
    )


@app.get("/staff/{employment_id}/ppe/statement/{statement_id}/print",
         response_class=HTMLResponse)
def print_statement(request: Request, employment_id: int, statement_id: int):
    """Печатная форма ведомости (06.10.2026, правка заказчика): открывается
    в новой вкладке и сразу вызывает печать — ту же форму, что и «Скачать»,
    только HTML вместо файла."""
    uid = require_user(request)
    with db(uid) as conn:
        st = staffdb.statement_for_print(conn, statement_id)
        if not st:
            raise HTTPException(404, "Ведомость не найдена")
    return templates.TemplateResponse(
        request, "ppe_statement_print.html", {"st": st})


@app.get("/api/forklift/notes")
def forklift_notes_list(request: Request):
    """Заметки коробки погрузчика — личные, только свои (RLS по пользователю)."""
    uid = require_user(request)
    with db(uid) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT id, body, created_at FROM app.forklift_note "
                "ORDER BY id DESC")
            rows = cur.fetchall()
    return JSONResponse({"notes": [
        {"id": r["id"], "body": r["body"],
         "at": r["created_at"].strftime("%d.%m.%Y %H:%M")}
        for r in rows
    ]})


@app.post("/api/forklift/notes")
async def forklift_note_add(request: Request):
    uid = require_user(request)
    form = await request.form()
    body = str(form.get("body") or "").strip()
    if not body:
        return JSONResponse({"error": "Пустая заметка"}, status_code=400)
    if len(body) > 2000:
        return JSONResponse(
            {"error": "Не больше 2000 знаков"}, status_code=400)
    with db(uid) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "INSERT INTO app.forklift_note (user_id, body) "
                "VALUES (app.current_user_id(), %s) "
                "RETURNING id, created_at",
                (body,))
            row = cur.fetchone()
        conn.commit()
    return JSONResponse({
        "id": row["id"],
        "at": row["created_at"].strftime("%d.%m.%Y %H:%M")})


@app.delete("/api/forklift/notes/{note_id}")
def forklift_note_delete(request: Request, note_id: int):
    uid = require_user(request)
    with db(uid) as conn:
        with conn.cursor() as cur:
            #  RLS не даст тронуть чужую заметку — удалится 0 строк
            cur.execute(
                "DELETE FROM app.forklift_note WHERE id = %s", (note_id,))
            gone = cur.rowcount
        conn.commit()
    return JSONResponse({"ok": bool(gone)})


@app.post("/api/forklift/suggestion")
async def forklift_suggestion_add(request: Request):
    """Предложение по доработке из коробки погрузчика: текст уходит задачей
    на доску Администрации ООУРЦ, в самой коробке история не хранится."""
    uid = require_user(request)
    form = await request.form()
    body = str(form.get("body") or "").strip()
    if not body:
        return JSONResponse({"error": "Пустое предложение"}, status_code=400)
    if len(body) > 300:
        return JSONResponse(
            {"error": "Не больше 300 знаков"}, status_code=400)
    with db(uid) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "INSERT INTO app.improvement_suggestion (user_id, body) "
                "VALUES (app.current_user_id(), %s) RETURNING id",
                (body,))
            sid = cur.fetchone()["id"]
        conn.commit()
    return JSONResponse({"id": sid})


@app.get("/api/ppe/statement/{statement_id}")
def download_statement(request: Request, statement_id: int):
    """
    Выгрузить ведомость по форме вкладки «Ведомость» файла управления.

    Это та форма, под которой работник подписывается при получении СИЗ,
    поэтому выгрузка идёт в неё: те же графы 1–9 и тот же блок подписи.
    """
    uid = require_user(request)
    with db(uid) as conn:
        st = staffdb.statement_for_print(conn, statement_id)
        if not st:
            raise HTTPException(404, "Ведомость не найдена")
        lines = [
            PpeLine(
                name=r["name"], classification=r["classification"],
                qty=float(r["qty"]), code=r["code"], size=r["size"],
                returned_at=r.get("returned_at"),
            )
            for r in st["rows"]
        ]

    OUT_DIR.mkdir(parents=True, exist_ok=True)
    #  Косая черта в номере второй ведомости за день — в имени файла её быть
    #  не может, поэтому в имени она становится подчёркиванием
    safe = st["number"].replace("/", "_")
    filename = f"vedomost_{safe}.xlsx"
    path = OUT_DIR / filename
    export_statement(
        str(path),
        organization=os.environ.get("ORGANIZATION", 'ООО «Триовист»'),
        org_unit=st["unit_full_name"] or st["unit_name"],
        number=st["number"],
        statement_date=st["statement_date"],
        fio=st["fio_full"].strip(),
        position=st["position_name"] or "",
        lines=lines,
        issuer_position=st["issuer_position"],
        issuer_name=st["issuer_name"],
    )
    return FileResponse(
        path,
        filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )


@app.post("/staff/{employment_id}/request")
def staff_request(
    request: Request,
    employment_id: int,
    kind: str = Form(...),
    effective_date: str = Form(""),
    reason_id: str = Form(""),
    non_renewal_id: str = Form(""),
    direction: str = Form(""),
    new_phone: str = Form(""),
    fix_field: str = Form(""),
    fix_value: str = Form(""),
    fix_value_date: str = Form(""),
    fix_value_position: str = Form(""),
    comment: str = Form(""),
    #  30.09.2026 (вычитка 2.25): заявке-переводу — новый РЦ
    transfer_unit: str = Form(""),
):
    """
    Заявка депо администрации: увольнение, перевод или исправление данных.

    Исправлять можно не только телефон: начальник РЦ видит своих людей каждый
    день и первым замечает опечатку в фамилии, табельном номере или дате
    рождения. Прав править кадровые данные у него нет, но заявку он подаёт, и
    по подтверждению известные поля применяются сами.

    Значение приходит из одного из трёх полей формы — обычного, даты или
    выбора должности: печатать дату руками и помнить код должности человек не
    должен.
    """
    uid = require_user(request)
    value = fix_value
    if fix_field == "birth_date":
        value = fix_value_date
    elif fix_field == "position":
        value = fix_value_position

    with db(uid) as conn:
        try:
            if kind == "fix" and not (value or "").strip():
                raise ValueError("Не указано новое значение")
            staffdb.request_create(
                conn,
                employment_id=employment_id,
                kind=kind,
                effective_date=parse_day(effective_date) if effective_date else None,
                reason_id=int(reason_id) if reason_id else None,
                #  Почему не продлили контракт: спрашивается только там, где
                #  первая причина этого требует (22.09.2026)
                non_renewal_id=int(non_renewal_id) if non_renewal_id else None,
                direction=direction or None,
                new_phone=new_phone or None,
                fix_field=fix_field or None,
                fix_value=value or None,
                comment=comment or None,
                transfer_unit=transfer_unit or None,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            if "staff_request_one_open_dismissal" in str(e):
                msg = "По этому сотруднику уже есть заявка, ждущая решения"
            return _back_to_card(employment_id, error=msg, tab="hr", sub="request")
    return _back_to_card(employment_id, msg="Заявка отправлена администрации", tab="hr", sub="history")


@app.post("/staff/request/{request_id}/decide")
def staff_request_decide(
    request: Request,
    request_id: int,
    approve: str = Form(...),
    comment: str = Form(""),
    back: str = Form("/staff?tab=requests"),
):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.request_decide(conn, request_id, approve == "1", comment or None)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(f"/staff?tab=requests&msg={quote(msg)}",
                                    status_code=303)
    done = "Заявка подтверждена" if approve == "1" else "Заявка отклонена"
    #  Адрес возврата приходит из формы — только внутренний (23.09.2026)
    back = security.safe_back(back, "/staff?tab=requests")
    sep = "&" if "?" in back else "?"
    return RedirectResponse(f"{back}{sep}msg={quote(done)}", status_code=303)


@app.post("/staff/{employment_id}/sizes")
def staff_sizes(request: Request, employment_id: int,
                clothing_size: str = Form(""), shoe_size: str = Form(""),
                height_cm: str = Form(""), headwear_size: str = Form(""),
                siz: str = Form("")):
    """
    Размеры одежды и обуви (23.09.2026).

    Ведёт депо — тот, кто выдаёт спецодежду. В личном кабинете сотрудник
    увидит их у себя; пока кабинета нет, они нужны для заказа СИЗ новичку.
    """
    uid = require_user(request)
    with db(uid) as conn:
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        try:
            h = height_cm.strip()
            if h and not h.isdigit():
                raise ValueError("Рост — целым числом в сантиметрах")
            staffdb.set_sizes(conn, person["employee_id"],
                              clothing_size or None, shoe_size or None,
                              int(h) if h else None, headwear_size or None)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="ppe", sub="", siz=siz)
    return _back_to_card(employment_id, msg="Размеры сохранены",
                         tab="ppe", siz=siz)


@app.post("/staff/{employment_id}/fio")
def staff_fio_fix(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    last_name: str = Form(...),
    first_name: str = Form(...),
    middle_name: str = Form(""),
):
    """
    Исправить ФИО сотрудника (вычитка 2.6).

    Опечатка при приёме — будничный случай; менять фамилию из-за неё
    заявкой «исправление данных» — обходной путь. Правит Администрация
    ООУРЦ прямо из карточки.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.update_employee_fio(
                conn, employee_id=employee_id, last_name=last_name,
                first_name=first_name, middle_name=middle_name)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="main")
    return _back_to_card(employment_id, msg="ФИО исправлено", tab="main")


@app.post("/staff/{employment_id}/contacts")
def staff_contacts(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    phone: str = Form(""),
    work_email: str = Form(""),
    birth_date: str = Form(""),
    tsd_login: str = Form(""),
    tsd_password: str = Form(""),
    gender: str = Form(""),
    #  02.10.2026 (правка заказчика): у начальника депо — четыре телефонные
    #  графы; поля приходят только из его карточки
    phone_depot: str = Form(""),
    phone_personal: str = Form(""),
    reserve_internet: str = Form(""),
):
    uid = require_user(request)
    with db(uid) as conn:
        #  30.09.2026 (вычитка 2.25): начальник и заместитель сохраняют
        #  логин и пароль ТСД — раньше поля им были видны, а сохранение
        #  упиралось в «Нет права править данные сотрудников». Личные
        #  данные (телефон, почта, дата рождения) по-прежнему правит
        #  только Администрация ООУРЦ
        may_full = webdb.has_perm(conn, "employee.write")
        may_tsd = may_full or webdb.has_perm(conn, "tsd.write")
        try:
            if may_full:
                staffdb.update_contacts(
                    conn,
                    employee_id=employee_id,
                    phone=phone or None, work_email=work_email or None,
                    birth_date=parse_day(birth_date) if birth_date else None,
                    tsd_login=(tsd_login or None) if may_tsd else None,
                    tsd_password=(tsd_password or None) if may_tsd else None,
                    phone_depot=phone_depot or None,
                    phone_personal=phone_personal or None,
                    reserve_internet=reserve_internet or None,
                )
            elif may_tsd:
                staffdb.update_tsd(
                    conn, employee_id=employee_id,
                    tsd_login=tsd_login, tsd_password=tsd_password or None)
            else:
                return _back_to_card(
                    employment_id,
                    error="Личные данные и ТСД правит администрация; "
                          "начальник депо и заместитель — только учётку ТСД",
                    tab="main")
            if gender in ("male", "female"):
                staffdb.set_gender(conn, employment_id, gender)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="main")
    return _back_to_card(employment_id, msg="Данные сохранены", tab="main")


# ---------------------------------------------------------------------------
#  Доступ в приложение — из карточки сотрудника
#
#  Уточнение заказчика от 15.09.2026: логин, пароль и роль выдаются в
#  карточке; там же роль меняется и доступ отзывается.
#
#  Обработчики тонкие намеренно. Проверки — право `user.manage`, запрет
#  выдавать доступ уволенному, запрет отозвать доступ себе, одна действующая
#  роль — живут в функциях базы. Правило, проверяемое только здесь, обошёл бы
#  любой второй путь к той же таблице; правило в базе не обходит ничто.
# ---------------------------------------------------------------------------

def _access_unit(org_unit_id: str) -> int | None:
    """Пустое значение — «все депо»: роль без привязки к подразделению."""
    value = (org_unit_id or "").strip()
    return int(value) if value else None


def _access_error(e: Exception) -> str:
    return (getattr(e, "diag", None) and e.diag.message_primary) or str(e)


NOTE_TTL_MINUTES = 10


def _note_put(conn, text: str) -> str | None:
    """
    Положить одноразовую записку и вернуть её номер для адреса страницы.

    Пароль в адрес не кладём (24.09.2026): адрес остаётся в истории браузера
    и в журнале обратного прокси. Номер записки — случайный, прочитать её
    может только тот, кто положил, и только один раз.
    """
    token = secrets.token_urlsafe(24)
    try:
        with conn.cursor() as cur:
            cur.execute(
                "DELETE FROM app.one_time_note WHERE created_at < now() - "
                "make_interval(mins => %s)", (NOTE_TTL_MINUTES,))
            cur.execute(
                "INSERT INTO app.one_time_note (token, user_id, body) "
                "VALUES (%s, app.current_user_id(), %s)", (token, text))
        conn.commit()
    except psycopg.Error:
        conn.rollback()
        return None
    return token


def _note_take(conn, token: str) -> str | None:
    """Прочитать записку и сразу удалить. Чужая или старая — не выдаётся."""
    try:
        with conn.cursor() as cur:
            cur.execute(
                "DELETE FROM app.one_time_note WHERE token = %s "
                "RETURNING body, created_at > now() - make_interval(mins => %s) AS fresh",
                (token, NOTE_TTL_MINUTES))
            row = cur.fetchone()
        conn.commit()
    except psycopg.Error:
        conn.rollback()
        return None
    if not row or not row["fresh"]:
        return None
    return row["body"]


def _deliver_password(conn, user_id: int, email: str, full_name: str,
                      password: str, kind: str) -> tuple[str, str | None]:
    """
    Отправить пароль письмом и сказать человеку, чем дело кончилось.

    Пока почта не настроена, пароль показывается на экране один раз — иначе
    выдать доступ было бы нечем. Настройки появятся (Яндекс), и поведение
    переключится само: ничего переделывать не придётся.

    Пароль не пишется ни в журнал, ни в адрес переадресации: он живёт ровно
    один показ. Возвращает текст для адреса (без пароля) и номер одноразовой
    записки с паролем, если письмо не ушло.
    """
    subject, body = (mail.access_letter(full_name, email, password)
                     if kind == "grant"
                     else mail.new_password_letter(full_name, email, password))
    sent, why = mail.send(email, subject, body)
    webdb.log_operation(
        conn, "password_mail", None, None, 1,
        (f"Пароль выслан на {email}" if sent
         else f"Письмо на {email} не ушло: {why}"),
        #  «partial», а не «warn»: журнал операций знает только ok, error и
        #  partial. С «warn» запись падала, а вместе с ней — выдача доступа
        #  и смена пароля, пока почта не настроена (найдено 24.09.2026)
        status="ok" if sent else "partial")
    if sent:
        return f"Пароль выслан письмом на {email}", None
    token = _note_put(conn, f"Пароль для {email}: {password}")
    if token is None:
        return (f"Письмо не отправлено ({why}), и показать пароль не удалось. "
                f"Нажмите «Сменить пароль» ещё раз"), None
    return (f"Письмо не отправлено ({why}). Передайте пароль лично — он "
            f"показан ниже один раз и после обновления страницы исчезнет"), token


def _candidates_back(unit: str, msg: str = "", error: str = "",
                     cand: str = ""):
    """Назад к списку кандидатов того же депо — и в ту же подвкладку.

    30.09.2026: ошибка уходит параметром error, а не msg — раньше любая
    ошибка на «Кандидатах» (включая «Депо не выбрано» при выборе «Все РЦ»)
    показывалась зелёной плашкой успеха."""
    tail = f"/staff?tab=candidates&unit={quote(unit)}"
    if cand:
        tail += f"&cand={quote(cand)}"
    if msg:
        tail += f"&msg={quote(msg)}"
    if error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


@app.post("/budget/headcount")
def headcount_request_add(
    request: Request,
    unit: str = Form(...),
    category_id: int = Form(...),
    period: str = Form(...),
    want: str = Form(...),
    reason: str = Form(...),
):
    """
    Заявка на увеличение бюджетной численности.

    «Для приёма сверх положенной нормы должно быть получено одобрение и
    изменена численность в бюджетных настройках» — решение заказчика от
    16.09.2026.
    """
    uid = require_user(request)
    with db(uid) as conn:
        sel = _selected_unit(webdb.accessible_units(conn), unit)
        if not sel:
            raise HTTPException(403, "Депо не выбрано")
        try:
            budgetdb.add_headcount_request(
                conn, sel["id"], category_id, parse_period(period),
                Decimal(want.replace(chr(44), chr(46)).strip()), reason)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/budget?msg=" + quote(_access_error(e)), status_code=303)
    return RedirectResponse(
        "/budget?msg=" + quote("Заявка подана — ждёт решения администрации"),
        status_code=303)


@app.post("/budget/headcount/{request_id}")
def headcount_request_decide(request: Request, request_id: int,
                             approve: str = Form("1"), note: str = Form("")):
    """
    Решение по заявке. Одобрение правит план на год само — иначе между
    «одобрили» и «поправили в настройках» остаётся зазор, в котором приём
    по-прежнему не проходит.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            budgetdb.decide_headcount_request(
                conn, request_id, approve == "1", note)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/budget?msg=" + quote(_access_error(e)), status_code=303)
    return RedirectResponse(
        "/budget?msg=" + quote(
            "Численность изменена в плане" if approve == "1"
            else "Заявка отклонена"),
        status_code=303)


@app.post("/staff/candidate")
def candidate_add(
    request: Request,
    unit: str = Form(...),
    last_name: str = Form(...),
    first_name: str = Form(...),
    middle_name: str = Form(""),
    phone: str = Form(""),
    position_id: int = Form(...),
    request_no: str = Form(""),
    request_date: str = Form(""),
    note: str = Form(""),
):
    """
    Завести кандидата. Согласие на обработку персональных данных берётся на
    бумаге — решение заказчика от 16.09.2026.
    """
    uid = require_user(request)
    with db(uid) as conn:
        sel = _selected_unit(webdb.accessible_units(conn), unit)
        if not sel:
            raise HTTPException(403, "Депо не выбрано")
        try:
            staffdb.add_candidate(
                conn, unit=sel["id"], position=position_id,
                last=last_name.strip(), first=first_name.strip(),
                middle=middle_name.strip() or None,
                phone=phone.strip() or None,
                req_no=request_no.strip() or None,
                req_date=parse_day(request_date) if request_date else None,
                note=note.strip() or None)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _candidates_back(unit, error=_access_error(e))
    return _candidates_back(unit, msg="Кандидат добавлен")


@app.post("/staff/candidate/{candidate_id}/stage")
def candidate_stage(
    request: Request,
    candidate_id: int,
    stage: str = Form(...),
    on_date: str = Form(""),
    passed: str = Form("1"),
    note: str = Form(""),
):
    """
    Отметка по этапу подбора. Непройденный этап обязан быть пояснён: «не
    прошёл» без причины не отвечает на вопрос, почему.
    """
    uid = require_user(request)
    with db(uid) as conn:
        who = staffdb.candidate(conn, candidate_id)
        unit = who["unit_code"] if who else "all"
        try:
            staffdb.set_candidate_stage(
                conn, candidate_id, stage,
                parse_day(on_date) if on_date else None,
                passed == "1", note)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _candidates_back(unit, error=_access_error(e))
    return _candidates_back(unit, msg="Этап записан")


@app.post("/staff/candidate/{candidate_id}/archive")
def candidate_to_archive(request: Request, candidate_id: int,
                         note: str = Form(...)):
    """В архив — «для оцифровки и отчётности по кандидатам»."""
    uid = require_user(request)
    with db(uid) as conn:
        who = staffdb.candidate(conn, candidate_id)
        unit = who["unit_code"] if who else "all"
        try:
            staffdb.archive_candidate(conn, candidate_id, note)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _candidates_back(unit, error=_access_error(e))
    return _candidates_back(unit, msg="Кандидат убран в архив")


@app.post("/staff/{employment_id}/asset")
def staff_asset_assign(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    asset_id: int = Form(...),
    note: str = Form(""),
):
    """
    Закрепить единицу ТМЦ или техники за сотрудником.

    До 16.09.2026 такого закрепления не было вовсе: техника числилась за депо,
    и «вернуть технику» при увольнении было не о чем.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.assign_asset(conn, asset_id, employee_id, note)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="tmc")
    return _back_to_card(employment_id, tab="tmc", msg="Закреплено")


@app.post("/staff/{employment_id}/asset/return")
def staff_asset_return(request: Request, employment_id: int,
                       assignment_id: int = Form(...)):
    """Принять единицу обратно — этим и закрывается задача при увольнении."""
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.return_asset(conn, assignment_id)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="tmc")
    return _back_to_card(employment_id, tab="tmc", msg="Принято обратно")


@app.post("/staff/{employment_id}/provision")
def staff_provision(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    kind: str = Form(...),
    provided: str = Form("0"),
    note: str = Form(""),
):
    """
    Отметка «предусмотрено / не предусмотрено» — топливная карта и
    свидетельства.

    «Не предусмотрено» — это ответ, а не пробел: без него пустая графа висела
    бы задачей на доске вечно. Решение заказчика от 16.09.2026.
    """
    uid = require_user(request)
    if kind not in ("fuel", "certificate"):
        raise HTTPException(400, "Неизвестный вид отметки")
    #  02.10.2026: топливо живёт на вкладке «Фото и топливо» и ведёт его
    #  админская учётка
    tab = "extra" if kind == "fuel" else "docs"
    with db(uid) as conn:
        need = "hiring.confirm" if kind == "fuel" else "card.write"
        if not webdb.has_perm(conn, need):
            raise HTTPException(403, "Топливную карту заполняет Администрация ООУРЦ"
                                if kind == "fuel" else CARD_DENIED)
        try:
            staffdb.set_provision(conn, employee_id, kind,
                                  provided == "1", note)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e), tab=tab)
    return _back_to_card(employment_id, tab=tab, msg="Отметка сохранена")


@app.post("/staff/{employment_id}/redraft")
def staff_redraft(
    request: Request,
    employment_id: int,
    last_name: str = Form(...),
    first_name: str = Form(...),
    middle_name: str = Form(""),
    personnel_no: str = Form(...),
    position_code: str = Form(...),
    hired_at: str = Form(...),
    birth_date: str = Form(""),
    phone: str = Form(""),
    work_email: str = Form(""),
    unit: str = Form("all"),
):
    """
    Депо правит карточку приёма, возвращённую администрацией на доработку.

    «Если администрация отправляет на доработку, то рядом с карточкой
    появляется пометка, что именно необходимо поправить» (22.09.2026). Чтобы
    пометка имела смысл, поправить должно быть чем: без этой формы возврат
    упирался бы в тупик — сказать есть кому, исправить некому.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.update_draft_hire(
                conn, employment_id,
                last_name=last_name, first_name=first_name,
                middle_name=middle_name or None,
                personnel_no=personnel_no.strip(),
                position_code=position_code,
                hired_at=parse_day(hired_at),
                birth_date=parse_day(birth_date) if birth_date else None,
                phone=phone or None, work_email=work_email or None,
            )
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _candidates_back(unit, error=_access_error(e), cand="review")
    return _candidates_back(
        unit, cand="review",
        msg="Карточка исправлена и снова ждёт проверки администрации")


@app.post("/staff/{employment_id}/depot-account")
def staff_depot_account(request: Request, employment_id: int,
                        login: str = Form(...)):
    """
    02.10.2026 (правка заказчика, вопрос 2.3): учётку новому сотруднику
    заводит начальник/заместитель своего депо. Учётка лежит отключённой
    и без пароля; подтверждение трудоустройства её включает, роль и пароль
    задаёт Администрация. Всё, кроме показа, проверяет база
    (app.create_depot_account, миграция 104).
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.create_depot_account(conn, employment_id, login)
            webdb.log_operation(
                conn, "staff.depot_account", None, None, 1,
                f"Учётка {login.strip().lower()} заведена депо — включится "
                f"подтверждением трудоустройства",
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_to_card(employment_id, error=msg, tab="main")
    return _back_to_card(
        employment_id,
        msg="Учётка заведена и ждёт подтверждения трудоустройства. "
            "Пароль задаст Администрация ООУРЦ после подтверждения",
        tab="main")


@app.post("/staff/{employment_id}/confirm")
def staff_confirm(request: Request, employment_id: int,
                  confirm_headcount: str = Form("")):
    """
    Подтвердить трудоустройство, оформленное депо.

    Подтверждение включает учётную запись: до него человек в приложение не
    входит. Решение заказчика от 16.09.2026.

    02.10.2026: численность перепроверяется на момент подтверждения — за
    время проверки могли принять ещё кого-то. Превышение подтверждается
    только галочкой «подтверждаю приём сверх численности».
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            hc = staffdb.headcount_for_employment(conn, employment_id)
            if hc and hc["over"] and confirm_headcount != "yes":
                raise ValueError(
                    f"Приём сверх численности: план {hc['plan']}, на "
                    f"{hc['date']:%d.%m.%Y} занято {hc['occupied']} без этого "
                    f"сотрудника. Отметьте «подтверждаю приём сверх "
                    f"численности» или верните карточку депо")
            staffdb.confirm_employment(conn, employment_id)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/staff?tab=pending&error=" + quote(_access_error(e)),
                status_code=303)
    return RedirectResponse(
        "/staff?tab=pending&msg=" + quote(
            "Трудоустройство подтверждено, доступ открыт"), status_code=303)


@app.post("/staff/{employment_id}/return")
def staff_return(request: Request, employment_id: int,
                 reason: str = Form(...)):
    """Вернуть трудоустройство на доработку — когда данные внесены неверно."""
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.return_employment(conn, employment_id, reason)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/staff?tab=pending&error=" + quote(_access_error(e)),
                status_code=303)
    return RedirectResponse(
        "/staff?tab=pending&msg=" + quote("Возвращено на доработку"),
        status_code=303)


@app.post("/staff/{employment_id}/hire-cancel")
def staff_hire_cancel(request: Request, employment_id: int,
                      reason: str = Form(...)):
    """
    Отменить неподтверждённый приём целиком (вычитка 2.25).

    Ошибочный приём, оформленный депо, раньше можно было убрать только
    увольнением — с задачами на расчёт и приёмом СИЗ. Теперь назначение
    удаляется, кандидат уходит в архив с причиной, ТСД и доступ закрываются.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.cancel_unconfirmed_hire(conn, employment_id, reason)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/staff?tab=pending&error=" + quote(_access_error(e)),
                status_code=303)
    return RedirectResponse(
        "/staff?tab=pending&msg=" + quote(
            "Приём отменён, кандидат в архиве"), status_code=303)


#  Окончательный расчёт как последний шаг увольнения (22.09.2026). Три
#  действия на один и тот же список: депо отправляет, администрация принимает
#  или возвращает. Все три возвращают во вкладку «Заявки» — туда, где список
#  и живёт.
_SETTLEMENT_ACTIONS = {
    "submit": "Окончательный расчёт отправлен администрации",
    "accept": "Расчёт принят, сотрудник переведён в уволенные",
    "reject": "Расчёт возвращён депо",
    "tsd": "Сдача ТСД подтверждена",
}


@app.post("/staff/{employment_id}/settlement/{action}")
def staff_settlement(request: Request, employment_id: int, action: str,
                     reason: str = Form(""), unit: str = Form("all"),
                     back_to: str = Form("")):
    """
    Последний шаг увольнения: расчёт уходит от депо к администрации.

    Пока он не принят, человек остаётся во вкладке «Заявки» — так решил
    заказчик: «сотрудник не попадает в "Уволенные", а остаётся в "Заявки"…
    после того, как депо отправит окончательный расчёт и администрация его
    примет, только тогда сотрудник попадает во вкладку "Уволенные"».
    """
    if action not in _SETTLEMENT_ACTIONS:
        raise HTTPException(404, "Неизвестное действие")
    uid = require_user(request)
    back = f"/staff?tab=requests&unit={quote(unit)}&msg="
    #  Со страницы расчёта возвращаемся на неё же — только на свою страницу,
    #  чужой адрес в форме не принимаем
    if back_to.startswith(f"/settlement/{employment_id}"):
        back = back_to + ("&" if "?" in back_to else "?") + "msg="
    with db(uid) as conn:
        try:
            if action == "tsd":
                staffdb.confirm_tsd_return(conn, employment_id)
            elif action == "submit":
                staffdb.submit_settlement(conn, employment_id, reason or None)
            elif action == "accept":
                staffdb.accept_settlement(conn, employment_id)
            else:
                staffdb.return_settlement(conn, employment_id, reason)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(back + quote(_access_error(e)),
                                    status_code=303)
    return RedirectResponse(back + quote(_SETTLEMENT_ACTIONS[action]),
                            status_code=303)


@app.post("/staff/reset/{request_id}/reject")
def staff_reset_reject(request: Request, request_id: int,
                       note: str = Form("")):
    """
    Отклонить заявку «Забыли пароль?».

    Нужна, когда заявка пришла с чужого или ошибочного адреса: закрывать её
    сменой пароля в этом случае нечему.
    """
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.reject_reset_request(conn, request_id,
                                         note or "Отклонена без пояснения")
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return RedirectResponse(
                "/staff?tab=passwords&msg=" + quote(_access_error(e)),
                status_code=303)
    return RedirectResponse(
        "/staff?tab=passwords&msg=" + quote("Заявка отклонена"),
        status_code=303)


def _check_role_unit_matches(conn, employee_id: int | None, role_code: str,
                             org_unit_id: int | None) -> None:
    """
    30.09.2026 (вычитка 1.24, «Город роли не сверяется с депо сотрудника»):
    для ролей депо город роли обязан совпадать с депо, где человек работает.
    Раньше начальнику из Барановичей выдавалась роль с городом «Гомель» —
    база это пропускала, и человек оставался без данных своего депо.
    """
    if not employee_id:
        return
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.unit_scoped,
                   %(unit)s::bigint AS role_unit,
                   w.org_unit_id AS work_unit, w.unit_name AS work_unit_name
            FROM app.role r
            LEFT JOIN LATERAL (
                SELECT e.org_unit_id, ou.name AS unit_name
                FROM app.employment e
                JOIN app.org_unit ou ON ou.id = e.org_unit_id
                WHERE e.employee_id = %(emp)s AND e.terminated_at IS NULL
                ORDER BY e.id DESC LIMIT 1
            ) w ON true
            WHERE r.code = %(role)s
            """,
            {"unit": org_unit_id, "emp": employee_id, "role": role_code})
        row = cur.fetchone()
    if not row or not row["unit_scoped"] or row["work_unit"] is None:
        return
    if row["role_unit"] != row["work_unit"]:
        raise ValueError(
            "Город роли не совпадает с депо сотрудника: человек работает "
            f"в «{row['work_unit_name']}» — выдайте роль с этим городом")


@app.post("/staff/{employment_id}/access/grant")
def staff_access_grant(
    request: Request,
    employment_id: int,
    employee_id: int = Form(...),
    email: str = Form(...),
    role_code: str = Form(...),
    org_unit_id: str = Form(""),
):
    uid = require_user(request)
    password = staffdb.new_password()
    with db(uid) as conn:
        try:
            _check_role_unit_matches(conn, employee_id, role_code,
                                     _access_unit(org_unit_id))
            user_id = staffdb.grant_access(conn, employee_id, email, password,
                                           role_code, _access_unit(org_unit_id))
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
        who = staffdb.app_account(conn, employee_id)
        note, token = _deliver_password(conn, user_id, email,
                                        (who or {}).get("full_name") or "Сотрудник",
                                        password, "grant")
    return _back_to_card(employment_id, tab="main", msg="Доступ выдан. " + note,
                         note=token)


@app.post("/staff/{employment_id}/access/role")
def staff_access_role(
    request: Request,
    employment_id: int,
    user_id: int = Form(...),
    role_code: str = Form(...),
    org_unit_id: str = Form(""),
):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            #  30.09.2026: сверяем город роли с депо сотрудника и при смене
            #  роли — сотрудник ищется по учётной записи
            acc = staffdb.app_account_by_user(conn, user_id)
            _check_role_unit_matches(
                conn, (acc or {}).get("employee_id"), role_code,
                _access_unit(org_unit_id))
            staffdb.set_role(conn, user_id, role_code,
                             _access_unit(org_unit_id))
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
    return _back_to_card(employment_id, tab="main",
                         msg="Роль записана. Прежняя закрыта датой и осталась "
                             "в истории")


@app.post("/staff/{employment_id}/access/email")
def staff_access_email(
    request: Request,
    employment_id: int,
    user_id: int = Form(...),
    email: str = Form(...),
):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.set_user_email(conn, user_id, email)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
    return _back_to_card(employment_id, tab="main",
                         msg="Логин изменён. Прежний больше не работает — "
                             "предупредите сотрудника")


@app.post("/staff/{employment_id}/access/password")
def staff_access_password(
    request: Request,
    employment_id: int,
    user_id: int = Form(...),
):
    uid = require_user(request)
    password = staffdb.new_password()
    with db(uid) as conn:
        try:
            staffdb.set_user_password(conn, user_id, password)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
        acc = staffdb.app_account_by_user(conn, user_id)
        note, token = _deliver_password(conn, user_id, acc["email"],
                                        acc["full_name"], password, "reset")
        #  Заявка «Забыли пароль?» разобрана ровно тогда, когда пароль сменён
        closed = staffdb.close_reset_requests_for(conn, user_id)
    return _back_to_card(
        employment_id, tab="main",
        msg=("Пароль заменён. " + note
             + (" Заявка на смену закрыта." if closed else "")),
        note=token)


@app.post("/staff/{employment_id}/access/revoke")
def staff_access_revoke(
    request: Request,
    employment_id: int,
    user_id: int = Form(...),
):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            staffdb.revoke_access(conn, user_id)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
    return _back_to_card(employment_id, tab="main",
                         msg="Доступ отозван: войти этой учётной записью "
                             "больше нельзя")


@app.post("/staff/{employment_id}/access/restore")
def staff_access_restore(
    request: Request,
    employment_id: int,
    user_id: int = Form(...),
    role_code: str = Form(...),
    org_unit_id: str = Form(""),
):
    uid = require_user(request)
    #  «Предусмотреть при отмене увольнения отправку нового пароля от учётной
    #  записи» — решение заказчика от 16.09.2026. Прежний пароль за время
    #  отзыва мог разойтись по чужим рукам, и возвращать доступ с ним значит
    #  возвращать не только доступ
    password = staffdb.new_password()
    with db(uid) as conn:
        try:
            #  30.09.2026: возврат доступа и смена пароля — одной транзакцией.
            #  Раньше шаги коммитились по отдельности: сорвись смена пароля,
            #  доступ возвращался со старым — вопреки решению от 16.09.2026
            acc0 = staffdb.app_account_by_user(conn, user_id)
            _check_role_unit_matches(
                conn, (acc0 or {}).get("employee_id"), role_code,
                _access_unit(org_unit_id))
            staffdb.restore_access_with_password(
                conn, user_id, role_code, _access_unit(org_unit_id), password)
        except (psycopg.Error, ValueError) as e:
            conn.rollback()
            return _back_to_card(employment_id, error=_access_error(e),
                                 tab="main")
        acc = staffdb.app_account_by_user(conn, user_id)
        note, token = _deliver_password(conn, user_id, acc["email"],
                                        acc["full_name"], password, "reset")
    return _back_to_card(employment_id, tab="main",
                         msg="Доступ возвращён. " + note, note=token)


# ---------------------------------------------------------------------------
#  Базовые настройки
#
#  Вводные данные расчёта, которые нельзя вывести из кода: норма рабочего
#  времени по месяцам (её устанавливает Минтруда, статья 124 ТК), особые дни
#  года, ставки за операции, показатели KPI и оклады.
#
#  Раздел доступен только с правом reference.write — у начальника РЦ его нет.
# ---------------------------------------------------------------------------

#  Базовые настройки сгруппированы по блокам работ — пункт 25 плана от
#  14.09.2026. Плоским списком из семи вкладок было непонятно, почему
#  «Оклады» стоят рядом с «Обозначениями табеля»: связь настройки с
#  разделом, который её использует, ниоткуда не читалась.
#
#  Теперь группа называется так же, как раздел приложения, и в неё входит
#  ровно то, чем этот раздел живёт: расписание считает норму и пишет
#  обозначения, кадры заводят должности и выдают СИЗ, мотивация платит по
#  окладам, ставкам и показателям.
SETTINGS_GROUPS = [
    ("Расписание", [
        ("norm", "Норма рабочего времени"),
        ("codes", "Обозначения табеля"),
    ]),
    ("Сотрудники", [
        ("positions", "Должности и справочники"),
    ]),
    ("Мотивация", [
        ("salary", "Оклады"),
        ("rates", "Ставки за операции"),
        ("kpi", "Показатели KPI"),
    ]),
    ("Обеспечение", [
        #  06.10.2026 (правка заказчика): три вкладки СИЗ переехали из
        #  «Сотрудников» в «Обеспечение» — они про снабжение, а не про кадры
        ("ppe", "Нормы выдачи СИЗ"),
        #  05.10.2026 (правка заказчика): типоразмерные карточки СИЗ
        ("ppe_base", "База СИЗ"),
        #  06.10.2026 (правка заказчика): импорт остатков МБП — своя вкладка,
        #  слова фильтра и история загрузок переехали с «Базы СИЗ»
        ("ppe_mbp", "Остатки МБП"),
        ("asset_kinds", "Виды ТМЦ и техники"),
        #  Данные заказчика от 21.09.2026: шесть организаций, у двух вместо
        #  телефона почта — поэтому в справочнике оба поля
        ("contractors", "Подрядчики"),
        #  Кабинет ОЗ (вычитка 30.09.2026, волна 4б): сколько поставок в
        #  день принимает каждое депо — база расчёта мощностей
        ("purchase", "Поставки"),
    ]),
    ("Бюджет", [
        ("budget_plan", "План на год"),
    ]),
    #  Системные настройки не относятся ни к одному блоку работ: они про
    #  саму систему, а не про то, что в ней ведут. Поэтому своя группа, а не
    #  приткнутая вкладка в чужой
    ("Система", [
        ("system", "Системные"),
        ("roles", "Роли и права"),
    ]),
]

#  Плоский список остаётся: по нему проверяется код вкладки из адреса, и
#  собирать его в двух местах руками — верный способ разойтись
SETTINGS_TABS = [tab for _, tabs in SETTINGS_GROUPS for tab in tabs]

#  Вкладка показателей — сама двухуровневая: список, веса, правка.
#  Раньше все три блока лежали на одной странице, и до формы нового
#  показателя приходилось прокручивать всю шкалу всех показателей.
KPI_SUBTABS = [
    ("list", "Общий список"),
    ("weights", "Веса по категориям должностей"),
    ("funds", "Фонды КПИ по депо"),
    ("edit", "Добавить и изменить"),
]

templates.env.globals["REPAIR_PROBLEMS"] = supplydb.REPAIR_PROBLEMS
templates.env.globals["UNIT_RU"] = settingsdb.UNIT_RU
templates.env.globals["BETTER_RU"] = settingsdb.BETTER_RU
templates.env.globals["KPI_SUBTABS"] = KPI_SUBTABS
templates.env.globals["SETTINGS_GROUPS"] = SETTINGS_GROUPS

DAY_TYPE_RU = {
    "work": "рабочий",
    "weekend": "выходной",
    "holiday": "праздничный",
    "preholiday": "предпраздничный",
}
templates.env.globals["DAY_TYPE_RU"] = DAY_TYPE_RU


def settings_context(conn, uid: int) -> dict[str, Any]:
    user = webdb.current_user(conn, uid)
    if not webdb.has_perm(conn, "reference.write"):
        raise HTTPException(403, "Базовые настройки ведёт администрация")
    units = webdb.accessible_units(conn)
    today = date.today()
    return {
        "user": user,
        "units": units,
        "unit": None,
        "period_iso": f"{today:%Y-%m}",
        "mode": "settings",
        "tabs": SETTINGS_TABS,
        "today": today,
        "today_iso": today.isoformat(),
        "open_requests": webdb.open_staff_requests(conn),
        "can_reference": True,
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
    }


def _weights_by_category(
    rows: list[dict[str, Any]], categories: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    """
    Веса по категориям должностей — сгруппированно, с суммой по категории.

    Сумма важна: вес — доля показателя в премии, и если по категории вышло
    не 1, премия посчитается не полностью или больше положенного. Плоский
    список это не показывал — теперь видно сразу.
    """
    out = []
    for cat in categories:
        # Ключ намеренно не «items»: в шаблоне g.items Jinja разбирает как
        # метод словаря, а не как значение по ключу.
        mine = [r for r in rows if r["category_id"] == cat["id"]]
        total = round(sum(float(r["weight"]) for r in mine), 4)
        out.append({
            "category": cat,
            "rows": mine,
            "total": total,
            "ok": bool(mine) and abs(total - 1) < 1e-6,
        })
    return out


def _funds_by_unit(
    rows: list[dict[str, Any]], units: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    """
    Фонды КПИ — таблицей «депо × категория должностей».

    Плоским списком из сорока восьми строк это нечитаемо, а различаются
    фонды именно по депо: четыре группы на двенадцать РЦ. Строка заводится
    на каждое депо, даже если фондов у него нет: пустая клетка значит, что
    премия по этой паре не посчитается, и видно это должно быть здесь, а не
    по нулю в расчёте.
    """
    by_unit = {
        u["id"]: {
            "unit_id": u["id"], "unit_code": u["code"],
            "unit_name": u["name"], "cells": {},
        }
        for u in units
    }
    for r in rows:
        target = by_unit.get(r["unit_id"])
        if target is not None:
            target["cells"][r["category_id"]] = r
    return sorted(by_unit.values(), key=lambda u: u["unit_name"])


def _norms_by_category(
    rows: list[dict[str, Any]], categories: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    """
    Нормы выдачи СИЗ по категориям должностей.

    Категория без нормы остаётся в списке пустой: это не «нет данных», а
    незаполненный документ — работникам этой категории выдавать нечего, и
    видно это должно быть сразу, а не по отсутствию заголовка.

    Ключ «rows», не «items»: g.items в Jinja разбирается как метод словаря.
    """
    return [
        {
            "category": cat,
            "rows": [r for r in rows if r["position_category_id"] == cat["id"]],
        }
        for cat in categories
    ]


def _settings_back(
    tab: str,
    year: int | None = None,
    msg: str = "",
    error: str = "",
    sub: str = "",
    kpi: int | None = None,
):
    tail = f"/settings?tab={tab}"
    if year:
        tail += f"&year={year}"
    if sub:
        tail += f"&sub={sub}"
    if kpi:
        tail += f"&kpi={kpi}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


@app.get("/settings", response_class=HTMLResponse)
def settings_page(
    request: Request,
    tab: str = "norm",
    year: int | None = None,
    on: str | None = None,
    edit: int | None = None,
    sub: str | None = None,
    kpi: int | None = None,
    plan_month: int | None = None,
    msg: str | None = None,
    error: str | None = None,
):
    uid = require_user(request)
    if tab not in dict(SETTINGS_TABS):
        tab = "norm"
    if tab == "kpi" and sub not in dict(KPI_SUBTABS):
        sub = "list"

    with db(uid) as conn:
        ctx = settings_context(conn, uid)
        y = year or date.today().year
        on_date = parse_day(on) if on else date.today()
        ctx.update({
            "tab": tab, "sub": sub, "year": y, "on_date": on_date,
            "on_date_iso": on_date.isoformat(),
            "msg": msg, "error": error, "edit_position": edit,
            "years": work_years(y, *settingsdb.norm_years(conn)),
        })

        if tab == "system":
            ctx["app_settings"] = settingsdb.app_settings_view(conn)
        elif tab == "roles":
            ctx["matrix"] = settingsdb.roles_matrix(conn)
            #  Смотреть можно всем, у кого открыты настройки: понимать, кто
            #  что может, полезно и без права это менять
            ctx["can_manage_roles"] = webdb.has_perm(conn, "user.manage")
        elif tab == "asset_kinds":
            #  Реестр: виды по группам и производители (22.09.2026). Виды
            #  берём все, включая закрытые: их надо видеть, чтобы вернуть
            ctx["asset_kinds"] = settingsdb.all_asset_kinds(conn)
            ctx["asset_groups"] = supplydb.groups(conn)
            ctx["asset_models"] = supplydb.models(conn)
            #  02.10.2026 (вычитка 5.5): код депо в инвентарном номере
            with conn.cursor() as cur:
                cur.execute(
                    "SELECT id, name, inventory_prefix FROM app.org_unit "
                    "WHERE kind = 'rc' AND is_active "
                    "ORDER BY inventory_prefix NULLS LAST, name")
                ctx["inv_units"] = cur.fetchall()
        elif tab == "contractors":
            #  Справочник подрядчиков и признак «годится для непродления»
            #  у причин увольнения — оба по данным от 21.09.2026
            ctx["contractors"] = settingsdb.contractors(conn)
            #  02.10.2026 (вычитка 5.20): виды ТО и кто их проводит
            ctx["maint_types"] = supplydb.maintenance_types(conn)
            ctx["maint_cats"] = [c for c in supplydb.categories(conn, kind="equipment")]
        elif tab == "budget_plan":
            #  Год берётся из адреса: план заводят на следующий, а открывается
            #  страница в текущем, и каждый раз переключать было бы мучением
            ctx["plan_year"] = y
            #  Месяц по умолчанию январь: план вводят сразу на год, и январь
            #  здесь значит «то, что разольётся на все двенадцать»
            plan_month = min(12, max(1, plan_month or 1))
            ctx["plan_month"] = plan_month
            ctx["grid"] = budgetdb.plan_grid(conn, y, plan_month)
            ctx["versions"] = budgetdb.plan_versions(conn, y)
            ctx["plan_ready"] = budgetdb.has_plan(conn)
            ctx["plan_years"] = budgetdb.plan_years(conn)
        elif tab == "norm":
            months = settingsdb.norm_year(conn, y)
            ctx["months"] = months
            # Код обновился, а база — нет: страницу показываем, но правку
            # закрываем и говорим, что запустить
            ctx["norm_editable"] = settingsdb.norm_is_editable(conn)
            ctx["norm_total_40"] = round(
                sum(float(m["norm_hours_40"] or 0) for m in months), 2)
            ctx["norm_total_35"] = round(
                sum(float(m["norm_hours_35"] or 0) for m in months), 2)
            ctx["days_work_total"] = sum(int(m["days_work"] or 0) for m in months)
            ctx["special"] = settingsdb.special_days(conn, y)
        elif tab == "positions":
            ctx["positions"] = settingsdb.positions(conn)
            #  Причины увольнения и непродления переехали сюда из вкладки
            #  «Подрядчики» (23.09.2026): это кадровый справочник
            ctx["reasons"] = settingsdb.termination_reasons_all(conn)
            ctx["categories"] = settingsdb.position_categories(conn)
            ctx["cert_types"] = settingsdb.ref_types(conn, "certificate")
            ctx["exam_types"] = settingsdb.ref_types(conn, "medical")
            ctx["brief_types"] = settingsdb.ref_types(conn, "briefing")
            # Матрица «вид инструктажа × должность»: кому что проводится
            ctx["brief_matrix"] = settingsdb.briefing_matrix(conn)
        elif tab == "codes":
            codes = settingsdb.day_codes(conn)
            ctx["codes"] = codes
            ctx["code_groups"] = _group_codes(codes)
        elif tab == "rates":
            ctx["operations"] = settingsdb.operation_types(conn)
            ctx["rates"] = settingsdb.operation_rates(conn, on_date)
        elif tab == "kpi":
            ctx["kpis"] = settingsdb.kpi_list(conn, on_date)
            ctx["categories"] = settingsdb.position_categories(conn)
            if sub == "list":
                ctx["scales"] = {
                    k["id"]: settingsdb.kpi_scale(conn, k["id"], on_date)
                    for k in ctx["kpis"]
                }
            elif sub == "weights":
                ctx["weight_groups"] = _weights_by_category(
                    settingsdb.kpi_weights(conn, on_date),
                    ctx["categories"],
                )
            elif sub == "funds":
                ctx["fund_rows"] = _funds_by_unit(
                    settingsdb.kpi_funds(conn, on_date), ctx["units"])
            else:
                # Правка: показатель либо выбран, либо форма пустая — новый
                ctx["kpi_edit"] = settingsdb.kpi_one(conn, kpi) if kpi else None
                ctx["kpi_steps"] = (
                    settingsdb.kpi_scale(conn, kpi, on_date) if kpi else []
                )
        elif tab == "ppe":
            ctx["categories"] = settingsdb.position_categories(conn)
            ctx["norm_groups"] = _norms_by_category(
                settingsdb.ppe_norms(conn, on_date), ctx["categories"]
            )
            ctx["ppe_kinds"] = settingsdb.PPE_KINDS
            ctx["norm_edit"] = (
                settingsdb.ppe_norm_one(conn, edit) if edit else None
            )
            ctx["chief_units"] = settingsdb.units_with_chief(conn)
            #  «Доработка 2» (25.09.2026): комиссия по осмотру СИЗ по депо
            ctx["commissions"] = settingsdb.ppe_commissions(conn)
        elif tab == "ppe_base":
            #  Карточки СИЗ с матрицами типоразмеров (06.10.2026, правка
            #  заказчика): семь вкладок, правится артикул 1С:УТ
            ctx["size_cards"] = settingsdb.ppe_size_cards(conn)
            codes = {c["code"] for c in ctx["size_cards"]}
            if sub not in codes:
                sub = (ctx["size_cards"][0]["code"]
                       if ctx["size_cards"] else "")
            ctx["size_sub"] = sub
            rows = settingsdb.ppe_size_rows(conn, sub) if sub else []
            ctx["size_rows"] = rows
            ctx["size_matrix"] = settingsdb.ppe_size_matrix(rows)
            #  07.10.2026 (№2 «Путь СИЗ»): карточка «Иное» — перечень
            #  произвольной номенклатуры вместо матрицы типоразмеров
            ctx["other_items"] = (settingsdb.ppe_other_items(conn)
                                  if sub == "other" else [])
        elif tab == "ppe_mbp":
            #  Остатки МБП (06.10.2026): загрузка из 1С УТ и история
            #  загрузок. 07.10.2026: слова фильтра убраны — позиция файла
            #  сопоставляется с Базой СИЗ по артикулу
            ctx["ppe_base_loads"] = settingsdb.ppe_base_loads(conn)
        elif tab == "purchase":
            #  Лимит поставок в день по каждому депо (волна 4б): на нём
            #  держится ограничение выбора даты в кабинете ОЗ
            with conn.cursor() as cur:
                cur.execute(
                    "SELECT id, code, name, supply_per_day FROM app.org_unit "
                    "WHERE kind = 'rc' AND is_active ORDER BY name")
                ctx["purchase_units"] = cur.fetchall()
        else:
            ctx["salaries"] = settingsdb.salaries(conn, on_date)

    return templates.TemplateResponse(request, "settings.html", ctx)


@app.post("/settings/norm")
async def settings_norm_save(request: Request):
    """
    Сохранить норму года целиком: двенадцать строк одной формой.

    Правится обычно весь год сразу — по бумаге из Минтруда, — поэтому
    построчных кнопок «сохранить» здесь нет.
    """
    uid = require_user(request)
    form = await request.form()
    year = int(form["year"])

    def num(name: str, default: float = 0) -> float:
        raw = (form.get(name) or "").strip().replace(",", ".")
        return float(raw) if raw else default

    with db(uid) as conn:
        settings_context(conn, uid)          # проверка права
        if not settingsdb.norm_is_editable(conn):
            return _settings_back(
                "norm", year,
                error=("База отстала от кода: не хватает колонок из миграции "
                       "07_base_settings.sql. Закройте окно сервера и запустите "
                       "update_db.cmd, потом start_app.cmd"),
            )
        try:
            saved = 0
            for month in range(1, 13):
                n40 = num(f"n40_{month}")
                n35 = num(f"n35_{month}")
                if n40 <= 0 and n35 <= 0:
                    continue                 # месяц не заполнен — пропускаем
                settingsdb.save_norm_month(
                    conn, uid, year, month,
                    norm_hours_40=n40,
                    norm_hours_35=n35 or round(n40 * 7 / 8, 2),
                    days_calendar=int(num(f"dc_{month}",
                                          calendar.monthrange(year, month)[1])),
                    days_work=int(num(f"dw_{month}")),
                    days_preholiday=int(num(f"dp_{month}")),
                    days_off=int(num(f"do_{month}")),
                    days_holiday=int(num(f"dh_{month}")),
                    note=(form.get(f"note_{month}") or "").strip() or None,
                )
                saved += 1
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("norm", year, error=msg)

    return _settings_back("norm", year, msg=f"Норма сохранена, месяцев: {saved}")


@app.post("/settings/day")
async def settings_day_save(
    request: Request,
    day: str = Form(...),
    day_type: str = Form(...),
    year: int = Form(...),
):
    """Особый день года: праздничный, предпраздничный или обычный."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        d = parse_day(day)
        try:
            if day_type == "reset":
                settingsdb.reset_day_type(conn, d)
                what = "вернулся к обычному"
            else:
                if day_type not in DAY_TYPE_RU:
                    raise ValueError(f"Неизвестный тип дня: {day_type}")
                settingsdb.set_day_type(conn, d, day_type)
                what = DAY_TYPE_RU[day_type]
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("norm", year, error=msg)
    return _settings_back("norm", year, msg=f"{d:%d.%m.%Y} — {what}")


@app.post("/settings/position")
async def settings_position_save(
    request: Request,
    position_id: str = Form(""),
    code: str = Form(...),
    name: str = Form(...),
    category_id: int = Form(...),
    note: str = Form(""),
    sort_order: str = Form("100"),
    is_active: str = Form(""),
):
    """
    Должность: добавить новую или поправить существующую.

    Ненужную можно либо выключить — она исчезает из выбора при приёме и
    переводе, а история остаётся читаемой, — либо убрать совсем, переведя
    людей на другую должность категории (см. /settings/position/delete).
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.save_position(
                conn,
                position_id=int(position_id) if position_id else None,
                code=code, name=name, category_id=category_id,
                note=note.strip() or None,
                is_active=is_active == "1",
                sort_order=int(sort_order or 100),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            if "position_code_key" in str(e):
                msg = f"Должность с кодом «{code}» уже есть"
            return _settings_back("positions", error=msg)
    return _settings_back("positions", msg=f"Должность «{name}» сохранена")


def _matrix_pairs(values: list[Any]) -> set[tuple[int, int]]:
    """
    Галочки матрицы приходят строками «вид:должность» — разбираем в пары.

    Мусор молча пропускаем: это значения из формы, а не из базы, и падать
    на подделанном поле незачем — достаточно его не учесть.
    """
    pairs: set[tuple[int, int]] = set()
    for raw in values:
        left, _, right = str(raw).partition(":")
        if left.isdigit() and right.isdigit():
            pairs.add((int(left), int(right)))
    return pairs


@app.post("/settings/briefing-matrix")
async def settings_briefing_matrix(request: Request):
    """
    Кому какой инструктаж требуется: галочки «вид × должность».

    Приходит полный набор отмеченных клеток, поэтому и записывается он
    целиком: снятая галочка должна означать «не требуется», а не «оставить
    как было».
    """
    uid = require_user(request)
    form = await request.form()
    pairs = _matrix_pairs(form.getlist("need"))

    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            changed = settingsdb.save_briefing_matrix(conn, pairs, uid)
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("positions", error=msg)
    if not changed:
        return _settings_back("positions", msg="Ничего не изменилось")
    return _settings_back("positions", msg=f"Изменено отметок: {changed}")


@app.post("/settings/position/delete")
async def settings_position_delete(
    request: Request,
    position_id: int = Form(...),
    move_to: int = Form(...),
):
    """
    Убрать должность из справочника, переведя людей на другую.

    Так убираются лишние названия одного и того же места — например разряды
    кладовщика, когда принят единый формат должностей как в окладах. Ссылки
    из назначений, расчётов и кандидатов переводятся на указанную должность,
    поэтому история не рвётся: у человека меняется название должности, а часы
    и даты остаются.
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            gone, moved = settingsdb.delete_position(
                conn, position_id=position_id, move_to_id=move_to
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("positions", error=msg)
    tail = f", переведено сотрудников: {moved}" if moved else ""
    return _settings_back("positions", msg=f"Должность «{gone}» убрана{tail}")


@app.post("/settings/ref/{kind}")
async def settings_ref_save(
    kind: str,
    request: Request,
    type_id: str = Form(""),
    code: str = Form(...),
    name: str = Form(...),
    note: str = Form(""),
    sort_order: str = Form("100"),
    is_active: str = Form(""),
):
    """Вид свидетельства или медосмотра — на случай, если появится новый."""
    uid = require_user(request)
    if kind not in settingsdb.REF_TABLES:
        raise HTTPException(404, "Неизвестный справочник")
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.save_ref_type(
                conn, kind,
                type_id=int(type_id) if type_id else None,
                code=code, name=name, note=note.strip() or None,
                is_active=is_active == "1",
                sort_order=int(sort_order or 100),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("positions", error=msg)
    return _settings_back("positions", msg=f"Сохранено: «{name}»")


@app.post("/settings/ppe-norm")
async def settings_ppe_norm_save(
    request: Request,
    norm_id: str = Form(""),
    category_id: int = Form(...),
    ppe_kind: str = Form(...),
    item_name: str = Form(...),
    classification: str = Form(""),
    qty: str = Form("1"),
    wear_period_months: str = Form(""),
    condition_note: str = Form(""),
    sort_order: str = Form("100"),
    valid_from: str = Form(...),
    no_size: str = Form(""),
):
    """
    Строка нормы выдачи СИЗ: что положено категории должностей и на сколько.

    Срок носки пустой — «до износа». Это не то же самое, что ноль: у выданного
    «до износа» даты замены нет вовсе, а ноль означал бы «менять сегодня».
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.save_ppe_norm(
                conn,
                norm_id=int(norm_id) if norm_id else None,
                category_id=category_id,
                ppe_kind=ppe_kind,
                item_name=item_name,
                classification=classification,
                qty=float(qty.replace(",", ".") or 1),
                wear_period_months=(
                    int(wear_period_months) if wear_period_months.strip() else None
                ),
                condition_note=condition_note,
                sort_order=int(sort_order or 100),
                valid_from=parse_day(valid_from),
                no_size=bool(no_size),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg=f"Норма сохранена: «{item_name}»")


@app.post("/settings/ppe-norm/close")
async def settings_ppe_norm_close(
    request: Request,
    norm_id: int = Form(...),
    valid_to: str = Form(...),
):
    """
    Закрыть строку нормы датой: с этого дня средство больше не положено.

    Удаления здесь нет намеренно. Норма — основание выдачи, и по ней потом
    объясняют, почему работнику выдали именно это. Удалённая строка оставила
    бы выданное без основания.
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.close_ppe_norm(conn, norm_id, parse_day(valid_to))
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg="Строка нормы закрыта")


@app.post("/settings/ppe-chief")
async def settings_ppe_chief_save(
    request: Request,
    unit_id: int = Form(...),
    chief_position: str = Form(""),
    chief_name: str = Form(""),
):
    """Кто на депо подписывает ведомость как лицо, выдавшее СИЗ."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.set_unit_chief(
                conn, unit_id=unit_id,
                chief_position=chief_position, chief_name=chief_name,
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg="Подписант ведомостей сохранён")


@app.post("/settings/ppe-commission")
async def settings_ppe_commission_save(request: Request):
    """
    Комиссия по осмотру СИЗ на депо (25.09.2026, «Доработка 2»): председатель
    и члены. Подставляются в акт осмотра на продление срока носки.
    """
    uid = require_user(request)
    form = await request.form()
    try:
        unit_id = int(form.get("unit_id") or 0)
    except ValueError:
        unit_id = 0
    names = form.getlist("member_name")
    positions = form.getlist("member_position")
    members = list(zip(names, positions + [""] * (len(names) - len(positions))))
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Комиссию ведёт Администрация ООУРЦ")
        try:
            settingsdb.save_ppe_commission(
                conn, unit_id, form.get("chair_name", ""),
                form.get("chair_position", ""), members)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg="Комиссия сохранена")


@app.post("/settings/ppe-base/add")
async def settings_ppe_base_add(request: Request):
    """
    Позиция «Базы СИЗ» (вычитка 30.09.2026): наименование + одна из шести
    групп. Если наименование уже выдавалось — позиция просто получает
    группу, и выдачи с ней попадают в выбор базы.
    """
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочник ведёт Администрация ООУРЦ")
        try:
            settingsdb.ppe_base_add_item(
                conn, form.get("name", ""), form.get("group", ""))
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg="Позиция добавлена в справочник базы")


@app.post("/settings/ppe-base/group")
async def settings_ppe_base_group(request: Request):
    """Перенести позицию в другую группу или убрать из базы."""
    uid = require_user(request)
    form = await request.form()
    item_id = int(form.get("item_id") or 0)
    group = form.get("group") or None
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочник ведёт Администрация ООУРЦ")
        try:
            settingsdb.ppe_base_set_group(conn, item_id, group)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back("ppe", msg="Группа позиции изменена")


@app.post("/settings/ppe-base/toggle")

@app.post("/settings/ppe-base/load")
async def settings_ppe_base_load(request: Request,
                                 file: UploadFile = File(...)):
    """Остатки Базы СИЗ из файла 1С УТ (07.10.2026, правка заказчика).

    Словесного фильтра больше нет: код номенклатуры из левой колонки файла
    (артикул) сверяется с артикулами карточек Базы СИЗ — позиция ложится
    в свою карточку. Склад «МБП РЦ» — это Минск. Остатки по складам
    замещают прежние файловые; прошлый снимок остаётся в истории
    загрузок. Действует всегда последняя загрузка."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Остатки загружает Администрация ООУРЦ")
        data = await file.read()
        if not data:
            return _settings_back("ppe_mbp", error="Файл не выбран")
        try:
            report = settingsdb.load_ppe_base_1c(
                conn, data, file.filename or "остатки.xlsx", uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe_mbp", error=msg)
    parts = [f"Загружено позиций: {report['positions']}",
             f"складов: {report['cities']}",
             f"мимо Базы СИЗ (артикул не найден в карточках): "
             f"{report['filtered_out']}"]
    if report["unknown_cities"]:
        parts.append("склады вне приложения: "
                     + ", ".join(report["unknown_cities"]))
    return _settings_back("ppe_mbp", msg=". ".join(parts))


@app.post("/settings/ppe-other/add")
def settings_ppe_other_add(request: Request, article: str = Form(...),
                           name: str = Form(...)):
    """Карточка «Иное»: добавить позицию в перечень произвольной
    номенклатуры (07.10.2026, №2 «Путь СИЗ»). Артикул — ключ сопоставления
    с файлом остатков."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочник ведёт Администрация ООУРЦ")
        try:
            settingsdb.ppe_other_add(conn, article, name)
        except (ValueError, psycopg.Error) as e:
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe_base", sub="other", error=msg)
    return _settings_back("ppe_base", sub="other", msg="Позиция добавлена")


@app.post("/settings/ppe-other/delete")
def settings_ppe_other_delete(request: Request, item_id: int = Form(...)):
    """Убрать устаревшую позицию из перечня карточки «Иное»."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочник ведёт Администрация ООУРЦ")
        try:
            settingsdb.ppe_other_delete(conn, item_id)
        except (ValueError, psycopg.Error) as e:
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe_base", sub="other", error=msg)
    return _settings_back("ppe_base", sub="other", msg="Позиция удалена")


@app.post("/settings/ppe-base/size-article")
def settings_ppe_base_size_article(request: Request, row_id: int = Form(...),
                                   article: str = Form(""),
                                   sub: str = Form("")):
    """Правка артикула 1С:УТ в строке матрицы типоразмеров (06.10.2026).

    Только артикул: рост, размер и обхват — из файла заказчика, приложением
    не меняются. Пустой артикул — строка ждёт заполнения (Starlette пустые
    поля формы не присылает, поэтому параметр необязательный)."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Артикулы правит Администрация ООУРЦ")
        if not settingsdb.ppe_size_article_set(conn, row_id, article):
            return _settings_back("ppe_base", sub=sub,
                                  error="Строка не найдена — обновите страницу")
    return _settings_back("ppe_base", sub=sub, msg="Артикул сохранён")


@app.post("/settings/ppe-base/order-name")
def settings_ppe_base_order_name(request: Request, card_code: str = Form(...),
                                 order_name: str = Form(...),
                                 tail: str = Form(""),
                                 sub: str = Form("")):
    """Наименование товара по 1С:УТ для сборки строки заказа (06.10.2026).

    Строка заказа собирается как «артикул, наименование размер (обхват)
    рост [дополнение]», например: 6561513, Комплект летний
    (куртка+полукомбинезон) 44-46 (88-92) 194/200 (для мастеров). Размер
    вставляется в середину имени, дополнение — после роста."""
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Наименование правит Администрация ООУРЦ")
        if not settingsdb.ppe_size_card_order_name_set(
                conn, card_code, order_name, tail):
            return _settings_back("ppe_base", sub=sub,
                                  error="Карточка не найдена")
    return _settings_back("ppe_base", sub=sub,
                          msg="Наименование для заказа сохранено")
async def settings_ppe_base_toggle(request: Request):
    """Закрыть позицию (не выбирать при внесении наличия) или открыть."""
    uid = require_user(request)
    form = await request.form()
    item_id = int(form.get("item_id") or 0)
    active = form.get("active") == "1"
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочник ведёт Администрация ООУРЦ")
        try:
            settingsdb.ppe_base_toggle(conn, item_id, active)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("ppe", error=msg)
    return _settings_back(
        "ppe", msg="Позиция открыта" if active else "Позиция закрыта")


@app.post("/settings/maintenance-types")
async def settings_maintenance_types(request: Request):
    """
    Виды ТО и кто их проводит (02.10.2026, вычитка 5.20): «своими силами»
    — задача на доске в день срока, «вызов специалиста» — объявляется 25-го
    на следующий месяц и идёт заявкой в три шага. Новый вид работает сразу:
    правила доски берут его отсюда, а не из списка названий.
    """
    uid = require_user(request)
    form = await request.form()

    def num(v):
        v = (v or "").strip().replace(",", ".")
        return float(v) if v else None

    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Виды ТО ведёт Администрация ООУРЦ")
        try:
            with conn.cursor() as cur:
                ids = {k.partition("_")[2] for k in form if k.startswith("name_")}
                for i in ids:
                    mode = form.get(f"mode_{i}") or "specialist"
                    cur.execute(
                        """
                        UPDATE app.maintenance_type
                           SET name = %s, period_hours = %s, period_days = %s,
                               is_self_service = %s, announce = %s,
                               category_code = %s, note = %s
                         WHERE id = %s
                        """,
                        ((form.get(f"name_{i}") or "").strip(),
                         num(form.get(f"hours_{i}")), num(form.get(f"days_{i}")),
                         mode == "self", "day" if mode == "self" else "month25",
                         (form.get(f"cat_{i}") or None),
                         (form.get(f"note_{i}") or "").strip() or None, int(i)))
                code = (form.get("new_code") or "").strip()
                if code:
                    mode = form.get("new_mode") or "specialist"
                    if not (num(form.get("new_hours")) or num(form.get("new_days"))):
                        raise ValueError("У нового вида ТО нужна периодичность: "
                                         "моточасы или дни")
                    cur.execute(
                        """
                        INSERT INTO app.maintenance_type
                            (code, name, period_hours, period_days,
                             is_self_service, announce, category_code, note)
                        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                        """,
                        (code, (form.get("new_name") or code).strip(),
                         num(form.get("new_hours")), num(form.get("new_days")),
                         mode == "self", "day" if mode == "self" else "month25",
                         form.get("new_cat") or None,
                         (form.get("new_note") or "").strip() or None))
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("contractors", error=msg)
    return _settings_back("contractors", msg="Виды ТО сохранены")


@app.post("/settings/inventory-prefix")
async def settings_inventory_prefix(request: Request):
    """Код депо в начале инвентарного номера (02.10.2026, вычитка 5.5)."""
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Коды ведёт Администрация ООУРЦ")
        try:
            with conn.cursor() as cur:
                #  Сначала снимаем все, потом ставим: иначе обмен кодами между
                #  двумя депо споткнулся бы об уникальность
                pairs = []
                for key, value in form.items():
                    if key.startswith("prefix_"):
                        value = (value or "").strip()
                        if value and not (value.isdigit() and 1 <= int(value) <= 99):
                            raise ValueError("Код депо — число от 1 до 99")
                        pairs.append((int(value) if value else None,
                                      int(key.partition("_")[2])))
                cur.execute("UPDATE app.org_unit SET inventory_prefix = NULL "
                            "WHERE kind = 'rc'")
                for value, unit_id in pairs:
                    cur.execute("UPDATE app.org_unit SET inventory_prefix = %s "
                                "WHERE id = %s", (value, unit_id))
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            if "org_unit_inventory_prefix_key" in str(e):
                msg = "Два депо с одним кодом: у каждого депо код свой"
            return _settings_back("asset_kinds", error=msg)
    return _settings_back("asset_kinds", msg="Коды депо сохранены")


@app.post("/settings/purchase-limits")
async def settings_purchase_limits(request: Request):
    """
    Лимит поставок в день по каждому депо (волна 4б): база расчёта
    мощностей. Пустое поле снимает лимит — депо принимает сколько согласуют.
    """
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Лимиты ведёт Администрация ООУРЦ")
        try:
            with conn.cursor() as cur:
                for key, value in form.items():
                    if not key.startswith("limit_"):
                        continue
                    unit_id = int(key.partition("_")[2] or 0)
                    value = (value or "").strip()
                    cur.execute(
                        "UPDATE app.org_unit SET supply_per_day = %s "
                        "WHERE id = %s",
                        (int(value) if value.isdigit() else None, unit_id))
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("purchase", error=msg)
    return _settings_back("purchase", msg="Лимиты сохранены")


@app.post("/settings/codes")
async def settings_codes_save(request: Request):
    """
    Признаки обозначений табеля — весь справочник одной формой.

    Главный признак — «уменьшает норму». По законодательству расчётная норма
    корректируется на часы по графику, пропущенные по уважительной причине, и
    не корректируется при отсутствии без уважительной причины: прогул
    остаётся недоработкой по вине работника. Что считать уважительным,
    наниматель закрепляет приказом об учёте рабочего времени — поэтому набор
    правится здесь.

    Список кодов берём из справочника, а не из формы: снятая галочка в форму
    не приходит вовсе, и по ней нельзя отличить «выключили» от «не присылали».
    """
    uid = require_user(request)
    form = await request.form()

    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            changed = 0
            for c in settingsdb.day_codes(conn):
                code = c["code"]
                worked = f"worked_{code}" in form
                norm = f"norm_{code}" in form
                if (bool(c["counts_as_worked"]) == worked
                        and bool(c["counts_in_norm"]) == norm):
                    continue
                settingsdb.set_day_code_flags(
                    conn, code=code,
                    counts_as_worked=worked, counts_in_norm=norm,
                )
                changed += 1
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("codes", error=msg)

    if not changed:
        return _settings_back("codes", msg="Ничего не изменилось")
    return _settings_back("codes", msg=f"Изменено обозначений: {changed}")


@app.post("/settings/rate")
async def settings_rate_save(
    request: Request,
    operation_type_id: int = Form(...),
    unit_kind: str = Form(...),
    org_unit: str = Form(""),
    rate: str = Form(...),
    valid_from: str = Form(...),
):
    uid = require_user(request)
    with db(uid) as conn:
        ctx = settings_context(conn, uid)
        try:
            if unit_kind not in settingsdb.UNIT_RU:
                raise ValueError("Не понял, за что ставка")
            ou = None
            if org_unit and org_unit != "all":
                ou = next((u["id"] for u in ctx["units"] if u["code"] == org_unit), None)
                if ou is None:
                    raise ValueError("Нет доступа к этому депо")
            settingsdb.set_operation_rate(
                conn,
                operation_type_id=operation_type_id,
                unit=unit_kind,
                org_unit_id=ou,
                rate=float(rate.replace(",", ".")),
                valid_from=parse_day(valid_from),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("rates", error=msg)
    return _settings_back("rates", msg="Ставка установлена")


@app.post("/settings/salary")
async def settings_salary_save(
    request: Request,
    category_id: int = Form(...),
    amount: str = Form(...),
    valid_from: str = Form(...),
):
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            settingsdb.set_salary(
                conn,
                category_id=category_id,
                amount=float(amount.replace(",", ".")),
                valid_from=parse_day(valid_from),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("salary", error=msg)
    return _settings_back("salary", msg="Оклад установлен")


@app.post("/settings/kpi")
async def settings_kpi_save(
    request: Request,
    kpi_id: str = Form(""),
    code: str = Form(...),
    name: str = Form(...),
    description: str = Form(""),
    better_when: str = Form("lower"),
    source: str = Form("manual"),
    is_active: str = Form("1"),
):
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            new_id = settingsdb.set_kpi(
                conn,
                kpi_id=int(kpi_id) if kpi_id else None,
                code=code.strip().lower(),
                name=name.strip(),
                description=description.strip() or None,
                better_when=better_when,
                source=source,
                is_active=is_active == "1",
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back(
                "kpi", sub="edit", kpi=int(kpi_id) if kpi_id else None, error=msg)
    if kpi_id:
        return _settings_back(
            "kpi", sub="edit", kpi=int(kpi_id), msg="Показатель изменён")
    # Сразу открываем шаг 2 у нового показателя: без шкалы он не считается
    return _settings_back(
        "kpi", sub="edit", kpi=new_id,
        msg=f"Показатель «{name.strip()}» добавлен. Теперь задайте ему шкалу.")


@app.post("/settings/kpi-scale")
async def settings_kpi_scale_save(request: Request):
    """
    Шкала показателя: пороги и коэффициенты ступенями.

    Полей заранее не знаем — сколько ступеней ввели, столько и пришло, —
    поэтому форму читаем целиком, а не объявляем параметрами.
    """
    uid = require_user(request)
    form = await request.form()
    kpi_id = int(str(form.get("kpi_id") or 0))
    if not kpi_id:
        return _settings_back("kpi", sub="edit", error="Показатель не выбран")
    valid_from = str(form.get("valid_from") or "")

    def dec(raw: object, what: str) -> float:
        text = str(raw or "").strip().replace(",", ".").replace(" ", "")
        try:
            return float(text)
        except ValueError:
            raise ValueError(f"{what}: «{raw}» — это не число") from None

    steps: list[tuple[float, float, float]] = []
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            for i in range(1, 21):
                thr = str(form.get(f"threshold_{i}") or "").strip()
                man = str(form.get(f"coef_manager_{i}") or "").strip()
                pie = str(form.get(f"coef_piecework_{i}") or "").strip()
                if not thr and not man and not pie:
                    continue           # пустая строка — ступени нет
                if not thr:
                    raise ValueError(f"Ступень {i}: не задан порог")
                steps.append((
                    dec(thr, f"Ступень {i}, порог"),
                    dec(man or 0, f"Ступень {i}, коэффициент руководителю"),
                    dec(pie or 0, f"Ступень {i}, коэффициент сдельщику"),
                ))
            n = settingsdb.set_kpi_scale(
                conn, kpi_id=kpi_id, steps=steps,
                valid_from=parse_day(valid_from),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("kpi", sub="edit", kpi=kpi_id, error=msg)
    return _settings_back(
        "kpi", sub="edit", kpi=kpi_id,
        msg=f"Шкала сохранена, ступеней: {n}")


@app.post("/settings/budget-plan")
async def settings_budget_plan_save(request: Request):
    """
    Записать редакцию годового плана бюджета.

    Плановый ФОТ не вводится суммой: вводятся численность и уровень дохода, а
    сумма считается по правилу заказчика «численность × уровень». Так число на
    экране всегда отвечает своим множителям — сумма, введённая отдельно,
    однажды разошлась бы с ними, и никто не заметил бы.

    Всегда новая версия, никогда правка на месте. План согласуют, потом
    пересогласовывают, и вопрос «что было в прошлой редакции» возникает всегда.
    """
    uid = require_user(request)
    form = await request.form()
    year = int(form.get("year") or date.today().year)
    scope = (form.get("scope") or "year").strip()
    month = int(form.get("month") or 1)
    note = (form.get("note") or "").strip()

    def number(name: str):
        raw = (form.get(name) or "").strip().replace(",", ".")
        if not raw:
            return None
        return Decimal(raw)

    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "План бюджета ведёт администратор")

        grid = budgetdb.plan_grid(conn, year, month)
        values: dict[tuple[int, str], dict[str, Any]] = {}
        extra: dict[int, Any] = {}
        try:
            for row in grid["rows"]:
                unit_id = row["unit"]["id"]
                for cat in grid["cats"]:
                    code = cat["code"]
                    values[(unit_id, code)] = {
                        "headcount_budget": number(f"hb_{unit_id}_{code}") or 0,
                        "headcount_managerial": number(f"hm_{unit_id}_{code}"),
                        "income_level": number(f"lv_{unit_id}_{code}") or 0,
                    }
                extra[unit_id] = number(f"ex_{unit_id}") or 0
        except (InvalidOperation, ValueError):
            return _settings_back("budget_plan", year,
                                  error="В числах опечатка: ожидаются цифры, "
                                        "разделитель — запятая или точка")

        months = None if scope == "year" else (month,)
        try:
            budgetdb.save_plan(conn, year, values, extra, uid, note, months)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("budget_plan", year, error=text)

    where = ("на весь год" if scope == "year"
             else f"только на {MONTHS_RU[month - 1].lower()}")
    return _settings_back("budget_plan", year,
                          msg=f"План {year} записан новой редакцией, {where}")


@app.post("/settings/budget-plan/restore")
async def settings_budget_plan_restore(request: Request,
                                       plan_id: int = Form(...),
                                       year: int = Form(...)):
    """
    Вернуться к прежней редакции плана.

    Копией, а не переключением флага: «вернулись к редакции 2» — отдельное
    решение, а не отмена того, что было принято между ними. История остаётся
    линейной и читается сверху вниз.
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "План бюджета ведёт администратор")
        try:
            budgetdb.restore_version(conn, plan_id, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("budget_plan", year, error=text)
    return _settings_back("budget_plan", year,
                          msg="Вернулись к прежней редакции — новой версией")


@app.post("/settings/roles")
async def settings_roles_save(request: Request):
    """
    Записать матрицу «право × роль».

    Форма одна на всю таблицу: права правят разом, обдумав картину целиком, —
    кнопка у каждой галочки превратила бы настройку прав в двести нажатий.

    Роль администратора форма не присылает и функция не трогает: он может всё
    по определению, и база подтверждает это триггером — снять у него право
    нельзя даже запросом мимо приложения.
    """
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "user.manage"):
            raise HTTPException(403, "Права раздаёт администратор")

        #  Чекбокс присылается только когда отмечен, поэтому снятые галочки
        #  видны как отсутствие ключа — а не как «ключ со значением нет»
        wanted = set()
        for key in form.keys():
            if not key.startswith("p_"):
                continue
            _, _, rest = key.partition("_")
            role_code, _, perm_code = rest.partition("|")
            if role_code and perm_code:
                wanted.add((role_code, perm_code))

        try:
            changed = settingsdb.save_role_permissions(conn, wanted)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("roles", error=text)

    if not changed:
        return _settings_back("roles", msg="Ничего не изменилось")
    return _settings_back(
        "roles", msg=f"Права изменены: {changed}. Люди с этими ролями увидят "
                     f"изменения при следующем открытии страницы")


@app.post("/settings/asset-kinds")
async def settings_asset_kinds_save(request: Request):
    """
    Какие виды ведём поштучно, а какие считаем количеством.

    Признак стоит у вида, а не у единицы: «штабелёр» — техника всегда, и
    решать это заново для каждой машины значит однажды ошибиться. Форма одна
    на все виды: их четыре, и отдельная кнопка у каждого была бы лишней.

    `has_meter` отсюда не меняется: «ведём поштучно» и «есть счётчик
    моточасов» — разные вопросы. ТСД вполне может понадобиться карточка без
    всяких моточасов.
    """
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочники ведёт администратор")
        changed = 0
        for row in supplydb.categories(conn):
            want = form.get(f"kind_{row['id']}") == "equipment"
            if want != row["is_equipment"]:
                supplydb.set_category_kind(conn, row["id"], want)
                changed += 1
    if not changed:
        return _settings_back("asset_kinds", msg="Ничего не изменилось")
    return _settings_back(
        "asset_kinds",
        msg=f"Видов изменено: {changed}. Единицы переедут между вкладками "
            f"«Техника» и «ТМЦ» сразу")


@app.post("/settings/asset-kind")
async def settings_asset_kind_add(
    request: Request,
    group_code: str = Form(...),
    name: str = Form(...),
    has_meter: str = Form(""),
):
    """
    Завести вид в реестре ТМЦ.

    Заказчик 22.09.2026: «сам реестр менять может администратор ООУРЦ и
    админ» — это и есть право `reference.write`.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Реестр ведёт администрация")
        try:
            settingsdb.add_asset_kind(
                conn, group_code=group_code, name=name,
                has_meter=bool(has_meter))
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("asset_kinds", error=msg)
    return _settings_back("asset_kinds", msg=f"Вид «{name.strip()}» добавлен")


@app.post("/settings/asset-kind-active")
async def settings_asset_kind_active(
    request: Request,
    category_id: int = Form(...),
    value: int = Form(...),
):
    """Закрыть вид или вернуть его. Удаления нет: на вид ссылается имущество."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Реестр ведёт администрация")
        try:
            settingsdb.set_asset_kind_active(conn, category_id, bool(value))
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _settings_back("asset_kinds", error=str(e))
    return _settings_back("asset_kinds",
                          msg="Вид открыт" if value else "Вид закрыт")


@app.post("/settings/asset-model")
async def settings_asset_model_add(
    request: Request, group_code: str = Form(...), name: str = Form(...),
):
    """Добавить производителя в список группы."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Реестр ведёт администрация")
        try:
            settingsdb.add_asset_model(conn, group_code=group_code, name=name)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("asset_kinds", error=msg)
    return _settings_back("asset_kinds", msg="Производитель добавлен")


@app.post("/settings/asset-model/drop")
async def settings_asset_model_drop(
    request: Request, group_code: str = Form(...), name: str = Form(...),
):
    """Убрать производителя из списка — запись закрывается, а не стирается."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Реестр ведёт администрация")
        try:
            settingsdb.drop_asset_model(conn, group_code=group_code, name=name)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _settings_back("asset_kinds", error=str(e))
    return _settings_back("asset_kinds", msg="Производитель убран из списка")


@app.post("/settings/contractor")
async def settings_contractor_save(
    request: Request,
    contractor_id: str = Form(""),
    name: str = Form(...),
    phone: str = Form(""),
    email: str = Form(""),
    note: str = Form(""),
    is_active: str = Form(""),
):
    """
    Завести или поправить подрядчика — справочник по данным от 21.09.2026.

    Телефон и почта отдельными полями: у «ФЛАРС» и «Высококачественных
    полимеров» есть только почта.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочники ведёт администратор")
        try:
            settingsdb.save_contractor(
                conn,
                contractor_id=int(contractor_id) if contractor_id.strip() else None,
                name=name, phone=phone, email=email, note=note,
                #  Флажок приходит только когда отмечен; у новой записи формы
                #  с флажком нет вовсе, и тогда она заводится действующей
                is_active=bool(is_active) or not contractor_id.strip(),
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("contractors", error=msg)
    return _settings_back("contractors", msg="Справочник подрядчиков обновлён")


@app.post("/settings/reason-renewal")
async def settings_reason_renewal(
    request: Request,
    reason_id: int = Form(...),
    value: int = Form(...),
):
    """
    Отметить, годится ли причина для непродления контракта.

    Ответ О10 от 21.09.2026: «Перевод» и «Стажер (до двух месяцев)» — причины
    увольнения, но не непродления. Признак стоит у самой причины, а не в
    отдельном справочнике: список тот же, различаются две позиции из десяти.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочники ведёт администратор")
        settingsdb.set_reason_non_renewal(conn, reason_id, bool(value))
    return _settings_back("positions", msg="Признак изменён")


@app.post("/settings/system")
async def settings_system_save(request: Request):
    """
    Сохранить системные настройки — вкладка «Системные».

    Форма одна на все переключатели: их три, и заставлять нажимать
    «Сохранить» у каждого незачем. Неизвестный код или значение вне списка
    отбрасывает settingsdb — в базу должно попадать только то, что
    приложение умеет прочитать обратно.
    """
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            changed = 0
            for item in settingsdb.APP_SETTINGS:
                value = form.get(item["code"])
                if value is None:
                    continue
                settingsdb.set_app_setting(conn, item["code"], str(value), uid)
                changed += 1
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("system", error=msg)
    _FORKLIFT_CACHE["at"] = 0.0          # погрузчик в шапке — сразу по новой настройке
    return _settings_back("system", msg=f"Системные настройки сохранены ({changed})")


@app.post("/settings/kpi-weight")
async def settings_kpi_weight_save(
    request: Request,
    kpi_id: int = Form(...),
    category_id: int = Form(...),
    weight: str = Form(...),
    valid_from: str = Form(...),
):
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            w = float(weight.replace(",", "."))
            if not 0 <= w <= 1:
                raise ValueError("Вес — доля от 0 до 1, например 0.3")
            settingsdb.set_kpi_weight(
                conn, kpi_id=kpi_id, category_id=category_id,
                weight=w, valid_from=parse_day(valid_from),
            )
            conn.commit()
        #  WeightOverflow — тоже ValueError, ловится этой же веткой и
        #  возвращается на экран своим текстом с цифрами (пункт 32)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("kpi", sub="weights", error=msg)
    return _settings_back("kpi", sub="weights", msg="Вес показателя сохранён")


@app.post("/settings/kpi-fund")
async def settings_kpi_fund_save(
    request: Request,
    unit_id: int = Form(...),
    category_id: int = Form(...),
    amount: str = Form(...),
    valid_from: str = Form(...),
):
    """
    Фонд КПИ пары «депо + категория должностей», с даты действия.

    Прежний фонд закрывается этой датой, а не переписывается: премия за
    прошлый месяц обязана остаться посчитанной по фонду, который тогда
    действовал. В таблице фонд лежит числом в блоке депо на листе
    «Мотивация», и правка меняет прошлое вместе с будущим.
    """
    uid = require_user(request)
    with db(uid) as conn:
        settings_context(conn, uid)
        try:
            value = float(amount.replace(",", ".").replace(" ", ""))
            if value < 0:
                raise ValueError("Фонд не может быть отрицательным")
            settingsdb.set_kpi_fund(
                conn, unit_id=unit_id, category_id=category_id,
                amount=value, valid_from=parse_day(valid_from),
            )
            conn.commit()
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settings_back("kpi", sub="funds", error=msg)
    return _settings_back("kpi", sub="funds", msg="Фонд КПИ сохранён")


# ---------------------------------------------------------------------------
#  Смена: рабочий экран ввода начальника РЦ
# ---------------------------------------------------------------------------



def parse_day(text: str | None) -> date:
    if not text:
        return date.today()
    try:
        return date.fromisoformat(text)
    except ValueError:
        raise HTTPException(400, f"Не понял дату: {text}") from None


def _plan_suggestion(row: dict[str, Any]) -> dict[str, Any] | None:
    """Что подставить в факт, если смена прошла ровно по плану."""
    plan: Any = row["plan"]
    if plan.day_code:
        return {"day_code": plan.day_code, "hours_day": 0, "hours_night": 0}
    if plan.shift_start is None or row["plan_total"] <= 0:
        return None
    return {
        "day_code": None,
        "hours_day": round(row["plan_total"] - row["plan_night"], 2),
        "hours_night": row["plan_night"],
    }


def _h(value: float) -> str:
    """Часы для поля ввода: пусто вместо нуля, 11 вместо 11.0."""
    v = round(float(value or 0), 2)
    if v == 0:
        return ""
    return str(int(v)) if abs(v - int(v)) < 1e-9 else f"{v:g}"


def _fact_text(fact: Any) -> str:
    """
    Итог дня словами экрана смены. В отличие от клетки табеля здесь видно и
    часть смены: «11 С3» — одиннадцать часов, из них три сверхурочных.
    """
    if fact is None:
        return ""
    if fact.day_code:
        return fact.day_code
    if fact.worked <= 0:
        return ""
    parts = [
        f"{_h(fact.hours_day) or '0'}/{_h(fact.hours_night)}"
        if fact.hours_night else _h(fact.hours_day)
    ]
    if fact.hours_weekend:
        parts.append(f"РВ{_h(fact.hours_weekend)}")
    if fact.hours_overtime:
        parts.append(f"С{_h(fact.hours_overtime)}")
    return " ".join(parts)


def _day_row_view(row: dict[str, Any]) -> dict[str, Any]:
    """Одна строка экрана смены: план, факт, расхождение, подсказка."""
    fact = row["fact"]
    worked = fact.worked if fact else 0.0
    plan_total = row["plan_total"]
    has_plan = row["plan"].shift_start is not None or bool(row["plan"].day_code)

    if fact is None:
        state = "empty" if has_plan else "idle"
    elif fact.day_code:
        state = "coded"
    elif not has_plan:
        state = "extra"
    elif abs(worked - plan_total) < 0.01:
        state = "ok"
    else:
        state = "diff"

    return {
        **row,
        "plan_text": format_plan_cell(row["plan"]),
        "plan_kind": plan_cell_kind(row["plan"]),
        "has_plan": has_plan,
        "f": {
            "day_code": fact.day_code if fact else "",
            "hours_day": _h(fact.hours_day) if fact else "",
            "hours_night": _h(fact.hours_night) if fact else "",
            "hours_weekend": _h(fact.hours_weekend) if fact else "",
            "hours_overtime": _h(fact.hours_overtime) if fact else "",
        },
        "fact_text": _fact_text(fact),
        "fact_kind": fact_cell_kind(fact) if fact else "empty",
        "worked": worked,
        "delta": round(worked - plan_total, 2) if has_plan and not (fact and fact.day_code) else 0.0,
        "state": state,
        "suggest": _plan_suggestion(row),
    }


def _day_summary(rows: list[dict[str, Any]]) -> dict[str, Any]:
    return {
        "people": len(rows),
        "planned": sum(1 for r in rows if r["state"] in ("empty", "ok", "diff")),
        "filled": sum(1 for r in rows if r["fact"] is not None),
        "not_filled": sum(1 for r in rows if r["state"] == "empty"),
        "coded": sum(1 for r in rows if r["state"] == "coded"),
        "hours": round(sum(r["worked"] for r in rows), 2),
        "hours_night": round(
            sum(r["fact"].hours_night for r in rows if r["fact"]), 2
        ),
        "hours_plan": round(sum(r["plan_total"] for r in rows), 2),
        "can_fill": sum(1 for r in rows if r["state"] == "empty" and r["suggest"]),
    }






def _need_perm_json(conn, code: str, text: str):
    """JSON-отказ для запросов сетки, если права нет (02.10.2026)."""
    if not webdb.has_perm(conn, code):
        return JSONResponse({"ok": False, "error": text}, status_code=403)
    return None


TS_DENIED = ("Недостаточно прав: табель правят начальник, заместитель, "
             "мастер и Администрация ООУРЦ")
PLAN_DENIED = ("Недостаточно прав: график правят начальник, заместитель "
               "и Администрация ООУРЦ")


@app.post("/api/day/row")
async def save_day_row(request: Request):
    uid = require_user(request)
    body = await request.json()
    d = parse_day(body["date"])
    emp_id = int(body["employment_id"])
    note = (body.get("note") or "").strip()

    with db(uid) as conn:
        unit = unit_or_403(conn, body["unit"])
        denied = _need_perm_json(conn, "timesheet.write", TS_DENIED)
        if denied:
            return denied
        if d > date.today() + timedelta(days=FILL_AHEAD_DAYS):
            return JSONResponse(
                {"ok": False, "error": "Табель заполняется не дальше чем на "
                                       "сутки вперёд"}, status_code=422)
        ts = webdb.ensure_timesheet(conn, unit["id"], d.replace(day=1))
        if ts["status"] in ("approved", "closed"):
            return JSONResponse(
                {"ok": False, "error": "Табель месяца уже утверждён — правка закрыта"},
                status_code=422,
            )

        try:
            cell = build_fact_cell(
                day_code=body.get("day_code") or None,
                hours_day=body.get("hours_day"),
                hours_night=body.get("hours_night"),
                hours_weekend=body.get("hours_weekend"),
                hours_overtime=body.get("hours_overtime"),
            )
            if cell.is_empty and note:
                raise CellError(
                    "Примечание сохраняется вместе с часами или кодом дня — "
                    "день пока пустой"
                )
            webdb.save_fact_cell(
                conn, ts["id"], emp_id, d, cell, note=note, set_note=True
            )
        except CellError as e:
            return JSONResponse({"ok": False, "error": str(e)}, status_code=422)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)

        rows = [_day_row_view(r)
                for r in webdb.day_sheet(conn, unit["id"], ts["id"], d)]

    mine = next((r for r in rows if r["employment_id"] == emp_id), None)
    return {
        "ok": True,
        "row": {
            "text": mine["fact_text"] if mine else "",
            "kind": mine["fact_kind"] if mine else "empty",
            "worked": mine["worked"] if mine else 0,
            "delta": mine["delta"] if mine else 0,
            "state": mine["state"] if mine else "idle",
        },
        "summary": _day_summary(rows),
    }


@app.post("/api/day/fill")
async def fill_day_from_plan(request: Request):
    uid = require_user(request)
    body = await request.json()
    d = parse_day(body["date"])

    with db(uid) as conn:
        unit = unit_or_403(conn, body["unit"])
        denied = _need_perm_json(conn, "timesheet.write", TS_DENIED)
        if denied:
            return denied
        denied = _need_perm_json(
            conn, "timesheet.fill",
            "Заполнять табель по плану скопом может Администрация ООУРЦ")
        if denied:
            return denied
        if d > date.today() + timedelta(days=FILL_AHEAD_DAYS):
            return JSONResponse(
                {"ok": False, "error": "Табель заполняется не дальше чем на "
                                       "сутки вперёд"}, status_code=422)
        ts = webdb.ensure_timesheet(conn, unit["id"], d.replace(day=1))
        if ts["status"] in ("approved", "closed"):
            return JSONResponse(
                {"ok": False, "error": "Табель месяца уже утверждён — правка закрыта"},
                status_code=422,
            )

        rows = [_day_row_view(r)
                for r in webdb.day_sheet(conn, unit["id"], ts["id"], d)]
        written = 0
        try:
            for r in rows:
                if r["state"] != "empty" or not r["suggest"]:
                    continue
                s = r["suggest"]
                cell = build_fact_cell(
                    day_code=s["day_code"],
                    hours_day=s["hours_day"],
                    hours_night=s["hours_night"],
                )
                webdb.save_fact_cell(conn, ts["id"], r["employment_id"], d, cell)
                written += 1
        except (CellError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)

        rows = [_day_row_view(r)
                for r in webdb.day_sheet(conn, unit["id"], ts["id"], d)]
        summary = _day_summary(rows)

    return {"ok": True, "written": written, "summary": summary}


# ---------------------------------------------------------------------------
#  Сохранение клеток
# ---------------------------------------------------------------------------

@app.post("/api/cell")
async def save_cell(request: Request):
    uid = require_user(request)
    body = await request.json()
    mode = body.get("mode")
    emp_id = int(body["employment_id"])
    day = date.fromisoformat(body["date"])
    raw = body.get("value", "")
    unit_code = body["unit"]
    p = parse_period(body["period"])

    with db(uid) as conn:
        unit = unit_or_403(conn, unit_code)
        #  Права разные: по таблице заказчика от 16.09.2026 мастер правит
        #  табель и не правит график. До этой правки обработчик не спрашивал
        #  никакого права вовсе — месяц мог переписать и кладовщик, и
        #  наблюдатель, лишь бы у них был доступ к депо.
        need = "timesheet.write" if mode == "fact" else "schedule.write"
        if not webdb.has_perm(conn, need):
            return JSONResponse(
                {"ok": False,
                 "error": ("Табель правят начальник депо, заместитель и мастер"
                           if mode == "fact"
                           else "График правят начальник депо и заместитель")},
                status_code=403)
        #  Табель — документ о том, что произошло. Заполнять его наперёд
        #  разрешено ровно на сутки (решение заказчика от 21.09.2026): столько
        #  нужно, чтобы закрыть месяц человеку, которого увольняют последним
        #  числом. График этим правилом не связан — он весь про будущее.
        if mode == "fact":
            limit = date.today() + timedelta(days=FILL_AHEAD_DAYS)
            if day > limit:
                return JSONResponse(
                    {"ok": False,
                     "error": (f"Табель заполняется не дальше чем на сутки "
                               f"вперёд: {day:%d.%m.%Y} ещё не наступило. "
                               f"Последняя доступная дата — {limit:%d.%m.%Y}")},
                    status_code=422)
        ts = webdb.ensure_timesheet(conn, unit["id"], p)

        try:
            if mode == "fact":
                # Правится половина клетки, а не вся: вторую надо сохранить.
                # Иначе ввод ночных часов стирал бы дневные.
                part = body.get("part") or "day"
                existing = webdb.fact_cells(conn, ts["id"]).get((emp_id, day))
                cell = merge_fact_part(existing, part, raw)
                #  Был ли в этой клетке больничный до правки: от него зависит,
                #  надо ли пересчитывать отпуск
                was_sick = bool(existing and existing.day_code == vacationdb.SICK_CODE)
                webdb.save_fact_cell(conn, ts["id"], emp_id, day, cell)
                parts = fact_cell_parts(cell if not cell.is_empty else None)
                shown = parts[part]
                shown_full = shown
                lines = [shown] if shown else []
                kind = fact_cell_kind(cell)
            else:
                cell = parse_plan_cell(raw)
                #  02.10.2026 (вычитка 3.22): в последний день месяца смена —
                #  только до 24:00. «20:00-08:00» 31-го числа раньше молча
                #  уходило за полночь, и с «00:00-08:00» 1-го хвост
                #  считался дважды
                if (day + timedelta(days=1)).month != day.month:
                    for a, b in cell.intervals:
                        if b != time(0, 0) and b <= a:
                            raise CellError(
                                "В последний день месяца смена — до 24:00: "
                                "введите «" + a.strftime("%H:%M") + "-24:00», а "
                                "часы после полуночи — в 1-е число следующего "
                                "месяца")
                webdb.save_plan_cell(conn, unit["id"], emp_id, day, cell)
                shown = format_plan_cell(cell)
                shown_full = shown
                lines = plan_cell_lines(cell)
                kind = plan_cell_kind(cell)
        except CellError as e:
            return JSONResponse({"ok": False, "error": str(e)}, status_code=422)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)

        payload: dict[str, Any] = {
            "ok": True, "value": shown, "full": shown_full, "kind": kind,
            "lines": lines, "date": day.isoformat(),
        }
        if mode == "fact":
            payload["parts"] = parts

        if mode == "fact":
            all_cells = webdb.fact_cells(conn, ts["id"])
            facts = webdb.fact_days(conn, ts["id"]).get(emp_id, [])
            totals = compute_totals(facts)
            # Отклонение считаем от персональной нормы: правка кода дня
            # (поставили отпуск) меняет и саму норму этого сотрудника
            em_row = webdb.employment_dates(conn, emp_id)
            pnorm, excused = personal_norm_for(
                person_month_norm(conn, float(webdb.month_norm(conn, p) or 0), p,
                                  em_row.get("hired_at"), em_row.get("terminated_at")),
                facts,
                plan_by_date(conn, unit["id"], p).get(emp_id, {}),
                webdb.norm_excusing_codes(conn),
            )
            day_totals = fact_day_totals(all_cells)
            payload["totals"] = {
                "worked_days": totals.worked_days,
                "hours_total": totals.hours_total,
                "hours_night": totals.hours_night,
                "deviation": compare_with_norm(totals, pnorm).deviation,
                "norm": pnorm,
                "norm_excused": excused,
                #  Годовые пределы меняются с каждой клеткой «РВ» и «С»
                **webdb.limits_text(webdb.year_limits(
                    conn, [emp_id],
                    date(p.year, p.month,
                         calendar.monthrange(p.year, p.month)[1]))[emp_id]),
            }
            payload["col"] = day_totals.get(day.isoformat(), 0)
            payload["grand"] = round(sum(day_totals.values()), 2)

            #  Больничный внутри отпуска его дни не занимает: отпуск
            #  продлевается (статья 171 ТК). Больничный вносят в табель, и
            #  пересчитать отпуск надо здесь же — иначе «О» осталась бы на
            #  прежних днях, и человек вернулся бы раньше положенного
            now_sick = cell.day_code == vacationdb.SICK_CODE
            if now_sick or was_sick:
                moved = vacationdb.refresh_around(
                    conn, webdb.employee_of(conn, emp_id), day)
                if moved:
                    payload["vacation_moved"] = [
                        {
                            "starts_at": m["starts_at"].strftime("%d.%m.%Y"),
                            "days": m["days"],
                            "was_last": (m["was_last"].strftime("%d.%m.%Y")
                                         if m["was_last"] else None),
                            "last": m["last"].strftime("%d.%m.%Y"),
                            "sick": len(m["sick"]),
                        }
                        for m in moved
                    ]
        else:
            computed = _recalc_plan(conn, unit["id"], p)
            emp_hours = [h for row, h in computed if row.employment_id == emp_id]
            #  Обе цифры, а не одна. Раньше отдавались только присутствие и
            #  ночные, а «к отработке» на экране оставалась от загрузки
            #  страницы: правишь клетку — строка показывает новое
            #  присутствие и старые часы к отработке. По «к отработке»
            #  считается персональная норма, и расхождение уезжало в сверку.
            plan_worked = round(sum(h.worked_total for h in emp_hours), 2)
            #  Расхождение с нормой — вместе с часами: убрал смену, и в
            #  колонке «Откл.» сразу видно, что график больше не сходится
            first_day, last_day = month_bounds(p)
            who = next((r for r in webdb.people(conn, unit["id"], p)
                        if r["employment_id"] == emp_id), None)
            plan_norm = schedule_norm(
                float(webdb.month_norm(conn, p) or 0),
                webdb.calendar_days(conn, p), first_day, last_day,
                (who["hired_at"] if who and who["hired_at"]
                 and who["hired_at"] > first_day else None),
                (who["terminated_at"] if who and who["terminated_at"]
                 and who["terminated_at"] < last_day else None),
            ) if who else 0.0
            payload["totals"] = {
                "plan_total": round(sum(h.total for h in emp_hours), 2),
                "plan_worked": plan_worked,
                "plan_night": round(sum(h.hours_night for h in emp_hours), 2),
                "plan_diff": round(plan_worked - plan_norm, 2),
                "plan_norm": plan_norm,
            }
            plan_cells = webdb.plan_cells(conn, unit["id"], p)
            payload["col"] = plan_day_totals(plan_cells).get(day.isoformat(), 0)
            payload["grand"] = round(sum(h.total for _, h in computed), 2)
            payload["grand_worked"] = round(
                sum(h.worked_total for _, h in computed), 2)

    return payload


def _recalc_plan(conn, unit_id: int, period: date):
    """
    Пересчитать и сохранить часы графика за месяц — обе цифры сразу.

    Присутствие — то, что стоит в графике: интервал вместе с часом обеда.
    К отработке — минус этот час: столько работник ставит в табеле. Считает
    их одна функция, поэтому разойтись они не могут.

    Прежнее правило перерыва (час из наибольшего интервала) здесь больше не
    применяется: обед задан окнами 11:00–14:00, 16:00–19:00 и 01:00–04:00.
    """
    from . import repo

    #  Соседние дни нужны обеду: смена на стыке месяцев записана двумя
    #  частями, а обед у неё один — без соседнего дня половина смены выглядит
    #  самостоятельной и получает свой час
    rows_db = repo.fetch_schedule(conn, unit_id, period, margin_days=1)
    computed = plan_and_worked(rows_db, night=NightWindow(), lunch=lunch_rule_from_env())
    repo.save_plan_hours(conn, unit_id, period, computed)
    return computed


def plan_hours_fresh(conn, unit_id: int, period: date) -> dict[int, list[PlanHours]]:
    """
    Часы графика за месяц, посчитанные действующим правилом.

    Считает сам в двух случаях: месяц открыт впервые (часов ещё нет) и часы
    посчитаны прежней версией правила. Второе важнее: правило обеда менялось,
    и без пересчёта в колонке «К отраб.» остались бы старые цифры, а сверка
    показывала бы «не оформлено 1 ч» там, где всё в порядке.
    """
    ph = webdb.plan_hours_map(conn, unit_id, period)
    stale = webdb.plan_hours_stale(conn, unit_id, period, RULE_VERSION)
    if stale or not ph:
        cells = webdb.plan_cells(conn, unit_id, period)
        if stale or any(c.shift_start for c in cells.values()):
            _recalc_plan(conn, unit_id, period)
            ph = webdb.plan_hours_map(conn, unit_id, period)
    return ph


@app.post("/api/timesheet/fill-from-plan")
async def timesheet_fill_from_plan(request: Request):
    """
    Проставить факт по графику — за одни сутки или за все прошедшие месяца.

    Заполнять вперёд по плану нельзя: табель — документ о том, что уже
    произошло, а не подпись за неотработанную смену. Поэтому дата должна быть
    строго раньше сегодняшней, а вариант «весь месяц» берёт только сутки,
    которые уже закончились.

    Раньше можно было только по одним суткам, и заполнение месяца означало
    тридцать раз выбрать дату, нажать кнопку и дождаться перезагрузки —
    притом что проверка «только прошедшие» и так стоит внутри. Теперь весь
    месяц делается одним нажатием, а по суткам осталось для точечной правки.

    Разбивку на дневные и ночные часы берём готовой из schedule_plan_hours:
    она посчитана по интервалу смены и границам ночи 22:00–06:00. Поэтому
    дневная смена ложится в дневную колонку, а хвост ночной приходит на эту
    дату с предыдущей смены — так же, как считается план.

    Заполненные дни не трогаем: это заполнение пустого, а не перезапись.
    """
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    today = date.today()
    whole_month = bool(body.get("whole_month"))

    if whole_month:
        last = last_fillable_day(p)
        if last < p:
            return JSONResponse(
                {"ok": False,
                 "error": f"{MONTHS_RU[p.month - 1].capitalize()} {p.year} "
                          f"ещё не начался — заполнять нечего"},
                status_code=422,
            )
        days = [d for d in month_days(p) if d <= last]
    else:
        day = parse_day(body["date"]) if body.get("date") else last_fillable_day(p)
        if day > today + timedelta(days=FILL_AHEAD_DAYS):
            return JSONResponse(
                {"ok": False,
                 "error": (f"Табель заполняется не дальше чем на сутки вперёд: "
                           f"{day:%d.%m.%Y} — это слишком далеко. "
                           "Последняя доступная дата — "
                           f"{today + timedelta(days=FILL_AHEAD_DAYS):%d.%m.%Y}")},
                status_code=422,
            )
        if day.replace(day=1) != p:
            return JSONResponse(
                {"ok": False,
                 "error": f"Дата {day:%d.%m.%Y} не входит в открытый месяц"},
                status_code=422,
            )
        days = [day]

    with db(uid) as conn:
        #  Кнопка осталась только у администрации (ответ О7 от 21.09.2026):
        #  депо ведёт табель по ходу месяца, а не подставляет план скопом в
        #  последний день. Проверка здесь, а не только в шаблоне: кнопки нет,
        #  но запрос можно послать и мимо страницы
        if not webdb.has_perm(conn, "timesheet.fill"):
            return JSONResponse(
                {"ok": False,
                 "error": ("Заполнение по графику доступно администрации. "
                           "Табель депо ведёт по ходу месяца — за прошедшие "
                           "сутки об этом напоминает задача на доске")},
                status_code=403)
        unit = unit_or_403(conn, body["unit"])
        ts = webdb.ensure_timesheet(conn, unit["id"], p)
        if ts["status"] in ("approved", "closed"):
            return JSONResponse(
                {"ok": False, "error": "Табель утверждён — правка закрыта"},
                status_code=422,
            )

        # план мог ни разу не считаться или считаться прежним правилом
        ph = plan_hours_fresh(conn, unit["id"], p)

        plan_codes = {
            (emp, d): c.day_code
            for (emp, d), c in webdb.plan_cells(conn, unit["id"], p).items()
            if c.day_code
        }
        existing = webdb.fact_cells(conn, ts["id"])

        # На одну дату может прийтись хвост вчерашней ночной смены и начало
        # сегодняшней — например при графике 20:00–08:00 подряд. Такие часы
        # надо складывать, а не записывать по очереди: вторая запись затирала
        # первую, и у ночников из 14 плановых ночных часов в табеле
        # оставалось 4.
        wanted = set(days)
        by_day: dict[tuple[int, date], list[float]] = {}
        for emp_id, hours in ph.items():
            for h in hours:
                if h.work_date not in wanted or h.worked_total <= 0:
                    continue
                acc = by_day.setdefault((emp_id, h.work_date), [0.0, 0.0])
                acc[0] += h.hours_day if h.worked_day is None else h.worked_day
                acc[1] += (h.hours_night if h.worked_night is None
                           else h.worked_night)

        written = 0
        try:
            for (emp_id, d), (d_hours, n_hours) in sorted(by_day.items()):
                if (emp_id, d) in existing:
                    continue
                webdb.save_fact_cell(
                    conn, ts["id"], emp_id, d,
                    FactCell(hours_day=round(d_hours, 2),
                             hours_night=round(n_hours, 2)),
                )
                written += 1

            # Дни, закрытые кодом в графике, тоже перенесём — но только те,
            # на которые не пришлось часов.
            #
            # При графике «2 через 2» с ночными сменами день после смены
            # помечен в графике «В», а на него приходится ночной хвост
            # предыдущей смены. Часы важнее кода: человек в этот день
            # работал. Раньше перенос кода затирал эти часы, и у ночников из
            # 14 плановых ночных часов в табеле оставалось 4.
            for (emp_id, d), code in sorted(plan_codes.items()):
                if d not in wanted:
                    continue
                if (emp_id, d) in existing or (emp_id, d) in by_day:
                    continue
                webdb.save_fact_cell(conn, ts["id"], emp_id, d,
                                     FactCell(day_code=code))
                written += 1
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)

    return {
        "ok": True,
        "written": written,
        "days": len(days),
        "date": days[0].isoformat() if len(days) == 1 else None,
        "period": f"{days[0]:%d.%m}–{days[-1]:%d.%m}" if len(days) > 1 else None,
    }


@app.post("/api/timesheet/clear")
async def timesheet_clear(request: Request):
    """
    Полная очистка табеля за месяц.

    Нужна, когда заполнение ушло не туда: проще стереть месяц и ввести руками,
    чем править клетку за клеткой. Утверждённый табель не чистим — сначала
    его возвращают на доработку на вкладке «Сверка и сдача».
    """
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    emp = body.get("employment_id")

    with db(uid) as conn:
        unit = unit_or_403(conn, body["unit"])
        denied = _need_perm_json(conn, "timesheet.write", TS_DENIED)
        if denied:
            return denied
        ts = webdb.ensure_timesheet(conn, unit["id"], p)
        if ts["status"] in ("approved", "closed"):
            return JSONResponse(
                {"ok": False, "error": "Табель утверждён — правка закрыта"},
                status_code=422,
            )
        try:
            removed = webdb.clear_fact_month(
                conn, ts["id"], int(emp) if emp else None
            )
            webdb.log_operation(
                conn, "timesheet_clear", unit["id"], p, removed,
                f"Полная очистка табеля за {p:%m.%Y}: удалено дней — {removed}",
            )
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)

    return {"ok": True, "removed": removed}


# ---------------------------------------------------------------------------
#  Сверка, сдача, выгрузка
# ---------------------------------------------------------------------------

def _review_required_days(person: dict, period: date, today: date) -> list[date]:
    """
    Дни, которые к сверке уже должны быть заполнены: прошедшие сутки месяца
    в пределах работы человека (24.09.2026). Выходной — тоже заполнение,
    буквой «В»; пустой день сверка показывает расхождением.
    """
    first = period.replace(day=1)
    last = date(first.year, first.month, calendar.monthrange(first.year, first.month)[1])
    last = min(last, today - timedelta(days=1))
    if person.get("terminated_at"):
        last = min(last, person["terminated_at"])
    start = max(first, person.get("hired_at") or first)
    return [start + timedelta(days=i) for i in range((last - start).days + 1)]


@app.get("/review", response_class=HTMLResponse)
def review(request: Request, unit: str | None = None, period: str | None = None,
           include_coded: int = 0):
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = grid_context(conn, uid, unit, p)
        unit_id = ctx["unit"]["id"]
        ts_id = ctx["timesheet"]["id"]

        rows = webdb.people(conn, unit_id, p)
        by_emp = {r["employment_id"]: r for r in rows}
        plan = webdb.plan_hours_map(conn, unit_id, p)
        facts = webdb.fact_days(conn, ts_id)

        #  Оформленные докладными дни: часы такого дня считаются заявленными,
        #  а день без часов — расхождение. Оформление не проставляет часы
        #  само: табель наперёд не ведут (решение заказчика от 22.09.2026)
        ordered = orderdb.ordered_days(conn, unit_id, p)
        required = {e: _review_required_days(r, p, date.today()) for e, r in by_emp.items()}

        # Основной набор — без дней, закрытых кодами. Его же сохраняем,
        # чтобы счётчик расхождений на главной был актуальным.
        base_found: list[tuple[int, Any]] = []
        for emp_id in by_emp:
            for d in compare(plan.get(emp_id, []), facts.get(emp_id, []),
                             skip_coded=True, ordered=ordered.get(emp_id),
                             days=required[emp_id], today=date.today()):
                base_found.append((emp_id, d))
        try:
            repo.save_discrepancies(conn, unit_id, p, base_found)
        except psycopg.Error:
            conn.rollback()

        found = []
        for emp_id in by_emp:
            for d in compare(plan.get(emp_id, []), facts.get(emp_id, []),
                             skip_coded=not include_coded,
                             ordered=ordered.get(emp_id),
                             days=required[emp_id], today=date.today()):
                found.append({"person": by_emp[emp_id], "d": d})

        all_plan = [h for hs in plan.values() for h in hs]
        all_fact = [f for fs in facts.values() for f in fs]
        summary = summarize(all_plan, all_fact, [x["d"] for x in found])

        # Месячный разрез по каждому: всего часов и из чего они сложились.
        # Сверка смотрит весь месяц, поэтому это и есть её главная таблица —
        # список расхождений по дням идёт после неё.
        month_norm = float(ctx["norm"] or 0)
        plans_by_date = plan_by_date(conn, unit_id, p)
        excusing = webdb.norm_excusing_codes(conn)
        by_person = []
        day_types = webdb.calendar_days(conn, p)
        for emp_id, person in by_emp.items():
            emp_facts = facts.get(emp_id, [])
            pnorm, excused = personal_norm_for(
                person_month_norm(conn, month_norm, p, person.get("hired_at"),
                                  person.get("terminated_at"), day_types),
                emp_facts, plans_by_date.get(emp_id, {}), excusing
            )
            by_person.append({
                "person": person,
                "row": month_row(
                    plan.get(emp_id, []), emp_facts,
                    [x["d"] for x in found if x["person"]["employment_id"] == emp_id],
                    norm_hours=pnorm, norm_excused=excused,
                ),
            })

        #  24.09.2026: расхождения свёрнуты по фамилии — одна строка на
        #  человека с числом дней, дни раскрываются по щелчку
        groups: dict[int, dict[str, Any]] = {}
        for x in found:
            g = groups.setdefault(x["person"]["employment_id"], {
                "person": x["person"], "items": [], "undeclared": 0.0, "kinds": set()})
            g["items"].append(x["d"])
            g["undeclared"] = round(g["undeclared"] + (x["d"].undeclared or 0), 2)
            g["kinds"].add(x["d"].kind)
        disc_groups = sorted(groups.values(), key=lambda g: g["person"]["fio_short"])

        ctx.update({
            "discrepancies": found,
            "disc_groups": disc_groups,
            "summary": summary,
            "by_person": by_person,
            "code_columns": _month_code_columns(by_person),
            "gaps": webdb.completeness_gaps(conn, ts_id),
            #  Журнал сверки и сдачи — это журнал табеля (пункт 16):
            #  общий журнал на всё приложение убран
            "journal": journal_of(conn, "timesheet", unit_id, p),
            "include_coded": bool(include_coded),
            "can_submit": webdb.has_perm(conn, "timesheet.submit"),
            #  Утверждение отделено от правки (16.09.2026): право
            #  `timesheet.write` есть у мастера, и мастер утверждал бы табель,
            #  который сдал начальник
            "can_approve": webdb.has_perm(conn, "timesheet.approve"),
            "can_export": webdb.has_perm(conn, "timesheet.export"),
            "can_close": webdb.has_perm(conn, "payroll.close"),
            "title": "Сверка и сдача табеля",
            "mode": "review",
        })
    return templates.TemplateResponse(request, "review.html", ctx)


def _month_code_columns(by_person: list[dict[str, Any]]) -> list[str]:
    """
    Какие коды дней показать колонками в месячном разрезе.

    Только те, что в этом месяце вообще встретились: показывать двадцать
    пустых колонок «на всякий случай» незачем. Порядок — как в печатной форме.
    """
    used = {code for x in by_person for code in (x["row"].days_by_code or {})}
    ordered = [c for c in SUMMARY_CODES if c in used]
    return ordered + sorted(used - set(ordered))


@app.post("/api/timesheet/{action}")
async def timesheet_action(action: str, request: Request):
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    fn_map = {
        "submit": ("submit_timesheet", ()),
        #  Депо отзывает свою сдачу, пока администрация не взяла табель в
        #  работу: опечатка, найденная через минуту после сдачи, не должна
        #  требовать обращения в Минск
        "withdraw": ("withdraw_timesheet", ()),
        "review": ("review_timesheet", ()),
        "approve": ("approve_timesheet", ()),
        "close": ("close_timesheet", ()),
        "reopen": ("reopen_timesheet", (body.get("reason") or "",)),
    }
    if action not in fn_map:
        raise HTTPException(404, "Неизвестное действие")
    fn, extra = fn_map[action]

    with db(uid) as conn:
        unit = unit_or_403(conn, body["unit"])
        ts = webdb.timesheet(conn, unit["id"], p)
        if not ts:
            raise HTTPException(404, "Табель не открыт")
        try:
            webdb.call_transition(conn, fn, ts["id"], *extra)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)
        ts = webdb.timesheet(conn, unit["id"], p)
    return {"ok": True, "status": ts["status"], "status_ru": STATUS_RU.get(ts["status"])}


def _schedule_editable(conn, unit_code: str, period: date):
    """Депо и право на правку графика; сданный график сначала возвращают."""
    unit = unit_or_403(conn, unit_code)
    if not webdb.has_perm(conn, "schedule.write"):
        return unit, "График правят начальник депо и заместитель"
    if webdb.schedule_status(conn, unit["id"], period).get("status") == "submitted":
        return unit, ("График сдан. Скопировать или очистить его можно "
                      "после возврата в работу — это делает Администрация ООУРЦ")
    return unit, None


@app.post("/api/schedule/copy")
async def schedule_copy(request: Request):
    """
    «Скопировать прошлый месяц» (24.09.2026): цикл каждого сотрудника
    продолжается, нераспознанный — по дням недели. Только пустые клетки.
    """
    from . import plancopy
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    with db(uid) as conn:
        unit, err = _schedule_editable(conn, body["unit"], p)
        if err:
            return JSONResponse({"ok": False, "error": err}, status_code=422)
        try:
            webdb.bulk_op(conn)
            res = plancopy.copy_month(conn, webdb, unit["id"], p)
            _recalc_plan(conn, unit["id"], p)
            webdb.log_operation(
                conn, "schedule_copy", unit["id"], p, res["filled"],
                f"График заполнен по прошлому месяцу: клеток {res['filled']}, "
                f"по циклу — {res['by_cycle']} чел., по дням недели — "
                f"{res['by_week']} чел.")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)
    return {"ok": True, **res}


@app.post("/api/schedule/clear")
async def schedule_clear(request: Request):
    """«Очистить график» за выбранный месяц (24.09.2026)."""
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    with db(uid) as conn:
        unit, err = _schedule_editable(conn, body["unit"], p)
        if err:
            return JSONResponse({"ok": False, "error": err}, status_code=422)
        try:
            webdb.bulk_op(conn)
            with conn.cursor() as cur:
                cur.execute(
                    "DELETE FROM app.schedule_plan WHERE org_unit_id = %s "
                    "AND work_date >= %s AND work_date < (%s::date + interval '1 month')",
                    (unit["id"], p, p))
                removed = cur.rowcount
            _recalc_plan(conn, unit["id"], p)
            webdb.log_operation(conn, "schedule_clear", unit["id"], p, removed,
                                f"График за {p:%m.%Y} очищен: удалено клеток — {removed}")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)
    return {"ok": True, "removed": removed}


@app.post("/api/schedule/{action}")
async def schedule_action(action: str, request: Request):
    """
    Сдать плановый график или вернуть его в работу.

    Сдача — это отметка «месяц составлен и выгружен в 1С ЗУП». Она ничего не
    запрещает на будущее: сданный график правится, потому что людей принимают
    и в середине месяца. Но с этого момента каждая правка клетки пишется в
    журнал операций — за этим следит триггер в базе, а не приложение.

    Сдать можно только сошедшийся график: у каждого сумма часов к отработке
    равна его норме месяца. Проверка появилась 21.09.2026 вместе с решением
    держать в графике полную норму независимо от отпусков — без неё
    пропущенные смены под отпуском уехали бы в табель недоработкой.
    """
    uid = require_user(request)
    body = await request.json()
    p = parse_period(body["period"])
    if action not in ("submit", "reopen"):
        raise HTTPException(404, "Неизвестное действие")

    with db(uid) as conn:
        unit = unit_or_403(conn, body["unit"])
        #  02.10.2026 (вычитка 3.22): сначала право, потом норма — раньше
        #  сообщение о несходимости нормы получал и тот, кому сдавать нельзя
        need = "schedule.submit" if action == "submit" else "schedule.reopen"
        if not webdb.has_perm(conn, need):
            return JSONResponse(
                {"ok": False, "error": (
                    "График сдают начальник и Администрация" if action == "submit"
                    else "Вернуть сданный график в работу может только "
                         "Администрация ООУРЦ")},
                status_code=403)
        if action == "submit":
            #  Без нормы месяца сдавать нельзя: сверять не с чем
            if not webdb.month_norm(conn, p):
                return JSONResponse(
                    {"ok": False, "error": (
                        "Норма часов на этот месяц не заведена — сдать график "
                        "нельзя: его не с чем сверить. Норму вносит "
                        "Администрация в «Базовых настройках»")},
                    status_code=422)
            gaps = schedule_norm_gaps(conn, unit["id"], p)
            if gaps:
                return JSONResponse(
                    {"ok": False, "error": schedule_norm_message(gaps)},
                    status_code=422)
        try:
            if action == "submit":
                webdb.submit_schedule(conn, unit["id"], p)
            else:
                webdb.reopen_schedule(conn, unit["id"], p,
                                      body.get("reason") or "")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)
        state = webdb.schedule_status(conn, unit["id"], p)
    return {"ok": True, "status": state["status"],
            "status_ru": SCHEDULE_STATUS_RU.get(state["status"])}


#  Привлечение к работе: докладная и, если нужно, приказ
#
#  Процесс заказчика от 22.09.2026: «первым этапом докладная, далее при
#  необходимости приказ… по итогу оформления готовый пакет для распечатки».
#  Часы и даты вводятся руками — докладную пишут до смены, когда в табеле
#  ещё пусто.
WORKORDER_DENIED = ("Докладные и приказы оформляют начальник депо и "
                    "заместитель")


def _full_organization() -> str:
    """«ООО "Триовист"» из настроек → «Общество с ограниченной … «Триовист»»."""
    raw = os.environ.get("ORGANIZATION", 'ООО "Триовист"').strip()
    name = raw.replace("ООО", "").strip().strip('"«»')
    return f"Общество с ограниченной ответственностью «{name}»"


def _wo_periods(form: Any) -> list[tuple[date, time, time]]:
    """
    Разобрать строки дней из формы.

    Строк может быть несколько: в сверхурочной привлекают на два-три вечера
    подряд, и в документе они идут перечислением. Пустые строки пропускаем —
    в форме их всегда больше, чем заполнят.
    """
    out: list[tuple[date, time, time]] = []
    dates = form.getlist("day_date")
    starts = form.getlist("day_from")
    ends = form.getlist("day_to")
    for i, raw in enumerate(dates):
        if not (raw or "").strip():
            continue
        t_from = (starts[i] if i < len(starts) else "").strip()
        t_to = (ends[i] if i < len(ends) else "").strip()
        if not t_from or not t_to:
            raise ValueError(f"У дня {raw} не указано время начала или конца")
        out.append((parse_day(raw),
                    time.fromisoformat(t_from), time.fromisoformat(t_to)))
    return out


@app.post("/api/workorder")
async def workorder_save(request: Request):
    """Сохранить оформление и вернуть его номер — для кнопки скачивания."""
    uid = require_user(request)
    form = await request.form()
    p = parse_period(form.get("period"))
    with db(uid) as conn:
        unit = unit_or_403(conn, form.get("unit"))
        if not webdb.has_perm(conn, "workorder.write"):
            return JSONResponse({"ok": False, "error": WORKORDER_DENIED},
                                status_code=403)
        try:
            with_order = form.get("with_order") == "1"
            order_id = orderdb.save(
                conn,
                unit_id=unit["id"],
                kind=form.get("kind") or "weekend",
                employment_id=int(form.get("employment_id")),
                report_date=parse_day(form.get("report_date")),
                author_position=form.get("author_position") or "",
                author_fio=form.get("author_fio") or "",
                addressed_post=form.get("addressed_post") or "",
                addressed_fio=form.get("addressed_fio") or "",
                periods=_wo_periods(form),
                with_order=with_order,
                order_date=(parse_day(form.get("order_date"))
                            if with_order and form.get("order_date") else None),
                order_no=form.get("order_no") or "",
                signer_position=form.get("signer_position") or "",
                signer_fio=form.get("signer_fio") or "",
                pay_month=(parse_period(form.get("pay_month"))
                           if form.get("pay_month") else None),
                note=form.get("note") or "",
                user_id=uid,
            )
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return JSONResponse({"ok": False, "error": msg}, status_code=422)
    return {"ok": True, "id": order_id,
            "url": f"/api/workorder/{order_id}/print",
            #  07.10.2026 (правка заказчика): печать как у путевого —
            #  страница-превью, окно печати открывается само
            "page_url": f"/api/workorder/{order_id}/print-page"}


def _wo_data(row) -> "OrderData":
    """OrderData из записи оформления — для Word-пакета и для печати."""
    from .order_print import OrderData
    from .order_print import Period as OrderPeriod

    return OrderData(
        kind=row["kind"],
        #  В названии депо города пишутся без «г.», а в документе оно уже есть
        unit_city=row["unit_name"].replace("г. ", "").strip(),
        person_genitive=row["fio_genitive"],
        person_position=row["position_genitive"].lower(),
        person_short=row["fio_short"],
        periods=[OrderPeriod(d["work_date"], d["time_from"], d["time_to"])
                 for d in row["days"]],
        report_date=row["report_date"],
        author_position=row["author_position"],
        author_fio=row["author_fio"],
        author_short=row["author_short"],
        addressed_post=row["addressed_post"],
        addressed_fio=row["addressed_fio"],
        with_order=row["with_order"],
        order_date=row["order_date"],
        order_no=row["order_no"] or "",
        signer_position=row["signer_position"] or "",
        signer_fio=row["signer_fio"] or "",
        pay_month=row["pay_month"],
        #  Полное наименование собирается из той же переменной окружения,
        #  что и у прочих печатных форм: в ней «ООО "Триовист"», а приказу
        #  нужно «Общество с ограниченной ответственностью «Триовист»»
        organization=_full_organization(),
    )


@app.get("/api/workorder/{order_id}/print")
def workorder_print(request: Request, order_id: int):
    """Готовый пакет: докладная и, если оформлялся, приказ следом."""
    try:
        from .order_print import build as build_order_package
    except ModuleNotFoundError as e:
        #  Говорим, чего не хватает и что с этим делать. «No module named
        #  docx» в браузере не отвечает ни на один из двух вопросов
        raise HTTPException(
            503,
            f"Печать приказа недоступна: не установлен пакет «{e.name}». "
            "Закройте приложение и запустите start_app.cmd — зависимости "
            "ставятся при запуске. Остальные разделы работают.") from e

    uid = require_user(request)
    with db(uid) as conn:
        row = orderdb.one(conn, order_id)
        if not row:
            raise HTTPException(404, "Оформление не найдено")
        if not webdb.can_access_unit(conn, row["org_unit_id"]):
            raise HTTPException(403, "Нет доступа к этому депо")

    data = _wo_data(row)
    kind_slug = "vyhodnoy" if row["kind"] == "weekend" else "sverhurochno"
    name = (f"dokladnaya_{kind_slug}_{row['last_name']}_"
            f"{row['report_date']:%d%m%Y}.docx")
    path = OUT_DIR / name
    build_order_package(data, path)
    return FileResponse(
        path, filename=name,
        media_type="application/vnd.openxmlformats-officedocument"
                   ".wordprocessingml.document")


@app.get("/api/workorder/{order_id}/print-page", response_class=HTMLResponse)
def workorder_print_page(request: Request, order_id: int):
    """Печать пакета как «Путевой» (07.10.2026, правка заказчика):
    страница-превью с панелью «Печать/Закрыть», окно печати открывается
    само, файл не скачивается. Докладная — первая страница, приказ — следом."""
    uid = require_user(request)
    with db(uid) as conn:
        row = orderdb.one(conn, order_id)
        if not row:
            raise HTTPException(404, "Оформление не найдено")
        if not webdb.can_access_unit(conn, row["org_unit_id"]):
            raise HTTPException(403, "Нет доступа к этому депо")
    from .order_html import pages as build_pages
    return templates.TemplateResponse(
        request, "workorder_print.html",
        {"pages": build_pages(_wo_data(row))})


@app.post("/api/workorder/{order_id}/cancel")
async def workorder_cancel(request: Request, order_id: int):
    """
    Аннулировать оформление.

    Заказчик 22.09.2026: «сотрудник может не выйти на работу, а при сверке
    будет требовать эти часы». Запись остаётся — докладную подписал работник,
    — но часов больше не требует.
    """
    uid = require_user(request)
    body = await request.json()
    with db(uid) as conn:
        unit = unit_or_403(conn, body.get("unit"))
        if not webdb.has_perm(conn, "workorder.write"):
            return JSONResponse({"ok": False, "error": WORKORDER_DENIED},
                                status_code=403)
        try:
            orderdb.cancel(conn, order_id, unit["id"],
                           body.get("reason") or "", uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return JSONResponse({"ok": False, "error": str(e)}, status_code=422)
    return {"ok": True}


@app.get("/api/timesheet/print")
def download_tabel(request: Request, unit: str, period: str,
                   employment: int | None = None):
    """
    Выгрузить табель по форме файла «Барановичи 08-26.xlsx».

    Это тот табель, который в ООУРЦ сдают сейчас и под которым подписывается
    ответственный за его ведение, поэтому выгрузка идёт именно в эту форму:
    с блоком «Утверждаю», строкой «ИТОГО ЧАСОВ» и легендой обозначений.
    """
    uid = require_user(request)
    p = parse_period(period)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        ts = webdb.timesheet(conn, u["id"], p)
        if not ts:
            raise HTTPException(404, "Табель не открыт")
        #  Решение заказчика от 16.09.2026: «кнопка скачать табель только у
        #  Администрации ООУРЦ и Админ», после статуса «утверждён» — для
        #  передачи в бухгалтерию. Начальник РЦ сверяет свой месяц на экране,
        #  открыв табель и график.
        #
        #  Запрет стоит здесь, а не только на кнопке: адрес выгрузки легко
        #  сохранить в закладки, и одной кнопкой его не закрыть.
        if not webdb.has_perm(conn, "timesheet.export"):
            raise HTTPException(
                403,
                "Табель для бухгалтерии выгружает Администрация ООУРЦ. "
                "Свой месяц можно сверить на странице сверки и в графике")
        #  Табель по одному сотруднику — для окончательного расчёта
        #  (23.09.2026): «в этот момент администрация скачивает табель по
        #  данному сотруднику». Человек уволился посреди месяца, и ждать
        #  утверждения табеля всего депо значит держать его без расчёта до
        #  начала следующего месяца. Поэтому по увольняемому выгрузка
        #  доступна сразу, пока его расчёт в работе
        settling = False
        if employment:
            who = staffdb.card(conn, employment)
            if not who or who["unit_code"] != u["code"]:
                raise HTTPException(404, "Сотрудник не найден в этом депо")
            settling = who.get("settlement_state") in ("pending", "submitted")
        if ts["status"] not in ("approved", "closed") and not settling:
            raise HTTPException(
                409,
                "Табель за этот месяц ещё не утверждён (сейчас «"
                + STATUS_RU.get(ts["status"], ts["status"])
                + "»). Выгрузка доступна после утверждения")
        rows_db = webdb.people(conn, u["id"], p)
        if employment:
            rows_db = [r for r in rows_db if r["employment_id"] == employment]
        facts = webdb.fact_days(conn, ts["id"])
        with conn.cursor() as cur:
            cur.execute("SELECT chief_name FROM app.org_unit WHERE id = %s", (u["id"],))
            chief = (cur.fetchone() or {}).get("chief_name")

        tabel_rows = []
        for i, r in enumerate(rows_db, start=1):
            days = facts.get(r["employment_id"], [])
            tabel_rows.append(TabelRow(
                no=i,
                fio=r["fio_full"].strip(),
                personnel_no=r["personnel_no"],
                #  24.09.2026: «строго по шаблону» — должность с городом,
                #  «Кладовщик г.Гродно», как в табелях депо
                position=f"{r['position_name']} г.{u['name']}",
                days=[
                    TabelDay(
                        day=f.work_date.day, day_code=f.day_code,
                        hours_day=f.hours_day, hours_night=f.hours_night,
                        hours_weekend=f.hours_weekend, hours_overtime=f.hours_overtime,
                    ) for f in days
                ],
                totals=compute_totals(days),
            ))

    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = (f"tabel_{u['code']}_{p:%Y-%m}_{tabel_rows[0].personnel_no}.xlsx"
                if employment and tabel_rows else f"tabel_{u['code']}_{p:%Y-%m}.xlsx")
    path = OUT_DIR / filename
    #  24.09.2026 («Доработка», п. 4): табель строго по шаблону — как в
    #  файлах депо: организация «ООО"Триовист"», подразделение «РЦ», номер
    #  не проставлен, ответственный за ведение — начальник депо
    export_tabel(
        path=str(path),
        organization=os.environ.get("ORGANIZATION", 'ООО"Триовист"'),
        org_unit="РЦ",
        period_month=p,
        rows=tabel_rows,
        number=None,
        responsible=chief,
    )
    return FileResponse(
        path,
        filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )


@app.get("/api/settlement/{employment_id}/zp")
def download_final_zp(request: Request, employment_id: int, period: str):
    """
    Файл расчёта ЗП по окончательному расчёту — строго по шаблону
    «Рудковский зп» (24.09.2026, «Доработка», п. 4). Выгружает Администрация
    ООУРЦ вместе с табелем сотрудника.
    """
    from .zp_print import export_zp
    uid = require_user(request)
    p = parse_period(period)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "hiring.confirm"):
            raise HTTPException(403, "Расчёт ЗП выгружает Администрация ООУРЦ")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        run = payrolldb.final_run(conn, employment_id, p)
        if not run:
            raise HTTPException(409, "Окончательный расчёт ещё не посчитан")
        lines = payrolldb.run_lines(conn, run["id"])
        with conn.cursor() as cur:
            for l in lines:
                cur.execute(
                    "SELECT k.name, lk.amount FROM app.payroll_line_kpi lk "
                    "  JOIN app.kpi k ON k.id = lk.kpi_id "
                    " WHERE lk.line_id = %s ORDER BY k.id", (l["id"],))
                l["kpis"] = cur.fetchall()
                l["position_label"] = f"{l['position_name']} г.{person['unit_name']}"
        norm = lines[0]["norm_hours"] if lines else None
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = f"zp_{person['personnel_no']}_{p:%Y-%m}.xlsx"
    path = OUT_DIR / filename
    export_zp(str(path), p, norm, lines)
    return FileResponse(
        path, filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")


@app.get("/api/schedule/print")
def download_schedule(request: Request, unit: str, period: str):
    """
    Выгрузить плановый график по форме листа «ГРАФИК ПЕЧАТЬ».

    Это та форма, которую в ООУРЦ печатают и под которой сотрудники
    подписываются об ознакомлении: с блоком «УТВЕРЖДАЮ», расчётной нормой
    месяца, подписями составителя и согласованием профкома. Поэтому
    выгрузка идёт именно в неё, а не в произвольную таблицу.
    """
    uid = require_user(request)
    p = parse_period(period)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        #  Печатная форма идёт с блоком «УТВЕРЖДАЮ» и подписями сотрудников
        #  об ознакомлении. Печатать её с черновика нельзя: люди распишутся
        #  за график, который ещё переставят
        state = webdb.schedule_status(conn, u["id"], p)
        if state["status"] != "submitted":
            raise HTTPException(
                409,
                "График за этот месяц ещё не сдан. Печатная форма доступна "
                "после сдачи графика — кнопка на странице «График»")
        people = webdb.people(conn, u["id"], p)
        cells = webdb.plan_cells(conn, u["id"], p)

        # План мог ни разу не считаться: без часов колонка «Итого часов»
        # вышла бы пустой, а её и смотрят в первую очередь
        ph = plan_hours_fresh(conn, u["id"], p)

        norm = webdb.month_norm(conn, p)
        rows = build_sched_rows(people, cells, ph)

    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = f"grafik_{u['code']}_{p:%Y-%m}.xlsx"
    path = OUT_DIR / filename
    export_schedule(
        path=str(path),
        unit_name=u["full_name"] or u["name"],
        period=p,
        rows=rows,
        norm_hours=float(norm) if norm else None,
    )
    return FileResponse(
        path,
        filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )


# ---------------------------------------------------------------------------
#  Мотивация: расчёт заработной платы и показатели
#
#  Раздел устроен как «Расписание»: один месяц с двух сторон, и вкладки
#  переключаются внутри раздела. «Расчёт ЗП» — то, что в старой системе было
#  листом депо; «Показатели» — то, что там вводилось в центральный файл
#  руками и потом возвращалось в премию через IMPORTRANGE.
#
#  Кто что делает: считает и подтверждает депо, закрывает администрация.
#  Начальник РЦ видит только своё депо — не потому, что список фильтруется в
#  шаблоне, а потому что RLS не отдаст ему чужие строки.
# ---------------------------------------------------------------------------

def motivation_context(conn, uid: int, unit_code: str | None,
                       period: date) -> dict[str, Any]:
    """
    Общий контекст раздела: пользователь, депо, месяц и права.

    Табель здесь не создаётся: расчёт читает часы, а не заводит документ.
    Открытие месяца — дело раздела «Расписание».
    """
    user = webdb.current_user(conn, uid)
    if not webdb.has_perm(conn, "payroll.read"):
        raise HTTPException(403, "Нет доступа к расчёту заработной платы")
    units = webdb.accessible_units(conn)
    if not units:
        raise HTTPException(403, "Нет доступа ни к одному подразделению")

    #  «Все депо» — режим для администрации (пункт 4). Расчёт по-прежнему
    #  идёт по одному депо: считает и подтверждает тот, кто знает своих
    #  людей. Но посмотреть двенадцать городов одной таблицей нужно, и
    #  обходить их по одному через выпадающий список — это двенадцать
    #  переходов ради одной суммы.
    all_units = unit_code == ALL_UNITS and len(units) > 1

    unit = None
    if unit_code and not all_units:
        unit = next((u for u in units if u["code"] == unit_code), None)
    unit = unit or units[0]

    ts = webdb.timesheet(conn, unit["id"], period)
    return {
        "user": user,
        "units": units,
        "unit": unit,
        "all_units": all_units,
        #  Выбор в списке депо: его надо удержать при переходе между
        #  вкладками раздела, иначе «все депо» слетает на первое же депо
        "unit_param": ALL_UNITS if all_units else unit["code"],
        "can_all_units": len(units) > 1,
        "period": period,
        "period_label": f"{MONTHS_RU[period.month - 1]} {period.year}",
        "period_iso": f"{period:%Y-%m}",
        "timesheet": ts,
        "open_requests": webdb.open_staff_requests(conn),
        "can_reference": webdb.has_perm(conn, "reference.write"),
        "can_payroll": True,
        "can_supply": webdb.has_perm(conn, "asset.read"),
        "can_calc": webdb.has_perm(conn, "payroll.calc"),
        "can_confirm": webdb.has_perm(conn, "payroll.confirm"),
        "can_close": webdb.has_perm(conn, "payroll.close"),
        "can_kpi": webdb.has_perm(conn, "kpi.write"),
        #  Удалять согласованную доплату или вычет может только
        #  администратор — отдельное право, выданное одной роли (пункт 7)
        "can_delete_adjustment": webdb.has_perm(conn, "adjustment.delete"),
        #  Отметка на вкладке «Вычеты и доплаты»: сколько записей ждёт решения
        "pending_adjustments": payrolldb.pending_adjustment_count(
            conn, [u["id"] for u in units], period),
        "RUN_STATUS_RU": payrolldb.RUN_STATUS_RU,
    }


def _motivation_back(path: str, unit: str, period: str,
                     msg: str = "", error: str = ""):
    tail = f"{path}?unit={unit}&period={period}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


@app.get("/payroll", response_class=HTMLResponse)
def payroll_page(request: Request, unit: str | None = None,
                 period: str | None = None,
                 msg: str | None = None, error: str | None = None):
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = motivation_context(conn, uid, unit, p)
        unit_id = ctx["unit"]["id"]

        run = payrolldb.latest_run(conn, unit_id, p)
        lines = payrolldb.run_lines(conn, run["id"]) if run else []
        kpi_by_line = payrolldb.run_kpi(conn, run["id"]) if run else {}

        #  Готовность к расчёту проверяем до нажатия кнопки: незаданный
        #  показатель или отсутствующая норма месяца — это не ошибка в
        #  середине расчёта, а причина, по которой его нельзя начинать.
        blockers = _payroll_blockers(conn, unit_id, p)

        if ctx["all_units"]:
            #  Все депо одной таблицей (пункт 4). Собираем последние расчёты
            #  каждого города; у кого расчёта нет — тот просто не даёт строк,
            #  а увидеть это можно в окне статусов выше.
            lines, kpi_by_line = [], {}
            for u in ctx["units"]:
                u_run = payrolldb.latest_run(conn, u["id"], p)
                if not u_run:
                    continue
                for line in payrolldb.run_lines(conn, u_run["id"]):
                    line["unit_name"] = u["name"]
                    lines.append(line)
                kpi_by_line.update(payrolldb.run_kpi(conn, u_run["id"]))
            #  Порядок — по депо, внутри депо прежний: категория, фамилия
            lines.sort(key=lambda r: (r["unit_name"], r["sort_order"],
                                      r["fio_full"]))
            #  Кнопок расчёта в этом режиме нет: считает и подтверждает депо
            run, blockers = None, []

        ctx.update({
            "mode": "payroll",
            "title": "Расчёт заработной платы",
            "run": run,
            "lines": lines,
            "kpi_by_line": kpi_by_line,
            "kpi_columns": payrolldb.kpi_catalog(conn, p),
            "history": [] if ctx["all_units"]
                       else payrolldb.run_history(conn, unit_id, p),
            "totals": _payroll_totals(lines),
            "journal": journal_of(conn, "payroll", unit_id, p),
            "blockers": blockers,
            #  Окно статусов табелей: администратору — все города разом,
            #  начальнику РЦ — своё депо. Без него «почему не считается»
            #  выяснялось обходом вкладок по одному городу (пункт 3)
            "ts_board": webdb.units_overview(conn, p),
            "adjustments": [] if ctx["all_units"]
                           else payrolldb.adjustments(conn, unit_id, p),
            "reasons": payrolldb.adjustment_reasons(conn),
            "people": webdb.people(conn, unit_id, p),
            "msg": msg,
            "error": error,
        })
    return templates.TemplateResponse(request, "payroll.html", ctx)


def _payroll_blockers(conn, unit_id: int, period: date) -> list[str]:
    """Чего не хватает, чтобы считать месяц."""
    out: list[str] = []
    if not payrolldb.month_norm(conn, period):
        out.append("не задана норма рабочего времени месяца "
                   "(«Базовые настройки» → «Норма рабочего времени»)")

    missing = [k["name"] for k in payrolldb.kpi_fact_rows(conn, unit_id, period)
               if k["fact"] is None]
    if missing:
        out.append("не заданы показатели: " + ", ".join(missing)
                   + " — вносятся на вкладке «Показатели»")

    salaries = payrolldb.base_salaries(conn, period)
    if not salaries:
        out.append("не заданы оклады категорий должностей "
                   "(«Базовые настройки» → «Оклады»)")

    #  Расчёт идёт по табелю, и считать его до сдачи нельзя: начальник РЦ
    #  ещё вносит часы и закрывает расхождения на сверке, цифры меняются под
    #  руками. Пункт 3 плана — сначала сдача табеля, потом деньги.
    ts = webdb.timesheet(conn, unit_id, period)
    if not ts:
        out.append("табель за этот месяц не открыт")
    elif ts["status"] == "open":
        left = webdb.open_discrepancies(conn, unit_id, period)
        out.append(
            "табель за этот месяц не сдан"
            + (f" — осталось расхождений: {left}" if left else "")
            + " (сдаётся на вкладке «Сверка и сдача»)")
    return out


def _payroll_totals(lines: list[dict[str, Any]]) -> dict[str, Any]:
    """Итоговая строка таблицы расчёта."""
    fields = (
        "hours_day", "hours_night", "hours_weekend", "hours_overtime",
        "amount_salary", "amount_piecework", "amount_night", "amount_weekend",
        "amount_kpi", "amount_additions", "amount_deductions", "amount_fuel",
        "net_total", "gross_salary", "gross_premium", "gross_night",
        "gross_compensation", "gross_total",
    )
    out: dict[str, Any] = {f: sum((l[f] or 0) for l in lines) for f in fields}
    out["overtime_ref"] = sum(
        (l["hours_overtime"] or 0) * (l["hour_rate"] or 0) for l in lines)
    out["count"] = len(lines)
    return out


@app.post("/payroll/calc")
async def payroll_calc(request: Request, unit: str = Form(...),
                       period: str = Form(...)):
    """
    Посчитать месяц и записать версию.

    Кнопка не «показать цифры», а «зафиксировать расчёт»: результат ложится в
    базу снимком. Повторное нажатие переписывает черновик целиком — двойной
    клик не удваивает месяц, как «Выгрузка» в старой системе.
    """
    uid = require_user(request)
    p = parse_period(period)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "payroll.calc"):
            raise HTTPException(403, "Нет права запускать расчёт")

        blockers = _payroll_blockers(conn, u["id"], p)
        if blockers:
            return _motivation_back(
                "/payroll", unit, period,
                error="Расчёт не запущен: " + "; ".join(blockers))

        people = payrolldb.employee_inputs(conn, u["id"], p)
        if not people:
            return _motivation_back("/payroll", unit, period,
                                    error="В этом месяце в депо нет сотрудников")
        kpis = payrolldb.kpi_inputs(conn, u["id"], p)
        prm = payrolldb.params(conn, p)

        try:
            result = payroll.calculate_run(people, kpis, prm)
            payrolldb.save_run(conn, u["id"], p, result, uid)
        except (payroll.PayrollError, ValueError) as e:
            conn.rollback()
            return _motivation_back("/payroll", unit, period, error=str(e))
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _motivation_back("/payroll", unit, period, error=msg)

    return _motivation_back("/payroll", unit, period,
                            msg=f"Расчёт выполнен: {len(result.lines)} строк")


@app.post("/payroll/{action}")
async def payroll_action(action: str, request: Request, unit: str = Form(...),
                         period: str = Form(...), reason: str = Form("")):
    """Переходы состояния расчёта: подтвердить, вернуть, закрыть, пересчитать."""
    uid = require_user(request)
    p = parse_period(period)
    if action not in ("confirm", "reopen", "close", "recalc"):
        raise HTTPException(404, "Неизвестное действие")

    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        run = payrolldb.latest_run(conn, u["id"], p)
        if not run:
            return _motivation_back("/payroll", unit, period,
                                    error="Расчёт за этот месяц не выполнялся")
        try:
            if action == "confirm":
                payrolldb.confirm_run(conn, run["id"])
                done = "Расчёт подтверждён депо"
            elif action == "reopen":
                payrolldb.reopen_run(conn, run["id"])
                done = "Расчёт возвращён в черновик"
            elif action == "close":
                payrolldb.close_run(conn, run["id"])
                done = "Месяц закрыт, правки расчёта запрещены"
            else:
                version = payrolldb.supersede_run(conn, run["id"], reason)
                done = (f"Открыт перерасчёт, версия {version}. "
                        f"Нажмите «Рассчитать», чтобы заполнить её.")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _motivation_back("/payroll", unit, period, error=msg)
    return _motivation_back("/payroll", unit, period, msg=done)


@app.post("/payroll/adjustment/add")
async def adjustment_add(request: Request, unit: str = Form(...),
                         period: str = Form(...), employee_id: int = Form(...),
                         kind: str = Form(...), reason_id: str = Form(""),
                         amount: str = Form(...), explanation: str = Form(""),
                         back_to: str = Form("")):
    """
    Подать доплату или вычет.

    Подаёт депо, согласует администрация. До согласования запись в расчёт не
    попадает — в отличие от слова «СОГЛАСОВАНО», набранного в ячейке формы.
    """
    uid = require_user(request)
    p = parse_period(period)
    if kind not in ("addition", "deduction"):
        raise HTTPException(400, "Неизвестный вид записи")

    #  24.09.2026 («Доработка», п. 4): поданное из окончательного расчёта
    #  возвращает в окончательный расчёт, а не в «Мотивация → Вычеты и
    #  доплаты». Принимаем только адрес своей страницы расчёта
    def back(msg: str = "", error: str = ""):
        if re.fullmatch(r"/settlement/\d+", back_to or ""):
            return _settlement_back(int(back_to.rsplit("/", 1)[1]), period,
                                    msg=msg, error=error)
        return _motivation_back("/adjustments", unit, period, msg=msg, error=error)

    try:
        value = Decimal(str(amount).replace(",", ".").strip())
    except (InvalidOperation, ValueError):
        return back(error=f"Не понял сумму: {amount}")
    if value <= 0:
        return back(error="Сумма должна быть больше нуля")

    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        try:
            payrolldb.add_adjustment(
                conn, u["id"], p, employee_id, kind,
                int(reason_id) if reason_id else None,
                value, explanation, uid,
            )
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return back(error=msg)
    return back(msg="Запись подана — согласует Администрация ООУРЦ")


@app.post("/payroll/adjustment/{adjustment_id}/decide")
async def adjustment_decide(adjustment_id: int, request: Request,
                            unit: str = Form(...), period: str = Form(...),
                            decision: str = Form(...), reason: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        try:
            if decision == "delete":
                payrolldb.delete_adjustment(conn, adjustment_id)
                done = "Запись убрана"
            elif decision == "delete_approved":
                #  Согласованную убирает только администратор и только с
                #  причиной: правило держит база, здесь лишь передаём ввод
                payrolldb.delete_approved_adjustment(
                    conn, adjustment_id, reason or "")
                done = "Согласованная запись удалена, причина записана в журнал"
            else:
                payrolldb.decide_adjustment(
                    conn, adjustment_id, decision == "approve", reason or None)
                done = ("Согласовано" if decision == "approve" else "Отклонено")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _motivation_back("/adjustments", unit, period, error=msg)
    return _motivation_back("/adjustments", unit, period, msg=done)


@app.get("/adjustments", response_class=HTMLResponse)
def adjustments_page(request: Request, unit: str | None = None,
                     period: str | None = None, kind: str = "all",
                     msg: str | None = None, error: str | None = None):
    """
    Реестр доплат и вычетов — отдельная вкладка (пункт 7).

    Раньше это был раздел внизу страницы расчёта: чтобы дойти до записей,
    надо было прокрутить таблицу на двадцать с лишним колонок. Реестр —
    самостоятельный список, по нему работают, а не заглядывают в него.
    """
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = motivation_context(conn, uid, unit, p)

        if ctx["all_units"]:
            #  Все депо одним реестром: администрации так и удобнее — она
            #  согласует записи всех городов
            rows = []
            for u in ctx["units"]:
                for a in payrolldb.adjustments(conn, u["id"], p):
                    a["unit_name"] = u["name"]
                    a["unit_code"] = u["code"]
                    rows.append(a)
            rows.sort(key=lambda r: (r["unit_name"], r["kind"], r["fio_short"]))
            people = []
        else:
            rows = payrolldb.adjustments(conn, ctx["unit"]["id"], p)
            people = webdb.people(conn, ctx["unit"]["id"], p)

        if kind in ("addition", "deduction"):
            rows = [r for r in rows if r["kind"] == kind]

        run = payrolldb.latest_run(conn, ctx["unit"]["id"], p)
        ctx.update({
            "mode": "adjustments",
            "title": "Доплаты и вычеты",
            "adjustments": rows,
            "kind": kind,
            "reasons": payrolldb.adjustment_reasons(conn),
            "people": people,
            "run": run,
            "totals_adj": _adjustment_totals(rows),
            "journal": journal_of(conn, "payroll", None if ctx["all_units"]
                                  else ctx["unit"]["id"], p),
            "msg": msg,
            "error": error,
        })
    return templates.TemplateResponse(request, "adjustments.html", ctx)


def _adjustment_totals(rows: list[dict[str, Any]]) -> dict[str, Any]:
    """Итоги реестра: сколько согласовано и сколько ещё ждёт решения."""
    def total(kind: str, *statuses: str):
        return sum((r["amount"] or 0) for r in rows
                   if r["kind"] == kind and r["status"] in statuses)

    return {
        "additions_approved": total("addition", "approved"),
        "deductions_approved": total("deduction", "approved"),
        "additions_pending": total("addition", "draft", "pending"),
        "deductions_pending": total("deduction", "draft", "pending"),
        "pending_count": sum(1 for r in rows if r["status"] in ("draft", "pending")),
        "count": len(rows),
    }


#  Выгрузка операций — файл 1С УТ на несколько мегабайт. Больше сорока
#  мегабайт ждать неоткуда: настоящая выгрузка за месяц весит около пяти
OPS_MAX_BYTES = 40 * 1024 * 1024


def _operations_context(conn, uid: int) -> dict[str, Any]:
    """Шапка окна загрузки: кто вошёл, что грузили раньше."""
    return {
        "user": webdb.current_user(conn, uid),
        "units": webdb.accessible_units(conn),
        "unit": webdb.accessible_units(conn)[0],
        "mode": "operations",
        "title": "Загрузка операций",
        "loads": opsimport.loads(conn),
        "open_requests": webdb.open_staff_requests(conn),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
        "can_reference": webdb.has_perm(conn, "reference.write"),
    }


@app.get("/operations", response_class=HTMLResponse)
def operations_page(request: Request):
    """
    Окно загрузки операций кладовщиков — отдельное, по просьбе заказчика.

    Файл выбирается в проводнике кнопкой, а не перетаскивается на .cmd:
    перетаскивание работает, но объяснять его каждому новому человеку
    дороже, чем один экран.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(
                403,
                "Операции загружает администрация: выгрузка приходит сразу по "
                "всем депо, и класть её по частям нельзя")
        ctx = _operations_context(conn, uid)
        ctx["result"] = None
    return templates.TemplateResponse(request, "operations.html", ctx)


@app.post("/operations", response_class=HTMLResponse)
async def operations_upload(request: Request,
                            file: UploadFile = File(...),
                            check_only: str = Form("")):
    """
    Принять выгрузку и записать выработку.

    Отчёт показывается тут же, а не уносится редиректом: в нём списки на
    сотни строк — кто не найден, у кого нет учётки ТСД, — и потерять их
    между страницами нельзя.
    """
    uid = require_user(request)
    data = await file.read()

    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Операции загружает администрация")
        ctx = _operations_context(conn, uid)
        ctx["result"] = None

        if not data:
            ctx["error"] = "Файл пустой"
        elif len(data) > OPS_MAX_BYTES:
            ctx["error"] = (
                f"Файл великоват — {len(data) / 1024 / 1024:.1f} МБ. "
                "Выгрузка за месяц весит около пяти")
        else:
            try:
                sheet = opsimport.open_sheet(data=data)
                imp, period, rows = opsimport.load(
                    conn, sheet,
                    note=f"1С УТ, {file.filename}",
                    dry_run=bool(check_only))
            except opsimport.OpsFileError as e:
                conn.rollback()
                ctx["error"] = str(e)
            except psycopg.Error as e:
                conn.rollback()
                ctx["error"] = ((getattr(e, "diag", None)
                                 and e.diag.message_primary) or str(e))
            else:
                ctx["result"] = {
                    "file": file.filename,
                    "period": period,
                    "period_label": f"{MONTHS_RU[period.month - 1]} {period.year}",
                    "rows": rows,
                    "check_only": bool(check_only),
                    "report": imp.report,
                    "unknown_people": imp.unknown_people,
                    "unknown_ops": imp.unknown_ops,
                    "ambiguous": imp.ambiguous,
                    "no_name": imp.no_name,
                    "without_tsd": imp.without_tsd,
                }
                #  История перечитывается после записи: только что созданная
                #  загрузка должна быть в списке
                ctx["loads"] = opsimport.loads(conn)
    return templates.TemplateResponse(request, "operations.html", ctx)


def _staff_nav_ctx(conn, uid: int, unit: dict | None) -> dict[str, Any]:
    """
    Всё, что нужно строке поиска и вкладкам раздела «Сотрудники»
    (`_staff_nav.html`) на странице, которая сама не список сотрудников.
    """
    base = staff_context(conn, uid)
    unit_id = unit["id"] if unit else None
    can_confirm = webdb.has_perm(conn, "hiring.confirm")
    can_users = webdb.has_perm(conn, "user.manage")
    can_candidates = webdb.has_perm(conn, "candidate.write")
    cc = staffdb.candidate_counts(conn, unit_id) if can_candidates else {}
    can_penalty_read = base["can_penalty_read"]
    return {
        "can_penalty_read": can_penalty_read,
        "penalty_count": (penaltydb.penalty_count(conn, unit_id)
                          if can_penalty_read else 0),
        "all_units": base["all_units"],
        "sel_unit": unit,
        "unit_param": unit["code"] if unit else "all",
        "q": "",
        "tabs": STAFF_TABS,
        "counts": staffdb.staff_counts(conn, unit_id),
        "can_confirm": can_confirm,
        "can_users": can_users,
        "can_candidates": can_candidates,
        "pending_count": len(staffdb.unconfirmed(conn)) if can_confirm else 0,
        "reset_count": staffdb.reset_requests_count(conn) if can_users else 0,
        "cand_count": cc.get("active", 0) + cc.get("review", 0),
    }


@app.get("/settlement/{employment_id}", response_class=HTMLResponse)
def settlement_page(request: Request, employment_id: int,
                    period: str | None = None,
                    msg: str | None = None, error: str | None = None):
    """
    Окончательный расчёт при увольнении — пункт 27 плана.

    Собирает в одном месте всё, что нужно закрыть по уходящему: часы из
    табеля, сделку по загруженным операциям, показатели, вычеты и доплаты.
    Считается тем же движком, что и месячный расчёт: два разных ответа на
    вопрос «сколько человек заработал» недопустимы.

    Месяц по умолчанию — месяц увольнения, а не текущий: расчёт делают в тот
    же день, но вернуться к нему могут и позже.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "payroll.read"):
            raise HTTPException(403, "Нет доступа к расчёту заработной платы")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")

        p = (parse_period(period) if period
             else (person["terminated_at"] or date.today()).replace(day=1))
        unit = webdb.unit_by_code(conn, person["unit_code"])
        if not unit or not webdb.can_access_unit(conn, unit["id"]):
            raise HTTPException(403, "Нет доступа к этому депо")

        blockers = payrolldb.final_blockers(conn, unit["id"], p, employment_id)
        preview = None
        if not blockers:
            try:
                preview = payrolldb.final_preview(conn, unit["id"], p, employment_id)
            except payroll.PayrollError as e:
                blockers.append(str(e))

        run = payrolldb.final_run(conn, employment_id, p)
        #  Вкладки раздела «Сотрудники» — те же, что в списке (23.09.2026):
        #  «когда открываешь окончательный расчёт, не должно пропадать поле с
        #  вкладками». Подсвечена та вкладка, где человек сейчас стоит
        nav = _staff_nav_ctx(conn, uid, unit)
        nav["tab"] = ("dismissed" if person.get("settlement_state") == "accepted"
                      else "requests")
        #  Кто что делает (23.09.2026): депо проверяет табель, вносит вычеты
        #  и доплаты и отправляет; итоговый расчёт делает администрация и
        #  скачивает табель по сотруднику
        is_hq = webdb.has_perm(conn, "hiring.confirm")
        ctx = {
            **nav,
            "is_hq": is_hq,
            "settle_state": person.get("settlement_state"),
            "settle_note": person.get("settlement_note"),
            "can_submit": (webdb.has_perm(conn, "payroll.read")
                           and person.get("settlement_state") == "pending"),
            #  24.09.2026: что ещё не сдано — СИЗ, техника, ТСД
            "outstanding": staffdb.settlement_outstanding(conn, employment_id),
            "user": webdb.current_user(conn, uid),
            "units": webdb.accessible_units(conn),
            "unit": unit,
            "mode": "staff",
            "title": "Окончательный расчёт",
            "person": person,
            "period": p,
            "period_label": f"{MONTHS_RU[p.month - 1]} {p.year}",
            "period_iso": f"{p:%Y-%m}",
            "blockers": blockers,
            "preview": preview,
            "run": run,
            "lines": payrolldb.run_lines(conn, run["id"]) if run else [],
            "adjustments": [a for a in payrolldb.adjustments(conn, unit["id"], p)
                            if a["employee_id"] == person["employee_id"]],
            "reasons": payrolldb.adjustment_reasons(conn),
            "timesheet": webdb.timesheet(conn, unit["id"], p),
            #  Итоговый расчёт — администрации (23.09.2026). Право считать
            #  зарплату у начальника депо есть для месячного расчёта своего
            #  депо, но окончательный он не считает: он его проверяет
            "can_calc": webdb.has_perm(conn, "payroll.calc") and is_hq,
            "can_run_confirm": is_hq,
            "open_requests": webdb.open_staff_requests(conn),
            "can_payroll": True,
            "can_supply": webdb.has_perm(conn, "asset.read"),
            "can_reference": webdb.has_perm(conn, "reference.write"),
            "RUN_STATUS_RU": payrolldb.RUN_STATUS_RU,
            "msg": msg,
            "error": error,
        }
    return templates.TemplateResponse(request, "settlement.html", ctx)


@app.post("/settlement/{employment_id}/calc")
async def settlement_calc(employment_id: int, request: Request,
                          period: str = Form(...)):
    """
    Посчитать и записать окончательный расчёт.

    Месячному расчёту депо он не мешает: у них разный вид, и незакрытая
    версия считается по виду отдельно.
    """
    uid = require_user(request)
    p = parse_period(period)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "payroll.calc"):
            raise HTTPException(403, "Нет права запускать расчёт")
        #  Итоговый расчёт при увольнении делает администрация (23.09.2026)
        if not webdb.has_perm(conn, "hiring.confirm"):
            raise HTTPException(403, "Окончательный расчёт считает Администрация "
                                     "ООУРЦ. Депо проверяет табель, вносит "
                                     "вычеты и доплаты и отправляет")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        unit = unit_or_403(conn, person["unit_code"])

        blockers = payrolldb.final_blockers(conn, unit["id"], p, employment_id)
        if blockers:
            return _settlement_back(employment_id, period,
                                    error="Расчёт не запущен: " + "; ".join(blockers))
        try:
            people = payrolldb.employee_inputs(conn, unit["id"], p, employment_id)
            kpis = payrolldb.kpi_inputs(conn, unit["id"], p)
            prm = payrolldb.params(conn, p)
            result = payroll.calculate_run(people, kpis, prm)
            payrolldb.save_final_run(conn, unit["id"], p, employment_id, result, uid)
        except (payroll.PayrollError, ValueError) as e:
            conn.rollback()
            return _settlement_back(employment_id, period, error=str(e))
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settlement_back(employment_id, period, error=msg)
    return _settlement_back(employment_id, period,
                            msg="Окончательный расчёт выполнен")


@app.post("/settlement/{employment_id}/{action}")
async def settlement_action(employment_id: int, action: str, request: Request,
                            period: str = Form(...), reason: str = Form("")):
    """Подтвердить окончательный расчёт, вернуть в черновик или закрыть."""
    uid = require_user(request)
    p = parse_period(period)
    if action not in ("confirm", "reopen", "close"):
        raise HTTPException(404, "Неизвестное действие")

    with db(uid) as conn:
        #  02.10.2026 (вычитка 2.25): окончательный расчёт целиком у
        #  Администрации — депо его формирует табелем, вычетами и доплатами
        #  и отправляет, но не подтверждает и не возвращает
        if not webdb.has_perm(conn, "hiring.confirm"):
            raise HTTPException(403, "Окончательный расчёт подтверждает и "
                                     "закрывает Администрация ООУРЦ")
        person = staffdb.card(conn, employment_id)
        if not person:
            raise HTTPException(404, "Сотрудник не найден")
        unit_or_403(conn, person["unit_code"])
        run = payrolldb.final_run(conn, employment_id, p)
        if not run:
            return _settlement_back(employment_id, period,
                                    error="Окончательный расчёт ещё не выполнен")
        try:
            if action == "confirm":
                payrolldb.confirm_run(conn, run["id"])
            elif action == "close":
                payrolldb.close_run(conn, run["id"])
            else:
                payrolldb.reopen_run(conn, run["id"])
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _settlement_back(employment_id, period, error=msg)
    done = {"confirm": "Расчёт подтверждён", "close": "Расчёт закрыт",
            "reopen": "Расчёт возвращён в черновик"}[action]
    return _settlement_back(employment_id, period, msg=done)


def _settlement_back(employment_id: int, period: str,
                     msg: str = "", error: str = ""):
    tail = f"/settlement/{employment_id}?period={period}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


WEEKDAYS_RU = ["понедельник", "вторник", "среда", "четверг", "пятница",
               "суббота", "воскресенье"]


def _kanban_span_nav(span: str, at_day: date, monday: date,
                     today: date) -> dict[str, Any]:
    """
    Подпись периода и стрелки для выбранного масштаба (23.09.2026).

    `nav` — хвост адреса текущего периода: его уносят формы на задачах, чтобы
    после отметки вернуться туда же, а не на текущую неделю.
    """
    if span == "day":
        prev_d, next_d = at_day - timedelta(days=1), at_day + timedelta(days=1)
        return {
            "period_label": f"{at_day:%d.%m.%Y}, {WEEKDAYS_RU[at_day.weekday()]}",
            "is_current": at_day == today,
            "current_tag": "сегодня",
            "prev_q": f"span=day&day={prev_d.isoformat()}",
            "next_q": f"span=day&day={next_d.isoformat()}",
            "nav": f"span=day&day={at_day.isoformat()}",
        }
    if span == "month":
        first = at_day.replace(day=1)
        prev_m = (first - timedelta(days=1)).replace(day=1)
        next_m = (first + timedelta(days=32)).replace(day=1)
        return {
            "period_label": f"{MONTHS_RU[first.month - 1]} {first.year}",
            "is_current": first == today.replace(day=1),
            "current_tag": "текущий месяц",
            "prev_q": f"span=month&month={prev_m:%Y-%m}",
            "next_q": f"span=month&month={next_m:%Y-%m}",
            "nav": f"span=month&month={first:%Y-%m}",
        }
    sunday = monday + timedelta(days=6)
    return {
        "period_label": f"{monday:%d.%m} — {sunday:%d.%m.%Y}",
        "is_current": monday == kanbandb.week_start(today),
        "current_tag": "текущая неделя",
        "prev_q": f"span=week&week={(monday - timedelta(days=7)).isoformat()}",
        "next_q": f"span=week&week={(monday + timedelta(days=7)).isoformat()}",
        "nav": f"span=week&week={monday.isoformat()}",
    }


def _kanban_window(span: str, day: str | None, week: str | None,
                   month: str | None, today: date) -> tuple[date, date, list]:
    """
    Опорный день, неделя и все недели выбранного периода (24.09.2026).

    Доска живёт неделями: «день» — срез его недели, «неделя» — одна неделя,
    «месяц» — все недели, которые в него попали.
    """
    if span == "day":
        at_day = parse_day(day) if day else today
        monday = kanbandb.week_start(at_day)
        return at_day, monday, [monday]
    if span == "month":
        if month:
            first = parse_period(month)
        elif week:
            first = parse_day(week).replace(day=1)
        else:
            first = today.replace(day=1)
        last = date(first.year, first.month,
                    calendar.monthrange(first.year, first.month)[1])
        weeks, w = [], kanbandb.week_start(first)
        while w <= last:
            weeks.append(w)
            w += timedelta(days=7)
        #  Опорная неделя — текущая, если месяц текущий, иначе первая
        monday = (kanbandb.week_start(today)
                  if first == today.replace(day=1) else weeks[0])
        return first, monday, weeks
    monday = kanbandb.week_start(parse_day(week)) if week else kanbandb.week_start(today)
    return monday, monday, [monday]


def _kanban_span_filter(tasks: list, span: str, at_day: date,
                        today: date) -> list:
    """Задачи, которые относятся к выбранному дню или месяцу."""
    if span == "day":
        if at_day == today:
            #  На сегодня: то, что просрочено или подходит сегодня. Задача
            #  без срока — тоже сегодняшняя: её никто не отложил на потом.
            #  Очередь Минска — заявки и согласования из городов — видна
            #  сегодня вся: пришла, значит, её уже можно и нужно разбирать
            return [t for t in tasks
                    if t["due_at"] is None or t["due_at"] <= today
                    or t["kind"] in kanbandb.HQ_KINDS]
        #  Другой день — то, что приходится именно на него
        return [t for t in tasks if t["due_at"] == at_day]
    if span == "month":
        #  Крайние недели захватывают соседние месяцы: в месяце — только его
        #  сроки и задачи без срока
        return [t for t in tasks if t["due_at"] is None
                or (t["due_at"].year, t["due_at"].month)
                == (at_day.year, at_day.month)]
    return tasks


@app.get("/kanban", response_class=HTMLResponse)
def kanban_page(request: Request, unit: str | None = None,
                week: str | None = None, view: str = "board",
                span: str = "week", day: str | None = None,
                month: str | None = None,
                who: str = "all", hide: int = 0, state: str = "",
                msg: str | None = None, error: str | None = None):
    """
    Доска задач на неделю — пункт 24 плана.

    Начальник РЦ видит свою доску, администрация — ещё и сводку по всем депо:
    «центральное окно, где он может посмотреть доску каждого из начальников
    отдельно, а также отдельной вкладкой результат его работы».

    Доска обновляется при открытии: новые задачи появляются, исчезнувшие
    закрываются сами. Отдельной кнопки «обновить» нет намеренно — человек
    заходит посмотреть, что делать, а не обслуживать доску.
    """
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        #  30.09.2026 (вычитка 1.24): доска — рабочая очередь, наблюдателю
        #  в ней делать нечего: он не выполняет и не откладывает задачи
        #  02.10.2026: то же для кабинетов служб — у них нет рабочей очереди
        #  депо, а действовать по доске «Минск» им нельзя. Вместо ошибки —
        #  своя стартовая страница
        if user and user["read_only"]:
            return RedirectResponse(user["start_page"], status_code=303)
        units = webdb.accessible_units(conn)
        if not units:
            raise HTTPException(403, "Нет доступа ни к одному подразделению")
        can_all = len(units) > 1
        #  Доска «Минск» (24.09.2026): у администрации своя доска — очередь
        #  согласований со всех городов, а не доска одного депо. Выбор депо
        #  у администрации убран: «Доска» — это Минск, «Результат по депо» —
        #  все депо списком. Доску конкретного депо по-прежнему можно
        #  открыть кнопкой «Смотреть доску» из сводки
        hq = kanbandb.hq_unit(conn) if can_all else None
        if unit == "*":
            view = "summary"
            unit = None
        if hq and unit in (None, "", hq["code"]):
            sel = {**hq, "name": hq["name"] or "Минск"}
            is_minsk = True
        else:
            sel = (next((u for u in units if u["code"] == unit), None)
                   or units[0])
            is_minsk = False

        today = date.today()
        if span not in ("day", "week", "month"):
            span = "week"
        at_day, monday, weeks = _kanban_window(span, day, week, month, today)
        ready = kanbandb.has_kanban(conn)
        this_week = kanbandb.week_start(today)

        def unit_tasks(unit_id: int) -> tuple[list, Any]:
            """Задачи депо за выбранный период — одинаково для доски и сводки."""
            stats = None
            if not ready:
                return [], stats
            for w in weeks:
                #  Прошлые недели — история, их не пересчитываем. Текущую —
                #  на сегодня, будущие — по их последнему дню: неделя (и
                #  месяц) показывает всё, что за неё предстоит сделать.
                #  Раньше «Месяц» наполнял только текущую неделю, и задачи на
                #  конец месяца в нём не появлялись (исправлено 24.09.2026)
                if w >= this_week:
                    as_of = today if w == this_week else w + timedelta(days=6)
                    got = kanbandb.refresh(conn, unit_id, as_of, week=w)
                    if w == monday:
                        stats = got
            #  Одна задача живёт на доске каждой недели, где её причина
            #  была. В месяце показываем её один раз — с той недели, что
            #  ближе всего к текущей: там её нынешнее состояние. Раньше
            #  задачи месяца задваивались (найдено 24.09.2026)
            order = sorted(weeks, key=lambda w: (w > this_week,
                                                 abs((w - this_week).days)))
            seen, out = set(), []
            for w in order:
                for t in kanbandb.board(conn, unit_id, w):
                    if t["task_key"] not in seen:
                        seen.add(t["task_key"])
                        out.append(t)
            return _kanban_span_filter(out, span, at_day, today), stats

        tasks, stats = unit_tasks(sel["id"])
        #  Трансляция персональных задач на доску «Минск» (вычитка
        #  30.09.2026, п. 6.4.1): Администрация видит поставленные ею
        #  поручения и их состояние, не открывая двенадцать досок. Сами
        #  строки лежат в депо и меняются там — здесь только чтение
        if is_minsk and ready:
            tasks = tasks + kanbandb.personal_tasks(conn, weeks)
        #  Состояние на экране (п. 6.1–6.2): «Просрочено» и «вернувшееся»
        #  вычисляются от сегодняшнего дня, а не хранятся в строке недели
        for t in tasks:
            t["eff"] = kanbandb.effective_status(t, today)
        #  Часть задач адресована не всем в депо: «заполнить табель за сутки»
        #  видят начальник и заместители, у которых есть право на график
        tasks = [t for t in tasks
                 if t["kind"] not in kanbandb.RESTRICTED_KINDS
                 or webdb.has_perm(conn, kanbandb.RESTRICTED_KINDS[t["kind"]])]
        #  Фильтры и порядок (24.09.2026): «фильтрацию по срокам, от
        #  ближайшей даты до менее актуальной», задачи по людям и по технике,
        #  и скрыть выполненные и отложенные
        if who not in ("all", "people", "tech"):
            who = "all"
        if who == "people":
            tasks = [t for t in tasks if t["kind"] in kanbandb.PEOPLE_KINDS]
        elif who == "tech":
            tasks = [t for t in tasks if t["kind"] in kanbandb.TECH_KINDS]
        #  Иерархия состояний (вычитка 30.09.2026, п. 6.2) — во всех режимах
        #  времени и состава: вернувшиеся из переноса наверху, дальше
        #  просроченные, работа, отложенные, выполненные; внутри — по сроку
        tasks.sort(key=lambda t: kanbandb.board_order(t, today))
        all_tasks = tasks
        #  24.09.2026: фильтр по состоянию — щелчком по карточкам счётчиков.
        #  30.09.2026: карточка «Просрочено» — четвёртая, тоже кликабельная;
        #  «Отложено» включает и вернувшиеся из переноса (это тоже
        #  «Отложено», просто его день настал)
        if hide and not state:
            state = "open"
        if state not in ("open", "done", "skipped", "overdue"):
            state = ""
        if state == "open":
            tasks = [t for t in tasks if t["eff"] == "open"]
        elif state == "done":
            tasks = [t for t in tasks if t["eff"] in kanbandb.DONE_STATUSES]
        elif state == "skipped":
            tasks = [t for t in tasks
                     if t["eff"] in ("skipped", "returned")]
        elif state == "overdue":
            tasks = [t for t in tasks if t["eff"] == "overdue"]
        flt = "&".join(x for x in (f"who={who}" if who != "all" else "",
                                   f"state={state}" if state else "") if x)

        #  Сводка по депо — за тот же период, что выбран кнопками, и по
        #  свежим доскам: раньше она считала только неделю и только те депо,
        #  чью доску кто-то открывал
        summary_rows = []
        if ready and can_all and view == "summary":
            for u in units:
                ut, _ = unit_tasks(u["id"])
                #  Состояния сводки — экранные (п. 6.2): «Просрочено»
                #  включает и истёкшие переносы, «Отложено» — вернувшиеся
                effs = [kanbandb.effective_status(t, today) for t in ut]
                row = {"id": u["id"], "code": u["code"], "name": u["name"],
                       "total": len(ut),
                       "open": sum(1 for e in effs if e == "open"),
                       "done": sum(1 for e in effs if e == "done"),
                       "auto_done": sum(1 for e in effs if e == "auto_done"),
                       "skipped": sum(1 for e in effs
                                      if e in ("skipped", "returned")),
                       "overdue": sum(1 for e in effs if e == "overdue")}
                row["closed"] = row["done"] + row["auto_done"]
                row["share"] = (round(row["closed"] / row["total"] * 100)
                                if row["total"] else None)
                summary_rows.append(row)

        ctx = {
            "user": user,
            "units": units,
            "unit": sel,
            "mode": "kanban",
            "title": "Доска задач",
            "view": view if view in ("board", "summary") else "board",
            #  02.10.2026 (вычитка 9.6): журнал доски — переносы, отметки
            #  «Выполнено», персональные задачи; раньше нигде не показывался
            "journal": journal_of(conn, "kanban",
                                  None if can_all else sel["id"], None),
            "monday": monday,
            "sunday": monday + timedelta(days=6),
            "prev_week": monday - timedelta(days=7),
            "next_week": monday + timedelta(days=7),
            "this_week": kanbandb.week_start(),
            #  ДЗ-5 (21.09.2026): день, неделя или месяц
            "span": span,
            **_kanban_span_nav(span, at_day, monday, today),
            "span_ru": {"day": "на сегодня", "week": "на неделю",
                        "month": "на месяц"}[span],
            "tasks": tasks,
            "who": who,
            "hide": state == "open",
            "state": state,
            #  хвост адреса фильтров — переносится в ссылки периода
            "flt_q": ("&" + flt) if flt else "",
            #  Весь столбец «кого касается» кликабелен: ТО ведёт в карточку
            #  техники, СИЗ — в карточку сотрудника на вкладку СИЗ, табель —
            #  на свой экран (требование от 22.09.2026)
            "task_links": (kanbandb.subject_urls(conn, sel["id"], sel["code"],
                                                 monday, tasks)
                           if ready else {}),
            "summary": summary_rows,
            "can_all": can_all,
            "is_minsk": is_minsk,
            "hq": hq,
            "ready": ready,
            "refreshed": stats,
            "open_requests": webdb.open_staff_requests(conn),
            "can_payroll": webdb.has_perm(conn, "payroll.read"),
            "can_supply": webdb.has_perm(conn, "asset.read"),
            "can_reference": webdb.has_perm(conn, "reference.write"),
            "today_date": date.today(),
            #  Минимальная дата переноса: отложить на сегодня или на вчера
            #  значит не отложить вовсе
            "tomorrow": (date.today() + timedelta(days=1)).isoformat(),
            "msg": msg,
            "error": error,
        }
        #  Счётчики — по задачам с учётом «Люди / Техника», но без фильтра
        #  по состоянию: иначе карточка «выполнено» всегда показывала бы
        #  ноль. Состояния — экранные (п. 6.2): «просрочено» — открытые со
        #  прошедшим сроком и истёкшие переносы, «отложено» — вместе с
        #  вернувшимися, «выполнено» — кнопкой и самой работой
        if flt:
            ctx["nav"] = ctx["nav"] + "&" + flt
        effs = [t["eff"] for t in all_tasks]
        ctx["counts"] = {
            "open": sum(1 for e in effs if e == "open"),
            "overdue": sum(1 for e in effs if e == "overdue"),
            "done": sum(1 for e in effs if e in kanbandb.DONE_STATUSES),
            "skipped": sum(1 for e in effs
                           if e in ("skipped", "returned")),
        }
        #  Кому Администрация может поставить персональную задачу (6.4.1):
        #  депо, без самой доски «Минск»
        ctx["personal_units"] = ([u for u in units if not hq or u["id"] != hq["id"]]
                                 if can_all else [])
    return templates.TemplateResponse(request, "kanban.html", ctx)


@app.get("/kanban/stamp")
def kanban_stamp(request: Request, unit: str):
    """
    Отпечаток доски недели (02.10.2026, вычитка 6.2): «доска задач должна
    обновляться автоматически при добавлении задач». Страница доски раз в
    минуту спрашивает отпечаток; если задачи появились или сменили
    состояние — перерисовывается сама (если человек ничего не заполняет).
    Пересчёт тот же, что при открытии доски, — новые задачи правил
    появляются без перехода по страницам.
    """
    uid = require_user(request)
    with db(uid) as conn:
        who = webdb.current_user(conn, uid)
        if who and who["read_only"]:
            raise HTTPException(403, "Доска задач этой учётке не показывается")
        u = unit_or_403(conn, unit)
        if not kanbandb.has_kanban(conn):
            return {"stamp": ""}
        today = date.today()
        kanbandb.refresh(conn, u["id"], today)
        rows = kanbandb.board(conn, u["id"], kanbandb.week_start(today))
    sig = sorted(f"{r['id']}:{r['status']}" for r in rows)
    import hashlib
    return {"stamp": hashlib.sha1("|".join(sig).encode()).hexdigest()[:16],
            "count": len(rows)}


@app.post("/kanban/task/{task_id}")
async def kanban_task_close(task_id: int, request: Request):
    """
    Отложить задачу, вернуть её в работу или выполнить.

    «ВЫПОЛНИТЬ» (переименовано 30.09.2026, п. 6.5) — не отметка о намерении,
    а запрос на проверку (16.09.2026): система пересчитывает свои правила и
    смотрит, исчезла ли причина задачи. Исчезла — закрывает, нет — отказывает
    и объясняет, что данные ещё не внесены. У ручных и персональных задач
    проверять нечего, там обязателен комментарий о сделанном.

    Поля читаем из request.form(), а не из Form(...): декларированный
    File() заставил бы FastAPI требовать multipart у каждой формы доски —
    а «Отложить» и «Вернуть в работу» отправляются как urlencoded.
    request.form() понимает оба, файл приходит как UploadFile.
    Персональная задача (п. 6.4.1) закрывается с отчётом: обязательное
    примечание и, по желанию, ссылка или файл (`link`, `file`).
    """
    uid = require_user(request)
    from . import filestore
    from starlette.datastructures import UploadFile as StarletteUpload

    form = await request.form()
    unit = form.get("unit") or ""
    week = form.get("week") or ""
    status = form.get("status") or ""
    note = form.get("note") or ""
    until = form.get("until") or ""
    nav = form.get("nav") or ""
    link = form.get("link") or ""
    file = form.get("file")

    stored = orig_name = None
    if isinstance(file, StarletteUpload) and status == "done":
        data = await file.read(filestore.MAX_BYTES + 1)
        if data:
            try:
                st = filestore.save(data, area="kanban")
            except filestore.FileRejected as e:
                return RedirectResponse(
                    f"/kanban?unit={unit}&{_kanban_back(week, nav)}"
                    f"&error={quote(str(e))}", status_code=303)
            stored = st.stored_name
            orig_name = file.filename or st.stored_name
    with db(uid) as conn:
        #  30.09.2026 (вычитка 1.24): наблюдатель ничего не меняет —
        #  в том числе не откладывает и не отмечает задачи
        who = webdb.current_user(conn, uid)
        if who and who["read_only"]:
            raise HTTPException(403, "Наблюдатель ничего не меняет: "
                                     "доступ только на просмотр")
        unit_or_403(conn, unit)
        #  02.10.2026: персональную задачу закрывает депо, а не Минск
        if unit == "hq" and kanbandb.task_kind(conn, task_id) == "personal":
            raise HTTPException(403, "Персональную задачу выполняет депо — "
                                     "на доске «Минск» она только видна")
        try:
            #  06.10.2026 (вечер): «Выполнить» на предложении по доработке
            #  гасит его в таблице предложений — иначе проверка «реально ли
            #  сделано» снова находила бы причину и не пускала
            if status == "done":
                kanbandb.suggestion_settle(conn, task_id, uid)
            kanbandb.close_task(
                conn, task_id, status, note or None, uid,
                parse_day(until) if until.strip() else None,
                result_link=(link.strip() or None) if status == "done" else None,
                result_file=stored,
                result_file_name=orig_name)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/kanban?unit={unit}&{_kanban_back(week, nav)}"
                f"&error={quote(text)}", status_code=303)
    done = {"skipped": "Задача отложена", "open": "Задача вернулась в работу",
            "done": "Отметка сохранена"}
    return RedirectResponse(
        f"/kanban?unit={unit}&{_kanban_back(week, nav)}"
        f"&msg={quote(done.get(status, 'Отметка сохранена'))}",
        status_code=303)


@app.post("/kanban/personal")
def kanban_personal_create(request: Request, depot: str = Form(...),
                           subject: str = Form(...), due: str = Form(...),
                           title: str = Form(...),
                           kind_label: str = Form(...),
                           nav: str = Form("")):
    """
    Поставить персональную задачу (вычитка 30.09.2026, п. 6.4.1).

    Форма живёт на вкладке «Результат по депо» и доступна тем, кто видит
    больше одного депо, — Администрации ООУРЦ. Все четыре поля постановки
    обязательны: «кого касается», «срок», «что сделать», «вид» — окно
    выполнения потом показывает их начальнику РЦ как условие задачи.
    """
    uid = require_user(request)
    with db(uid) as conn:
        who = webdb.current_user(conn, uid)
        if who and who["read_only"]:
            raise HTTPException(403, "Наблюдатель ничего не меняет: "
                                     "доступ только на просмотр")
        units = webdb.accessible_units(conn)
        if len(units) < 2:
            raise HTTPException(
                403, "Персональную задачу ставит Администрация ООУРЦ — "
                     "доступ больше чем к одному депо")
        unit_row = next((u for u in units if u["code"] == depot), None)
        due_at = parse_day(due) if due.strip() else None
        #  Возврат на сводку: хвост адреса из формы, если он похож на адрес,
        #  — иначе текущая неделя
        back = (nav if re.fullmatch(r"[a-z]+=[0-9a-z-]+(&[a-z]+=[0-9a-z-]+)*",
                                    nav or "") else "span=week")
        problems = ((None if unit_row else "Выберите депо, на чью доску поставить задачу"),
                    (None if due_at else "Укажите срок задачи"))
        problems += tuple(
            f"Заполните «{label}»: без него задача на доске не прочитается"
            for value, label in ((subject.strip(), "кого касается"),
                                 (title.strip(), "что сделать"),
                                 (kind_label.strip(), "вид"))
            if not value)
        if any(problems):
            first = next(p for p in problems if p)
            return RedirectResponse(
                f"/kanban?view=summary&{back}"
                f"&error={quote(first)}", status_code=303)
        try:
            kanbandb.personal_create(conn, unit_row["id"], title, subject,
                                     kind_label, due_at, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/kanban?view=summary&{back}"
                f"&error={quote(text)}", status_code=303)
    ok_msg = ("Задача поставлена: она уже на доске депо — начальник РЦ "
              "увидит её среди задач недели")
    return RedirectResponse(
        f"/kanban?view=summary&{back}&msg={quote(ok_msg)}",
        status_code=303)


@app.get("/kanban/task/{task_id}/file")
def kanban_task_file(task_id: int, request: Request):
    """
    Открыть файл отчёта о выполнении персональной задачи (п. 6.4.1).

    Отдаёт приложение, а не веб-сервер: файл видит тот, кто видит доску
    этого депо, — как и саму задачу.
    """
    from fastapi.responses import FileResponse
    from . import filestore

    uid = require_user(request)
    with db(uid) as conn:
        with conn.cursor() as cur:
            cur.execute("SELECT result_file, result_file_name, org_unit_id "
                        "FROM app.kanban_task WHERE id = %s", (task_id,))
            row = cur.fetchone()
        if row and not webdb.can_access_unit(conn, row["org_unit_id"]):
            row = None
    if not row or not row["result_file"]:
        raise HTTPException(404, "Файл отчёта не найден")
    try:
        path = filestore.path_of(row["result_file"])
    except filestore.FileRejected:
        raise HTTPException(404, "Файл отчёта не найден")
    if not path.exists():
        raise HTTPException(
            404, "Файл отчёта не найден в хранилище. Сведения о нём в базе "
                 "есть — вероятно, папка хранилища не перенесена вместе с базой")
    return FileResponse(path, filename=row["result_file_name"],
                        content_disposition_type="inline")


def _kanban_back(week: str, nav: str) -> str:
    """
    Вернуть на тот же масштаб и период, откуда отмечали задачу. В `nav`
    приходит хвост адреса из формы — пропускаем только его буквы, цифры и
    разделители: это кусок адреса, а не место для чего угодно.
    """
    if nav and re.fullmatch(r"[a-z]+=[0-9a-z-]+(&[a-z]+=[0-9a-z-]+)*", nav):
        return nav
    return f"week={quote(week)}"


#  Техника и ТМЦ разведены по вкладкам (уточнение по блоку F от 15.09.2026).
#  Разница не в цене, а в том, как ведут: технику поштучно — у каждой единицы
#  карточка, моточасы, сроки ТО и история ремонтов; ТМЦ количеством. На одной
#  вкладке у половины строк колонки моточасов и ТО стояли пустыми, а у другой
#  половины пустовало количество.
#  Три вкладки вместо двух (требование от 22.09.2026): «складская техника,
#  поверенная техника, ТМЦ и офисное оборудование». Поверочное оборудование
#  до сих пор лежало на вкладке техники со сквозными пустыми столбцами
#  моточасов и ТО — у алкотестера и лабораторных весов их не бывает, у них
#  срок поверки. Разбивка повторяет группы реестра «Виды ТМЦ и техники».
LOG_PAGE = 20

SUPPLY_TABS = [
    ("equipment", "Складская техника"),
    ("verification", "Поверенная техника"),
    ("stock", "ТМЦ и офисное оборудование"),
    #  07.10.2026 (№1 документа «Путь СИЗ»): свод остатков по всем депо —
    #  только для Администрации, пункт вкладки показывается по праву
    ("mbp", "Остатки МБП"),
    #  06.10.2026 (правка заказчика): вкладку «База СИЗ» убрали — её
    #  заменили карточки типоразмеров в «Базовых настройках»
    ("maintenance", "Техническое обслуживание"),
    ("repairs", "Заявки на ремонт"),
    ("report", "Отчёт: что заканчивается"),
    #  02.10.2026 (вычитка 9.6): журнал ремонтов, ТО и поставок — записи
    #  велись, но нигде не показывались
    ("journal", "Журнал"),
]
templates.env.globals["SUPPLY_TABS"] = SUPPLY_TABS
#  Кабинет ОЗ (волна 4б): названия статусов поставки и дней недели слотов
templates.env.globals["ORDER_STATUS_RU"] = purchasedb.ORDER_STATUS_RU
templates.env.globals["SLOT_WEEKDAYS_RU"] = purchasedb.WEEKDAYS_RU
#  Группы «Базы СИЗ» — справочник один на настройки и обеспечение
templates.env.globals["PPE_BASE_GROUPS"] = supplydb.PPE_BASE_GROUPS
templates.env.globals["PPE_BASE_GROUP_RU"] = supplydb.PPE_BASE_GROUP_RU
#  Кнопка действия вместо «Выполнено» у задач ТО и ремонта (24.09.2026)
templates.env.globals["task_action"] = kanbandb.action_label


def _supply_context(conn, uid: int, unit_code: str | None,
                    tab: str) -> dict[str, Any]:
    """
    Общий контекст раздела «Обеспечение».

    Депо выбирается, как в расписании: ТМЦ и техника принадлежат депо, и
    смотреть их имеет смысл по одному городу. Права — `asset.read`: мастер и
    кладовщик видят, чем работают, а меняет только тот, у кого `asset.write`.
    """
    user = webdb.current_user(conn, uid)
    if not webdb.has_perm(conn, "asset.read"):
        raise HTTPException(403, "Нет доступа к разделу обеспечения")
    units = webdb.accessible_units(conn)
    if not units:
        raise HTTPException(403, "Нет доступа ни к одному подразделению")

    #  «Все депо» (требование от 21.09.2026): администрация сводит двенадцать
    #  депо и должна видеть их одним списком. Появляется выбор только там, где
    #  депо больше одного, — начальнику РЦ показывать его незачем
    all_units = len(units) > 1
    every = all_units and unit_code == ALL_UNITS
    unit = (None if every
            else next((u for u in units if u["code"] == unit_code), None) or units[0])
    #  Шаблоны обращаются к unit.code и unit.name на каждой странице раздела,
    #  поэтому у «всех депо» тоже есть имя и код
    shown = unit or {"id": None, "code": ALL_UNITS, "name": "Все депо"}

    return {
        "user": user,
        "units": units,
        "unit": shown,
        "unit_id": None if every else shown["id"],
        "all_units": all_units,
        "every_unit": every,
        "ALL_UNITS": ALL_UNITS,
        "mode": "supply",
        "tab": tab,
        "title": "Обеспечение",
        #  Счётчики считают то же, что показывает список под ними: на вкладке
        #  техники — технику, на вкладке ТМЦ — ТМЦ
        "counts": supplydb.asset_counts(
            conn, None if every else shown["id"],
            kind=tab if tab in ("equipment", "verification", "stock")
                 else "all"),
        "open_repairs": (0 if every else
                         len(supplydb.repair_requests(conn, shown["id"],
                                                      only_open=True))),
        "open_requests": webdb.open_staff_requests(conn),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
        "can_reference": webdb.has_perm(conn, "reference.write"),
        #  Видеть раздел и править в нём — разные права. Один ключ на оба
        #  означал бы, что читатель теряет «Обеспечение» из меню ровно на
        #  странице обеспечения, а на остальных страницах видит его
        #  Матрица О9 от 21.09.2026: раздел больше не держится на одном
        #  праве. Заводит и правит единицы начальник с заместителем, заявки и
        #  ТО делает ещё и мастер, списывает только администрация
        "can_supply_write": webdb.has_perm(conn, "asset.write"),
        "can_repair_open": webdb.has_perm(conn, "repair.open"),
        "can_maintenance": webdb.has_perm(conn, "maintenance.do"),
        #  Администрация ООУРЦ: формирует заявки на ТО, вызывает специалиста
        #  на ремонт, исправляет отметки ТО (24.09.2026)
        "can_plan": webdb.has_perm(conn, "maintenance.plan"),
        "can_writeoff": webdb.has_perm(conn, "asset.writeoff"),
        #  Маршрут заявки на стороне Минска двигают администрация и начальник
        #  депо — по той же матрице
        "can_repair_hq": webdb.has_perm(conn, "repair.hq"),
        #  07.10.2026 (№1 «Путь СИЗ»): свод остатков МБП по всем депо —
        #  для Администрации; у депо своей сводки нет
        "can_mbp": webdb.has_perm(conn, "employee.write"),
        #  Акт к заявке (23.09.2026) прикладывает любой, кто ведёт заявки
        "can_attach_act": _can_attach_act(conn),
        "today_iso": date.today().isoformat(),
        #  Удалить акт может тот, кто его приложил, — шаблону нужен «кто я»
        "me_id": uid,
        "has_repairs": supplydb.has_repairs(conn),
        #  Производители по группам реестра: выбрали вид — список моделей
        #  подстроился (требование от 22.09.2026). В контексте раздела, а не
        #  одной вкладки: разметка списка одна на всю страницу
        "asset_models": supplydb.models(conn),
        "today": date.today().isoformat(),
        #  Датой, а не строкой: список поверочного считает по ней остаток
        #  дней и красит просрочку
        "today_date": date.today(),
    }


def _back_from(unit: str, back: str, asset_id: int | None,
               msg: str = "", error: str = ""):
    """
    Вернуть человека туда, откуда он нажал кнопку.

    Формы раздела живут в двух местах сразу: на вкладке и в карточке единицы.
    Возвращать всех на вкладку значило бы уводить со страницы, на которой
    работали, ради подтверждения того, что и так видно.
    """
    if back == "card" and asset_id:
        return _asset_back(asset_id, msg=msg, error=error)
    return _supply_back(unit, back if back in dict(SUPPLY_TABS) else "equipment",
                        msg=msg, error=error)


def _supply_back(unit: str, tab: str, msg: str = "", error: str = ""):
    tail = f"/supply?unit={unit}&tab={tab}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


#  №1 документа «Путь СИЗ» (07.10.2026): свод остатков МБП по всем депо.
#  Размеры в остатках живут в наименовании позиции: одежда — «44-46
#  (88-92) 170/176», обувь — «(р-р 47, Чёрный)». Критерии группировок —
#  из Базовых настроек (карточки Базы СИЗ)
_MBP_CLOTHES_RE = re.compile(r"\b(\d{2}-\d{2})\b")
_MBP_HEIGHT_RE = re.compile(r"\b(\d{3}/\d{3})\b")
_MBP_SHOE_RE = re.compile(r"р-р\s+(\d{2})")
#  В своде — депо городов и Минский склад «МБП РЦ» (07.10.2026); служебное
#  подразделение ООУРЦ колонкой не бывает
_MBP_CITY_EXCLUDE = ("ooucr",)


def _mbp_items(stock: list[dict]) -> list[dict]:
    """Строки свода для клиентской сборки таблицы: карточка (группа),
    наименование, депо, количество и распознанные размеры из наименования
    (размер одежды, рост, размер обуви) — по ним работают фильтры."""
    out: list[dict] = []
    for r in stock:
        m = _MBP_CLOTHES_RE.search(r["name"])
        h = _MBP_HEIGHT_RE.search(r["name"])
        s = _MBP_SHOE_RE.search(r["name"])
        out.append({
            "group": r["group_title"], "sort": r["group_sort"],
            "name": r["name"], "unit": r["unit_code"],
            "qty": float(r["qty"]),
            "cs": m.group(1) if m else "",
            "ht": h.group(1) if h else "",
            "sh": s.group(1) if s else "",
        })
    return out


@app.get("/supply", response_class=HTMLResponse)
def supply_page(request: Request, unit: str | None = None,
                tab: str = "equipment", status: str = "ok",
                show: str | None = None,
                msg: str | None = None, error: str | None = None):
    """
    Обеспечение: ТМЦ, техника, ТО и заявки на ремонт — пункт 23 плана.

    Раздел отвечает на один вопрос: чем депо работает и в каком это
    состоянии. До сих пор ответ жил на листах «ТМЦ Депо» и «ТО» файла
    управления РЦ, где состояние стояло словом, а где вещь физически — не
    было видно вовсе.
    """
    uid = require_user(request)
    if tab not in dict(SUPPLY_TABS):
        #  Ссылки на прежнюю общую вкладку ведут на технику: это она обросла
        #  карточкой, и ради неё раздел переделывали
        tab = "equipment"
    with db(uid) as conn:
        #  «Все депо» работает на списках техники и ТМЦ: там вопрос «сколько
        #  этого всего по отделу» осмыслен. ТО, заявки и отчёт ведутся по
        #  одному депо — там сводный список ничего не отвечает, а действия
        #  (снять показания, двинуть заявку) без депо вообще не выполнить
        if unit == ALL_UNITS and tab not in ("equipment", "verification", "stock"):
            unit = None
        ctx = _supply_context(conn, uid, unit, tab)
        #  07.10.2026 (№1 «Путь СИЗ»): свод остатков МБП — только
        #  Администрации; остальным вкладка не показывается и не открывается
        if tab == "mbp" and not ctx["can_mbp"]:
            tab = "equipment"
            ctx = _supply_context(conn, uid, unit, tab)
        unit_id = ctx["unit"]["id"]

        if tab in ("equipment", "verification", "stock"):
            ctx["assets"] = supplydb.assets(conn, unit_id, status, kind=tab)
            ctx["status"] = status
            #  Сроки ТО прямо в списке: до сих пор, чтобы узнать, не пора ли
            #  обслуживать машину, приходилось уходить на другую вкладку.
            #  Считаются тем же расчётом, что и на вкладке ТО, — двух ответов
            #  на вопрос «когда следующее» быть не должно
            ctx["due_by_asset"] = {}
            if tab == "equipment":
                #  02.10.2026 (вычитка 5.20): на «Все депо» колонки «ТО-1 до» и
                #  «ТО-2 до» были пустыми — сроки считаются по каждому депо
                for uid_ in ([unit_id] if unit_id is not None
                             else [u["id"] for u in ctx["units"]]):
                    for d in supplydb.maintenance_due(conn, uid_):
                        ctx["due_by_asset"].setdefault(d["asset_id"], {})[
                            d["type_code"]] = d
            #  В форме добавления — только виды своей вкладки: иначе тележка
            #  однажды окажется техникой по недосмотру
            ctx["categories"] = supplydb.categories(conn, kind=tab)
            #  Следующий свободный инвентарный номер подставляется в форму
            #  (22.09.2026): в файле под будущие поступления держали пустые
            #  строки — №00073 и №00074, — а подсказка снимает повод их
            #  заводить. На «всех депо» номера нет: депо неизвестно
            ctx["next_no"] = ("" if unit_id is None
                              else supplydb.next_inventory_no(conn, unit_id))
        elif tab == "maintenance":
            ctx["due"] = supplydb.maintenance_due(conn, unit_id)
            #  Поверочное оборудование идёт своим списком: у него нет ни
            #  моточасов, ни ТО-1 с ТО-2 — только срок поверки (22.09.2026)
            ctx["verify_due"] = supplydb.verification_due(conn, unit_id)
            ctx["types"] = supplydb.maintenance_types(conn)
            #  Реестр проведённых — рядом с «когда следующее», но отдельной
            #  таблицей: один список отвечает, что делать, другой — что сделано
            #  24.09.2026: «скрыть 200 записей, оставлять последних 20, далее
            #  кнопка „ещё“ — добавляется по 20». Запрашиваем на одну больше:
            #  лишняя говорит, что продолжение есть
            want = max(LOG_PAGE, int(show) if str(show).isdigit() else LOG_PAGE)
            log = supplydb.maintenance_log(conn, unit_id, limit=want + 1)
            ctx["log"] = log[:want]
            ctx["log_more"] = len(log) > want
            ctx["log_next"] = want + LOG_PAGE
        elif tab == "mbp":
            #  №1 «Путь СИЗ»: строки свода — карточки Базы СИЗ (по артикулу),
            #  внутри разворачиваются номенклатуры; цифры живые
            ctx["mbp_items"] = _mbp_items(supplydb.mbp_stock(conn))
            #  Колонки — депо городов и Минский склад «МБП РЦ»: в
            #  accessible_units Минска нет (он не rc), а его остатки — та
            #  колонка, ради которой склад и заведён (07.10.2026)
            with conn.cursor() as cur:
                cur.execute(
                    """
                    SELECT code, name FROM app.org_unit
                     WHERE (kind = 'rc' AND is_active) OR code = 'hq'
                     ORDER BY (code = 'hq'), name
                    """)
                ctx["mbp_units"] = [u for u in cur.fetchall()
                                    if u["code"] not in _MBP_CITY_EXCLUDE]
        elif tab == "journal":
            ctx["journal"] = journal_of(conn, "supply", unit_id, None)
        elif tab == "repairs":
            rows = supplydb.repair_requests(conn, unit_id)
            ctx["repairs"] = rows
            ctx["events"] = supplydb.repair_events(conn, [r["id"] for r in rows])
            #  «Вызов специалиста» — не кнопка перехода, а форма Администрации
            #  с датой приезда (24.09.2026): из списка шагов её убираем
            #  02.10.2026 (вычитка 5.20): каждому — только шаги его стороны.
            #  Депо: отправить в Минск, принять вернувшееся, отменить новую;
            #  Минск: свои четыре шага. Ту же проверку держит база
            can_hq = webdb.has_perm(conn, "repair.hq")
            can_open = webdb.has_perm(conn, "repair.open")
            ctx["next"] = ({r["id"]: [n for n in supplydb.next_statuses(
                                conn, r["status"], r.get("route") or "minsk")
                                if n != "specialist_called"
                                and supplydb.step_allowed(
                                    r.get("route") or "minsk", r["status"], n,
                                    can_hq=can_hq, can_open=can_open)]
                            for r in rows} if ctx["has_repairs"] else {})
            ctx["contractors"] = supplydb.contractors(conn)
            ctx["can_plan"] = webdb.has_perm(conn, "maintenance.plan")
            ctx["acts"] = supplydb.repair_acts(conn, [r["id"] for r in rows])
            ctx["broken"] = [a for a in supplydb.assets(conn, unit_id)
                             if a["status"] in ("repair", "needs_replacement")
                             and not a["open_request_id"]]
        else:
            ctx["ppe_due"] = supplydb.ppe_expiring(conn, unit_id)
            ctx["due"] = [d for d in supplydb.maintenance_due(conn, unit_id)
                          if d["overdue"] or d["soon"]]
        ctx["msg"] = msg
        ctx["error"] = error
    return templates.TemplateResponse(request, "supply.html", ctx)


@app.post("/supply/ppe-base")
def supply_ppe_base_add(request: Request, unit: str = Form(...),
                        item_id: int = Form(...), size: str = Form(""),
                        qty: int = Form(...)):
    """
    Внести позицию в «Базу СИЗ» депо (вычитка 30.09.2026, п. 5.17).

    Позиция выбирается из справочника «Базовых настроек», размер и
    количество вводит депо. Повторное внесение той же позиции с тем же
    размером прибавляется к остатку.
    """
    uid = require_user(request)
    with db(uid) as conn:
        unit_row = unit_or_403(conn, unit)
        try:
            supplydb.ppe_base_add(conn, unit_row["id"],
                                  item_id, size, qty, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/supply?unit={unit}&tab=ppe_base&error={quote(msg)}",
                status_code=303)
    return RedirectResponse(
        f"/supply?unit={unit}&tab=ppe_base&msg={quote('Позиция внесена в базу')}",
        status_code=303)


@app.post("/supply/ppe-base/set")
def supply_ppe_base_set(request: Request, unit: str = Form(...),
                        stock_id: int = Form(...), qty: int = Form(0)):
    """Поправить количество строки базы (инвентаризация)."""
    uid = require_user(request)
    with db(uid) as conn:
        unit_id = unit_or_403(conn, unit)["id"]
        try:
            supplydb.ppe_base_set_qty(conn, unit_id, stock_id, qty)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/supply?unit={unit}&tab=ppe_base&error={quote(msg)}",
                status_code=303)
    return RedirectResponse(
        f"/supply?unit={unit}&tab=ppe_base&msg={quote('Количество поправлено')}",
        status_code=303)


@app.post("/supply/ppe-base/del")
def supply_ppe_base_del(request: Request, unit: str = Form(...),
                        stock_id: int = Form(...)):
    """Убрать строку базы целиком (завели ошибочную)."""
    uid = require_user(request)
    with db(uid) as conn:
        unit_id = unit_or_403(conn, unit)["id"]
        try:
            supplydb.ppe_base_delete(conn, unit_id, stock_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return RedirectResponse(
                f"/supply?unit={unit}&tab=ppe_base&error={quote(msg)}",
                status_code=303)
    return RedirectResponse(
        f"/supply?unit={unit}&tab=ppe_base&msg={quote('Строка убрана из базы')}",
        status_code=303)


PURCHASE_RULE = (
    "Во всех депо действует правило приёма: одного местного поставщика "
    "принимаем при объёме не более 1,5 м³ для обычных товаров и не более "
    "300 шт для маркируемых. Поставку сверх правила склад не принимает: "
    "товар размещается в хранение и отгружается под ЗК либо вручную "
    "перемещается по заявке ОЗ на другой склад. Если разместить некуда — "
    "поставка не принимается, поставщик связывается с ответственным "
    "менеджером."
)


def _purchase_notify(to_email: str | None, subject: str, body: str) -> None:
    """
    Уведомление почтой о шагах поставки. Почта может быть не настроена —
    тогда письмо не блокирует действие, а статус всегда виден в кабинете.
    """
    if not to_email:
        return
    try:
        ok, err = mail.send(to_email, subject, body)
        if not ok:
            print(f"почта ОЗ не отправлена ({to_email}): {err}", flush=True)
    except Exception as e:                                  # noqa: BLE001
        print(f"почта ОЗ не отправлена ({to_email}): {e}", flush=True)


def header_menu_flags(conn, units: list) -> dict[str, Any]:
    """
    Флаги прав, по которым шапка показывает разделы меню.

    Контексты страниц кладут их каждая сама — так исторически сложилось.
    Кабинеты ОЗ/ОТ/Руководства (волны 4б/4в) про них не знали: на этих
    страницах у администрации пропадали «Обеспечение», «Мотивация»,
    «Бюджет», «Базовые настройки» и «Загрузки» — меню «съедало» кнопки
    (инцидент 01.10.2026). Новые страницы зовут этот хелпер, чтобы шапка
    была одинаковой везде.
    """
    return {
        "open_requests": webdb.open_staff_requests(conn),
        "all_units": len(units) > 1,
        "can_reference": webdb.has_perm(conn, "reference.write"),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
    }


def _optional_filter_id(value: str, label: str) -> int | None:
    """Пустой option из HTML select означает «все», а не ошибку числа."""
    value = value.strip()
    if not value:
        return None
    try:
        result = int(value)
    except ValueError as exc:
        raise HTTPException(400, f"Неверный фильтр «{label}»") from exc
    if result <= 0:
        raise HTTPException(400, f"Неверный фильтр «{label}»")
    return result


def _optional_filter_date(value: str, label: str) -> date | None:
    """Пустая дата означает отсутствие границы интервала."""
    value = value.strip()
    if not value:
        return None
    try:
        return date.fromisoformat(value)
    except ValueError as exc:
        raise HTTPException(400, f"Неверная дата «{label}»") from exc


def _parse_date_range(value: str) -> tuple[date | None, date | None]:
    """Интервал из одного поля: «ДД.ММ.ГГГГ — ДД.ММ.ГГГГ»."""
    value = value.strip()
    if not value:
        return None, None
    parts = re.split(r"\s*(?:—|–|\.\.)\s*", value, maxsplit=1)
    if len(parts) != 2:
        raise HTTPException(400, "Выберите начало и конец периода")

    def parse_part(part: str) -> date:
        for pattern in ("%d.%m.%Y", "%Y-%m-%d"):
            try:
                return datetime.strptime(part.strip(), pattern).date()
            except ValueError:
                pass
        raise HTTPException(400, "Неверный период дат")

    return parse_part(parts[0]), parse_part(parts[1])


def _pagination_items(page: int, pages: int) -> list[int | None]:
    """Номера вокруг текущей страницы; None отображается как многоточие."""
    numbers = sorted({1, pages, *range(max(1, page - 2), min(pages, page + 2) + 1)})
    result: list[int | None] = []
    previous = 0
    for number in numbers:
        if previous and number - previous > 1:
            result.append(None)
        result.append(number)
        previous = number
    return result


# Kufar is a standalone module (2026.11.04.3, 04.11.2026 MSK).
from . import kufar, kufarstock, kufarweb
kufarweb.install(app, db, require_user, templates, header_menu_flags, OUT_DIR / "kufar")


def _discount_kufar_state() -> dict[str, Any]:
    """Latest read-only profile scan joined to exact discount product ids."""
    with kufar.connect(OUT_DIR / "kufar") as local:
        return kufarstock.live_product_links(local)


@app.get("/defects", response_class=HTMLResponse)
def defect_search_page(request: Request, q: str = "",
                       warehouse: str = "", manager: str = "",
                       classification: str = "", category: str = "",
                       date_range: str = "", date_from: str = "", date_to: str = "",
                       processing: str = "",
                       sort: str = "name", direction: str = "asc",
                       page: int = Query(1, ge=1)):
    """Отдельный поиск по текущему снимку остатков брака."""
    uid = require_user(request)
    warehouse_id = _optional_filter_id(warehouse, "место хранения")
    manager_id = _optional_filter_id(manager, "менеджер")
    classification_id = _optional_filter_id(classification, "классификация")
    category_id = _optional_filter_id(category, "категория")
    if date_range.strip():
        from_date, to_date = _parse_date_range(date_range)
    else:
        from_date = _optional_filter_date(date_from, "с")
        to_date = _optional_filter_date(date_to, "по")
    if from_date and to_date and from_date > to_date:
        raise HTTPException(400, "Дата «с» не может быть позже даты «по»")
    allowed_sorts = {"name", "unit_cost", "quantity", "defect_amount", "manager"}
    if sort not in allowed_sorts:
        sort = "name"
    if direction not in {"asc", "desc"}:
        direction = "asc"
    if processing not in defectdb.PROCESSING_STATUS_LABELS:
        processing = ""
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        result = defectdb.search(
            conn, q, warehouse_id, manager_id, classification_id,
            category_id, from_date, to_date, processing, sort, direction,
            page=page)
        normalized_range = (
            f"{from_date.strftime('%d.%m.%Y')} — {to_date.strftime('%d.%m.%Y')}"
            if from_date and to_date else "")
        search_query = urlencode({
            "q": q, "warehouse": warehouse, "manager": manager,
            "classification": classification, "category": category,
            "date_range": normalized_range,
            "processing": processing,
            "sort": sort, "direction": direction,
        })
        all_filters = defectdb.filters(conn)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — поиск по базе",
            "defect_section": "search",
            "q": q, "selected_warehouse": warehouse_id,
            "selected_manager": manager_id,
            "selected_classification": classification_id,
            "selected_category": category_id,
            "selected_processing": processing,
            "processing_labels": defectdb.PROCESSING_STATUS_LABELS,
            "workflow_labels": defectdb.HANDLER_WORKFLOW_LABELS,
            "date_range": normalized_range,
            "date_from_iso": from_date.isoformat() if from_date else "",
            "date_to_iso": to_date.isoformat() if to_date else "",
            "sort": sort, "direction": direction,
            "current": defectdb.current_summary(conn),
            "results": result["rows"], "result_total": result["total"],
            "page": result["page"], "pages": result["pages"],
            "per_page": result["per_page"],
            "page_items": _pagination_items(result["page"], result["pages"]),
            "search_query": search_query,
            "can_import_defects": webdb.has_perm(conn, "reference.write"),
        }
        ctx.update(all_filters)
        ctx["warehouse_groups"] = defectdb.grouped_warehouses(
            all_filters["warehouses"])
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_search.html", ctx)


@app.get("/defects/directories", response_class=HTMLResponse)
def defect_directories_page(request: Request):
    """Списки складов и менеджеров с итогами текущих остатков."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — склады и менеджеры",
            "defect_section": "directories",
            "current": defectdb.current_summary(conn),
            "can_import_defects": webdb.has_perm(conn, "reference.write"),
        }
        directory = defectdb.directory_summary(conn)
        ctx.update(directory)
        ctx["warehouse_groups"] = defectdb.grouped_warehouses(
            directory["warehouse_rows"])
        ctx["warehouse_group_options"] = defectdb.WAREHOUSE_GROUPS
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_directories.html", ctx)


@app.get("/defects/discounts", response_class=HTMLResponse)
def discount_products_page(request: Request, q: str = "", status: str = "active",
                           grade: str = "", category: str = "",
                           manufacturer: str = "",
                           has_price: str = "", kufar_status: str = "",
                           sort: str = "name",
                           direction: str = "asc",
                           page: int = Query(1, ge=1),
                           msg: str | None = None,
                           error: str | None = None):
    """Текущий свободный остаток уценки и архив прошлых карточек."""
    uid = require_user(request)
    if status not in {"active", "archive", "all"}:
        status = "active"
    if has_price not in {"", "yes", "no"}:
        has_price = ""
    if kufar_status not in {"", "yes", "no"}:
        kufar_status = ""
    if sort not in {"name", "created", "age", "price", "discount", "updated"}:
        sort = "name"
    if direction not in {"asc", "desc"}:
        direction = "asc"
    kufar_state = _discount_kufar_state()
    kufar_ids = list(kufar_state["links"])
    kufar_checked_at = (datetime.fromisoformat(kufar_state["scan"]["scanned_at"]).astimezone().strftime("%d.%m.%Y %H:%M")
                        if kufar_state["scan"] else None)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        result = discountdb.search(
            conn, q, status, grade, category, manufacturer, has_price,
            sort, direction, page=page,
            kufar_status=kufar_status, kufar_product_ids=kufar_ids)
        for row in result["rows"]:
            row["kufar_ads"] = kufar_state["links"].get(row["product_id"], [])
        search_query = urlencode({
            "q": q, "status": status, "grade": grade,
            "category": category, "manufacturer": manufacturer,
            "has_price": has_price, "kufar_status": kufar_status,
            "sort": sort, "direction": direction,
        })
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — уценка",
            "defect_section": "discounts",
            "discount_source": discountdb.SOURCE_NAME,
            "discount_summary": discountdb.summary(conn),
            "discount_history": discountdb.history(conn),
            "q": q, "selected_discount_status": status,
            "selected_grade": grade, "selected_discount_category": category,
            "selected_manufacturer": manufacturer,
            "selected_has_price": has_price,
            "selected_kufar_status": kufar_status,
            "sort": sort, "direction": direction,
            "results": result["rows"], "result_total": result["total"],
            "page": result["page"], "pages": result["pages"],
            "page_items": _pagination_items(result["page"], result["pages"]),
            "search_query": search_query,
            "can_import_defects": webdb.has_perm(conn, "reference.write"),
            "can_place_kufar": not webdb.is_read_only(user),
            "kufar_state": kufar_state,
            "kufar_checked_at": kufar_checked_at,
            "msg": msg, "error": error,
        }
        ctx.update(discountdb.filters(conn))
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "discount_products.html", ctx)


@app.get("/defects/discounts/export.xlsx")
def discount_products_export(request: Request, q: str = "",
                             status: str = "active", grade: str = "",
                             category: str = "", manufacturer: str = "",
                             has_price: str = "", kufar_status: str = "",
                             sort: str = "name",
                             direction: str = "asc"):
    """Выгрузить в Excel всю текущую выборку, а не только экранную страницу."""
    uid = require_user(request)
    if status not in {"active", "archive", "all"}:
        status = "active"
    if has_price not in {"", "yes", "no"}:
        has_price = ""
    if kufar_status not in {"", "yes", "no"}:
        kufar_status = ""
    if sort not in {"name", "created", "age", "price", "discount", "updated"}:
        sort = "name"
    if direction not in {"asc", "desc"}:
        direction = "asc"
    kufar_state = _discount_kufar_state()
    kufar_ids = list(kufar_state["links"])
    with db(uid) as conn:
        rows = discountdb.export_rows(
            conn, q, status, grade, category, manufacturer, has_price,
            sort, direction, kufar_status, kufar_ids)
        current = discountdb.summary(conn)
    status_labels = {
        "active": "текущий остаток", "archive": "архив", "all": "все карточки"}
    price_labels = {"yes": "есть цена", "no": "без цены"}
    applied = [status_labels[status]]
    if q.strip():
        applied.append(f"поиск: {q.strip()}")
    if grade:
        applied.append(f"грейд: {grade}")
    if category:
        applied.append(f"категория: {category}")
    if manufacturer:
        applied.append(f"производитель: {manufacturer}")
    if has_price:
        applied.append(price_labels[has_price])
    if kufar_status:
        applied.append("Kufar: " + ("размещено" if kufar_status == "yes" else "не размещено"))
    content = discountdb.build_export_xlsx(
        rows, current.get("source_snapshot_at"), "; ".join(applied))
    snapshot_at = current.get("source_snapshot_at")
    stamp = snapshot_at.strftime("%Y-%m-%d") if snapshot_at else date.today().isoformat()
    filename = f"Уценка_{stamp}.xlsx"
    return Response(
        content=content,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition":
                 "attachment; filename=discounts.xlsx; filename*=UTF-8''" + quote(filename)})


@app.get("/defects/discounts/assortment.xlsx")
def discount_assortment_export(request: Request):
    """Полный десятилистовый отчёт для подготовки ассортиментной матрицы."""
    uid = require_user(request)
    with db(uid) as conn:
        rows = discountdb.assortment_rows(conn)
        stock_rows = discountdb.assortment_stock_rows(conn)
        current = discountdb.summary(conn)
    snapshot_at = current.get("source_snapshot_at")
    content = discountreport.build_report_xlsx(rows, stock_rows, snapshot_at)
    stamp = snapshot_at.strftime("%Y-%m-%d") if snapshot_at else date.today().isoformat()
    filename = f"Ассортимент_уценки_{stamp}.xlsx"
    return Response(
        content=content,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition":
                 "attachment; filename=discount-assortment.xlsx; filename*=UTF-8''" + quote(filename)})


@app.post("/defects/discounts/kufar/prepare")
def discount_product_prepare_kufar(request: Request, product_id: str = Form(...)):
    """Refresh the public count, reject duplicates, then open a prefilled draft."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if webdb.is_read_only(user):
            raise HTTPException(403, "Недостаточно прав для подготовки объявления")
        product = conn.execute(
            "SELECT product_id FROM app.discount_product WHERE product_id=%s AND is_active",
            (product_id,)).fetchone()
    if not product:
        return RedirectResponse(
            "/defects/discounts?" + urlencode({"q": product_id, "error": "Позиция отсутствует в текущем остатке уценки."}),
            status_code=303)
    try:
        profile_url, live_rows = kufarstock.scan_profile()
        with kufar.connect(OUT_DIR / "kufar") as local:
            kufarstock.store_live_scan(local, profile_url, live_rows, uid)
            state = kufarstock.live_product_links(local)
        existing = state["links"].get(product_id, [])
        if existing:
            message = f"Позиция уже размещена на Kufar: объявление №{existing[0]['ad_id']}. Новая карточка не создавалась."
            return RedirectResponse(
                "/defects/discounts?" + urlencode({"q": product_id, "kufar_status": "yes", "msg": message}),
                status_code=303)
        active = len(live_rows)
        if active >= kufar.LIMIT:
            message = f"На Kufar уже {active} активных объявлений из {kufar.LIMIT}. Подготовка новой позиции заблокирована."
            return RedirectResponse(
                "/defects/discounts?" + urlencode({"q": product_id, "error": message}),
                status_code=303)
        message = f"Проверено: на Kufar {active} активных объявлений, свободно {kufar.LIMIT-active}. Заполните характеристики и фотографии."
        return RedirectResponse(
            "/kufar?" + urlencode({"view": "feed", "new_product_id": product_id, "message": message}),
            status_code=303)
    except kufar.Error as exc:
        return RedirectResponse(
            "/defects/discounts?" + urlencode({"q": product_id, "error": str(exc)}),
            status_code=303)
    except Exception:
        return RedirectResponse(
            "/defects/discounts?" + urlencode({"q": product_id, "error": "Не удалось проверить актуальное число объявлений Kufar. Подготовка не начата."}),
            status_code=303)


@app.post("/defects/discounts/sync")
def discount_products_sync(request: Request):
    """Прочитать полный свежий срез ch-stage и обновить локальную копию."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Уценку синхронизирует администрация")
        try:
            report = discountdb.synchronize(conn, uid)
        except (RuntimeError, ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/discounts?error=" + quote(detail), status_code=303)
    if report.get("unchanged"):
        message = (
            f"Срез {report['snapshot_at'].strftime('%d.%m.%Y %H:%M')} уже загружен; "
            "повторные строки не создавались.")
    else:
        message = (
            f"Уценка обновлена: {report['rows_total']} активных позиций. "
            f"Добавлено: {report['added']}, изменено: {report['updated']}, "
            f"без изменений: {report['unchanged_count']}, "
            f"возвращено из архива: {report['restored']}, "
            f"перенесено в архив: {report['archived']}.")
    return RedirectResponse(
        "/defects/discounts?msg=" + quote(message), status_code=303)


@app.post("/defects/warehouses/{warehouse_id}/group")
def defect_warehouse_group_update(request: Request, warehouse_id: int,
                                  group_code: str = Form(...)):
    """Ручное назначение группы склада администрацией справочников."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Группы складов меняет администрация")
        try:
            defectdb.update_warehouse_group(conn, warehouse_id, group_code)
        except ValueError as exc:
            raise HTTPException(400, str(exc)) from exc
    return RedirectResponse("/defects/directories", status_code=303)


@app.get("/defects/managers", response_class=HTMLResponse)
def defect_manager_statistics_page(request: Request):
    """Статистика текущего снимка по менеджерам и выбранным складам."""
    uid = require_user(request)
    raw_warehouses = request.query_params.getlist("warehouse")
    selected_warehouses = [
        _optional_filter_id(value, "место хранения")
        for value in raw_warehouses if value.strip()
    ]
    warehouse_ids = [value for value in selected_warehouses if value is not None]
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        all_filters = defectdb.filters(conn)
        stats = defectdb.manager_statistics(conn, warehouse_ids)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — статистика менеджеров",
            "defect_section": "managers",
            "current": defectdb.current_summary(conn),
            "warehouses": all_filters["warehouses"],
            "warehouse_groups": defectdb.grouped_warehouses(
                all_filters["warehouses"]),
            "selected_warehouses": set(warehouse_ids),
            "manager_stats": stats,
            "stats_total": {
                "positions": sum(row["positions"] for row in stats),
                "products": sum(row["products"] for row in stats),
                "quantity": sum((row["quantity"] for row in stats), Decimal("0")),
                "amount": sum((row["amount"] for row in stats), Decimal("0")),
            },
            "can_import_defects": webdb.has_perm(conn, "reference.write"),
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_manager_stats.html", ctx)


@app.get("/defects/sources", response_class=HTMLResponse)
def defect_work_sources_page(request: Request):
    """Реестр рабочих файлов менеджеров — будущих источников РМ брака."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — источники рабочих мест",
            "defect_section": "sources",
            "sources": defectdb.work_sources(conn),
            "can_import_defects": webdb.has_perm(conn, "reference.write"),
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_sources.html", ctx)


@app.get("/defects/rmb", response_class=HTMLResponse)
def defect_rmb_page(request: Request, view: str = "manager", status: str = "",
                    direction: str = "", manager: str = "",
                    specialist: str = "",
                    overdue: str = "", created_from: str = "", created_to: str = "",
                    due_from: str = "", due_to: str = "", q: str = "",
                    msg: str | None = None, error: str | None = None):
    """Решения менеджера, общая очередь и исполнительские задачи РМБ."""
    uid = require_user(request)
    view = view if view in {"manager", "specialist"} else "manager"
    filters = dict(overdue=overdue, created_from=created_from, created_to=created_to,
                   due_from=due_from, due_to=due_to, q=q)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        try:
            data = rmbdb.workspace(conn, uid, view, status, direction,
                                   manager, specialist, filters=filters)
        except PermissionError as exc:
            roles = rmbdb.user_roles(conn, uid)
            fallback = "specialist" if rmbdb.can_execute(roles) else "manager"
            if fallback != view:
                return RedirectResponse(f"/defects/rmb?view={fallback}", status_code=303)
            raise HTTPException(403, str(exc))
        except ValueError as exc:
            raise HTTPException(400, str(exc))
        can_configure = webdb.has_perm(conn, "reference.write")
        manager_sources = rmbdb.manager_sources_for_user(conn, uid)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — рабочее место РМБ",
            "defect_section": "rmb", "rmb_view": view, "rmb_status": status,
            "rmb_direction": direction, "rmb_manager": manager,
            "rmb_specialist": specialist,
            "rmb_filters": filters,
            "rmb": data, "case_status_labels": rmbdb.CASE_STATUS_LABELS,
            "task_status_labels": rmbdb.TASK_STATUS_LABELS,
            "direction_labels": rmbdb.DIRECTION_LABELS,
            "priority_labels": rmbdb.PRIORITY_LABELS,
            "location_labels": rmbdb.LOCATION_LABELS,
            "service_status_labels": rmbdb.SERVICE_STATUS_LABELS,
            "service_result_labels": rmbdb.SERVICE_RESULT_LABELS,
            "supplier_status_labels": rmbdb.SUPPLIER_STATUS_LABELS,
            "supplier_outcome_labels": rmbdb.SUPPLIER_OUTCOME_LABELS,
            "can_configure_rmb": can_configure,
            "manager_sources": manager_sources,
            "can_import_defects": can_configure, "msg": msg, "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_rmb.html", ctx)


@app.get("/defects/rmb/images/{code}")
@app.get("/defects/images/{code}")
def defect_rmb_image(request: Request, code: str):
    require_user(request)
    if code == "unknown":
        return FileResponse(BASE_DIR / "static/img/product-placeholder.svg", media_type="image/svg+xml",
                            headers={"Cache-Control": "private, max-age=86400", "X-Product-Image": "placeholder"})
    try:
        photo = productimages.resolve(OUT_DIR / "product-images", code)
    except ValueError as exc:
        raise HTTPException(400, str(exc))
    if not photo:
        return FileResponse(BASE_DIR / "static/img/product-placeholder.svg", media_type="image/svg+xml",
                            headers={"Cache-Control": "private, max-age=60", "X-Product-Image": "placeholder"})
    path, mime = photo
    return FileResponse(path, media_type=mime,
                        headers={"Cache-Control": "private, max-age=604800"})


@app.get("/defects/image-catalogue", response_class=HTMLResponse)
def product_image_catalogue(request: Request, q: str = "", status: str = "",
                            page: int = Query(1, ge=1)):
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        ctx = dict(user=user, units=units, unit=units[0] if units else None,
                   mode="defects", title="Каталог изображений", defect_section="images",
                   can_import_defects=webdb.has_perm(conn, "reference.write"), q=q, image_status=status,
                   catalogue=productimages.catalogue(OUT_DIR / "product-images", q, status, page))
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "product_image_catalogue.html", ctx)


@app.get("/defects/rmb/cases/{case_id}/history")
def defect_rmb_history(request: Request, case_id: int, view: str = "manager"):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            events = rmbdb.case_history(conn, uid, view, case_id)
        except PermissionError as exc:
            raise HTTPException(403, str(exc))
        except ValueError as exc:
            raise HTTPException(400, str(exc))
    return {"events": [dict(event, created_at=event["created_at"].isoformat())
                       for event in events]}


@app.post("/defects/rmb/bulk")
async def defect_rmb_bulk_action(request: Request):
    """Общие безопасные изменения выбранных дел без смены направления."""
    uid = require_user(request)
    form = await request.form()
    selected_raw = [str(value).strip() for value in form.getlist("case_ids")]
    priority_raw = str(form.get("priority", "")).strip()
    due_raw = str(form.get("due_at", "")).strip()
    specialist_raw = str(form.get("specialist_user_id", "")).strip()
    filters = {
        "view": "manager",
        "status": str(form.get("return_status", "")).strip(),
        "direction": str(form.get("return_direction", "")).strip(),
        "manager": str(form.get("return_manager", "")).strip(),
        "specialist": str(form.get("return_specialist", "")).strip(),
    }
    filters.update({name: str(form.get("return_" + name, "")).strip()
                    for name in ("overdue", "created_from", "created_to", "due_from", "due_to", "q")})
    filters = {key: value for key, value in filters.items() if value}

    try:
        case_ids = [int(value) for value in selected_raw if value]
        if any(case_id <= 0 for case_id in case_ids):
            raise ValueError
        due_at = date.fromisoformat(due_raw) if due_raw else None
        specialist_id = int(specialist_raw) if specialist_raw else None
        if specialist_id is not None and specialist_id <= 0:
            raise ValueError
    except ValueError:
        filters["error"] = "Неверные параметры группового действия"
        return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)

    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            result = rmbdb.bulk_update_cases(
                conn, case_ids, uid, priority_raw or None, due_at,
                specialist_id)
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            detail = ((getattr(exc, "diag", None) and exc.diag.message_primary)
                      or str(exc))
            filters["error"] = detail
            return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)
    message = f"Обновлено дел: {result['selected']}"
    if specialist_id is not None:
        message += f"; назначен специалист: {result['assigned']}"
        if result["assignment_skipped"]:
            message += f"; без активной задачи: {result['assignment_skipped']}"
    filters["msg"] = message
    return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)


@app.post("/defects/rmb/bulk/decision")
async def defect_rmb_bulk_decision(request: Request):
    """Один шаблон решения менеджера для выбранных позиций."""
    uid = require_user(request)
    form = await request.form()
    filters = {
        "view": "manager",
        "status": str(form.get("return_status", "")).strip(),
        "direction": str(form.get("return_direction", "")).strip(),
        "manager": str(form.get("return_manager", "")).strip(),
        "specialist": str(form.get("return_specialist", "")).strip(),
    }
    filters.update({name: str(form.get("return_" + name, "")).strip()
                    for name in ("overdue", "created_from", "created_to", "due_from", "due_to", "q")})
    filters = {key: value for key, value in filters.items() if value}
    try:
        case_ids = [int(str(value).strip()) for value in form.getlist("case_ids")]
        import json as _rmb_json
        versions_raw = _rmb_json.loads(str(form.get("expected_versions", "{}")))
        if not isinstance(versions_raw, dict) or len(versions_raw) > 200:
            raise ValueError
        expected_versions = {int(key): int(value) for key, value in versions_raw.items()}
        if any(case_id <= 0 for case_id in case_ids):
            raise ValueError
        specialist_raw = str(form.get("specialist_user_id", "")).strip()
        specialist_id = int(specialist_raw) if specialist_raw else None
        due_raw = str(form.get("due_at", "")).strip()
        due_at = date.fromisoformat(due_raw) if due_raw else None
    except (ValueError, TypeError):
        filters["error"] = "Неверные параметры группового решения"
        return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            result = rmbdb.bulk_decide_cases(
                conn, case_ids, uid, str(form.get("direction", "")),
                str(form.get("priority", "normal")), specialist_id, due_at,
                str(form.get("instruction", "")), str(form.get("reason", "")),
                str(form.get("service_center", "")),
                str(form.get("supplier_name", "")), expected_versions=expected_versions)
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            filters["error"] = ((getattr(exc, "diag", None)
                                 and exc.diag.message_primary) or str(exc))
            return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)
    filters["msg"] = f"По шаблону создано задач: {result['created']}"
    return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)


@app.post("/defects/rmb/cases/{case_id}/decision")
async def defect_rmb_decision(request: Request, case_id: int):
    uid = require_user(request)
    form = await request.form()
    specialist_raw = str(form.get("specialist_user_id", "")).strip()
    due_raw = str(form.get("due_at", "")).strip()
    try:
        specialist_id = int(specialist_raw) if specialist_raw else None
        due_at = date.fromisoformat(due_raw) if due_raw else None
        version_raw = str(form.get("expected_version", "")).strip()
        expected_version = int(version_raw) if version_raw else None
    except ValueError:
        return RedirectResponse(
            "/defects/rmb?view=manager&error=" + quote("Неверный специалист или срок"),
            status_code=303)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            rmbdb.decide_case(
                conn, case_id, uid, str(form.get("direction", "")),
                str(form.get("priority", "normal")), specialist_id, due_at,
                str(form.get("instruction", "")), str(form.get("reason", "")),
                str(form.get("service_center", "")),
                str(form.get("supplier_name", "")), expected_version=expected_version)
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb?view=manager&error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/rmb?view=manager&msg=" + quote("Решение сохранено, задача создана"),
        status_code=303)


@app.post("/defects/rmb/tasks/{task_id}/action")
async def defect_rmb_task_action(request: Request, task_id: int):
    uid = require_user(request)
    form = await request.form()
    action = str(form.get("action", ""))
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            rework_event_id = rmbdb.task_action(
                conn, task_id, uid, action, str(form.get("comment", "")),
                str(form.get("external_confirmed", "")) == "1")
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb?view=specialist&error=" + quote(detail), status_code=303)
    if rework_event_id:
        return RedirectResponse(
            "/defects/rmb?view=specialist&msg="
            + quote("Запрос на складскую дообработку создан. Работа остаётся в РМБ."),
            status_code=303)
    return RedirectResponse(
        "/defects/rmb?view=specialist&msg=" + quote("Статус задачи обновлён"),
        status_code=303)


@app.post("/defects/rmb/tasks/bulk")
async def defect_rmb_tasks_bulk_action(request: Request):
    """Одинаковое действие над несколькими задачами специалиста."""
    uid = require_user(request)
    form = await request.form()
    filters = {
        "view": "specialist",
        "status": str(form.get("return_status", "")).strip(),
        "direction": str(form.get("return_direction", "")).strip(),
        "manager": str(form.get("return_manager", "")).strip(),
        "specialist": str(form.get("return_specialist", "")).strip(),
    }
    filters.update({name: str(form.get("return_" + name, "")).strip()
                    for name in ("overdue", "created_from", "created_to", "due_from", "due_to", "q")})
    filters = {key: value for key, value in filters.items() if value}
    try:
        task_ids = [int(str(value).strip()) for value in form.getlist("task_ids")]
        if any(task_id <= 0 for task_id in task_ids):
            raise ValueError
    except ValueError:
        filters["error"] = "Неверный список задач"
        return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)
    action = str(form.get("action", "")).strip()
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            result = rmbdb.bulk_task_action(
                conn, task_ids, uid, action, str(form.get("comment", "")),
                str(form.get("external_confirmed", "")) == "1")
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            filters["error"] = ((getattr(exc, "diag", None)
                                 and exc.diag.message_primary) or str(exc))
            return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)
    filters["msg"] = f"Обновлено задач: {result['selected']}"
    if result["rework_created"]:
        filters["msg"] += "; запросов на дообработку: " + str(result["rework_created"])
    return RedirectResponse("/defects/rmb?" + urlencode(filters), status_code=303)


@app.post("/defects/rmb/service/{task_id}/action")
async def defect_rmb_service_action(request: Request, task_id: int):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            rmbdb.service_action(
                conn, task_id, uid, str(form.get("service_action", "")),
                str(form.get("comment", "")), str(form.get("result_type", "")),
                str(form.get("document_reference", "")))
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb?view=specialist&direction=service&error="
                + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/rmb?view=specialist&direction=service&msg="
        + quote("Сервисное событие сохранено"), status_code=303)


@app.post("/defects/rmb/supplier-return/{task_id}/action")
async def defect_rmb_supplier_return_action(request: Request, task_id: int):
    uid=require_user(request); form=await request.form()
    with db(uid) as conn:
        user=webdb.current_user(conn,uid)
        if user["read_only"]: raise HTTPException(403,"Учётная запись доступна только для просмотра")
        try:
            rmbdb.supplier_return_action(
                conn,task_id,uid,str(form.get("return_action","")),
                str(form.get("comment","")),str(form.get("outcome","")),
                str(form.get("document_reference","")))
        except (ValueError,PermissionError,psycopg.Error) as exc:
            conn.rollback(); detail=(getattr(exc,"diag",None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse("/defects/rmb?view=specialist&direction=supplier_return&error="+quote(detail),status_code=303)
    return RedirectResponse("/defects/rmb?view=specialist&direction=supplier_return&msg="+quote("Событие возврата сохранено"),status_code=303)


@app.post("/defects/rmb/cases/{case_id}/close")
async def defect_rmb_case_close(request: Request, case_id: int):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            rmbdb.close_case(conn, case_id, uid, str(form.get("result", "")))
        except (ValueError, PermissionError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb?view=manager&error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/rmb?view=manager&msg=" + quote("Дело закрыто"), status_code=303)


@app.get("/defects/rmb/settings", response_class=HTMLResponse)
def defect_rmb_settings(request: Request, msg: str | None = None,
                        error: str | None = None, note: str | None = None):
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Настройки РМБ доступны администратору")
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        can_create_user = webdb.has_perm(conn, "user.manage")
        secret_note = _note_take(conn, note) if note else None
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — настройки РМБ",
            "defect_section": "rmb", "settings": rmbdb.settings_data(conn),
            "role_labels": rmbdb.ROLE_LABELS,
            "timing_labels": rmbdb.TIMING_LABELS,
            "timing_policy": rmbdb.timing_policy(conn),
            "can_configure_rmb": True, "can_import_defects": True,
            "can_create_rmb_user": can_create_user,
            "secret_note": secret_note, "msg": msg, "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_rmb_settings.html", ctx)


@app.post("/defects/rmb/settings/timing")
async def defect_rmb_timing_save(request: Request):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"] or not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Общие сроки РМБ изменяет администратор")
        try:
            count = rmbdb.save_timing_policy(conn, uid,
                {code: form.get("days_" + code, "") for code in rmbdb.TIMING_LABELS},
                recalculate=form.get("recalculate") == "1")
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            return RedirectResponse("/defects/rmb/settings?error=" + quote(str(exc)) + "#timing", status_code=303)
    return RedirectResponse("/defects/rmb/settings?msg=" + quote(
        f"Сроки сохранены. Пересчитано открытых дел: {count}") + "#timing", status_code=303)


@app.post("/defects/rmb/settings/specialists")
async def defect_rmb_specialist_create(request: Request):
    uid = require_user(request)
    form = await request.form()
    manager_raw = str(form.get("manager_user_id", "")).strip()
    password = staffdb.new_password()
    with db(uid) as conn:
        if not (webdb.has_perm(conn, "reference.write")
                and webdb.has_perm(conn, "user.manage")):
            raise HTTPException(403, "Создавать специалистов может администратор")
        try:
            specialist_id = rmbdb.create_specialist(
                conn, uid, str(form.get("full_name", "")),
                str(form.get("email", "")), password,
                int(manager_raw) if manager_raw else None)
            account = rmbdb.settings_data(conn)["users"]
            created = next(p for p in account if p["id"] == specialist_id)
            delivery, token = _deliver_password(
                conn, specialist_id, created["email"], created["full_name"],
                password, "grant")
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    target = "/defects/rmb/settings?msg=" + quote(
        "Специалист создан и может войти в РМБ. " + delivery)
    if token:
        target += "&note=" + quote(token)
    return RedirectResponse(target, status_code=303)


@app.post("/defects/rmb/settings/role")
async def defect_rmb_setting_role(request: Request):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Настройки РМБ доступны администратору")
        try:
            rmbdb.set_user_role(
                conn, uid, int(str(form.get("user_id", ""))),
                str(form.get("role_code", "")), str(form.get("enabled", "")) == "1")
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    return RedirectResponse("/defects/rmb/settings?msg=" + quote("Роль обновлена"),
                            status_code=303)


@app.post("/defects/rmb/settings/manager-map")
async def defect_rmb_setting_manager_map(request: Request):
    uid = require_user(request)
    form = await request.form()
    manager_raw = str(form.get("manager_user_id", "")).strip()
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Настройки РМБ доступны администратору")
        try:
            rmbdb.set_manager_mapping(
                conn, uid, int(str(form.get("defect_manager_id", ""))),
                int(manager_raw) if manager_raw else None)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/rmb/settings?msg=" + quote("Закрепление менеджера обновлено"),
        status_code=303)


@app.post("/defects/rmb/settings/team")
async def defect_rmb_setting_team(request: Request):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Настройки РМБ доступны администратору")
        try:
            rmbdb.set_team_member(
                conn, uid, int(str(form.get("manager_user_id", ""))),
                int(str(form.get("specialist_user_id", ""))),
                str(form.get("enabled", "")) == "1")
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/rmb/settings?msg=" + quote("Состав группы обновлён"), status_code=303)


@app.post("/defects/rmb/settings/team-roster")
async def defect_rmb_team_roster_sync(request: Request):
    """Создать недостающие пары менеджер → специалист из рабочего списка."""
    uid = require_user(request)
    token = None
    with db(uid) as conn:
        if not (webdb.has_perm(conn, "reference.write")
                and webdb.has_perm(conn, "user.manage")):
            raise HTTPException(403, "Состав РМБ настраивает администратор")
        try:
            report = rmbdb.sync_default_team_roster(conn, uid, staffdb.new_password)
            if report["created"]:
                lines = ["Новые учётные записи РМБ (показываются один раз):"]
                lines.extend(
                    f"{person['full_name']} — {person['email']} — {person['password']}"
                    for person in report["created"])
                token = _note_put(conn, "\n".join(lines))
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    message = (f"Состав синхронизирован: {report['pairs_total']} пар, "
               f"создано учётных записей: {len(report['created'])}")
    target = "/defects/rmb/settings?msg=" + quote(message)
    if token:
        target += "&note=" + quote(token)
    return RedirectResponse(target, status_code=303)


@app.post("/defects/rmb/settings/manager-sources")
async def defect_rmb_manager_source_register(request: Request):
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Источники РМБ настраивает администратор")
        try:
            source_id = rmbdb.register_manager_source(
                conn, uid, int(str(form.get("manager_user_id", ""))),
                str(form.get("source_url", "")),
                str(form.get("source_title", "")))
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        f"/defects/rmb/settings/manager-sources/{source_id}/sync", status_code=303)


@app.get("/defects/rmb/settings/manager-sources/{source_id}/sync")
def defect_rmb_manager_source_sync(source_id: int, request: Request):
    uid = require_user(request)
    # Сетевой запрос выполняется без занятого соединения PostgreSQL.
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Источники РМБ синхронизирует администратор")
        try:
            source = rmbdb.manager_source_data(conn, source_id)
        except ValueError as exc:
            return RedirectResponse(
                "/defects/rmb/settings?error=" + quote(str(exc)), status_code=303)
    try:
        data = rmbdb.download_manager_source_csv(
            source["source_spreadsheet_id"], source["source_gid"])
        with db(uid) as conn:
            report = rmbdb.sync_manager_source(conn, source_id, uid, data)
    except (ValueError, psycopg.Error) as exc:
        detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
        return RedirectResponse(
            "/defects/rmb/settings?error=" + quote(detail), status_code=303)
    message = (f"Вкладка «РМ» синхронизирована: {report['rows_total']} строк; "
               f"активных {report['active_total']}, исторических "
               f"{report['completed_total']}")
    return RedirectResponse(
        f"/defects/rmb/settings/manager-sources/{source_id}?msg=" + quote(message),
        status_code=303)


@app.get("/defects/rmb/settings/manager-sources/{source_id}",
         response_class=HTMLResponse)
def defect_rmb_manager_source_page(
        source_id: int, request: Request, q: str = "", state: str = "",
        page: int = Query(1, ge=1), msg: str | None = None,
        error: str | None = None):
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        allowed_source_ids = {
            source["id"] for source in rmbdb.manager_sources_for_user(conn, uid)}
        can_configure = webdb.has_perm(conn, "reference.write")
        if source_id not in allowed_source_ids and not can_configure:
            raise HTTPException(403, "Рабочий файл доступен своей группе менеджера")
        try:
            result = rmbdb.manager_source_rows(conn, source_id, q, state, page)
        except ValueError as exc:
            raise HTTPException(404, str(exc)) from exc
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — импорт рабочего места",
            "defect_section": "rmb", "source_result": result,
            "direction_labels": rmbdb.DIRECTION_LABELS,
            "page_items": _pagination_items(result["page"], result["pages"]),
            "msg": msg, "error": error,
            "can_configure_rmb": can_configure,
            "can_import_defects": can_configure,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(
        request, "defect_rmb_manager_source.html", ctx)


@app.get("/defects/handler", response_class=HTMLResponse)
def defect_handler_page(request: Request, q: str = "", status: str = "",
                        processor: str = "", manager: str = "",
                        workflow: str = "", mine: bool = False,
                        page: int = Query(1, ge=1), msg: str | None = None,
                        error: str | None = None):
    """История обработанных БК-единиц и её связь с текущими остатками."""
    uid = require_user(request)
    manager_id = _optional_filter_id(manager, "менеджер")
    if status not in defectdb.HANDLER_MATCH_LABELS:
        status = ""
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        result = defectdb.handler_search(
            conn, q, status, processor, manager_id,
            workflow_status=workflow, owner_only=mine, user_id=uid, page=page)
        search_query = urlencode({
            "q": q, "status": status, "processor": processor,
            "manager": manager, "workflow": workflow,
            "mine": "true" if mine else "",
        })
        can_manage = webdb.has_perm(conn, "reference.write")
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — обработчик",
            "defect_section": "handler",
            "handler_summary": defectdb.handler_summary(conn),
            "handler_history": defectdb.handler_import_history(conn),
            "handler_source_url": defectdb.HANDLER_SOURCE_URL,
            "match_labels": defectdb.HANDLER_MATCH_LABELS,
            "processing_labels": defectdb.PROCESSING_STATUS_LABELS,
            "workflow_labels": defectdb.HANDLER_WORKFLOW_LABELS,
            "q": q, "selected_status": status,
            "selected_processor": processor,
            "selected_handler_manager": manager_id,
            "selected_workflow": workflow, "mine": mine,
            "results": result["rows"], "result_total": result["total"],
            "page": result["page"], "pages": result["pages"],
            "page_items": _pagination_items(result["page"], result["pages"]),
            "search_query": search_query,
            "can_import_defects": can_manage,
            "can_manage_handler": can_manage,
            "can_edit_handler": not user["read_only"],
            "msg": msg, "error": error,
        }
        ctx.update(defectdb.handler_filters(conn))
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_handler.html", ctx)


@app.get("/defects/handler/new", response_class=HTMLResponse)
def defect_handler_new_page(request: Request, error: str | None = None):
    """Поиск товара в текущих остатках перед новой обработкой."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        can_manage = webdb.has_perm(conn, "reference.write")
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — новая обработка",
            "defect_section": "handler",
            "current_stock": defectdb.current_summary(conn),
            "can_edit_handler": not user["read_only"],
            "can_import_defects": can_manage,
            "can_manage_handler": can_manage,
            "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_handler_new.html", ctx)


@app.get("/api/defects/handler/stock-search")
def defect_handler_stock_search(request: Request, q: str = ""):
    """Быстрые подсказки по коду, БК, артикулу, штрихкоду или наименованию."""
    uid = require_user(request)
    with db(uid) as conn:
        rows = defectdb.handler_stock_search(conn, q, uid)
    return {"results": rows, "query": q.strip(), "minimum_length": 2}


@app.post("/defects/handler/new")
async def defect_handler_new_create(request: Request):
    """Открыть новый черновик после явного выбора складской строки."""
    uid = require_user(request)
    form = await request.form()
    try:
        stock_line_id = int(str(form.get("stock_line_id", "")))
    except ValueError:
        return RedirectResponse(
            "/defects/handler/new?error="
            + quote("Сначала найдите и выберите товар"), status_code=303)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        try:
            event_id = defectdb.create_handler_event(
                conn, stock_line_id, uid, user.get("full_name"))
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/handler/new?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        f"/defects/handler/{event_id}/edit?msg="
        + quote("Черновик создан. Заполните результаты осмотра."),
        status_code=303)


@app.get("/defects/handler/{event_id}/edit", response_class=HTMLResponse)
def defect_handler_edit_page(request: Request, event_id: int,
                             msg: str | None = None,
                             error: str | None = None,
                             modal: bool = Query(False),
                             saved: bool = Query(False)):
    """Форма ручной корректировки события без потери данных источника."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        event = defectdb.handler_event(conn, event_id)
        if not event:
            raise HTTPException(404, "Позиция обработчика не найдена")
        can_manage = webdb.has_perm(conn, "reference.write")
        owns_local_draft = (
            event.get("source_origin") != "local_app"
            or event.get("workflow_status") != "draft"
            or event.get("created_by") == uid
            or event.get("processor_user_id") == uid)
        can_edit_event = (not user["read_only"]
                          and (can_manage or owns_local_draft)
                          and event.get("deleted_at") is None)
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — редактирование обработки",
            "defect_section": "handler", "event": event,
            "edit_options": defectdb.handler_edit_options(conn),
            "edit_history": defectdb.handler_event_edits(conn, event_id),
            "unit_history": defectdb.handler_unit_history(conn, event_id),
            "photos": defectdb.handler_photos(conn, event_id),
            "processor_users": (defectdb.handler_user_options(conn)
                                if can_manage else []),
            "match_labels": defectdb.HANDLER_MATCH_LABELS,
            "can_import_defects": can_manage,
            "can_manage_handler": can_manage,
            "can_edit_handler": can_edit_event,
            "msg": msg, "error": error, "modal": modal, "saved": saved,
            "processing_labels": defectdb.PROCESSING_STATUS_LABELS,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_handler_edit.html", ctx)


@app.post("/defects/handler/{event_id}/edit")
async def defect_handler_edit_save(request: Request, event_id: int):
    """Сохранить ручные поля и записать аудит изменений."""
    uid = require_user(request)
    form = await request.form()
    modal = str(form.get("modal", "")) == "1"
    save_mode = str(form.get("save_mode", "draft"))
    rmb_case_id = None
    values = {
        field: str(form.get(field, ""))
        for field, _label in defectdb.HANDLER_EDIT_FIELDS
    }
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        event = defectdb.handler_event(conn, event_id)
        if not event:
            raise HTTPException(404, "Позиция обработчика не найдена")
        can_manage = webdb.has_perm(conn, "reference.write")
        if (not can_manage and event.get("source_origin") == "local_app"
                and event.get("workflow_status") == "draft"
                and event.get("created_by") != uid
                and event.get("processor_user_id") != uid):
            raise HTTPException(403, "Этот черновик принадлежит другому обработчику")
        processor_id = event.get("processor_user_id")
        processor_name = event.get("processor")
        if can_manage:
            raw_processor = str(form.get("processor_user_id", "")).strip()
            if raw_processor:
                try:
                    processor_id = int(raw_processor)
                except ValueError as exc:
                    raise HTTPException(400, "Неверный обработчик") from exc
        elif event.get("source_origin") == "local_app" or not processor_name:
            processor_id = uid
            processor_name = user.get("full_name")
        values["processor"] = processor_name or user.get("full_name") or "Сотрудник"
        try:
            changed = defectdb.update_handler_event(
                conn, event_id, uid, values,
                str(form.get("assigned_manager", "")),
                str(form.get("assignment_note", "")), save_mode,
                values["processor"], processor_id)
            if save_mode == "complete":
                rmb_case_id = rmbdb.ensure_case_from_handler(conn, event_id, uid)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                f"/defects/handler/{event_id}/edit?error=" + quote(detail)
                + ("&modal=1" if modal else ""),
                status_code=303)
    if save_mode == "complete":
        if changed and rmb_case_id:
            message = "Обработка завершена и передана в РМБ"
        else:
            message = "Обработка завершена" if changed else "Обработка уже завершена"
    else:
        message = "Черновик сохранён" if changed else "Изменений не было"
    return RedirectResponse(
        f"/defects/handler/{event_id}/edit?msg=" + quote(message)
        + ("&modal=1" if modal else "") + "&saved=1", status_code=303)


@app.post("/defects/handler/{event_id}/delete")
async def defect_handler_draft_delete(request: Request, event_id: int):
    """Убрать черновик из работы, не стирая аудиторский след."""
    uid = require_user(request)
    form = await request.form()
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if user["read_only"]:
            raise HTTPException(403, "Учётная запись доступна только для просмотра")
        can_manage = webdb.has_perm(conn, "reference.write")
        try:
            defectdb.delete_handler_draft(
                conn, event_id, uid, can_manage, str(form.get("delete_reason", "")))
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                f"/defects/handler/{event_id}/edit?error=" + quote(detail),
                status_code=303)
    return RedirectResponse(
        "/defects/handler?workflow=draft&msg=" + quote("Черновик удалён"),
        status_code=303)


@app.post("/defects/handler/{event_id}/photos")
async def defect_handler_photo_upload(request: Request, event_id: int,
                                      photos: list[UploadFile] = File(...)):
    uid = require_user(request)
    payloads: list[tuple[str, bytes]] = []
    for photo in photos:
        data = await photo.read(defectdb.HANDLER_PHOTO_MAX_BYTES + 1)
        payloads.append((photo.filename or "photo", data))
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        event = defectdb.handler_event(conn, event_id)
        if not event:
            raise HTTPException(404, "Карточка обработки не найдена")
        can_manage = webdb.has_perm(conn, "reference.write")
        if user["read_only"] or (not can_manage
                and event.get("processor_user_id") not in (None, uid)
                and event.get("created_by") != uid):
            raise HTTPException(403, "Загружать фото может обработчик или администратор")
        try:
            count = defectdb.save_handler_photos(conn, event_id, uid, payloads)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                f"/defects/handler/{event_id}/edit?error=" + quote(detail),
                status_code=303)
    return RedirectResponse(
        f"/defects/handler/{event_id}/edit?msg="
        + quote(f"Фотографии загружены: {count}"), status_code=303)


@app.get("/defects/handler/photo/{photo_id}")
def defect_handler_photo(request: Request, photo_id: int):
    uid = require_user(request)
    with db(uid) as conn:
        row = defectdb.handler_photo_bytes(conn, photo_id)
    if not row:
        raise HTTPException(404, "Фотография не найдена")
    suffix = {"image/jpeg": "jpg", "image/png": "png", "image/webp": "webp"}[row["mime_type"]]
    return Response(
        content=bytes(row["data"]), media_type=row["mime_type"],
        headers={"Cache-Control": "private, max-age=3600",
                 "Content-Disposition": f'inline; filename="handler-photo-{photo_id}.{suffix}"'})


@app.post("/defects/handler/{event_id}/photos/{photo_id}/delete")
def defect_handler_photo_delete(request: Request, event_id: int, photo_id: int):
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        event = defectdb.handler_event(conn, event_id)
        if not event:
            raise HTTPException(404, "Карточка обработки не найдена")
        can_manage = webdb.has_perm(conn, "reference.write")
        if user["read_only"] or (not can_manage
                and event.get("processor_user_id") != uid
                and event.get("created_by") != uid):
            raise HTTPException(403, "Удалять фото может обработчик или администратор")
        removed = defectdb.delete_handler_photo(conn, photo_id, event_id)
    return RedirectResponse(
        f"/defects/handler/{event_id}/edit?msg="
        + quote("Фотография удалена" if removed else "Фотография уже удалена"),
        status_code=303)


@app.get("/defects/handler/monitor", response_class=HTMLResponse)
def defect_handler_monitor(request: Request, date_from: str = "",
                           date_to: str = "", error: str | None = None):
    uid = require_user(request)
    today = datetime.now(defectdb._HANDLER_TZ).date()
    try:
        start = date.fromisoformat(date_from) if date_from else today
        finish = date.fromisoformat(date_to) if date_to else today
    except ValueError:
        start = finish = today
        error = "Даты интервала заданы неверно"
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        try:
            monitoring = defectdb.handler_monitoring(conn, start, finish)
        except ValueError as exc:
            monitoring = defectdb.handler_monitoring(conn, today, today)
            start = finish = today
            error = str(exc)
        can_manage = webdb.has_perm(conn, "reference.write")
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — мониторинг обработчиков",
            "defect_section": "handler", "monitoring": monitoring,
            "date_from": start, "date_to": finish, "error": error,
            "can_import_defects": can_manage,
            "can_manage_handler": can_manage,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_handler_monitor.html", ctx)


@app.get("/defects/handler/settings", response_class=HTMLResponse)
def defect_handler_settings(request: Request, msg: str | None = None,
                            error: str | None = None):
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочниками обработчика управляет администратор")
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        rows = defectdb.handler_options_admin(conn)
        groups = []
        for key, label in defectdb.HANDLER_OPTION_FIELDS.items():
            groups.append({"key": key, "label": label,
                           "rows": [row for row in rows if row["field_key"] == key]})
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — справочники обработчика",
            "defect_section": "handler", "option_groups": groups,
            "can_import_defects": True, "can_manage_handler": True,
            "msg": msg, "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_handler_settings.html", ctx)


@app.post("/defects/handler/settings/options")
async def defect_handler_option_save(request: Request):
    uid = require_user(request)
    form = await request.form()
    raw_id = str(form.get("option_id", "")).strip()
    try:
        option_id = int(raw_id) if raw_id else None
        sort_order = int(str(form.get("sort_order", "100")))
    except ValueError:
        return RedirectResponse(
            "/defects/handler/settings?error=" + quote("Неверный номер или порядок"),
            status_code=303)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Справочниками обработчика управляет администратор")
        try:
            defectdb.save_handler_option(
                conn, uid, str(form.get("field_key", "")),
                str(form.get("value", "")), sort_order,
                str(form.get("is_active", "")) == "1", option_id)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/handler/settings?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/handler/settings?msg=" + quote("Справочник обновлён"),
        status_code=303)


@app.post("/defects/handler/import")
async def defect_handler_import(request: Request,
                                file: UploadFile = File(...)):
    """Обновить локальную историю из XLSX-экспорта Google-обработчика."""
    uid = require_user(request)
    data = await file.read(50 * 1024 * 1024 + 1)
    if len(data) > 50 * 1024 * 1024:
        return RedirectResponse(
            "/defects/handler?error=" + quote("Файл больше 50 МБ"), status_code=303)
    if not data:
        return RedirectResponse(
            "/defects/handler?error=" + quote("Файл не выбран"), status_code=303)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Историю обработчика загружает администрация")
        try:
            report = defectdb.import_handler_xlsx(
                conn, data, file.filename or "Обработчик.xlsx", uid)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/handler?error=" + quote(detail), status_code=303)
    message = _handler_import_message(report)
    return RedirectResponse(
        "/defects/handler?msg=" + quote(message), status_code=303)


def _handler_import_message(report: dict[str, Any]) -> str:
    if report.get("unchanged"):
        return "Данные уже актуальны: обработанные товары не дублировались."
    return (
        f"Обработчик синхронизирован: {report['rows_total']} событий. "
        f"Добавлено: {report['inserted_events']}, "
        f"обновлено: {report['updated_events']}, "
        f"без изменений: {report['unchanged_events']}. "
        f"В текущих остатках: {report['matched_current']}; "
        f"нет в текущих остатках: {report['not_in_current']}.")


@app.post("/defects/handler/sync")
def defect_handler_sync(request: Request):
    """Скачать актуальную вкладку Google Sheets и обновить «Обработчик»."""
    uid = require_user(request)
    # Не держим соединение с PostgreSQL, пока Google формирует большой экспорт.
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Историю обработчика загружает администрация")
    try:
        data = defectdb.download_handler_csv()
        with db(uid) as conn:
            report = defectdb.import_handler_csv(
                conn, data, "Обработчик — Google Sheets.csv", uid)
    except (ValueError, psycopg.Error) as exc:
        detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
        return RedirectResponse(
            "/defects/handler?error=" + quote(detail), status_code=303)
    return RedirectResponse(
        "/defects/handler?msg=" + quote(_handler_import_message(report)),
        status_code=303)


@app.get("/defects/import", response_class=HTMLResponse)
def defect_import_page(request: Request, msg: str | None = None,
                       error: str | None = None):
    """Форма загрузки и история снимков."""
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        units = webdb.accessible_units(conn)
        can_import = webdb.has_perm(conn, "reference.write")
        ctx = {
            "user": user, "units": units, "unit": units[0] if units else None,
            "mode": "defects", "title": "Брак — загрузка остатков",
            "defect_section": "import",
            "current": defectdb.current_summary(conn),
            "history": defectdb.import_history(conn),
            "can_import_defects": can_import, "msg": msg, "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "defect_import.html", ctx)


@app.post("/defects/import")
async def defect_import_upload(request: Request,
                               file: UploadFile = File(...)):
    """Загрузить новый снимок; прежний остаётся в истории."""
    uid = require_user(request)
    data = await file.read(50 * 1024 * 1024 + 1)
    if len(data) > 50 * 1024 * 1024:
        return RedirectResponse(
            "/defects/import?error=" + quote("Файл больше 50 МБ"), status_code=303)
    if not data:
        return RedirectResponse(
            "/defects/import?error=" + quote("Файл не выбран"), status_code=303)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "reference.write"):
            raise HTTPException(403, "Остатки брака загружает администрация")
        try:
            report = defectdb.import_stock_xlsx(
                conn, data, file.filename or "остатки брака.xlsx", uid)
        except (ValueError, psycopg.Error) as exc:
            conn.rollback()
            detail = (getattr(exc, "diag", None) and exc.diag.message_primary) or str(exc)
            return RedirectResponse(
                "/defects/import?error=" + quote(detail), status_code=303)
    if report.get("unchanged"):
        return RedirectResponse(
            "/defects/import?msg=" + quote(
                "Файл проверен: остатки по номенклатуре и местам хранения "
                "не изменились. Новая запись не создана."), status_code=303)
    message = (f"Снимок загружен: {report['rows_total']} строк, "
               f"{report['product_count']} товаров, "
               f"{report['warehouse_count']} мест хранения. "
               f"Добавлено позиций: {report['added_positions']}, "
               f"убрано: {report['removed_positions']}, "
               f"изменено: {report['changed_positions']}")
    return RedirectResponse(
        "/defects/import?msg=" + quote(message), status_code=303)


@app.get("/purchase", response_class=HTMLResponse)
def purchase_page(request: Request, unit: str | None = None,
                  tab: str = "queue", span: str = "day",
                  msg: str | None = None, error: str | None = None):
    """
    Кабинет ОЗ и рабочее место приёмки — вычитка 30.09.2026, волна 4б.

    Сотрудник ОЗ видит все депо: очередь согласования, подтверждённые
    поставки с фильтрами сегодня/неделя/месяц, слоты мелких поставщиков и
    свободное место на складах. Депо — приёмку: что согласовать, что
    принять, свои слоты и место.
    """
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        can_oz = webdb.has_perm(conn, "supply.oz")
        can_receive = webdb.has_perm(conn, "supply.receive")
        #  02.10.2026: без прав раздела страница не открывается вовсе.
        #  Раньше ОТ и Руководство попадали на рабочее место приёмки депо
        if not (can_oz or can_receive):
            raise HTTPException(403, "Раздел «Поставки» ведут отдел закупок "
                                     "и склады депо")
        units = webdb.accessible_units(conn)
        if not units:
            raise HTTPException(403, "Нет доступа ни к одному подразделению")
        #  Кабинет ОЗ — у кого право supply.oz; приёмка — у депо
        is_oz = can_oz
        sel = (next((u for u in units if u["code"] == unit), None)
               or (None if is_oz else units[0]))
        unit_id = sel["id"] if sel else None

        today = date.today()
        if not purchasedb.has_tables(conn):
            ctx = {
                "user": user, "units": units, "unit": sel,
                "mode": "purchase", "title": "Поставки",
                "ready": False, "can_oz": can_oz,
                "can_receive": can_receive,
                "msg": msg, "error": error,
            }
            ctx.update(header_menu_flags(conn, units))
            return templates.TemplateResponse(request, "purchase.html", ctx)

        ctx = {
            "user": user, "units": units, "unit": sel,
            "mode": "purchase", "title": "Поставки",
            "ready": True, "is_oz": is_oz, "can_oz": can_oz,
            "can_receive": can_receive,
            "tab": tab if tab in ("queue", "schedule", "slots", "space")
                   else "queue",
            "span": span if span in ("day", "week", "month") else "day",
            "today_date": today,
            "tomorrow": (today + timedelta(days=1)).isoformat(),
            "rule_text": PURCHASE_RULE,
            "msg": msg, "error": error,
        }
        ctx.update(header_menu_flags(conn, units))
        if is_oz:
            #  Квартира кабинета: очередь — все депо сразу; подтверждённые —
            #  с фильтром депо из адреса
            if tab == "queue":
                ctx["orders"] = purchasedb.orders(
                    conn, unit_id,
                    statuses=("approval", "pre_approved", "rejected"))
            elif tab == "schedule":
                if span == "day":
                    ctx["days"] = [{"date": today,
                                    "orders": purchasedb.orders(
                                        conn, unit_id, only=today)}]
                elif span == "week":
                    monday = kanbandb.week_start(today)
                    ctx["days"] = [
                        {"date": monday + timedelta(days=i),
                         "orders": purchasedb.orders(
                             conn, unit_id, only=monday + timedelta(days=i))}
                        for i in range(7)]
                else:
                    first = today.replace(day=1)
                    n = calendar.monthrange(today.year, today.month)[1]
                    ctx["days"] = [
                        {"date": first + timedelta(days=i),
                         "orders": purchasedb.orders(
                             conn, unit_id,
                             only=first + timedelta(days=i))}
                        for i in range(n)]
            elif tab == "slots":
                ctx["slots"] = purchasedb.slots(conn, unit_id)
            else:
                ctx["space"] = purchasedb.space_of(conn)
                ctx["contacts"] = purchasedb.unit_contacts(conn)
                ctx["limits"] = {u["id"]: None for u in units}
                with conn.cursor() as cur:
                    cur.execute("SELECT id, supply_per_day FROM app.org_unit "
                                "WHERE kind = 'rc' AND is_active")
                    ctx["limits"] = {r["id"]: r["supply_per_day"]
                                     for r in cur.fetchall()}
            if tab == "queue" and unit_id:
                ctx["busy"] = purchasedb.busy_days(
                    conn, unit_id, today, today + timedelta(days=13))
        else:
            #  Рабочее место приёмки депо: одна страница без вкладок
            ctx["orders"] = purchasedb.orders(conn, unit_id)
            ctx["slots"] = purchasedb.slots(conn, unit_id)
            sp = purchasedb.space_of(conn, unit_id)
            ctx["space"] = sp[0] if sp else None
            with conn.cursor() as cur:
                cur.execute("SELECT supply_per_day FROM app.org_unit "
                            "WHERE id = %s", (unit_id,))
                ctx["limit"] = cur.fetchone()["supply_per_day"]
    return templates.TemplateResponse(request, "purchase.html", ctx)


def _purchase_back(unit: str | None, tab: str, msg: str = "",
                   error: str = "") -> RedirectResponse:
    tail = f"/purchase?tab={tab}"
    if unit:
        tail += f"&unit={quote(unit)}"
    if msg:
        tail += f"&msg={quote(msg)}"
    elif error:
        tail += f"&error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


@app.post("/purchase/order")
def purchase_order_create(request: Request, unit: str = Form(...),
                          category: str = Form(...),
                          volume: str = Form(""),
                          supplier: str = Form(...),
                          planned_date: str = Form(""),
                          exact_date: str = Form("")):
    """Запрос поставки из кабинета ОЗ — сразу «на согласовании» у депо."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.oz"):
            raise HTTPException(403, "Поставки ставит отдел закупок")
        unit_row = unit_or_403(conn, unit)
        try:
            purchasedb.create_order(
                conn, unit_id=unit_row["id"], category=category,
                volume=volume, supplier=supplier,
                planned_date=parse_day(planned_date) if planned_date else None,
                exact_date=parse_day(exact_date) if exact_date else None,
                user_id=uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(unit, "queue", error=text)
    return _purchase_back(
        unit, "queue",
        msg="Запрос отправлен в депо — поставка на согласовании")


@app.post("/purchase/order/{order_id}/decide")
def purchase_order_decide(order_id: int, request: Request,
                          decision: str = Form(...), note: str = Form("")):
    """Решение депо: согласовать, предварительно или отказать."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.receive"):
            raise HTTPException(403, "Поставки согласовывает склад депо")
        try:
            order = purchasedb.decide_order(conn, order_id, decision,
                                            note, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(None, "queue", error=text)
        with conn.cursor() as cur:
            cur.execute("SELECT code, name FROM app.org_unit WHERE id = %s",
                        (order["org_unit_id"],))
            u = cur.fetchone()
        #  Уведомление инициатору в кабинете ОЗ — и на почту
        if order["created_by_email"]:
            _purchase_notify(
                order["created_by_email"],
                f"Поставка №{order_id}: {purchasedb.ORDER_STATUS_RU[order['status']]}",
                f"Депо {u['name']} решило по поставке №{order_id} "
                f"({order['category']}, {order['supplier']}): "
                f"{purchasedb.ORDER_STATUS_RU[order['status']]}"
                + (f". Причина: {note.strip()}" if note.strip() else ""))
    return _purchase_back(
        u["code"], "queue",
        msg=f"Решение сохранено: {purchasedb.ORDER_STATUS_RU[order['status']]}")


@app.post("/purchase/order/{order_id}/exact")
def purchase_order_exact(order_id: int, request: Request,
                         exact_date: str = Form(...)):
    """ОЗ указал точную дату — снова на согласование депо."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.oz"):
            raise HTTPException(403, "Точную дату заполняет отдел закупок")
        try:
            order = purchasedb.set_exact_date(
                conn, order_id, parse_day(exact_date), uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(None, "queue", error=text)
        with conn.cursor() as cur:
            cur.execute("SELECT code FROM app.org_unit WHERE id = %s",
                        (order["org_unit_id"],))
            code = cur.fetchone()["code"]
    return _purchase_back(code, "queue",
                          msg="Точная дата указана — депо согласует её")


@app.post("/purchase/order/{order_id}/arrival")
def purchase_order_arrival(order_id: int, request: Request):
    """Запрос приёмки по согласованной поставке."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.oz"):
            raise HTTPException(403, "Приёмку запрашивает отдел закупок")
        try:
            order = purchasedb.request_arrival(conn, order_id, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(None, "schedule", error=text)
        with conn.cursor() as cur:
            cur.execute("SELECT code, name FROM app.org_unit WHERE id = %s",
                        (order["org_unit_id"],))
            u = cur.fetchone()
            #  Склад депо узнаёт о запросе почтой начальника, если он есть
            cur.execute("SELECT app.default_assignee(%s) AS uid",
                        (order["org_unit_id"],))
            chief = cur.fetchone()["uid"]
            if chief:
                cur.execute("SELECT email FROM app.app_user WHERE id = %s",
                            (chief,))
                email = cur.fetchone()["email"]
                _purchase_notify(
                    email,
                    f"Поставка №{order_id}: запрошена приёмка",
                    f"Отдел закупок просит подтвердить приёмку поставки "
                    f"№{order_id} ({order['category']}, {order['supplier']}, "
                    f"{order['exact_date']:%d.%m.%Y}) — раздел «Поставки».")
    return _purchase_back(u["code"], "schedule", msg="Склад уведомлён — "
                          "подтвердите приёмку в разделе «Поставки»")


@app.post("/purchase/order/{order_id}/received")
def purchase_order_received(order_id: int, request: Request,
                            unit: str = Form("")):
    """Склад подтвердил получение товара."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.receive"):
            raise HTTPException(403, "Приёмку подтверждает склад депо")
        try:
            order = purchasedb.confirm_received(conn, order_id, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(unit or None, "queue", error=text)
        if order["created_by_email"]:
            _purchase_notify(
                order["created_by_email"],
                f"Поставка №{order_id}: принято складом",
                f"Склад подтвердил приёмку поставки №{order_id} "
                f"({order['category']}, {order['supplier']}).")
    return _purchase_back(unit or None, "queue", msg="Приёмка подтверждена")


@app.post("/purchase/slot")
def purchase_slot_save(request: Request, unit: str = Form(...),
                       slot_id: int = Form(0), weekday: int = Form(...),
                       time_from: str = Form(...), time_to: str = Form(...),
                       note: str = Form("")):
    """Слот мелких поставщиков — правит депо, видит весь отдел."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.receive"):
            raise HTTPException(403, "Слоты заполняет депо")
        unit_row = unit_or_403(conn, unit)
        try:
            purchasedb.slot_save(conn, unit_row["id"], slot_id or None,
                                 weekday, time_from, time_to, note)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(unit, "slots", error=text)
    return _purchase_back(unit, "slots", msg="Слот сохранён")


@app.post("/purchase/slot/{slot_id}/del")
def purchase_slot_delete(slot_id: int, request: Request,
                         unit: str = Form(...)):
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.receive"):
            raise HTTPException(403, "Слоты заполняет депо")
        unit_row = unit_or_403(conn, unit)
        try:
            purchasedb.slot_delete(conn, unit_row["id"], slot_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(unit, "slots", error=text)
    return _purchase_back(unit, "slots", msg="Слот убран")


@app.post("/purchase/space")
def purchase_space_update(request: Request, unit: str = Form(...),
                          free_text: str = Form(...)):
    """Свободное место обновляет депо — пн и чт до 10:00, задача на доске."""
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "supply.receive"):
            raise HTTPException(403, "Место на складе обновляет депо")
        unit_row = unit_or_403(conn, unit)
        try:
            purchasedb.space_update(conn, unit_row["id"], free_text, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _purchase_back(unit, "space", error=text)
    return _purchase_back(unit, "space", msg="Свободное место обновлено")


@app.get("/safety", response_class=HTMLResponse)
def safety_page(request: Request, unit: str | None = None):
    """
    Кабинет ОТ — каркас (вычитка 30.09.2026, волна 4в).

    Сводка охраны труда по всем депо: просроченные и истекающие допуски
    (медосмотр, инструктаж, удостоверение) и люди, у которых срок горит.
    Подробные требования заказчик ещё не собрал — каркас собран из данных,
    которые уже ведутся, и ляжет на эту же страницу.
    """
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if not webdb.has_perm(conn, "ot.read"):
            raise HTTPException(403, "Кабинет ОТ ведёт охрана труда")
        units = webdb.accessible_units(conn)
        sel = next((u for u in units if u["code"] == unit), None)
        rows = cabinetdb.ot_units(conn)
        people = cabinetdb.ot_people(
            conn, sel["id"] if sel else None) if cabinetdb.has_role_tables(conn) else []
        ctx = {
            "user": user, "units": units, "unit": sel,
            "mode": "safety", "title": "Охрана труда",
            "ready": cabinetdb.has_role_tables(conn),
            "permit_kinds": cabinetdb.PERMIT_KIND_RU,
            "summary": rows,
            "people": people,
            "today_date": date.today(),
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "safety.html", ctx)


@app.get("/board", response_class=HTMLResponse)
def board_page(request: Request):
    """
    Кабинет Руководства — каркас (вычитка 30.09.2026, волна 4в).

    «Отображение метрик бюджета и информации по аренде, основные параметры
    метрик по состоянию в отделе централизованно». Каркас: численность и
    задачи по каждому депо, аренда месяца и долг по ней; детали — в
    «Бюджете» и «Финансах». Метрики заказчика лягут сюда же.
    """
    uid = require_user(request)
    with db(uid) as conn:
        user = webdb.current_user(conn, uid)
        if not webdb.has_perm(conn, "board.read"):
            raise HTTPException(403, "Кабинет Руководства — для руководства "
                                     "отдела")
        totals = (cabinetdb.board_totals(conn)
                  if cabinetdb.has_role_tables(conn) else {"units": []})
        units = webdb.accessible_units(conn)
        ctx = {
            "user": user, "units": units, "unit": None,
            "mode": "board", "title": "Руководство",
            "ready": cabinetdb.has_role_tables(conn),
            "totals": totals,
            "today_date": date.today(),
        }
        ctx.update(header_menu_flags(conn, units))
    return templates.TemplateResponse(request, "board.html", ctx)


def _card_day(value: str | None) -> date | None:
    """
    Дата из фильтра истории ТО. Пусто или мусор — значит «без границы».

    Отказывать за кривую дату здесь незачем: фильтр — удобство, и пустая
    граница даёт ровно тот же список, что был до фильтрации.
    """
    if not value:
        return None
    try:
        return date.fromisoformat(value.strip())
    except ValueError:
        return None


@app.get("/supply/asset/{asset_id}", response_class=HTMLResponse)
def asset_card_page(request: Request, asset_id: int, modal: int = 0,
                    mo: str | None = None,
                    vf: str | None = None, vt: str | None = None,
                    show: str | None = None,
                    msg: str | None = None, error: str | None = None):
    """
    Карточка единицы техники — уточнение по блоку F от 15.09.2026.

    Собирает в одном месте то, что до сих пор лежало по трём вкладкам: сама
    машина, когда у неё следующее ТО, что из ТО уже проведено, как росли
    моточасы и что с ней случалось. Отвечает на вопрос, который задают про
    конкретную машину: «а что с ней вообще было?»

    Карточка есть и у ТМЦ — не запрещаем: инвентарный номер и история
    ремонтов у тележки тоже бывают. Просто из списка ТМЦ на неё не ходят:
    там считают количество, а не разбирают каждую штуку.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "asset.read"):
            raise HTTPException(403, "Нет доступа к разделу обеспечения")
        card = supplydb.asset_card(conn, asset_id)
        if not card:
            raise HTTPException(404, "Единица не найдена")
        if not webdb.can_access_unit(conn, card["org_unit_id"]):
            raise HTTPException(403, "Нет доступа к этому депо")

        #  Вкладка, из которой пришли: у поверочного своя (22.09.2026)
        if card.get("group_code") == supplydb.VERIFICATION_GROUP:
            tab = "verification"
        else:
            tab = "equipment" if card["is_equipment"] else "stock"
        ctx = _supply_context(conn, uid, card["unit_code"], tab)
        ctx["title"] = card["name"]
        ctx["asset"] = card
        #  Проведённые ТО: показываем двенадцать записей и кнопку «Показать
        #  ещё» (22.09.2026). Разрез по месяцам заменён диапазоном «с и до»:
        #  месяцы годились, пока записей было немного, а когда их полсотни,
        #  ищут не «месяц», а период.
        d_from = _card_day(vf)
        d_to = _card_day(vt)
        want = max(supplydb.HISTORY_PAGE,
                   int(show) if str(show).isdigit() else supplydb.HISTORY_PAGE)
        rows = supplydb.maintenance_history(conn, asset_id, None,
                                            d_from, d_to, limit=want)
        #  Запрошено на одну больше: лишняя говорит, что есть продолжение
        ctx["history_more"] = len(rows) > want
        ctx["history"] = rows[:want]
        ctx["history_shown"] = want
        ctx["history_next"] = want + supplydb.HISTORY_PAGE
        ctx["history_from"] = vf or ""
        ctx["history_to"] = vt or ""
        ctx["repairs"] = supplydb.repairs_of_asset(conn, asset_id)
        ctx["acts"] = supplydb.repair_acts(conn, [r["id"] for r in ctx["repairs"]])
        ctx["types"] = supplydb.maintenance_types(conn)
        ctx["categories"] = supplydb.categories(conn)
        #  Сроки берём из общего расчёта депо и оставляем только эту машину:
        #  два способа считать «когда следующее ТО» однажды разойдутся
        ctx["due"] = [d for d in supplydb.maintenance_due(conn, card["org_unit_id"])
                      if d["asset_id"] == asset_id]
        #  ТО со специалистом по ролям (24.09.2026): заявка, подрядчик, дата
        ctx["mrequests"] = list(supplydb.open_maintenance_requests(
            conn, asset_id=asset_id).values())
        ctx["contractors"] = supplydb.contractors(conn)
        ctx["can_plan"] = webdb.has_perm(conn, "maintenance.plan")
        ctx["MREQ_STATUS_RU"] = supplydb.MREQ_STATUS_RU
        #  Техника — только Администрация ООУРЦ; у ТМЦ — как раньше
        ctx["can_edit_card"] = (ctx["can_plan"] if card["is_equipment"]
                                else ctx.get("can_supply_write"))
        #  Поверка — не ТО: у прибора свой блок со сроком и своя история
        #  («Проведённые поверки» вместо «Проведённых ТО»)
        ctx["is_verification"] = tab == "verification"
        ctx["verifications"] = (supplydb.verifications(conn, asset_id)
                                if ctx["is_verification"] else [])
        #  «Путевой» (25.09.2026): чек-лист выпуска на линию — только у
        #  складской техники. Алкотестер — из «Поверенной техники» депо
        if card.get("group_code") == "warehouse_tech":
            from .waybill_print import MONTHS_NOM
            today = date.today()
            ctx["waybill"] = {
                "month": f"{today:%Y-%m}",
                "month_label": f"{MONTHS_NOM[today.month - 1]} {today.year}",
                "vehicle_type": " ".join(x for x in (card["name"], card.get("model")) if x),
                "inventory_no": card["inventory_no"],
                "alcotesters": supplydb.alcotesters(conn, card["org_unit_id"]),
            }
        ctx["msg"] = msg
        ctx["error"] = error
    #  Карточка техники открывается окном поверх списка — так же, как карточка
    #  сотрудника (правка от 15.09.2026). Признак окна берём из заголовка
    #  запроса: браузер помечает им всё, что грузится в рамку, включая
    #  переходы по ссылкам внутри неё и переадресацию после форм.
    ctx["modal"] = bool(modal) or         request.headers.get("sec-fetch-dest") == "iframe"
    return templates.TemplateResponse(request, "asset_card.html", ctx)


@app.get("/supply/asset/{asset_id}/waybill/print", response_class=HTMLResponse)
def supply_asset_waybill_print(request: Request, asset_id: int, month: str = "",
                               month_label: str = "", vehicle_type: str = "",
                               inventory_no: str = "", alcotester: str = ""):
    """
    «Путевой» — печать прямо из приложения (25.09.2026): страница, свёрстанная
    по шаблону чек-листа, сама открывает окно печати. Файл не скачивается.
    """
    from .waybill_print import MONTHS_NOM, print_scale, render_pages

    uid = require_user(request)
    with db(uid) as conn:
        card = supplydb.asset_card(conn, asset_id)
        if not card:
            raise HTTPException(404, "Единица не найдена")
    label = month_label.strip()
    if not label and month:
        try:
            y, m = month.split("-")[:2]
            label = f"{MONTHS_NOM[int(m) - 1]} {int(y)}"
        except (ValueError, IndexError):
            label = ""
    values = dict(
        month_label=label,
        vehicle_type=vehicle_type.strip() or " ".join(
            x for x in (card["name"], card.get("model")) if x),
        inventory_no=inventory_no.strip() or card["inventory_no"],
        alcotester=alcotester.strip())
    ctx = dict(values, pages=render_pages(**values), scale=print_scale())
    return templates.TemplateResponse(request, "waybill_print.html", ctx)


@app.get("/supply/asset/{asset_id}/waybill")
def supply_asset_waybill(request: Request, asset_id: int, month: str = "",
                         month_label: str = "", vehicle_type: str = "",
                         inventory_no: str = "", alcotester: str = ""):
    """
    «Путевой» — чек-лист выпуска на линию НБТ по шаблону заказчика
    (25.09.2026). Поля приходят из окна в карточке: там они уже заполнены из
    карточки техники и «Поверенной техники», и их можно поправить руками.
    """
    from .waybill_print import MONTHS_NOM, export_waybill

    uid = require_user(request)
    with db(uid) as conn:
        card = supplydb.asset_card(conn, asset_id)
        if not card:
            raise HTTPException(404, "Единица не найдена")
    label = month_label.strip()
    if not label and month:
        try:
            y, m = month.split("-")[:2]
            label = f"{MONTHS_NOM[int(m) - 1]} {int(y)}"
        except (ValueError, IndexError):
            label = ""
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    safe = re.sub(r"[^0-9A-Za-zА-Яа-я_-]", "_", card["inventory_no"] or str(asset_id)).strip("_")
    filename = f"putevoy_{safe}_{month or f'{date.today():%Y-%m}'}.xlsx"
    path = OUT_DIR / filename
    export_waybill(str(path), month_label=label,
                   vehicle_type=vehicle_type.strip() or " ".join(
                       x for x in (card["name"], card.get("model")) if x),
                   inventory_no=inventory_no.strip() or card["inventory_no"],
                   alcotester=alcotester.strip())
    return FileResponse(
        path, filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")


def _asset_back(asset_id: int, msg: str = "", error: str = ""):
    tail = f"/supply/asset/{asset_id}"
    if msg:
        tail += f"?msg={quote(msg)}"
    elif error:
        tail += f"?error={quote(error)}"
    return RedirectResponse(tail, status_code=303)


@app.post("/supply/asset")
async def supply_asset_save(request: Request, unit: str = Form(...),
                            asset_id: str = Form(""),
                            category_id: int = Form(...),
                            inventory_no: str = Form(...),
                            #  У складской техники наименование берётся из
                            #  вида, и поля в форме нет — значение по
                            #  умолчанию пустое, а не обязательное
                            name: str = Form(""),
                            model: str = Form(""), serial_no: str = Form(""),
                            completeness: str = Form(""), qty: str = Form("1"),
                            note: str = Form(""), status: str = Form("ok"),
                            tracking: str = Form("unit"),
                            verified_at: str = Form(""),
                            verified_until: str = Form(""),
                            back: str = Form("equipment")):
    """
    Завести или поправить единицу ТМЦ — те же поля, что на листе «ТМЦ Депо»
    файла управления РЦ.
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "asset.write"):
            raise HTTPException(403, "Технику и ТМЦ ведут начальник депо и "
                                     "заместитель")
        #  Списание — отдельная строка матрицы О9 и единственная, где у депо
        #  «нет»: списанная единица уходит из учёта, и это решение не депо
        if status == "written_off" and not webdb.has_perm(conn, "asset.writeoff"):
            return _back_from(unit, back, None,
                              error="Списание оформляет администрация")
        #  Последние ТО новой машины (24.09.2026): поля last_at_<код> и
        #  last_hours_<код> в форме заведения складской техники
        aid = int(asset_id) if str(asset_id).strip().isdigit() else None
        #  24.09.2026: карточку техники (складской и поверенной) правит
        #  только Администрация ООУРЦ; депо заводит новую, но не правит
        if aid and _is_equipment_asset(conn, aid) and not webdb.has_perm(conn, "maintenance.plan"):
            return _back_from(unit, back, aid,
                              error="Карточку техники правит Администрация ООУРЦ")
        form = await request.form()
        last_done = {}
        for t in supplydb.maintenance_types(conn):
            key = supplydb.LAST_DONE_FIELD.get(t["code"])
            if key:
                last_done[t["code"]] = (form.get(f"last_at_{key}", ""),
                                        form.get(f"last_hours_{key}", ""))
        try:
            supplydb.save_asset(
                conn, last_done=last_done, user_id=uid,
                asset_id=int(asset_id) if str(asset_id).strip() else None,
                unit_id=u["id"], category_id=category_id,
                inventory_no=inventory_no, name=name, model=model,
                serial_no=serial_no, completeness=completeness,
                qty=str(qty).strip() or "1",
                note=note, status=status, tracking=tracking,
                verified_at=verified_at, verified_until=verified_until)
        except (ValueError, InvalidOperation, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_from(unit, back, aid, error=text)
    #  Правка из карточки (24.09.2026) возвращает в карточку
    return _back_from(unit, back, aid, msg="Запись сохранена")


def _is_equipment_asset(conn, asset_id: int) -> bool:
    """Техника (складская или поверенная), а не ТМЦ."""
    with conn.cursor() as cur:
        cur.execute("SELECT c.is_equipment FROM app.asset a JOIN app.asset_category c "
                    "ON c.id = a.category_id WHERE a.id = %s", (asset_id,))
        row = cur.fetchone()
    return bool(row and row["is_equipment"])


@app.post("/supply/asset/{asset_id}/delete")
async def supply_asset_delete(request: Request, asset_id: int,
                              unit: str = Form(...),
                              back: str = Form("equipment")):
    """
    Удалить единицу ТМЦ, заведённую по ошибке.

    ОБ-10 от 21.09.2026: «список ТМЦ нельзя ни исправить, ни удалить».
    Удаляется только запись без следа — без ремонтов, ТО, показаний и
    движений. Единицу с историей стирать нельзя: она в депо была, и её
    переводят в состояние «списано».
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "asset.write"):
            raise HTTPException(403, "Технику и ТМЦ ведут начальник депо и "
                                     "заместитель")
        if _is_equipment_asset(conn, asset_id) and not webdb.has_perm(conn, "maintenance.plan"):
            return _back_from(unit, back, None,
                              error="Карточку техники правит и удаляет Администрация ООУРЦ")
        try:
            what = supplydb.delete_asset(conn, asset_id, u["id"])
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_from(unit, back, None, error=text)
    return _back_from(unit, back, None, msg=f"Удалено: {what}")


@app.post("/supply/repair/open")
async def supply_repair_open(request: Request, unit: str = Form(...),
                             asset_id: int = Form(...), problem: str = Form(""),
                             route: str = Form(""),
                             back: str = Form("repairs")):
    """
    Открыть заявку на ремонт: техника сразу помечается «в ремонте».

    `back` — куда вернуть человека. Заявку открывают из трёх мест: из списка
    техники («вот эта сломалась»), из карточки машины и со вкладки заявок.
    Возвращать всех на вкладку заявок значило бы уводить со страницы, на
    которой работали, ради подтверждения того, что и так видно.
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        #  Матрица О9 от 21.09.2026: заявку оформляют начальник, заместитель
        #  и мастер. Кладовщику в «Обеспечении» не положено ничего
        if not webdb.has_perm(conn, "repair.open"):
            raise HTTPException(403, "Заявку на ремонт оформляют начальник "
                                     "депо, заместитель и мастер")
        try:
            supplydb.open_repair(conn, asset_id, u["id"], problem, uid,
                                 route=route)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            if back == "card":
                return _asset_back(asset_id, error=text)
            return _supply_back(unit, back if back in dict(SUPPLY_TABS) else "repairs",
                                error=text)
    done = (f"Заявка открыта — {supplydb.REPAIR_ROUTE_RU.get(route, '').lower()}; "
            f"единица помечена «в ремонте»")
    if back == "card":
        return _asset_back(asset_id, msg=done)
    return _supply_back(unit, back if back in dict(SUPPLY_TABS) else "repairs",
                        msg=done)


@app.post("/supply/repair/{request_id}/move")
async def supply_repair_move(request_id: int, request: Request,
                             unit: str = Form(...), status: str = Form(...),
                             note: str = Form("")):
    """
    Следующий шаг заявки. Маршрут проверяет база: получить в депо то, что
    ещё не отправляли, нельзя.
    """
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        #  Матрица О9 от 21.09.2026: маршрут в Минск двигают администрация и
        #  начальник депо. Вызов специалиста (23.09.2026) ведёт и депо, и
        #  Минск — шаги по нему отмечает любой, кто вправе открыть заявку.
        #  Точную проверку по шагу делает база
        #  02.10.2026: шаг — своей стороне (вычитка 5.20). Точную проверку
        #  по шагу и состоянию делает база
        if not (webdb.has_perm(conn, "repair.hq")
                or webdb.has_perm(conn, "repair.open")):
            raise HTTPException(403, "Заявки на ремонт ведут начальник, "
                                     "заместитель, мастер и Администрация")
        form = await request.form()
        outcome = (form.get("outcome") or "").strip() or None
        try:
            supplydb.move_repair(conn, request_id, status, note or None,
                                 outcome=outcome)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _supply_back(unit, "repairs", error=text)
    return _supply_back(
        unit, "repairs",
        msg=f"Заявка №{request_id}: {supplydb.REPAIR_STATUS_RU.get(status, status)}")


def _can_attach_act(conn) -> bool:
    """Приложить акт может любой, кто ведёт заявки: депо и администрация."""
    return any(webdb.has_perm(conn, p)
               for p in ("repair.open", "repair.hq", "asset.write"))


@app.post("/supply/repair/{request_id}/act")
async def supply_repair_act(request_id: int, request: Request,
                            unit: str = Form(...), act_date: str = Form(""),
                            note: str = Form(""), back: str = Form("repairs"),
                            asset_id: int = Form(0),
                            file: UploadFile = File(...)):
    """
    Приложить акт к заявке: фото или PDF, с датой акта.

    «Фото акта или скрин акта привязать к дате» (23.09.2026). Не обязателен
    для закрытия: прикладывается на любом шаге и после закрытия — акт от
    специалиста часто приходит днём позже ремонта.
    """
    from . import filestore

    uid = require_user(request)
    data = await file.read(filestore.MAX_BYTES + 1)

    def back_to(**kw):
        if back == "card" and asset_id:
            return _asset_back(asset_id, **kw)
        return _supply_back(unit, "repairs", **kw)

    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not _can_attach_act(conn):
            raise HTTPException(403, "Акт прикладывают начальник депо, "
                                     "заместитель, мастер или администрация")
        try:
            day = parse_day(act_date) if act_date else date.today()
            supplydb.add_repair_act(conn, request_id, day,
                                    file.filename or "акт", data, note)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return back_to(error=text)
    return back_to(msg=f"Акт к заявке №{request_id} приложен")


@app.get("/supply/repair/act/{act_id}")
def supply_repair_act_file(act_id: int, request: Request):
    """
    Открыть акт. Файл отдаёт приложение, а не веб-сервер напрямую: доступ
    проверяется тем же правилом, что и к заявке, — чужое депо акт не увидит.
    """
    from fastapi.responses import FileResponse
    from . import filestore

    uid = require_user(request)
    with db(uid) as conn:
        act = supplydb.repair_act(conn, act_id)
        #  Чужое депо акт не получит уже на уровне базы (RLS). Проверяем и
        #  здесь: файл — это то, что уходит за пределы приложения, и держать
        #  его на одном рубеже незачем
        if act and not webdb.can_access_unit(conn, act["org_unit_id"]):
            act = None
    if not act:
        raise HTTPException(404, "Акт не найден")
    try:
        path = filestore.path_of(act["stored_name"])
    except filestore.FileRejected:
        raise HTTPException(404, "Акт не найден")
    if not path.exists():
        raise HTTPException(
            404, "Файл акта не найден в хранилище. Сведения о нём в базе "
                 "есть — вероятно, папка хранилища не перенесена вместе с базой")
    #  inline: фото и PDF открываются во вкладке браузера, а не скачиваются
    return FileResponse(path, media_type=act["mime_type"],
                        filename=act["file_name"],
                        content_disposition_type="inline")


@app.get("/supply/maintenance/{maintenance_id}/act")
def supply_maintenance_act_file(maintenance_id: int, request: Request):
    """Акт специалиста по проведённому ТО (02.10.2026, вычитка 5.10)."""
    from fastapi.responses import FileResponse
    from . import filestore

    uid = require_user(request)
    with db(uid) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT m.act_stored, m.act_name, m.act_mime, a.org_unit_id "
                "FROM app.maintenance m JOIN app.asset a ON a.id = m.asset_id "
                "WHERE m.id = %s", (maintenance_id,))
            row = cur.fetchone()
        if row and not webdb.can_access_unit(conn, row["org_unit_id"]):
            row = None
    if not row or not row["act_stored"]:
        raise HTTPException(404, "Акт не найден")
    try:
        path = filestore.path_of(row["act_stored"])
    except filestore.FileRejected:
        raise HTTPException(404, "Акт не найден")
    if not path.exists():
        raise HTTPException(404, "Файл акта не найден в хранилище")
    return FileResponse(path, media_type=row["act_mime"],
                        filename=row["act_name"] or path.name,
                        content_disposition_type="inline")


@app.post("/supply/repair/act/{act_id}/drop")
async def supply_repair_act_drop(act_id: int, request: Request,
                                 unit: str = Form(...),
                                 back: str = Form("repairs"),
                                 asset_id: int = Form(0)):
    """
    Удалить ошибочно приложенный акт. Может тот, кто его приложил, и
    администрация: чужой акт депо не стирает.
    """
    uid = require_user(request)

    def back_to(**kw):
        if back == "card" and asset_id:
            return _asset_back(asset_id, **kw)
        return _supply_back(unit, "repairs", **kw)

    with db(uid) as conn:
        unit_or_403(conn, unit)
        act = supplydb.repair_act(conn, act_id)
        if not act:
            raise HTTPException(404, "Акт не найден")
        #  02.10.2026 (вычитка 5.20): акты удаляет только Администрация
        if not webdb.has_perm(conn, "repair.hq"):
            raise HTTPException(403, "Удалить акт может только "
                                     "Администрация ООУРЦ")
        try:
            name = supplydb.drop_repair_act(conn, act_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return back_to(error=str(e))
    return back_to(msg=f"Акт «{name}» удалён")


@app.post("/supply/meter")
async def supply_meter_save(request: Request, unit: str = Form(...),
                            asset_id: int = Form(...), read_at: str = Form(...),
                            engine_hours: str = Form(...),
                            back: str = Form("maintenance")):
    """
    Снять показания моточасов. От них считается срок следующего ТО — так же,
    как на листе «ТО» файла управления РЦ.
    """
    uid = require_user(request)
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        #  Матрица О9: моточасы снимает в том числе мастер — это работа на
        #  месте, а не ведение справочника техники
        if not webdb.has_perm(conn, "maintenance.do"):
            raise HTTPException(403, "Показания вносят начальник депо, "
                                     "заместитель и мастер")
        try:
            hours = Decimal(str(engine_hours).replace(",", ".").strip())
            supplydb.save_meter(conn, asset_id, parse_day(read_at), hours, uid,
                                unit_id=u["id"])
        except (ValueError, InvalidOperation, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_from(unit, back, asset_id, error=text)
    return _back_from(unit, back, asset_id, msg="Показания сохранены")


@app.post("/supply/maintenance/done")
async def supply_maintenance_done(request: Request, unit: str = Form(...),
                                  asset_id: int = Form(...),
                                  type_id: int = Form(...),
                                  done_at: str = Form(...),
                                  done_hours: str = Form(""),
                                  note: str = Form(""),
                                  request_id: str = Form(""),
                                  back: str = Form("maintenance")):
    """
    Отметить проведённое ТО — от него пойдёт отсчёт следующего.

    02.10.2026 (вычитка 5.10): к ТО со специалистом — сумма (с НДС или без)
    и акт, фото или PDF. Форма отправляется как multipart, поля читаем из
    request.form(), чтобы обычная отметка ТО-1 по-прежнему шла без файла.
    """
    from . import filestore
    from starlette.datastructures import UploadFile as StarletteUpload
    uid = require_user(request)
    form = await request.form()
    raw_cost = (form.get("cost") or "").strip()
    cost_vat = (form.get("cost_vat") or "").strip() or None
    upload = form.get("act")
    act = act_name = None
    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        #  Матрица О9: отметку о проведённом ТО ставит и мастер
        if not webdb.has_perm(conn, "maintenance.do"):
            raise HTTPException(403, "Отметку о ТО ставят начальник депо, "
                                     "заместитель и мастер")
        try:
            cost = (Decimal(raw_cost.replace(",", ".").replace(" ", ""))
                    if raw_cost else None)
            if isinstance(upload, StarletteUpload):
                data = await upload.read(filestore.MAX_BYTES + 1)
                if data:
                    act = filestore.save(data, area="maintenance")
                    act_name = upload.filename or act.stored_name
            hours = (Decimal(str(done_hours).replace(",", ".").strip())
                     if str(done_hours).strip() else None)
            #  Депо — из формы, проверенное выше: машина должна быть его
            supplydb.mark_maintenance_done(
                conn, asset_id, type_id, parse_day(done_at), hours,
                note or None, uid, unit_id=u["id"],
                #  «Пройти ТО-2» — по сформированной заявке (24.09.2026)
                request_id=int(request_id) if request_id.strip().isdigit() else None,
                cost=cost, cost_vat=cost_vat, act=act, act_name=act_name)
        except (ValueError, InvalidOperation, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_from(unit, back, asset_id, error=text)
    return _back_from(unit, back, asset_id, msg="ТО отмечено как проведённое")


# ---------------------------------------------------------------------------
#  ТО со специалистом по ролям и правка отметок (24.09.2026, TO_PROCESS 7.4.1)
# ---------------------------------------------------------------------------

def _db_error(e: Exception) -> str:
    return (getattr(e, "diag", None) and e.diag.message_primary) or str(e)


@app.post("/supply/maintenance/request")
async def supply_mreq_fill(request: Request, unit: str = Form(...),
                           asset_id: int = Form(...), type_id: int = Form(...),
                           note: str = Form(""), due: str = Form("")):
    """Шаг 1 — начальник РЦ: заполнить заявку, примечание обязательно."""
    uid = require_user(request)
    with db(uid) as conn:
        unit_or_403(conn, unit)
        try:
            supplydb.fill_maintenance_request(
                conn, asset_id, type_id, note,
                parse_day(due) if due.strip() else None)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _asset_back(asset_id, error=_db_error(e))
    return _asset_back(asset_id, msg="Заявка отправлена в Администрацию ООУРЦ")


@app.post("/supply/maintenance/request/{request_id}/schedule")
async def supply_mreq_schedule(request: Request, request_id: int,
                               asset_id: int = Form(...), note: str = Form(""),
                               contractor_id: str = Form(""),
                               planned_date: str = Form("")):
    """Шаг 2 — Администрация: подрядчик из реестра и дата; и исправление."""
    uid = require_user(request)
    with db(uid) as conn:
        try:
            supplydb.schedule_maintenance_request(
                conn, request_id, note,
                int(contractor_id) if contractor_id.strip().isdigit() else None,
                parse_day(planned_date) if planned_date.strip() else None)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _asset_back(asset_id, error=_db_error(e))
    return _asset_back(asset_id, msg="Заявка сформирована — депо видит "
                                     "подрядчика и дату на доске")


@app.post("/supply/maintenance/request/{request_id}/cancel")
async def supply_mreq_cancel(request: Request, request_id: int,
                             asset_id: int = Form(...)):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            supplydb.cancel_maintenance_request(conn, request_id)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _asset_back(asset_id, error=_db_error(e))
    return _asset_back(asset_id, msg="Заявка отменена")


@app.post("/supply/maintenance/{maintenance_id}/fix")
async def supply_maintenance_fix(request: Request, maintenance_id: int,
                                 asset_id: int = Form(...),
                                 done_at: str = Form(...),
                                 done_hours: str = Form(""),
                                 note: str = Form("")):
    """Администрация исправляет ошибочную отметку ТО — с записью в журнал."""
    uid = require_user(request)
    with db(uid) as conn:
        try:
            hours = (Decimal(str(done_hours).replace(",", ".").strip())
                     if str(done_hours).strip() else None)
            supplydb.fix_maintenance(conn, maintenance_id, parse_day(done_at),
                                     hours, note, uid)
        except (ValueError, InvalidOperation, psycopg.Error) as e:
            conn.rollback()
            return _asset_back(asset_id, error=_db_error(e))
    return _asset_back(asset_id, msg="Отметка ТО исправлена")


@app.post("/supply/maintenance/{maintenance_id}/drop")
async def supply_maintenance_drop(request: Request, maintenance_id: int,
                                  asset_id: int = Form(...)):
    uid = require_user(request)
    with db(uid) as conn:
        try:
            supplydb.drop_maintenance(conn, maintenance_id, uid)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _asset_back(asset_id, error=_db_error(e))
    return _asset_back(asset_id, msg="Отметка ТО удалена")


@app.post("/supply/repair/{request_id}/specialist")
async def supply_repair_specialist(request: Request, request_id: int,
                                   unit: str = Form(...),
                                   specialist_date: str = Form(""),
                                   contractor_id: str = Form(""),
                                   note: str = Form(""),
                                   back: str = Form("repairs"),
                                   asset_id: str = Form("")):
    """Администрация вызывает специалиста на ремонт и назначает дату."""
    uid = require_user(request)
    aid = int(asset_id) if asset_id.strip().isdigit() else None
    with db(uid) as conn:
        unit_or_403(conn, unit)
        try:
            supplydb.call_specialist(
                conn, request_id,
                parse_day(specialist_date) if specialist_date.strip() else None,
                int(contractor_id) if contractor_id.strip().isdigit() else None,
                note or None)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            return _back_from(unit, back, aid, error=_db_error(e))
    return _back_from(unit, back, aid, msg="Специалист вызван, дата приезда "
                                           "видна депо на доске")


@app.post("/supply/verification")
async def supply_verification_done(request: Request, unit: str = Form(...),
                                   asset_id: int = Form(...),
                                   verified_at: str = Form(...),
                                   verified_until: str = Form(""),
                                   certificate_no: str = Form(""),
                                   note: str = Form(""),
                                   back: str = Form("maintenance")):
    """
    Отметить проведённую поверку.

    Не «ещё один вид ТО» (22.09.2026): поверку не проводят своими силами и не
    считают по наработке — прибор везут в поверочную организацию, и срок
    приходит из протокола. Отмечает её то же депо, что и ТО: начальник,
    заместитель и мастер.
    """
    uid = require_user(request)
    if not verified_until.strip():
        #  30.09.2026: «Годна до» обязательна — без срока напоминание о
        #  следующей поверке на доске не появится, прибор теряется из вида
        return _back_from(unit, back, asset_id,
                          error="Укажите, до какой даты прибор годен: "
                                "срок приходит из протокола поверки")
    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "maintenance.do"):
            raise HTTPException(403, "Поверку отмечают начальник депо, "
                                     "заместитель и мастер")
        try:
            supplydb.record_verification(
                conn, asset_id=asset_id, verified_at=verified_at,
                verified_until=verified_until or None,
                certificate_no=certificate_no, note=note)
        except (ValueError, psycopg.Error) as e:
            conn.rollback()
            text = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _back_from(unit, back, asset_id, error=text)
    return _back_from(unit, back, asset_id, msg="Поверка отмечена")


@app.get("/budget", response_class=HTMLResponse)
def budget_page(request: Request, period: str | None = None):
    """
    Бюджетные данные — пункт 1 плана от 14.09.2026.

    Города слева, должности в верхней строке, в клетке численность. Рядом
    деньги: бюджет ФОТ, начислено и отклонение — то самое «не вышли ли мы за
    предел».

    Депо не выбирается: смысл вкладки в том, чтобы видеть все города разом.
    Начальник РЦ увидит здесь только своё депо — за этим следит RLS.
    """
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "payroll.read"):
            raise HTTPException(403, "Нет доступа к бюджетным данным")
        data = budgetdb.matrix(conn, p)
        ctx = {
            "user": webdb.current_user(conn, uid),
            "units": webdb.accessible_units(conn),
            "unit": webdb.accessible_units(conn)[0],
            "mode": "budget",
            #  Решение заказчика от 16.09.2026: «бюджеты по сумма ФОТ не видны
            #  начальникам, замам и мастерам, кладовщикам, внешним
            #  наблюдателям, только данные по численности сотрудников».
            #  Расчётных листков и «Мотивации» это не касается — там начальник
            #  согласует доплаты и суммы видеть должен
            "can_money": webdb.has_perm(conn, "budget.money"),
            #  Заявки на численность: депо видит свои, администрация — все
            #  Политика таблицы уже режет строки по доступу к депо: депо
            #  увидит свои, администрация — все
            "hc_requests": budgetdb.headcount_requests(conn, None),
            "can_decide_hc": webdb.has_perm(conn, "reference.write"),
            "categories": settingsdb.position_categories(conn),
            "title": "Бюджетные данные",
            "period": p,
            "period_label": f"{MONTHS_RU[p.month - 1]} {p.year}",
            "period_iso": f"{p:%Y-%m}",
            "budget": data,
            "budget_months": budgetdb.budget_months(conn),
            "open_requests": webdb.open_staff_requests(conn),
            "can_payroll": True,
            "can_supply": webdb.has_perm(conn, "asset.read"),
            "can_reference": webdb.has_perm(conn, "reference.write"),
        }
    return templates.TemplateResponse(request, "budget.html", ctx)


@app.get("/payslip/{line_id}", response_class=HTMLResponse)
def payslip_page(request: Request, line_id: int):
    """
    Расчётный листок — пункт 26 плана.

    Собирается из сохранённого расчёта, а не считается заново: листок —
    документ о том, что было начислено. Открывается только для
    подтверждённого или закрытого расчёта; черновик листком не оформляем,
    он ещё пересчитается, а на руках у человека останется другая сумма.
    """
    uid = require_user(request)
    with db(uid) as conn:
        if not webdb.has_perm(conn, "payroll.read"):
            raise HTTPException(403, "Нет доступа к расчёту заработной платы")
        slip = payrolldb.payslip(conn, line_id)
        if not slip:
            raise HTTPException(404, "Расчётный листок не найден")
        if slip["run_status"] not in payrolldb.FINAL_RUN_STATUSES:
            raise HTTPException(
                409,
                "Расчёт за этот месяц ещё не подтверждён — "
                "листок оформляется по финальному расчёту")
        unit = webdb.unit_by_code(conn, slip["unit_code"])
        if not unit or not webdb.can_access_unit(conn, unit["id"]):
            raise HTTPException(403, "Нет доступа к этому депо")
        p = slip["period_month"]
        ctx = {
            "user": webdb.current_user(conn, uid),
            "units": webdb.accessible_units(conn),
            "unit": unit,
            "slip": slip,
            "period": p,
            "period_label": f"{MONTHS_RU[p.month - 1]} {p.year}",
            "period_iso": f"{p:%Y-%m}",
            "open_requests": webdb.open_staff_requests(conn),
            "can_payroll": True,
            "can_supply": webdb.has_perm(conn, "asset.read"),
            "can_reference": webdb.has_perm(conn, "reference.write"),
        }
    return templates.TemplateResponse(request, "payslip.html", ctx)


@app.get("/metrics", response_class=HTMLResponse)
def metrics_page(request: Request, unit: str | None = None,
                 period: str | None = None):
    """
    Метрики начисления — итоги расчётного периода (пункт 10).

    Вопросы, которые задают сразу после расчёта: сколько всего начислено, из
    чего это сложилось, на скольких людей, сколько вышло в среднем по
    категории должностей и как это против прошлого месяца. По таблице
    расчёта шириной в двадцать с лишним колонок это в уме не складывается.
    """
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = motivation_context(conn, uid, unit, p)
        unit_ids = ([u["id"] for u in ctx["units"]] if ctx["all_units"]
                    else [ctx["unit"]["id"]])
        ctx.update({
            "mode": "metrics",
            "title": "Метрики начисления",
            "metrics": payrolldb.accrual_metrics(conn, unit_ids, p),
            "prev_label": None,
        })
        prev = ctx["metrics"]["prev_period"]
        ctx["prev_label"] = f"{MONTHS_RU[prev.month - 1]} {prev.year}"
    return templates.TemplateResponse(request, "metrics.html", ctx)


@app.get("/indicators", response_class=HTMLResponse)
def indicators_page(request: Request, unit: str | None = None,
                    period: str | None = None,
                    msg: str | None = None, error: str | None = None):
    """
    Показатели депо за месяц.

    Сверху — таблица «депо × показатель»: те четыре показателя, что идут в
    премию. Они вводятся руками, и в действующей системе именно эти колонки
    лежат в центральном файле без формул. Строка на каждое депо плюс сводная
    строка по отделу — так же, как в таблице, откуда это переносится.

    Ниже — то, что система считает сама по выбранному депо: часы, ФОТ,
    сделка, укомплектованность, текучесть. Их не правят: это следствие
    введённых данных.
    """
    uid = require_user(request)
    p = sticky_period(request, period)
    with db(uid) as conn:
        ctx = motivation_context(conn, uid, unit, p)
        unit_id = ctx["unit"]["id"]
        run = payrolldb.latest_run(conn, unit_id, p)
        ctx.update({
            "mode": "indicators",
            "title": "Показатели",
            "matrix": payrolldb.kpi_matrix(conn, p, unit_id),
            #  Шкалы показываются по выбранному депо: подсвечена ступень, на
            #  которую попал его факт. По каждому депо своя, и в таблице выше
            #  этого не видно — там значения, а не ступени.
            "kpi_rows": payrolldb.kpi_fact_rows(conn, unit_id, p),
            "ind": payrolldb.indicators(conn, unit_id, p),
            "fuel": payrolldb.fuel_rows(conn, unit_id, p),
            "run": run,
            "msg": msg,
            "error": error,
        })
    return templates.TemplateResponse(request, "indicators.html", ctx)


@app.post("/indicators/kpi")
async def indicators_kpi_save(request: Request):
    """
    Сохранить факты показателей за месяц — всю таблицу «депо × показатель».

    Имя поля несёт и депо, и показатель (`kpi_<депо>_<показатель>`), потому
    что форма одна на всю таблицу: править обычно приходится сразу несколько
    строк, и отдельная кнопка у каждой клетки означала бы тринадцать
    перезагрузок страницы.

    Пустое поле означает «показатель не задан» и стирает прежнее значение —
    это не то же самое, что ноль: ноль по переносам даёт полную премию, а
    «не задан» обязан блокировать расчёт.

    Чужое депо в имени поля не пройдёт: доступ проверяет сама база, в
    функции записи, а не форма.
    """
    uid = require_user(request)
    form = await request.form()
    unit = str(form.get("unit") or "")
    period = str(form.get("period") or "")
    p = parse_period(period)
    raw = ""
    saved = 0

    with db(uid) as conn:
        unit_or_403(conn, unit)
        if not webdb.has_perm(conn, "kpi.write"):
            raise HTTPException(403, "Нет права вводить показатели")
        try:
            for key, raw in form.multi_items():
                if not key.startswith("kpi_"):
                    continue
                _, unit_part, kpi_part = key.split("_", 2)
                text = str(raw).replace(",", ".").strip()
                value = Decimal(text) if text else None
                payrolldb.set_kpi_fact(
                    conn, int(unit_part), p, int(kpi_part), value)
                saved += 1
            conn.commit()
        except (InvalidOperation, ValueError):
            conn.rollback()
            return _motivation_back("/indicators", unit, period,
                                    error=f"Не понял значение показателя: {raw}")
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _motivation_back("/indicators", unit, period, error=msg)
    return _motivation_back("/indicators", unit, period,
                            msg=f"Показатели сохранены, клеток: {saved}")


@app.post("/indicators/fuel")
async def indicators_fuel_save(request: Request, unit: str = Form(...),
                               period: str = Form(...),
                               employee_id: int = Form(...),
                               liters_fact: str = Form(...),
                               cost_per_liter: str = Form("")):
    """Фактический расход топлива за месяц; вычет за перерасход считается сам."""
    uid = require_user(request)
    p = parse_period(period)
    try:
        liters = Decimal(str(liters_fact).replace(",", ".").strip() or "0")
        price = (Decimal(str(cost_per_liter).replace(",", ".").strip())
                 if str(cost_per_liter).strip() else None)
    except InvalidOperation:
        return _motivation_back("/indicators", unit, period,
                                error="Не понял число литров или цену литра")

    with db(uid) as conn:
        u = unit_or_403(conn, unit)
        try:
            payrolldb.set_fuel(conn, u["id"], p, employee_id, liters, price)
        except psycopg.Error as e:
            conn.rollback()
            msg = (getattr(e, "diag", None) and e.diag.message_primary) or str(e)
            return _motivation_back("/indicators", unit, period, error=msg)
    return _motivation_back("/indicators", unit, period, msg="Расход топлива внесён")


@app.get("/whatsnew", response_class=HTMLResponse)
def whats_new(request: Request):
    """
    Что изменилось в последнем обновлении.

    Читает `CHANGELOG.md` из корня приложения — тот же файл, что кладётся в
    комплект обновления под именем «ЧТО ОБНОВИЛОСЬ.txt». Один источник:
    два списка изменений однажды разошлись бы, и правым оказался бы не тот,
    который человек прочитал.
    """
    uid = require_user(request)
    root = BASE_DIR.parent.parent
    text = ""
    for path in (root / "CHANGELOG.md", root / "app" / "CHANGELOG.md"):
        try:
            text = path.read_text(encoding="utf-8")
            break
        except OSError:
            continue

    with db(uid) as conn:
        ctx = {
            "user": webdb.current_user(conn, uid),
            "units": webdb.accessible_units(conn),
            "mode": "",
            "title": "Что нового",
            "blocks": _changelog_blocks(text),
            "open_requests": webdb.open_staff_requests(conn),
            "can_payroll": webdb.has_perm(conn, "payroll.read"),
            "can_supply": webdb.has_perm(conn, "asset.read"),
            "can_reference": webdb.has_perm(conn, "reference.write"),
        }
    return templates.TemplateResponse(request, "whatsnew.html", ctx)


def _changelog_blocks(text: str) -> list[dict[str, Any]]:
    """
    Разметка списка изменений в то немногое, что в нём есть.

    Полного разборщика не нужно: файл пишем мы сами, и в нём только
    заголовки двух уровней, абзацы, списки и **жирный**.
    """
    out: list[dict[str, Any]] = []
    buf: list[str] = []

    def flush():
        if buf:
            out.append({"kind": "p", "text": " ".join(buf)})
            buf.clear()

    for line in text.splitlines():
        if line.startswith("### "):
            flush()
            out.append({"kind": "h3", "text": line[4:]})
        elif line.startswith("## "):
            flush()
            out.append({"kind": "h2", "text": line[3:]})
        elif line.startswith("# "):
            flush()
            out.append({"kind": "h1", "text": line[2:]})
        elif line.startswith("* "):
            flush()
            out.append({"kind": "li", "text": line[2:]})
        elif not line.strip():
            flush()
        else:
            buf.append(line.strip())
    flush()
    return out


@app.get("/healthz")
def healthz():
    try:
        with db() as conn, conn.cursor() as cur:
            cur.execute("SELECT 1")
        return {"ok": True}
    except Exception as e:  # noqa: BLE001
        return JSONResponse({"ok": False, "error": str(e)}, status_code=503)


# ===========================================================================
#  Финансы: аренда и услуги связи (24.09.2026, миграция 86)
#
#  Раздел только у Администрации ООУРЦ: смотреть — `finance.read`, вести —
#  `finance.write`. Политики таблиц держат то же правило в базе. Логика
#  расчёта — в `financedb`, здесь только разбор форм и страницы.
# ===========================================================================

FINANCE_TABS = (("rent", "Аренда"), ("telecom", "Услуги связи"),
                ("rates", "Курсы НБРБ"), ("summary", "Сводка"))


def _finance_back(tab: str = "", contract_id: int | None = None,
                  msg: str = "", error: str = "", anchor: str = ""):
    url = f"/finance/contract/{contract_id}" if contract_id else f"/finance?tab={tab or 'rent'}"
    sep = "&" if "?" in url else "?"
    if msg:
        url += f"{sep}msg={quote(msg)}"
    elif error:
        url += f"{sep}error={quote(error)}"
    if anchor:
        url += f"#{anchor}"
    return RedirectResponse(url, status_code=303)


def _finance_guard(conn, write: bool = False) -> None:
    if not financedb.has_finance(conn):
        raise HTTPException(409, "Раздел «Финансы» ещё не заведён в базе: не накатана "
                                 "миграция 86_finance.sql. Запустите update_db.cmd")
    if not webdb.has_perm(conn, "finance.write" if write else "finance.read"):
        raise HTTPException(403, "Раздел «Финансы» ведёт Администрация ООУРЦ")


def _finance_error(conn, e: Exception) -> str:
    conn.rollback()
    return (getattr(e, "diag", None) and e.diag.message_primary) or str(e)


def _finance_ctx(conn, uid: int, **extra: Any) -> dict[str, Any]:
    units = webdb.accessible_units(conn)
    ctx = {
        "user": webdb.current_user(conn, uid),
        "units": units,
        "unit": units[0] if units else None,
        "mode": "finance",
        "open_requests": webdb.open_staff_requests(conn),
        "can_payroll": webdb.has_perm(conn, "payroll.read"),
        "can_supply": webdb.has_perm(conn, "asset.read"),
        "can_reference": webdb.has_perm(conn, "reference.write"),
        "can_finance_write": webdb.has_perm(conn, "finance.write"),
        "FINANCE_TABS": FINANCE_TABS,
        "FIN_KIND_RU": financedb.KIND_RU,
        "FIN_CURRENCIES": financedb.CURRENCIES,
        "FIN_RATE_RULE_RU": financedb.RATE_RULE_RU,
        "FIN_PAY_MONTH_RU": financedb.PAY_MONTH_RU,
        "FIN_DOC_KIND_RU": financedb.DOC_KIND_RU,
        "fin_units": financedb.units(conn),
        "today": date.today().isoformat(),
    }
    ctx.update(extra)
    return ctx


def _month_arg(text: str | None, default: date) -> date:
    if not text:
        return default
    try:
        y, m = text.split("-")[:2]
        return date(int(y), int(m), 1)
    except (ValueError, TypeError):
        return default


@app.get("/finance", response_class=HTMLResponse)
def finance_page(request: Request, tab: str = "rent", closed: int = 0,
                 start: str | None = None, end: str | None = None,
                 kind: str = "", on: str | None = None,
                 msg: str | None = None, error: str | None = None):
    """
    Финансы: вкладки «Аренда», «Услуги связи», «Курсы НБРБ», «Сводка».
    При открытии начисления приводятся в порядок: недостающие месяцы
    заводятся, договоры с пролонгацией продлеваются, курсы подтягиваются.
    """
    uid = require_user(request)
    if tab not in dict(FINANCE_TABS):
        tab = "rent"
    today = date.today()
    with db(uid) as conn:
        _finance_guard(conn)
        if webdb.has_perm(conn, "finance.write"):
            financedb.ensure(conn, user_id=uid)
        extra: dict[str, Any] = {"tab": tab, "msg": msg, "error": error,
                                 "title": "Финансы", "show_closed": bool(closed)}
        if tab in financedb.KINDS:
            extra["contracts"] = financedb.contracts(conn, tab, bool(closed))
        extra["missing_rates"] = financedb.missing_rates(conn)
        extra["journal"] = journal_of(conn, "finance", None, None)
        if tab == "rates":
            extra["rates"] = financedb.rates(conn)
        if tab == "summary":
            last = _month_arg(end, today.replace(day=1))
            first = _month_arg(start, financedb.add_months(last, -2))
            if first > last:
                first, last = last, first
            try:
                on_day = financedb.parse_day(on) if on else today
            except ValueError:
                on_day = today
            extra["sum"] = financedb.summary(conn, first, last,
                                             kind if kind in financedb.KINDS else None,
                                             on_day)
            extra["sum_kind"] = kind if kind in financedb.KINDS else ""
        ctx = _finance_ctx(conn, uid, **extra)
    return templates.TemplateResponse(request, "finance.html", ctx)


@app.post("/finance/contract")
async def finance_contract_new(request: Request):
    uid = require_user(request)
    form = dict(await request.form())
    kind = form.get("kind") if form.get("kind") in financedb.KINDS else "rent"
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            cid = financedb.save_contract(conn, form, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(kind, error=_finance_error(conn, e))
    return _finance_back(contract_id=cid, msg="Договор заведён")


@app.get("/finance/contract/{contract_id}", response_class=HTMLResponse)
def finance_contract_page(request: Request, contract_id: int,
                          msg: str | None = None, error: str | None = None):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn)
        if webdb.has_perm(conn, "finance.write"):
            financedb.ensure(conn, user_id=uid)
        c = financedb.contract(conn, contract_id)
        if not c:
            raise HTTPException(404, "Договор не найден")
        ctx = _finance_ctx(conn, uid, c=c, tab=c["kind"], msg=msg, error=error,
                           title=f"{financedb.KIND_RU[c['kind']]}: {c['counterparty']}")
    return templates.TemplateResponse(request, "finance_contract.html", ctx)


@app.post("/finance/contract/{contract_id}/edit")
async def finance_contract_edit(request: Request, contract_id: int):
    uid = require_user(request)
    form = dict(await request.form())
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            financedb.save_contract(conn, form, uid, contract_id)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e))
    return _finance_back(contract_id=contract_id, msg="Реквизиты договора сохранены")


@app.post("/finance/contract/{contract_id}/amount")
async def finance_contract_amount(request: Request, contract_id: int,
                                  valid_from: str = Form(""), amount: str = Form(""),
                                  reason: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            financedb.add_amount(conn, contract_id, financedb.parse_day(valid_from),
                                 financedb.money(amount, "сумму в месяц"), reason, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e))
    return _finance_back(contract_id=contract_id, msg="Новая сумма записана, начисления пересчитаны")


@app.post("/finance/contract/{contract_id}/close")
async def finance_contract_close(request: Request, contract_id: int,
                                 closed_on: str = Form(""), reason: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            financedb.close_contract(conn, contract_id, financedb.parse_day(closed_on),
                                     reason, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e))
    return _finance_back(contract_id=contract_id, msg="Договор закрыт")


@app.post("/finance/contract/{contract_id}/reopen")
async def finance_contract_reopen(request: Request, contract_id: int):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            financedb.reopen_contract(conn, contract_id, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e))
    return _finance_back(contract_id=contract_id, msg="Договор возвращён в работу")


@app.post("/finance/accrual/{accrual_id}/edit")
async def finance_accrual_edit(request: Request, accrual_id: int,
                               contract_id: int = Form(0), amount: str = Form(""),
                               reason: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            cid = financedb.edit_accrual(
                conn, accrual_id, financedb.money(amount, "сумму начисления", allow_zero=True),
                reason, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e),
                                 anchor="accruals")
    return _finance_back(contract_id=cid, msg="Начисление исправлено", anchor="accruals")


@app.post("/finance/accrual/{accrual_id}/pay")
async def finance_accrual_pay(request: Request, accrual_id: int,
                              contract_id: int = Form(0), paid_on: str = Form(""),
                              amount: str = Form(""), doc_no: str = Form(""),
                              note: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            cid = financedb.add_payment(
                conn, accrual_id, financedb.parse_day(paid_on),
                financedb.money(amount, "сумму оплаты"), doc_no, note, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e),
                                 anchor="accruals")
    return _finance_back(contract_id=cid, msg="Оплата отмечена", anchor="accruals")


@app.post("/finance/payment/{payment_id}/drop")
async def finance_payment_drop(request: Request, payment_id: int,
                               contract_id: int = Form(0)):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            cid = financedb.drop_payment(conn, payment_id, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e),
                                 anchor="payments")
    return _finance_back(contract_id=cid, msg="Оплата удалена", anchor="payments")


@app.post("/finance/rate")
async def finance_rate(request: Request, currency: str = Form(""),
                       rate_date: str = Form(""), rate: str = Form(""),
                       back: int = Form(0)):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            day = financedb.parse_day(rate_date)
            n = financedb.set_rate(conn, currency, day, financedb.rate_value(rate), uid)
        except (ValueError, psycopg.Error) as e:
            err = _finance_error(conn, e)
            return (_finance_back(contract_id=back, error=err) if back
                    else _finance_back("rates", error=err))
    text = f"Курс {currency} на {day:%d.%m.%Y} внесён" + (
        f", пересчитано начислений: {n}" if n else "")
    return _finance_back(contract_id=back, msg=text) if back else _finance_back("rates", msg=text)


@app.post("/finance/rate/drop")
async def finance_rate_drop(request: Request, currency: str = Form(""),
                            rate_date: str = Form("")):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            financedb.drop_rate(conn, currency, financedb.parse_day(rate_date), uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back("rates", error=_finance_error(conn, e))
    return _finance_back("rates", msg="Курс удалён")


@app.post("/finance/contract/{contract_id}/file")
async def finance_file_add(request: Request, contract_id: int,
                           doc_kind: str = Form("contract"), doc_date: str = Form(""),
                           note: str = Form(""), file: UploadFile = File(...)):
    from . import filestore

    uid = require_user(request)
    data = await file.read(filestore.MAX_BYTES + 1)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            day = financedb.parse_day(doc_date) if doc_date else None
            financedb.add_file(conn, contract_id, doc_kind, day,
                               file.filename or "скан", data, note, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e),
                                 anchor="files")
    return _finance_back(contract_id=contract_id, msg="Скан приложен", anchor="files")


@app.get("/finance/file/{file_id}")
def finance_file_open(request: Request, file_id: int):
    from fastapi.responses import FileResponse
    from . import filestore

    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn)
        f = financedb.file_row(conn, file_id)
    if not f:
        raise HTTPException(404, "Скан не найден")
    try:
        path = filestore.path_of(f["stored_name"])
    except filestore.FileRejected:
        raise HTTPException(404, "Скан не найден")
    if not path.exists():
        raise HTTPException(404, "Файл скана не найден в хранилище. Сведения о нём в базе "
                                 "есть — вероятно, папка хранилища не перенесена вместе с базой")
    return FileResponse(path, media_type=f["mime_type"], filename=f["file_name"],
                        content_disposition_type="inline")


@app.post("/finance/file/{file_id}/drop")
async def finance_file_drop(request: Request, file_id: int, contract_id: int = Form(0)):
    uid = require_user(request)
    with db(uid) as conn:
        _finance_guard(conn, write=True)
        try:
            cid = financedb.drop_file(conn, file_id, uid)
        except (ValueError, psycopg.Error) as e:
            return _finance_back(contract_id=contract_id, error=_finance_error(conn, e),
                                 anchor="files")
    return _finance_back(contract_id=cid, msg="Скан удалён", anchor="files")


@app.get("/api/finance/summary.xlsx")
def finance_summary_xlsx(request: Request, start: str | None = None,
                         end: str | None = None, kind: str = "",
                         on: str | None = None):
    uid = require_user(request)
    today = date.today()
    last = _month_arg(end, today.replace(day=1))
    first = _month_arg(start, financedb.add_months(last, -2))
    if first > last:
        first, last = last, first
    k = kind if kind in financedb.KINDS else None
    with db(uid) as conn:
        _finance_guard(conn)
        try:
            on_day = financedb.parse_day(on) if on else today
        except ValueError as e:
            raise HTTPException(400, str(e)) from None
        data = financedb.summary(conn, first, last, k, on_day)
        rows = financedb.accrual_list(conn, first, last, k)
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    filename = f"finansy_{first:%Y-%m}_{last:%Y-%m}.xlsx"
    path = OUT_DIR / filename
    financedb.export_xlsx(str(path), data, rows)
    return FileResponse(
        path, filename=filename,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
