"""
Обеспечение: ТМЦ, техника, ТО и заявки на ремонт — пункт 23 плана.

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

Что здесь есть:

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

Правила переходов заявки лежат в базе (`move_repair_request`), а не здесь:
заявка про чужое имущество на чужих руках, и обойти маршрут скриптом не
должно быть проще, чем пройти его.
"""

from __future__ import annotations

import re
from datetime import date, timedelta
from decimal import Decimal, InvalidOperation
from typing import Any

import psycopg

#  Два маршрута заявки на ремонт (23.09.2026): «В ремонт: 1. Вызов
#  специалиста в Депо, 2. Отправить в Минск». Названия шагов — дословно из
#  решения заказчика. Порядок важен: по нему рисуется цепочка на экране
REPAIR_ROUTES = [
    ("specialist", "Вызов специалиста в депо"),
    ("minsk", "Отправить в Минск"),
]
REPAIR_ROUTE_RU = dict(REPAIR_ROUTES)

REPAIR_FLOWS = {
    "specialist": [
        ("new", "Заявка открыта"),
        ("specialist_called", "Вызов специалиста"),
        ("fixed", "Произведён ремонт"),
    ],
    "minsk": [
        ("new", "Заявка открыта"),
        ("sent_to_hq", "Передано в Минск"),
        ("hq_received", "Минск подтвердил получение"),
        ("in_repair", "Отправлено в ремонт"),
        ("repaired", "Вернулась с ремонта"),
        ("sent_to_unit", "Отправлено в депо"),
        ("received", "Приняло депо"),
    ],
}
#  Прежнее имя — маршрут в Минск: на него опираются старые места
REPAIR_FLOW = REPAIR_FLOWS["minsk"]
REPAIR_STATUS_RU = (dict(REPAIR_FLOWS["minsk"]) | dict(REPAIR_FLOWS["specialist"])
                    | {"cancelled": "Отменена"})

#  Закрытых состояний три: приняли из Минска, починили на месте, отменили.
#  Условие пишется одной строкой — оно стоит в шести запросах, и разойдись
#  они, заявка числилась бы открытой в одном списке и закрытой в другом
REPAIR_CLOSED = ("received", "fixed", "cancelled")
REPAIR_CLOSED_SQL = "('received', 'fixed', 'cancelled')"
REPAIR_OPEN = tuple(code for flow in REPAIR_FLOWS.values()
                    for code, _ in flow if code not in REPAIR_CLOSED)

#  Три вкладки раздела — по ответу заказчика от 22.09.2026: «складская
#  техника, поверенная техника, ТМЦ и офисное оборудование». Делит их не цена
#  и не размер, а что приложение с вещью делает: у складской техники моточасы
#  и ТО, у поверочной — срок поверки по календарю, у остального ни того ни
#  другого. На одной вкладке половина строк стояла с пустыми столбцами.
#
#  Признак «поверочная» берётся из группы реестра, а не из отдельной колонки:
#  группа у вида уже есть, и второй источник правды однажды разошёлся бы
#  с первым.
VERIFICATION_GROUP = "verification"
WAREHOUSE_GROUP = "warehouse_tech"

#  Какая группа реестра в какую вкладку попадает — заказчик отметил это на
#  экране «Виды ТМЦ и техники» 22.09.2026. Подпись показывается там же, чтобы
#  связь была видна, а не держалась в голове
GROUP_TAB_RU = {
    WAREHOUSE_GROUP:    "Складская техника",
    VERIFICATION_GROUP: "Поверенная техника",
}
TAB_FOR_THE_REST = "ТМЦ и офисное оборудование"


def group_tab(group_code: str | None) -> str:
    """Название вкладки, в которую попадает группа реестра."""
    return GROUP_TAB_RU.get(group_code or "", TAB_FOR_THE_REST)


def kind_filter(kind: str, alias: str) -> str | None:
    """
    Условие отбора для вкладки. `alias` — псевдоним таблицы видов в запросе.

    Одно место на три запроса: список, счётчики и виды для формы должны
    показывать одно и то же. Когда условие было написано в каждом своём,
    расхождение находилось только глазами.
    """
    if kind == "equipment":                       # складская техника
        return (f"{alias}.is_equipment AND "
                f"coalesce({alias}.group_code, '') <> '{VERIFICATION_GROUP}'")
    if kind == "verification":                    # поверочное оборудование
        return f"{alias}.group_code = '{VERIFICATION_GROUP}'"
    if kind == "stock":                           # ТМЦ и офисное оборудование
        return f"NOT {alias}.is_equipment"
    return None


ASSET_STATUS_RU = {
    "ok": "Исправно",
    "repair": "В ремонте",
    "needs_replacement": "Требует замены",
    #  «Резерв» — из файла управления РЦ, добавлен 22.09.2026: замки для
    #  крепления траверс (880 шт.) и отбойники лежат на складе целыми и
    #  годными, но в работе не используются. «Исправно» посчитало бы их
    #  рабочим имуществом депо, «требует замены» подняло бы жёлтую карточку
    "reserve": "Резерв",
    "written_off": "Списано",
}

#  Как ведут позицию — решение заказчика от 22.09.2026: «давай сделаем при
#  внесении выбор, это позиция индивидуальная или общая с указанием
#  количества». Семьдесят камер одной строкой, кофемашина — своей, и то и
#  другое правильно: дробность решает не вкладка, а сама вещь
ASSET_TRACKING_RU = {
    "unit": "Индивидуальная — своя строка и свой номер",
    "bulk": "Общая — одна строка с количеством",
}
#  Короткие подписи для колонки списка: длинные там не помещаются
ASSET_TRACKING_SHORT = {"unit": "поштучно", "bulk": "количеством"}

#  Типовые причины заявки на ремонт — подсказка к свободному полю, а не
#  закрытый список: «Наварка колёс» добавлена по требованию заказчика от
#  21.09.2026, но неописанная поломка должна отправляться тоже
REPAIR_PROBLEMS = [
    "Наварка колёс",
    "Не заряжается",
    "Не держит заряд",
    "Проблема с подъёмом",
    "Течь гидравлики",
    "Не работает управление",
    "Повреждён корпус",
    "Требуется замена аккумулятора",
]

#  За сколько дней до срока предупреждать. Десять дней — то же окно, что у
#  напоминаний о медосмотрах и инструктажах: меньше не успеть заказать,
#  больше — список перестают читать
LEAD_DAYS = 10


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


# ---------------------------------------------------------------------------
#  ТМЦ и техника
# ---------------------------------------------------------------------------

def assets(conn: psycopg.Connection, unit_id: int | None,
           status: str = "all", kind: str = "all") -> list[dict[str, Any]]:
    """
    Единицы депо. Повторяет лист «ТМЦ Депо» файла управления РЦ:
    инвентарный номер, наименование, серийный, комплектность, количество,
    примечание и состояние.

    `kind` разделяет технику и ТМЦ. Разница не в цене, а в том, как ведут:
    технику поштучно — серийный номер, моточасы, свои сроки ТО и своя история
    ремонтов; ТМЦ количеством — пятнадцать тележек это пятнадцать тележек.
    Признак стоит у вида в справочнике, а не у единицы.

    `unit_id = None` — «Все депо» (требование от 21.09.2026): администрация
    сводит двенадцать депо и должна видеть их одним списком. Кому какие депо
    доступны, решает не этот запрос, а список доступных подразделений.
    """
    where = [] if unit_id is None else ["a.org_unit_id = %(unit)s"]
    args: dict[str, Any] = {"unit": unit_id}
    #  «В работе» — всё, кроме списанного, и это положение по умолчанию
    #  (решение заказчика от 22.09.2026: «спрятать во вкладку списанного»).
    #  В рабочем списке должно быть то, чем депо пользуется; списанное никуда
    #  не девается, но и глаза не занимает
    if status == "in_use":
        where.append("a.status <> 'written_off'")
    elif status != "all":
        where.append("a.status = %(status)s")
        args["status"] = status
    only = kind_filter(kind, "c")
    if only:
        where.append(only)

    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT a.id, a.inventory_no, a.name, a.model, a.serial_no,
                   a.completeness, a.qty, a.tracking, a.note, a.status,
                   a.category_id,
                   a.verified_at, a.verified_until,
                   c.name AS category_name, c.has_meter, c.is_equipment,
                   c.group_code,
                   ou.name AS unit_name,
                   --  Моточасы — из последней отметки о проведённом ТО
                   --  (22.09.2026). Отдельных замеров счётчика больше нет
                   (SELECT m.done_hours FROM app.maintenance m
                     WHERE m.asset_id = a.id AND m.status = 'done'
                       AND m.done_hours IS NOT NULL
                     ORDER BY m.done_at DESC, m.id DESC LIMIT 1) AS engine_hours,
                   (SELECT m.done_at FROM app.maintenance m
                     WHERE m.asset_id = a.id AND m.status = 'done'
                       AND m.done_hours IS NOT NULL
                     ORDER BY m.done_at DESC, m.id DESC LIMIT 1) AS meter_date,
                   (SELECT r.id FROM app.repair_request r
                     WHERE r.asset_id = a.id
                       AND r.status NOT IN ('received', 'fixed', 'cancelled')
                     ORDER BY r.opened_at DESC LIMIT 1) AS open_request_id,
                   (SELECT r.status FROM app.repair_request r
                     WHERE r.asset_id = a.id
                       AND r.status NOT IN ('received', 'fixed', 'cancelled')
                     ORDER BY r.opened_at DESC LIMIT 1) AS open_request_status
            FROM app.asset a
            JOIN app.asset_category c ON c.id = a.category_id
            JOIN app.org_unit ou ON ou.id = a.org_unit_id
            WHERE {' AND '.join(where) if where else 'TRUE'}
            --  Поверочное — по сроку: у него в списке главный вопрос «что
            --  просрочено», и ближайшее должно быть сверху. Незаполненный
            --  срок уходит вниз: он не «самый срочный», он неизвестный
            ORDER BY {'a.verified_until NULLS LAST, '
                      if kind == 'verification' else ''}
                     ou.name, c.name, a.inventory_no
            """,
            args,
        )
        return cur.fetchall()


#  Номера депо — «№00001», «№00074». Длинные коды 1С («№10000000000880322»)
#  и старые метки ТСД («Д-12») в эту нумерацию не входят и в подсчёт
#  следующего номера не берутся: иначе следующим свободным оказался бы
#  №10000000000880323
INVENTORY_NO_RE = re.compile(r"^№?0*(\d{1,6})$")
INVENTORY_NO_WIDTH = 5


def _as_date(value: Any, what: str) -> date | None:
    """Дата из формы. Пусто — значит не заполнено, а не «сегодня»."""
    if value in (None, ""):
        return None
    if isinstance(value, date):
        return value
    try:
        return date.fromisoformat(str(value).strip())
    except ValueError:
        raise ValueError(f"{what}: дата не разобрана — нужен вид ГГГГ-ММ-ДД")


def next_inventory_no(conn: psycopg.Connection, unit_id: int | None) -> str:
    """
    Следующий свободный инвентарный номер для депо.

    Зачем: в файле управления РЦ под следующие поступления заранее заведены
    пустые строки — №00073 и №00074, в которых нет ничего, кроме номера.
    Заказчик 22.09.2026: «не заводить, номер подсказывать». Пустая строка в
    учёте ничего не сообщает, а вот подсказка снимает повод её заводить.

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

    Номеров нет вовсе — предлагается первый.
    """
    with conn.cursor() as cur:
        #  02.10.2026 (вычитка 5.5): у депо свой код в начале номера —
        #  Брест 1 → №10001, №10002…; код ведётся в «Базовых настройках»
        prefix = None
        if unit_id is not None:
            cur.execute("SELECT inventory_prefix FROM app.org_unit WHERE id = %s",
                        (unit_id,))
            row = cur.fetchone()
            prefix = row["inventory_prefix"] if row else None
        cur.execute("SELECT inventory_no FROM app.asset")
        taken = {r["inventory_no"] for r in cur.fetchall()}
        if prefix:
            head = f"№{prefix}"
            used = [int(n[len(head):]) for n in taken
                    if n and n.startswith(head) and len(n) == len(head) + 4
                    and n[len(head):].isdigit()]
            number = (max(used) + 1) if used else 1
            while f"{head}{number:04d}" in taken:
                number += 1
            return f"{head}{number:04d}"
        cur.execute(
            "SELECT inventory_no FROM app.asset"
            + ("" if unit_id is None else " WHERE org_unit_id = %s"),
            () if unit_id is None else (unit_id,))
        mine = [r["inventory_no"] for r in cur.fetchall()]

    used = [int(m.group(1)) for m in
            (INVENTORY_NO_RE.match((n or "").strip()) for n in mine) if m]
    number = (max(used) + 1) if used else 1
    while f"№{number:0{INVENTORY_NO_WIDTH}d}" in taken:
        number += 1
    return f"№{number:0{INVENTORY_NO_WIDTH}d}"


def categories(conn: psycopg.Connection,
               kind: str = "all") -> list[dict[str, Any]]:
    """
    Виды: терминалы, тележки, штабелёры, прочее.

    `kind` нужен формам добавления: на вкладке техники в списке видов не
    должно быть тележек, иначе тележка окажется техникой по недосмотру.

    Вместе с видом отдаётся его группа реестра (миграция 60): от неё зависит,
    какие производители подставятся в выпадающий список и можно ли вписать
    своё. Закрытые виды (`is_active = false`) в форму не идут — реестр ведёт
    администрация, и снятый вид не должен появляться у депо.
    """
    #  Префикс обязателен: у вида и у группы одинаковые имена колонок, и
    #  без него запрос падает на «ambiguous column»
    where = ["k.is_active"]
    only = kind_filter(kind, "k")
    if only:
        where.append(only)
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT k.id, k.code, k.name, k.has_meter, k.is_equipment,
                   k.group_code, g.name AS group_name,
                   coalesce(g.free_model, true) AS free_model
              FROM app.asset_category k
              LEFT JOIN app.asset_group g ON g.code = k.group_code
             WHERE {' AND '.join(where)}
             ORDER BY g.sort_order NULLS LAST, k.sort_order, k.name
            """
        )
        return cur.fetchall()


def models(conn: psycopg.Connection) -> dict[str, list[str]]:
    """
    Производители и модели по группам реестра — для выпадающего списка.

    Возвращается словарём: форма выбирает вид, а список моделей меняется под
    его группу, не перезагружая страницу.
    """
    out: dict[str, list[str]] = {}
    with conn.cursor() as cur:
        cur.execute(
            "SELECT group_code, name FROM app.asset_model "
            " WHERE is_active ORDER BY group_code, sort_order, name"
        )
        for r in cur.fetchall():
            out.setdefault(r["group_code"], []).append(r["name"])
    return out


def groups(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """Группы реестра — для «Базовых настроек»."""
    with conn.cursor() as cur:
        cur.execute(
            "SELECT code, name, is_equipment, free_name, free_model, sort_order "
            "  FROM app.asset_group ORDER BY sort_order, name"
        )
        return cur.fetchall()


def maintenance_types(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """Виды ТО со сроками — ТО-1 и ТО-2 из файла управления РЦ."""
    with conn.cursor() as cur:
        cur.execute(
            "SELECT id, code, name, period_hours, period_days, is_self_service, "
            "note, announce, category_code FROM app.maintenance_type "
            "ORDER BY announce, code")
        return cur.fetchall()


def _check_listed_model(conn: psycopg.Connection, group_code: str,
                        model: str, asset_id: int | None) -> None:
    """
    Производитель/модель складской и поверенной техники — только из реестра
    (24.09.2026: «убрать возможность ручного ввода, работаем только с
    выпадающим списком»).

    Уже записанное прежде значение, которого в реестре нет, при правке
    единицы оставить можно: иначе смена состояния или примечания требовала
    бы сначала завести модель.
    """
    model = (model or "").strip()
    if not model:
        raise ValueError("Выберите производителя/модель из списка. Нет нужной "
                         "— её добавляют в «Базовых настройках» → «Реестр ТМЦ»")
    with conn.cursor() as cur:
        cur.execute("SELECT 1 FROM app.asset_model WHERE group_code = %s "
                    "AND name = %s AND is_active", (group_code, model))
        if cur.fetchone():
            return
        if asset_id:
            cur.execute("SELECT model FROM app.asset WHERE id = %s", (asset_id,))
            old = cur.fetchone()
            if old and (old["model"] or "") == model:
                return
    raise ValueError(f"«{model}» нет в реестре ТМЦ. Выберите из списка или "
                     "добавьте модель в «Базовых настройках» → «Реестр ТМЦ»")


def save_asset(conn: psycopg.Connection, *, asset_id: int | None, unit_id: int,
               category_id: int, inventory_no: str, name: str,
               model: str = "", serial_no: str = "", completeness: str = "",
               qty: Any = 1, note: str = "", status: str = "ok",
               tracking: str = "unit",
               verified_at: Any = None, verified_until: Any = None,
               last_done: dict[str, tuple[Any, Any]] | None = None,
               user_id: int | None = None) -> int:
    """
    Завести или поправить единицу ТМЦ.

    Инвентарный номер уникален на всю систему — так же, как в файле: по нему
    вещь и опознают, когда передают в Минск.

    `tracking` — решение заказчика от 22.09.2026: «давай сделаем при внесении
    выбор, это позиция индивидуальная или общая с указанием количества».
    Индивидуальная — своя строка и количество всегда 1; общая — одна строка на
    наименование, количеством. Техника всегда индивидуальна: моточасы и сроки
    ТО ведутся по единице, и «штабелёров 5 штук» сделало бы их бессмысленными.
    """
    if not (inventory_no or "").strip():
        raise ValueError("Без инвентарного номера единицу не опознать")
    if status not in ASSET_STATUS_RU:
        raise ValueError(f"Неизвестное состояние: {status}")
    if tracking not in ASSET_TRACKING_RU:
        raise ValueError(f"Неизвестный вид учёта: {tracking}")

    with conn.cursor() as cur:
        cur.execute("SELECT name, is_equipment, group_code, code "
                    "  FROM app.asset_category WHERE id = %s", (category_id,))
        row = cur.fetchone()

    #  Наименование складской техники берётся из вида, а не пишется руками
    #  (требование от 22.09.2026: «в столбике наименование отображать вид
    #  техники и производитель/модель, и при добавлении ТМЦ убрать ячейку
    #  наименование»). Руками получалось «Электрический штабелер E-P 1»,
    #  «Электроштабелер STILL FV-XI 16», «телега» — одна и та же машина в
    #  двенадцати депо называлась двенадцатью способами, а модель ещё и
    #  дублировалась в соседнем поле.
    #  22.09.2026, второй заход: то же и у поверочной техники. Виды там
    #  закрытые — «Алкотестер», «Весы лабораторные», — и вписывать рядом с
    #  ними «Алкотест-203» значило бы дублировать производителя из
    #  соседнего поля
    if row and row["group_code"] in (WAREHOUSE_GROUP, VERIFICATION_GROUP):
        name = row["name"]
        _check_listed_model(conn, row["group_code"], model, asset_id)
    if not (name or "").strip():
        raise ValueError("Укажите наименование")

    if row and row["is_equipment"] and tracking != "unit":
        raise ValueError(
            "Техника ведётся поштучно: у общей позиции нет ни моточасов, "
            "ни срока ТО. Заведите каждую машину своей строкой")

    #  30.09.2026: серийный номер уникален, как и инвентарный — двух единиц
    #  с одним заводским номером не бывает. Сообщение человеком читаемо,
    #  а не технической ошибкой базы (решение заказчика из вычитки 5.20)
    serial = (serial_no or "").strip() or None
    if serial:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT inventory_no FROM app.asset "
                "WHERE serial_no = %s AND id <> COALESCE(%s, 0)",
                (serial, asset_id))
            clash = cur.fetchone()
        if clash:
            raise ValueError(
                f"Серийный номер «{serial}» уже записан за единицей "
                f"«{clash['inventory_no']}» — проверьте, ту ли вещь заводите")

    #  Срок поверки — только у поверочного. У штабелёра его не бывает, и
    #  записанный по ошибке он поднял бы задачу на доске из ниоткуда
    verifiable = bool(row and row["group_code"] == VERIFICATION_GROUP)
    verified_at = _as_date(verified_at, "Дата поверки") if verifiable else None
    verified_until = (_as_date(verified_until, "Срок поверки")
                      if verifiable else None)
    if verified_at and verified_until and verified_until < verified_at:
        raise ValueError("Срок поверки не может быть раньше самой поверки")

    if tracking == "unit":
        qty = 1
    else:
        try:
            qty = Decimal(str(qty).replace(",", "."))
        except (InvalidOperation, AttributeError):
            raise ValueError("Количество — это число")
        if qty <= 0:
            raise ValueError("У общей позиции количество больше нуля")

    #  24.09.2026: «при внесении новой техники сразу необходимо указать
    #  последние сроки ТО (можно задним числом). Для техники МПРП ЧТО и ПОПГ
    #  так же». От этих дат и считаются следующие сроки — не от дня
    #  заведения в приложение
    initial = []
    if not asset_id and row and row["group_code"] == WAREHOUSE_GROUP:
        initial = _initial_maintenance(conn, row["code"], last_done or {})

    fields = {
        "org_unit_id": unit_id, "category_id": category_id,
        "inventory_no": inventory_no.strip(), "name": name.strip(),
        "model": (model or "").strip() or None,
        "serial_no": (serial_no or "").strip() or None,
        "completeness": (completeness or "").strip() or None,
        "qty": qty, "note": (note or "").strip() or None, "status": status,
        "tracking": tracking,
        "verified_at": verified_at, "verified_until": verified_until,
    }
    with conn.cursor() as cur:
        if asset_id:
            sets = ", ".join(f"{k} = %({k})s" for k in fields)
            cur.execute(f"UPDATE app.asset SET {sets} WHERE id = %(id)s "
                        "RETURNING id", {**fields, "id": asset_id})
        else:
            cols = ", ".join(fields)
            vals = ", ".join(f"%({k})s" for k in fields)
            cur.execute(f"INSERT INTO app.asset ({cols}) VALUES ({vals}) "
                        "RETURNING id", fields)
        row = cur.fetchone()
        if row is None:
            raise ValueError("Запись не найдена — обновите страницу")
    #  Последние ТО — по порядку дат, чтобы проверка «счётчик назад не идёт»
    #  сравнивала их между собой правильно
    for type_id, day, hours in sorted(initial, key=lambda x: x[1]):
        mark_maintenance_done(conn, row["id"], type_id, day, hours,
                              "последнее ТО до заведения в приложение",
                              user_id, unit_id=unit_id, initial=True,
                              commit=False)
    conn.commit()
    return row["id"]


def _initial_maintenance(conn: psycopg.Connection, category_code: str,
                         last_done: dict[str, tuple[Any, Any]]
                         ) -> list[tuple[int, date, Any]]:
    """
    Проверить и разобрать даты последних ТО новой машины.

    `last_done` — {код ТО: (дата, моточасы)}. Обязательны все виды ТО,
    относящиеся к этой машине: ТО-1 и ТО-2 у всей складской техники, ПОПГ и
    ЧТО ещё и у МПРП. Моточасы — там, где по ним считается срок.
    """
    out = []
    for t in maintenance_types(conn):
        if t["category_code"] and t["category_code"] != category_code:
            continue
        day_raw, hours_raw = last_done.get(t["code"], (None, None))
        day = _as_date(day_raw, f"Дата последнего {t['code']}")
        if day is None:
            raise ValueError(f"Укажите дату последнего {t['code']}: от неё "
                             "считается следующий срок. Можно задним числом")
        if day > date.today():
            raise ValueError(f"Последнее {t['code']} не может быть в будущем")
        hours = None
        if t["period_hours"]:
            text = str(hours_raw or "").strip().replace(",", ".")
            if not text:
                raise ValueError(f"Укажите моточасы последнего {t['code']}")
            try:
                hours = Decimal(text)
            except InvalidOperation:
                raise ValueError(f"Моточасы последнего {t['code']} — это число")
            if hours < 0:
                raise ValueError("Моточасы не бывают отрицательными")
        out.append((t["id"], day, hours))
    return out


def delete_asset(conn: psycopg.Connection, asset_id: int, unit_id: int) -> str:
    """
    Удалить единицу ТМЦ, заведённую по ошибке.

    ОБ-10 от 21.09.2026: «список ТМЦ нельзя ни исправить, ни удалить —
    возможности нет».

    Удаляется только запись без следа: ни ремонтов, ни проведённых ТО, ни
    показаний счётчика. «Последние ТО до заведения» (`is_initial`) и
    показания на их даты следом не считаются — это исходные данные самой
    карточки, и ошибочную карточку Администрация удаляет вместе с ними
    (решение 24.09.2026). Если что-то из этого есть, единица в депо была, и
    стирать её нельзя — тогда её переводят в состояние «списано», и история
    остаётся читаемой. Об этом и говорит возвращаемая ошибка.

    Возвращает наименование удалённой единицы — для сообщения человеку.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.name, a.inventory_no,
                   (SELECT count(*) FROM app.repair_request r
                     WHERE r.asset_id = a.id)            AS repairs,
                   (SELECT count(*) FROM app.meter_reading m
                     WHERE m.asset_id = a.id
                       AND m.read_at NOT IN (
                           SELECT i.done_at FROM app.maintenance i
                            WHERE i.asset_id = a.id AND i.is_initial
                              AND i.done_at IS NOT NULL)) AS meters,
                   (SELECT count(*) FROM app.maintenance d
                     WHERE d.asset_id = a.id
                       AND d.done_at IS NOT NULL
                       AND NOT d.is_initial)             AS done,
                   (SELECT count(*) FROM app.asset_movement v
                     WHERE v.asset_id = a.id)            AS moves
              FROM app.asset a
             WHERE a.id = %s AND a.org_unit_id = %s
            """,
            (asset_id, unit_id),
        )
        row = cur.fetchone()
        if row is None:
            raise ValueError("Единица не найдена — обновите страницу")

        left = []
        if row["repairs"]:
            left.append(f"заявок на ремонт — {row['repairs']}")
        if row["done"]:
            left.append(f"ТО, проведённых в приложении — {row['done']}")
        if row["meters"]:
            left.append(f"показаний счётчика — {row['meters']}")
        if row["moves"]:
            left.append(f"движений — {row['moves']}")
        if left:
            raise ValueError(
                f"По этой единице есть история ({', '.join(left)}) — удалять "
                "её нельзя. Поставьте состояние «списано»: запись останется, "
                "и из списка исправных единица уйдёт")

        #  Остались только исходные данные карточки — уходят вместе с ней
        cur.execute("DELETE FROM app.maintenance WHERE asset_id = %s", (asset_id,))
        cur.execute("DELETE FROM app.meter_reading WHERE asset_id = %s", (asset_id,))
        cur.execute("DELETE FROM app.asset WHERE id = %s", (asset_id,))
    conn.commit()
    return f"{row['name']} ({row['inventory_no']})"


def save_meter(conn: psycopg.Connection, asset_id: int, read_at: date,
               engine_hours: Any, user_id: int | None,
               unit_id: int | None = None) -> None:
    """
    Снять показания моточасов.

    Счётчик не крутится назад: показание меньше предыдущего — это опечатка,
    и принимать её нельзя, иначе срок следующего ТО уедет в прошлое.
    """
    if float(engine_hours) < 0:
        raise ValueError("Моточасы не бывают отрицательными")
    _check_maintainable(conn, asset_id, unit_id)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT engine_hours, read_at FROM app.meter_reading
             WHERE asset_id = %s AND read_at < %s
             ORDER BY read_at DESC LIMIT 1
            """,
            (asset_id, read_at),
        )
        prev = cur.fetchone()
        if prev and float(engine_hours) < float(prev["engine_hours"]):
            raise ValueError(
                f"Показание {engine_hours} меньше предыдущего "
                f"{prev['engine_hours']} от {prev['read_at']:%d.%m.%Y}. "
                "Счётчик моточасов назад не идёт — проверьте цифру")
        cur.execute(
            """
            INSERT INTO app.meter_reading (asset_id, read_at, engine_hours, entered_by)
            VALUES (%s, %s, %s, %s)
            ON CONFLICT (asset_id, read_at)
            DO UPDATE SET engine_hours = EXCLUDED.engine_hours,
                          entered_by = EXCLUDED.entered_by
            """,
            (asset_id, read_at, engine_hours, user_id),
        )
    conn.commit()


def mark_maintenance_done(conn: psycopg.Connection, asset_id: int,
                          type_id: int, done_at: date, done_hours: Any,
                          note: str | None, user_id: int | None,
                          unit_id: int | None = None,
                          request_id: int | None = None,
                          initial: bool = False,
                          commit: bool = True,
                          cost: Any = None, cost_vat: str | None = None,
                          act: Any = None, act_name: str | None = None) -> int:
    """
    Отметить проведённое ТО. От этой записи пойдёт отсчёт следующего — и по
    календарю, и по моточасам.

    Три правила, и все три — из разбора 21.09.2026:

    * моточасы обязательны. Без наработки следующий срок считать не от чего,
      и в истории такие строки стояли с пустым столбцом «Наработка»;
    * будущим числом ТО не проводят. Задача о подходящем сроке появляется
      заранее, и по ней отмечали «проведено» в день появления — в истории
      оказывались записи на неделю вперёд;
    * «Кто отметил» берётся из учётной записи. Столбец был всегда пуст:
      поле в запись не попадало вовсе.
    """
    with conn.cursor() as cur:
        cur.execute("SELECT code, period_hours, announce, category_code "
                    "  FROM app.maintenance_type WHERE id = %s", (type_id,))
        mtype = cur.fetchone()
    if not mtype:
        raise ValueError("Неизвестный вид ТО")
    #  Моточасы обязательны там, где по ним считается срок (ТО-1, ТО-2).
    #  У ПОПГ и ЧТО срок только по календарю (24.09.2026)
    if done_hours is None and mtype["period_hours"]:
        raise ValueError("Без моточасов ТО не отметить: "
                         "по наработке считается следующий срок")
    if done_at > date.today():
        raise ValueError("ТО нельзя отметить будущим числом — "
                         "поставьте день, когда его провели")
    if done_hours is not None and float(done_hours) < 0:
        raise ValueError("Моточасы не бывают отрицательными")
    #  ТО со специалистом (ТО-2, ПОПГ, ЧТО) проводится по сформированной
    #  заявке (24.09.2026, п. 7.4.1). Без заявки его вносят только данные
    #  при заведении машины и Администрация — исправляя историю
    if mtype["announce"] == "month25" and request_id is None and not initial:
        with conn.cursor() as cur:
            cur.execute("SELECT app.has_perm('maintenance.plan') AS ok")
            if not cur.fetchone()["ok"]:
                raise ValueError(
                    f"{mtype['code']} проводится по заявке: заполните заявку, "
                    "Администрация ООУРЦ назначит подрядчика и дату")

    #  Чья машина и техника ли это (23.09.2026). Раньше форма проверяла
    #  только депо из адреса, а номер машины брала на веру: начальник одного
    #  депо мог отметить ТО машине другого, а через подменённую форму — и
    #  клавиатуре. Теперь машина должна быть из того же депо, складской
    #  техникой и не списанной
    _check_maintainable(conn, asset_id, unit_id)
    if mtype["category_code"]:
        with conn.cursor() as cur:
            cur.execute("SELECT c.code FROM app.asset a JOIN app.asset_category c "
                        "ON c.id = a.category_id WHERE a.id = %s", (asset_id,))
            row = cur.fetchone()
        if not row or row["code"] != mtype["category_code"]:
            raise ValueError(f"{mtype['code']} проводится только у МПРП")
    if done_hours is not None:
        _check_hours_order(conn, asset_id, done_at, float(done_hours))

    who = None
    if user_id is not None:
        with conn.cursor() as cur:
            cur.execute("SELECT full_name FROM app.app_user WHERE id = %s",
                        (user_id,))
            row = cur.fetchone()
            who = row["full_name"] if row else None

    with conn.cursor() as cur:
        cur.execute(
            """
            INSERT INTO app.maintenance
                (asset_id, maintenance_type_id, done_at, done_hours,
                 status, note, performed_by, is_initial)
            VALUES (%s, %s, %s, %s, 'done', %s, %s, %s)
            RETURNING id
            """,
            (asset_id, type_id, done_at, done_hours, note, who, bool(initial)),
        )
        maintenance_id = cur.fetchone()["id"]
        #  02.10.2026 (вычитка 5.10): сумма за ТО и акт специалиста
        if cost is not None or act is not None:
            if cost is not None and cost_vat not in ("with", "without"):
                raise ValueError("Укажите, сумма с НДС или без НДС")
            cur.execute(
                """
                UPDATE app.maintenance
                   SET cost = %s, cost_vat = %s, act_stored = %s,
                       act_name = %s, act_mime = %s
                 WHERE id = %s
                """,
                (cost, cost_vat if cost is not None else None,
                 act.stored_name if act else None,
                 (act_name or None) if act else None,
                 act.mime_type if act else None, maintenance_id))
        if request_id is not None:
            cur.execute("SELECT app.maintenance_request_done(%s, %s)",
                        (request_id, maintenance_id))
        #  Показания на день ТО — чтобы следующий срок считался от них, даже
        #  если отдельно счётчик в этот день не снимали
        if done_hours is not None:
            cur.execute(
                """
                INSERT INTO app.meter_reading (asset_id, read_at, engine_hours, entered_by)
                VALUES (%s, %s, %s, %s)
                ON CONFLICT (asset_id, read_at) DO NOTHING
                """,
                (asset_id, done_at, done_hours, user_id),
            )
    if commit:
        conn.commit()
    return maintenance_id


def _check_maintainable(conn: psycopg.Connection, asset_id: int,
                        unit_id: int | None) -> None:
    """ТО отмечают только своей, живой, складской технике."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.org_unit_id, a.status, c.is_equipment, c.group_code
              FROM app.asset a
              JOIN app.asset_category c ON c.id = a.category_id
             WHERE a.id = %s
            """,
            (asset_id,),
        )
        row = cur.fetchone()
    #  Чужую машину политика доступа не покажет вовсе — ответ тот же, что и
    #  для несуществующей: незачем подсказывать, что такой номер где-то есть
    if row is None or (unit_id is not None and row["org_unit_id"] != unit_id):
        raise ValueError("Машина не найдена в этом депо — обновите страницу")
    if not row["is_equipment"] or row["group_code"] == VERIFICATION_GROUP:
        raise ValueError("ТО отмечается только у складской техники. У "
                         "поверочного оборудования — поверка, у ТМЦ ТО нет")
    if row["status"] == "written_off":
        raise ValueError("Машина списана — ТО по ней не отмечают")


def _check_hours_order(conn: psycopg.Connection, asset_id: int,
                       done_at: date, hours: float) -> None:
    """
    Счётчик моточасов назад не идёт — и при отметке ТО тоже (23.09.2026).

    Раньше это проверял только отдельный ввод показаний, а его убрали:
    после 500 моточасов принимались 120, и срок по наработке уезжал. ТО,
    внесённое задним числом, должно встать между соседними: не меньше
    того, что было раньше, и не больше того, что записано позже.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT
              (SELECT max(h) FROM (
                  SELECT done_hours AS h FROM app.maintenance
                   WHERE asset_id = %(a)s AND status = 'done'
                     AND done_hours IS NOT NULL AND done_at <= %(d)s
                  UNION ALL
                  SELECT engine_hours FROM app.meter_reading
                   WHERE asset_id = %(a)s AND read_at <= %(d)s) x) AS before,
              (SELECT min(h) FROM (
                  SELECT done_hours AS h FROM app.maintenance
                   WHERE asset_id = %(a)s AND status = 'done'
                     AND done_hours IS NOT NULL AND done_at > %(d)s
                  UNION ALL
                  SELECT engine_hours FROM app.meter_reading
                   WHERE asset_id = %(a)s AND read_at > %(d)s) y) AS after
            """,
            {"a": asset_id, "d": done_at},
        )
        row = cur.fetchone()
    before, after = row["before"], row["after"]
    if before is not None and hours < float(before):
        raise ValueError(
            f"Моточасов {hours:g} меньше, чем уже записано на эту дату или "
            f"раньше ({float(before):g}). Счётчик моточасов назад не идёт — "
            "проверьте цифру")
    if after is not None and hours > float(after):
        raise ValueError(
            f"Моточасов {hours:g} больше, чем записано позже этой даты "
            f"({float(after):g}). Проверьте дату или цифру")


# ---------------------------------------------------------------------------
#  Заявка на ТО со специалистом (24.09.2026, п. 7.4.1 TO_PROCESS)
#
#  ТО-2, ПОПГ и ЧТО проводит сторонний специалист, и путь у них в три шага:
#  начальник РЦ заполняет заявку с примечанием для специалиста →
#  Администрация ООУРЦ формирует её (подрядчик из реестра, дата) → начальник
#  РЦ «Пройти ТО-2»: дата, моточасы, примечание. Права и правила держит база
#  (миграция 79), здесь — только вызовы и выборки.
# ---------------------------------------------------------------------------

#  Поля формы заведения техники для дат последних ТО: латиницей, чтобы не
#  тащить кириллицу в имена полей
LAST_DONE_FIELD = {"ТО-1": "to1", "ТО-2": "to2", "ПОПГ": "popg", "ЧТО": "cto"}

MREQ_STATUS_RU = {
    "filled": "Заявка заполнена — ждёт Администрацию ООУРЦ",
    "scheduled": "Заявка сформирована",
    "done": "Проведено",
    "cancelled": "Отменена",
}


def has_maintenance_requests(conn: psycopg.Connection) -> bool:
    with conn.cursor() as cur:
        cur.execute("SELECT to_regclass('app.maintenance_request') IS NOT NULL AS ok")
        return bool(cur.fetchone()["ok"])


def open_maintenance_requests(conn: psycopg.Connection,
                              unit_id: int | None = None,
                              asset_id: int | None = None
                              ) -> dict[tuple[int, int], dict[str, Any]]:
    """Открытые заявки: (машина, вид ТО) → заявка."""
    if not has_maintenance_requests(conn):
        return {}
    where = ["q.status IN ('filled', 'scheduled')"]
    args: dict[str, Any] = {}
    if unit_id is not None:
        where.append("q.org_unit_id = %(unit)s")
        args["unit"] = unit_id
    if asset_id is not None:
        where.append("q.asset_id = %(asset)s")
        args["asset"] = asset_id
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT q.*, t.code AS type_code, k.name AS contractor_name,
                   k.phone AS contractor_phone,
                   uf.full_name AS filled_by_name,
                   us.full_name AS scheduled_by_name
              FROM app.maintenance_request q
              JOIN app.maintenance_type t ON t.id = q.maintenance_type_id
              LEFT JOIN app.contractor k ON k.id = q.contractor_id
              LEFT JOIN app.app_user uf ON uf.id = q.filled_by
              LEFT JOIN app.app_user us ON us.id = q.scheduled_by
             WHERE {' AND '.join(where)}
            """,
            args,
        )
        return {(r["asset_id"], r["maintenance_type_id"]): r
                for r in cur.fetchall()}


def maintenance_request(conn: psycopg.Connection,
                        request_id: int) -> dict[str, Any] | None:
    with conn.cursor() as cur:
        cur.execute("SELECT * FROM app.maintenance_request WHERE id = %s",
                    (request_id,))
        return cur.fetchone()


def fill_maintenance_request(conn: psycopg.Connection, asset_id: int,
                             type_id: int, note: str,
                             due: date | None) -> int:
    with conn.cursor() as cur:
        cur.execute("SELECT app.maintenance_request_fill(%s, %s, %s, %s) AS id",
                    (asset_id, type_id, note, due))
        rid = cur.fetchone()["id"]
    conn.commit()
    return rid


def schedule_maintenance_request(conn: psycopg.Connection, request_id: int,
                                 note: str, contractor_id: int | None,
                                 planned: date | None) -> None:
    with conn.cursor() as cur:
        cur.execute("SELECT app.maintenance_request_schedule(%s, %s, %s, %s)",
                    (request_id, note, contractor_id, planned))
    conn.commit()


def cancel_maintenance_request(conn: psycopg.Connection, request_id: int) -> None:
    with conn.cursor() as cur:
        cur.execute("SELECT app.maintenance_request_cancel(%s)", (request_id,))
    conn.commit()


def contractors(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """Реестр подрядчиков — выпадающий список в заявках."""
    with conn.cursor() as cur:
        cur.execute("SELECT id, name, phone FROM app.contractor "
                    " WHERE is_active ORDER BY sort_order, name")
        return cur.fetchall()


# ---------------------------------------------------------------------------
#  Правка и удаление ошибочной отметки ТО — Администрация ООУРЦ (24.09.2026)
# ---------------------------------------------------------------------------

def _move_reading(cur, asset_id: int, old_day: date, old_hours: Any,
                  new_day: date | None, new_hours: Any,
                  user_id: int | None) -> None:
    """
    Показание счётчика, записанное вместе с отметкой ТО, живёт вместе с ней
    (02.10.2026, вычитка 5.20): исправили отметку — исправилось и оно,
    удалили — удалилось. Раньше показание оставалось, его не было видно, и
    оно запрещало следующие отметки («счётчик назад не идёт») и удаление
    ошибочной карточки.
    """
    if old_hours is not None:
        cur.execute(
            "DELETE FROM app.meter_reading WHERE asset_id = %s AND read_at = %s "
            "AND engine_hours = %s", (asset_id, old_day, old_hours))
    if new_day is not None and new_hours is not None:
        cur.execute(
            """
            INSERT INTO app.meter_reading (asset_id, read_at, engine_hours, entered_by)
            VALUES (%s, %s, %s, %s)
            ON CONFLICT (asset_id, read_at) DO UPDATE
               SET engine_hours = EXCLUDED.engine_hours
            """, (asset_id, new_day, new_hours, user_id))


def fix_maintenance(conn: psycopg.Connection, maintenance_id: int,
                    done_at: date, done_hours: Any, note: str | None,
                    user_id: int | None) -> None:
    """
    Исправить дату и моточасы отметки. Счётчик назад не идёт и здесь:
    исправленная отметка должна встать между соседними. Кто и что поменял —
    в журнале операций и в журнале изменений (аудит таблицы).
    """
    with conn.cursor() as cur:
        cur.execute("SELECT app.has_perm('maintenance.plan') AS ok")
        if not cur.fetchone()["ok"]:
            raise ValueError("Отметку ТО исправляет Администрация ООУРЦ")
        cur.execute(
            "SELECT m.*, t.code, t.period_hours, a.org_unit_id, a.inventory_no "
            "  FROM app.maintenance m JOIN app.maintenance_type t "
            "    ON t.id = m.maintenance_type_id "
            "  JOIN app.asset a ON a.id = m.asset_id WHERE m.id = %s",
            (maintenance_id,))
        old = cur.fetchone()
    if not old:
        raise ValueError("Отметка не найдена")
    if done_at > date.today():
        raise ValueError("ТО нельзя отметить будущим числом")
    if done_hours is None and old["period_hours"]:
        raise ValueError("Моточасы обязательны")
    #  02.10.2026 (вычитка 5.20): Администрация исправляет моточасы в любом
    #  диапазоне — опечатку (5000 вместо 500) иначе было не поправить: её
    #  саму сравнивали с ней же через записанное показание счётчика
    if done_hours is not None and float(done_hours) < 0:
        raise ValueError("Моточасы не бывают отрицательными")
    with conn.cursor() as cur:
        cur.execute(
            "UPDATE app.maintenance SET done_at = %s, done_hours = %s, note = %s "
            " WHERE id = %s",
            (done_at, done_hours, (note or "").strip() or None, maintenance_id))
        if cur.rowcount != 1:
            raise ValueError("Отметку ТО исправляет Администрация ООУРЦ")
        #  Показание счётчика, записанное вместе с отметкой, — вместе с ней
        _move_reading(cur, old["asset_id"], old["done_at"], old["done_hours"],
                      done_at, done_hours, user_id)
        cur.execute(
            """
            INSERT INTO app.operation_log (user_id, operation, org_unit_id,
                                           status, rows_affected, message)
            VALUES (%s, 'maintenance_fix', %s, 'ok', 1, %s)
            """,
            (user_id, old["org_unit_id"],
             f"{old['code']} {old['inventory_no']}: было "
             f"{old['done_at']:%d.%m.%Y}, {old['done_hours'] if old['done_hours'] is not None else '—'} мч; "
             f"стало {done_at:%d.%m.%Y}, {done_hours if done_hours is not None else '—'} мч"))
    conn.commit()


def drop_maintenance(conn: psycopg.Connection, maintenance_id: int,
                     user_id: int | None) -> None:
    """Удалить ошибочную отметку ТО (двойной клик, не та машина)."""
    with conn.cursor() as cur:
        cur.execute("SELECT app.has_perm('maintenance.plan') AS ok")
        if not cur.fetchone()["ok"]:
            raise ValueError("Отметку ТО удаляет Администрация ООУРЦ")
        cur.execute(
            "SELECT m.done_at, m.done_hours, t.code, a.org_unit_id, a.inventory_no "
            "  FROM app.maintenance m JOIN app.maintenance_type t "
            "    ON t.id = m.maintenance_type_id "
            "  JOIN app.asset a ON a.id = m.asset_id WHERE m.id = %s",
            (maintenance_id,))
        old = cur.fetchone()
        if not old:
            raise ValueError("Отметка не найдена")
        cur.execute("SELECT asset_id FROM app.maintenance WHERE id = %s",
                    (maintenance_id,))
        asset_id = cur.fetchone()["asset_id"]
        cur.execute("DELETE FROM app.maintenance WHERE id = %s", (maintenance_id,))
        if cur.rowcount != 1:
            raise ValueError("Отметку ТО удаляет Администрация ООУРЦ")
        #  02.10.2026: показание, записанное с этой отметкой, уходит с ней
        _move_reading(cur, asset_id, old["done_at"], old["done_hours"],
                      None, None, user_id)
        cur.execute(
            """
            INSERT INTO app.operation_log (user_id, operation, org_unit_id,
                                           status, rows_affected, message)
            VALUES (%s, 'maintenance_drop', %s, 'ok', 1, %s)
            """,
            (user_id, old["org_unit_id"],
             f"Удалена отметка {old['code']} {old['inventory_no']} от "
             f"{old['done_at']:%d.%m.%Y}"))
    conn.commit()


def call_specialist(conn: psycopg.Connection, request_id: int, day: date | None,
                    contractor_id: int | None, note: str | None) -> None:
    """Администрация вызывает специалиста на ремонт и назначает дату приезда."""
    with conn.cursor() as cur:
        cur.execute("SELECT app.repair_call_specialist(%s, %s, %s, %s)",
                    (request_id, day, contractor_id, note))
    conn.commit()


def asset_counts(conn: psycopg.Connection, unit_id: int | None,
                 kind: str = "all") -> dict[str, int]:
    """
    Сколько единиц в каком состоянии — для отметок над таблицей.

    `kind` обязателен по смыслу, хотя и со значением по умолчанию: счётчики
    стоят над списком и должны считать то же, что в списке. Когда вкладки
    разделили на технику и ТМЦ, а счётчики остались общими, над одной
    строкой техники висело «2 единицы» — второй был терминал сбора данных
    с соседней вкладки.

    `unit_id = None` — «Все депо».
    """
    where = [] if unit_id is None else ["a.org_unit_id = %(unit)s"]
    only = kind_filter(kind, "c")
    if only:
        where.append(only)

    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT a.status, count(*) AS n
            FROM app.asset a
            JOIN app.asset_category c ON c.id = a.category_id
            WHERE {' AND '.join(where) if where else 'TRUE'}
            GROUP BY a.status
            """,
            {"unit": unit_id},
        )
        out = {r["status"]: int(r["n"]) for r in cur.fetchall()}
    out["all"] = sum(out.values())
    #  02.10.2026: «всего» на карточке-фильтре — то же, что показывает
    #  фильтр «Все»: без списанных. Раньше числа расходились
    out["in_use"] = out["all"] - out.get("written_off", 0)
    return out


# ---------------------------------------------------------------------------
#  Техническое обслуживание
# ---------------------------------------------------------------------------

def maintenance_due(conn: psycopg.Connection, unit_id: int,
                    on_day: date | None = None) -> list[dict[str, Any]]:
    """
    Когда у техники следующее ТО.

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

    Техника без счётчика моточасов в расчёт по часам не идёт: у тележки
    моточасов не бывает, и «через 50 часов» для неё ничего не значит. По
    календарю она считается наравне — требование от 21.09.2026.

    Поверочное оборудование сюда не попадает вовсе (22.09.2026): «в
    поверенной технике нет моточасов, тут только дата окончания срока
    поверки». Весы и алкотестер стояли здесь двумя строками — ТО-1 и ТО-2 —
    с пустыми моточасами и сроками, посчитанными по периодичности штабелёра.
    У них не ТО, а поверка: раз в год, в поверочной организации. Она
    считается отдельно — `verification_due`.
    """
    today = on_day or date.today()
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.id AS asset_id, a.inventory_no, a.name, a.model,
                   a.serial_no, a.status, c.has_meter, c.name AS category_name,
                   t.id AS type_id, t.code AS type_code, t.name AS type_name,
                   t.period_hours, t.period_days, t.is_self_service, t.note,
                   t.announce, c.code AS category_code,
                   m.done_hours   AS current_hours,
                   m.done_at      AS meter_date,
                   m0.done_hours  AS first_hours,
                   m0.done_at     AS first_meter_date,
                   a.created_at::date AS registered_at,
                   d.done_at      AS last_done_at,
                   d.done_hours   AS last_done_hours
            FROM app.asset a
            JOIN app.asset_category c ON c.id = a.category_id
            CROSS JOIN app.maintenance_type t
            --  Текущая наработка — из последней отметки о проведённом ТО
            --  (22.09.2026: «брать наработку по часам с ТО-1 и ТО-2»).
            --  Отдельных замеров счётчика больше нет: одно число вводилось
            --  в двух местах и расходилось, а какое считать текущим — было
            --  непонятно
            LEFT JOIN LATERAL (
                SELECT done_hours, done_at FROM app.maintenance
                 WHERE asset_id = a.id AND status = 'done'
                   AND done_hours IS NOT NULL
                 ORDER BY done_at DESC, id DESC LIMIT 1
            ) m ON true
            --  Самое раннее известное состояние машины: от него считается
            --  срок, пока этот вид ТО не проводили ни разу
            LEFT JOIN LATERAL (
                SELECT done_hours, done_at FROM app.maintenance
                 WHERE asset_id = a.id AND status = 'done'
                   AND done_hours IS NOT NULL
                 ORDER BY done_at ASC, id ASC LIMIT 1
            ) m0 ON true
            LEFT JOIN LATERAL (
                SELECT done_at, done_hours FROM app.maintenance
                 WHERE asset_id = a.id AND maintenance_type_id = t.id
                   AND status = 'done'
                 ORDER BY done_at DESC LIMIT 1
            ) d ON true
            WHERE a.org_unit_id = %s
              --  24.09.2026: «если техника требует замены или списана — то
              --  убираем»; в ремонте ТО остаётся
              AND a.status NOT IN ('written_off', 'needs_replacement')
              --  ПОПГ и ЧТО — только у МПРП (вид из реестра)
              AND (t.category_code IS NULL OR t.category_code = c.code)
              --  Только складская техника — то же условие, что у вкладки
              --  «Складская техника» (23.09.2026). Раньше отсекалось лишь
              --  поверочное, и ТМЦ — гидравлические тележки, клавиатуры —
              --  получали сроки ТО по календарю от даты заведения и задачи
              --  «Провести ТО-1» на доске
              AND c.is_equipment
              AND coalesce(c.group_code, '') <> %s
            ORDER BY a.inventory_no, t.code
            """,
            (unit_id, VERIFICATION_GROUP),
        )
        rows = cur.fetchall()

    requests = open_maintenance_requests(conn, unit_id)
    out = []
    for r in rows:
        due_hours = None
        left_hours = None
        if r["period_hours"] and r["current_hours"] is not None:
            #  Отсчёт от последнего проведённого ТО, а пока его не было —
            #  от ПЕРВЫХ известных показаний. Раньше здесь стояли последние,
            #  и цель уезжала вместе с каждым замером: «осталось» всегда
            #  показывало ровно 50 и 250 моточасов, то есть по наработке ТО
            #  не наступало никогда
            base = r["last_done_hours"]
            if base is None:
                base = r["first_hours"]
            if base is not None:
                due_hours = float(base) + float(r["period_hours"])
                left_hours = round(due_hours - float(r["current_hours"]), 1)

        due_date = None
        left_days = None
        if r["period_days"]:
            #  То же и по календарю: пока ТО не проводили, считаем от первого
            #  снятия показаний, а если их не было — от постановки на учёт.
            #  От последнего замера считать нельзя: регулярные замеры
            #  отодвигали бы срок до бесконечности
            base_date = (r["last_done_at"] or r["first_meter_date"]
                         or r["registered_at"])
            if base_date:
                due_date = base_date + timedelta(days=int(r["period_days"]))
                left_days = (due_date - today).days

        out.append({
            **r,
            "request": requests.get((r["asset_id"], r["type_id"])),
            "due_hours": due_hours,
            "left_hours": left_hours,
            "due_date": due_date,
            "left_days": left_days,
            #  Просрочено, если прошёл срок по любому из двух счётчиков
            "overdue": bool((left_days is not None and left_days < 0)
                            or (left_hours is not None and left_hours < 0)),
            "soon": bool((left_days is not None and 0 <= left_days <= LEAD_DAYS)
                         or (left_hours is not None and 0 <= left_hours <= 10)),
        })
    return out


# ---------------------------------------------------------------------------
#  Заявки на ремонт
# ---------------------------------------------------------------------------

def repair_requests(conn: psycopg.Connection, unit_id: int,
                    only_open: bool = False) -> list[dict[str, Any]]:
    if not has_repairs(conn):
        return []
    where = ["r.org_unit_id = %(unit)s"]
    args: dict[str, Any] = {"unit": unit_id}
    if only_open:
        where.append("r.status NOT IN ('received', 'fixed', 'cancelled')")
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT r.id, r.problem, r.status, r.opened_at, r.closed_at,
                   r.route, a.id AS asset_id, r.specialist_date,
                   (SELECT k.name FROM app.contractor k
                     WHERE k.id = r.contractor_id) AS contractor_name,
                   a.inventory_no, a.name AS asset_name, a.model,
                   u.full_name AS opened_by_name,
                   (SELECT e.at FROM app.repair_request_event e
                     WHERE e.request_id = r.id ORDER BY e.at DESC LIMIT 1)
                     AS last_move_at
            FROM app.repair_request r
            JOIN app.asset a ON a.id = r.asset_id
            LEFT JOIN app.app_user u ON u.id = r.opened_by
            WHERE {' AND '.join(where)}
            ORDER BY (r.status IN ('received', 'fixed', 'cancelled')), r.opened_at DESC
            """,
            args,
        )
        return cur.fetchall()


def repair_events(conn: psycopg.Connection,
                  request_ids: list[int]) -> dict[int, list[dict[str, Any]]]:
    """История переходов по заявкам — «когда передали в Минск» без раскопок."""
    if not request_ids or not has_repairs(conn):
        return {}
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT e.request_id, e.status, e.note, e.at, u.full_name AS by_name
            FROM app.repair_request_event e
            LEFT JOIN app.app_user u ON u.id = e.by_user
            WHERE e.request_id = ANY(%s)
            ORDER BY e.at
            """,
            (request_ids,),
        )
        out: dict[int, list[dict[str, Any]]] = {}
        for r in cur.fetchall():
            out.setdefault(r["request_id"], []).append(r)
    return out


def next_statuses(conn: psycopg.Connection, status: str,
                  route: str = "minsk") -> list[str]:
    """Куда можно перейти из этого состояния по своему маршруту. Список даёт база."""
    with conn.cursor() as cur:
        cur.execute("SELECT app.repair_next_statuses(%s, %s) AS s",
                    (route, status))
        return list(cur.fetchone()["s"] or [])


def open_repair(conn: psycopg.Connection, asset_id: int, unit_id: int,
                problem: str, user_id: int | None,
                route: str = "minsk") -> int:
    """
    Открыть заявку. Техника сразу помечается «в ремонте».

    `route` — маршрут: вызвать специалиста в депо или отправить в Минск.
    Выбирается при открытии и дальше не меняется: у маршрутов разные шаги, и
    заявка, прошедшая половину одного, в другой не встанет.
    """
    if route not in REPAIR_ROUTE_RU:
        raise ValueError("Выберите маршрут: вызов специалиста в депо или "
                         "отправка в Минск")
    if not (problem or "").strip():
        raise ValueError("Опишите, что сломалось: по пустой заявке не "
                         "поймут, что чинить")
    with conn.cursor() as cur:
        #  02.10.2026 (вычитка 5.20): заявка — только на единицу своего депо
        #  и не на списанную. Раньше запросом в обход экрана открывалась
        #  заявка на чужую или списанную технику
        cur.execute("SELECT org_unit_id, status FROM app.asset WHERE id = %s",
                    (asset_id,))
        a = cur.fetchone()
        if not a or a["org_unit_id"] != unit_id:
            raise ValueError("Единица не найдена в этом депо")
        if a["status"] == "written_off":
            raise ValueError("Единица списана — заявку на ремонт по ней не "
                             "открывают")
        cur.execute(
            """
            SELECT 1 FROM app.repair_request
             WHERE asset_id = %s AND status NOT IN ('received', 'fixed', 'cancelled')
            """,
            (asset_id,),
        )
        if cur.fetchone():
            raise ValueError("По этой единице уже есть незакрытая заявка")

        cur.execute(
            """
            INSERT INTO app.repair_request
                (asset_id, org_unit_id, problem, opened_by, route,
                 asset_status_before)
            VALUES (%s, %s, %s, %s, %s, %s) RETURNING id
            """,
            (asset_id, unit_id, problem.strip(), user_id, route, a["status"]),
        )
        request_id = cur.fetchone()["id"]
        cur.execute(
            """
            INSERT INTO app.repair_request_event (request_id, status, note, by_user)
            VALUES (%s, 'new', %s, %s)
            """,
            (request_id, problem.strip(), user_id),
        )
        cur.execute("UPDATE app.asset SET status = 'repair' WHERE id = %s",
                    (asset_id,))
    conn.commit()
    return request_id


REPAIR_OUTCOME_RU = {"ok": "Исправна",
                     "not_fixed": "Не отремонтирована — остаётся «в ремонте»",
                     "needs_replacement": "Требует замены"}

#  Шаги маршрута в Минск по сторонам (вычитка 5.20, 02.10.2026)
REPAIR_HQ_STEPS = ("hq_received", "in_repair", "repaired", "sent_to_unit")
REPAIR_DEPOT_STEPS = ("sent_to_hq", "received")


def step_allowed(route: str, current: str, step: str, *,
                 can_hq: bool, can_open: bool) -> bool:
    """Показывать ли этой учётке кнопку шага. База проверяет то же самое."""
    if route == "specialist":
        return can_hq or can_open
    if step in REPAIR_HQ_STEPS:
        return can_hq
    if step in REPAIR_DEPOT_STEPS:
        return can_open and not can_hq
    if step == "cancelled":
        return can_hq or (can_open and current == "new")
    return False


def move_repair(conn: psycopg.Connection, request_id: int, status: str,
                note: str | None = None, outcome: str | None = None) -> None:
    """
    Перевести заявку на следующий шаг. Маршрут и сторону проверяет база.
    `outcome` — итог ремонта при закрытии: ok / not_fixed / needs_replacement.
    """
    if outcome and outcome not in REPAIR_OUTCOME_RU:
        raise ValueError("Неизвестный итог ремонта")
    with conn.cursor() as cur:
        cur.execute("SELECT app.move_repair_request(%s, %s, %s, %s)",
                    (request_id, status, note, outcome))
    conn.commit()


def repair_route(conn: psycopg.Connection, request_id: int) -> str | None:
    """Маршрут заявки. None — заявки нет или она чужого депо (RLS)."""
    with conn.cursor() as cur:
        cur.execute("SELECT route FROM app.repair_request WHERE id = %s",
                    (request_id,))
        row = cur.fetchone()
    return row["route"] if row else None


# ---------------------------------------------------------------------------
#  Акты по заявке
#
#  «Фото акта или скрин акта привязать к дате» (23.09.2026). Акт не
#  обязателен для закрытия — его можно приложить на любом шаге, в том числе
#  после закрытия: акт от специалиста часто приходит днём позже ремонта.
# ---------------------------------------------------------------------------

def add_repair_act(conn: psycopg.Connection, request_id: int, act_date,
                   file_name: str, data: bytes,
                   note: str | None = None) -> int:
    """
    Записать файл в хранилище и сведения о нём в базу.

    Сначала проверяем доступ к заявке (RLS вернёт пусто для чужого депо), и
    только потом пишем файл: иначе на диске копились бы файлы, которые никому
    не принадлежат.
    """
    from . import filestore

    if repair_route(conn, request_id) is None:
        raise ValueError("Заявка не найдена")
    if act_date is None:
        raise ValueError("Укажите дату акта")
    stored = filestore.save(data, "repair", act_date)
    try:
        with conn.cursor() as cur:
            cur.execute(
                """
                INSERT INTO app.repair_act
                    (request_id, act_date, file_name, stored_name, mime_type,
                     size_bytes, sha256, note, uploaded_by)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, app.current_user_id())
                RETURNING id
                """,
                (request_id, act_date,
                 (file_name or "акт").strip()[:200] or "акт",
                 stored.stored_name, stored.mime_type, stored.size_bytes,
                 stored.sha256, (note or "").strip() or None),
            )
            act_id = cur.fetchone()["id"]
        conn.commit()
    except Exception:
        #  База не приняла — файл на диске никому не нужен
        conn.rollback()
        filestore.remove(stored.stored_name)
        raise
    return act_id


def repair_acts(conn: psycopg.Connection,
                request_ids: list[int]) -> dict[int, list[dict[str, Any]]]:
    """Акты по заявкам, по дате акта."""
    if not request_ids:
        return {}
    with conn.cursor() as cur:
        cur.execute("SELECT to_regclass('app.repair_act') IS NOT NULL AS ok")
        if not cur.fetchone()["ok"]:
            return {}
        cur.execute(
            """
            SELECT a.id, a.request_id, a.act_date, a.file_name, a.mime_type,
                   a.size_bytes, a.note, a.uploaded_at, a.uploaded_by,
                   u.full_name AS uploaded_by_name
            FROM app.repair_act a
            LEFT JOIN app.app_user u ON u.id = a.uploaded_by
            WHERE a.request_id = ANY(%s)
            ORDER BY a.act_date, a.id
            """,
            (request_ids,),
        )
        out: dict[int, list[dict[str, Any]]] = {}
        for r in cur.fetchall():
            out.setdefault(r["request_id"], []).append(r)
    return out


def repair_act(conn: psycopg.Connection, act_id: int) -> dict[str, Any] | None:
    """Один акт — для выдачи файла. Чужое депо получит None (RLS)."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.*, r.asset_id, r.org_unit_id, o.code AS unit_code
            FROM app.repair_act a
            JOIN app.repair_request r ON r.id = a.request_id
            JOIN app.org_unit o ON o.id = r.org_unit_id
            WHERE a.id = %s
            """,
            (act_id,),
        )
        return cur.fetchone()


def drop_repair_act(conn: psycopg.Connection, act_id: int) -> str:
    """Удалить акт: строку в базе и файл. Возвращает имя файла для сообщения."""
    from . import filestore

    with conn.cursor() as cur:
        cur.execute(
            "DELETE FROM app.repair_act WHERE id = %s "
            "RETURNING stored_name, file_name",
            (act_id,),
        )
        row = cur.fetchone()
    if not row:
        raise ValueError("Акт не найден")
    conn.commit()
    #  Файл — после того, как база подтвердила удаление: наоборот можно
    #  остаться со строкой, которая ссылается в пустоту
    filestore.remove(row["stored_name"])
    return row["file_name"]


# ---------------------------------------------------------------------------
#  Отчёт: что заканчивается
# ---------------------------------------------------------------------------

# ---------------------------------------------------------------------------
#  Карточка техники — уточнение по блоку F от 15.09.2026
#
#  «Для техники должна быть карточка и реестр история по проведенным ТО».
#
#  Собрано на одной странице то, что до сих пор лежало по трём вкладкам:
#  сама единица, когда у неё следующее ТО, что из ТО уже проведено, как росли
#  моточасы и что с ней случалось. Отвечает на вопрос, который задают про
#  конкретную машину: «а что с ней вообще было?»
# ---------------------------------------------------------------------------

def asset_card(conn: psycopg.Connection,
               asset_id: int) -> dict[str, Any] | None:
    """Единица техники со всем, что нужно шапке карточки."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.id, a.org_unit_id, a.inventory_no, a.name, a.model,
                   a.serial_no, a.completeness, a.qty, a.tracking,
                   a.note, a.status,
                   a.category_id, a.created_at,
                   a.verified_at, a.verified_until,
                   c.name AS category_name, c.code AS category_code,
                   c.has_meter, c.is_equipment, c.group_code,
                   u.code AS unit_code, u.name AS unit_name,
                   --  Моточасы — из последней отметки о проведённом ТО
                   --  (22.09.2026). Отдельных замеров счётчика больше нет
                   (SELECT m.done_hours FROM app.maintenance m
                     WHERE m.asset_id = a.id AND m.status = 'done'
                       AND m.done_hours IS NOT NULL
                     ORDER BY m.done_at DESC, m.id DESC LIMIT 1) AS engine_hours,
                   (SELECT m.done_at FROM app.maintenance m
                     WHERE m.asset_id = a.id AND m.status = 'done'
                       AND m.done_hours IS NOT NULL
                     ORDER BY m.done_at DESC, m.id DESC LIMIT 1) AS meter_date,
                   (SELECT r.id FROM app.repair_request r
                     WHERE r.asset_id = a.id
                       AND r.status NOT IN ('received', 'fixed', 'cancelled')
                     ORDER BY r.opened_at DESC LIMIT 1) AS open_request_id,
                   (SELECT r.status FROM app.repair_request r
                     WHERE r.asset_id = a.id
                       AND r.status NOT IN ('received', 'fixed', 'cancelled')
                     ORDER BY r.opened_at DESC LIMIT 1) AS open_request_status
            FROM app.asset a
            JOIN app.asset_category c ON c.id = a.category_id
            JOIN app.org_unit u       ON u.id = a.org_unit_id
            WHERE a.id = %s
            """,
            (asset_id,),
        )
        return cur.fetchone()


def maintenance_months(conn: psycopg.Connection,
                       asset_id: int) -> list[dict[str, Any]]:
    """
    Месяцы, в которых у единицы есть проведённые ТО, и сколько их в каждом.

    По ним строится переключатель над списком: на одной машине за полгода
    набирается полтора десятка строк, и читать их сплошняком незачем
    (ТЕХ-16, 21.09.2026).
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT date_trunc('month', done_at)::date AS month,
                   count(*) AS n
              FROM app.maintenance
             WHERE asset_id = %s AND status = 'done'
             GROUP BY 1
             ORDER BY 1 DESC
            """,
            (asset_id,),
        )
        return cur.fetchall()


#  Сколько строк истории показывать сразу и сколько добавлять по кнопке
#  (22.09.2026: «свернуть до 12 прохождений ТО и добавить кнопку показать
#  ещё»). У машины за полгода набирается полсотни записей, и сплошным
#  списком карточка перестаёт читаться
HISTORY_PAGE = 12


def maintenance_history(conn: psycopg.Connection, asset_id: int,
                        month: date | None = None,
                        date_from: date | None = None,
                        date_to: date | None = None,
                        limit: int | None = None) -> list[dict[str, Any]]:
    """
    Проведённые ТО по единице — от свежих к старым.

    Это и есть «реестр история по проведенным ТО» из задания. До сих пор из
    таблицы читалась только последняя запись по виду — ею считались сроки, а
    показать историю было негде.

    `month` — показать только этот месяц; `date_from` и `date_to` — диапазон
    «с и до» для быстрого поиска (22.09.2026). `limit` отдаёт на одну запись
    больше запрошенного: по ней страница понимает, показывать ли кнопку
    «Показать ещё», не считая всё заново вторым запросом.
    """
    where = ["m.asset_id = %(asset)s", "m.status = 'done'"]
    params: dict[str, Any] = {"asset": asset_id}
    if month is not None:
        where.append("date_trunc('month', m.done_at)::date = %(month)s")
        params["month"] = month
    if date_from is not None:
        where.append("m.done_at >= %(from)s")
        params["from"] = date_from
    if date_to is not None:
        where.append("m.done_at <= %(to)s")
        params["to"] = date_to

    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT m.id, m.done_at, m.done_hours, m.note, m.status, m.cost, m.cost_vat, m.act_stored,
                   t.code AS type_code, t.name AS type_name,
                   t.is_self_service,
                   --  Кто отметил: учётная запись того, кто нажал
                   --  «Проведено». Кто проводил работы — видно по виду ТО:
                   --  ТО-1 своими силами, ТО-2 сторонний специалист
                   m.performed_by AS performed_by_name
            FROM app.maintenance m
            JOIN app.maintenance_type t ON t.id = m.maintenance_type_id
            WHERE {' AND '.join(where)}
            ORDER BY m.done_at DESC, m.id DESC
            {'LIMIT %(limit)s' if limit else ''}
            """,
            {**params, "limit": (limit + 1) if limit else None},
        )
        return cur.fetchall()


def meter_history(conn: psycopg.Connection, asset_id: int,
                  limit: int = 20) -> list[dict[str, Any]]:
    """
    Показания счётчика — от свежих к старым.

    Рядом с каждым показанием — сколько наработано с прошлого раза: по этой
    колонке видно, работает машина или стоит, и она же объясняет, почему срок
    ТО подошёл раньше ожидаемого.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT m.id, m.read_at, m.engine_hours,
                   m.engine_hours - lag(m.engine_hours)
                        OVER (ORDER BY m.read_at, m.id) AS added,
                   u.full_name AS entered_by_name
            FROM app.meter_reading m
            LEFT JOIN app.app_user u ON u.id = m.entered_by
            WHERE m.asset_id = %s
            ORDER BY m.read_at DESC, m.id DESC
            LIMIT %s
            """,
            (asset_id, limit),
        )
        return cur.fetchall()


def repairs_of_asset(conn: psycopg.Connection,
                     asset_id: int) -> list[dict[str, Any]]:
    """Все заявки на ремонт этой единицы, включая закрытые и отменённые."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.id, r.problem, r.status, r.opened_at, r.closed_at,
                   r.route, r.specialist_date,
                   (SELECT k.name FROM app.contractor k
                     WHERE k.id = r.contractor_id) AS contractor_name,
                   u.full_name AS opened_by_name,
                   (SELECT count(*) FROM app.repair_request_event e
                     WHERE e.request_id = r.id) AS steps
            FROM app.repair_request r
            LEFT JOIN app.app_user u ON u.id = r.opened_by
            WHERE r.asset_id = %s
            ORDER BY r.opened_at DESC
            """,
            (asset_id,),
        )
        return cur.fetchall()



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

def verification_due(conn: psycopg.Connection,
                     unit_id: int | None) -> list[dict[str, Any]]:
    """
    Поверочное оборудование депо со сроком поверки.

    Одна строка на прибор, а не две, как у ТО-1 и ТО-2: поверка одна.
    Незаполненный срок уходит вниз — он не «самый срочный», он неизвестный.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.id AS asset_id, a.inventory_no, a.name, a.model,
                   a.serial_no, a.status,
                   a.verified_at, a.verified_until,
                   k.name AS category_name
              FROM app.asset a
              JOIN app.asset_category k ON k.id = a.category_id
             WHERE k.group_code = %s
               AND a.status <> 'written_off'
               AND (%s::bigint IS NULL OR a.org_unit_id = %s)
             ORDER BY a.verified_until NULLS LAST, a.inventory_no
            """,
            (VERIFICATION_GROUP, unit_id, unit_id),
        )
        return cur.fetchall()


def verifications(conn: psycopg.Connection,
                  asset_id: int) -> list[dict[str, Any]]:
    """Проведённые поверки одной единицы — от свежих к старым."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT v.id, v.verified_at, v.verified_until, v.certificate_no,
                   v.note, u.full_name AS done_by_name, v.created_at
              FROM app.verification v
              LEFT JOIN app.app_user u ON u.id = v.done_by
             WHERE v.asset_id = %s
             ORDER BY v.verified_at DESC, v.id DESC
            """,
            (asset_id,),
        )
        return cur.fetchall()


def record_verification(conn: psycopg.Connection, *, asset_id: int,
                        verified_at: Any, verified_until: Any = None,
                        certificate_no: str = "", note: str = "") -> int:
    """
    Отметить проведённую поверку.

    Журнал и текущее состояние меняются одной функцией базы: два запроса из
    приложения однажды разошлись бы — запись в журнале есть, а в списке
    старый срок.
    """
    at = _as_date(verified_at, "Дата поверки")
    until = _as_date(verified_until, "Срок поверки")
    if at is None:
        raise ValueError("Не указана дата поверки")
    if until and until < at:
        raise ValueError("Срок поверки не может быть раньше самой поверки")
    with conn.cursor() as cur:
        cur.execute(
            "SELECT app.record_verification(%s, %s, %s, %s, %s) AS id",
            (asset_id, at, until, certificate_no or None, note or None),
        )
        new_id = cur.fetchone()["id"]
    conn.commit()
    return int(new_id)

def maintenance_log(conn: psycopg.Connection, unit_id: int,
                    limit: int = 200) -> list[dict[str, Any]]:
    """
    Реестр проведённых ТО по всему депо — от свежих к старым.

    Отдельно от «когда следующее»: тот список отвечает, что делать, этот —
    что уже сделано. Смешивать их в одной таблице значит получить список, по
    которому нельзя ни спланировать, ни отчитаться.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT m.id, m.done_at, m.done_hours, m.note, m.cost, m.cost_vat, m.act_stored,
                   a.id AS asset_id, a.inventory_no, a.name AS asset_name,
                   a.model,
                   t.code AS type_code, t.name AS type_name,
                   t.is_self_service,
                   m.performed_by AS performed_by_name
            FROM app.maintenance m
            JOIN app.asset a            ON a.id = m.asset_id
            JOIN app.maintenance_type t ON t.id = m.maintenance_type_id
            WHERE a.org_unit_id = %s AND m.status = 'done'
            ORDER BY m.done_at DESC, m.id DESC
            LIMIT %s
            """,
            (unit_id, limit),
        )
        return cur.fetchall()


def set_category_kind(conn: psycopg.Connection, category_id: int,
                      is_equipment: bool) -> None:
    """
    Перевести вид из ТМЦ в технику и обратно.

    `has_meter` при этом не трогаем: это разные вопросы. «Ведём поштучно» и
    «есть счётчик моточасов» совпадают сегодня, но совпадать не обязаны —
    ТСД вполне может понадобиться карточка без всяких моточасов.
    """
    with conn.cursor() as cur:
        cur.execute(
            "UPDATE app.asset_category SET is_equipment = %s WHERE id = %s",
            (bool(is_equipment), category_id),
        )
    conn.commit()


def ppe_expiring(conn: psycopg.Connection, unit_id: int,
                 on_day: date | None = None) -> list[dict[str, Any]]:
    """
    СИЗ, у которых подходит срок замены.

    Дату берём из самой выдачи (`replace_at`) — она проставляется при выдаче
    по норме носки. Выдачи без неё сюда не попадают: это позиции «до износа»,
    у них нет даты, к которой готовиться.
    """
    today = on_day or date.today()
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT i.id, i.issued_at, i.replace_at, i.qty, i.wear_percent,
                   it.name AS item_name, it.size,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio_short,
                   e.personnel_no
            FROM app.ppe_issue i
            JOIN app.ppe_item it ON it.id = i.ppe_item_id
            JOIN app.employee e  ON e.id = i.employee_id
            WHERE i.org_unit_id = %(unit)s
              AND i.status = 'issued'
              AND i.replace_at IS NOT NULL
              AND i.replace_at <= %(edge)s
            ORDER BY i.replace_at
            """,
            {"unit": unit_id, "edge": today + timedelta(days=60)},
        )
        rows = cur.fetchall()
    for r in rows:
        r["left_days"] = (r["replace_at"] - today).days
        r["overdue"] = r["left_days"] < 0
    return rows


def alcotesters(conn: psycopg.Connection, unit_id: int) -> list[dict[str, Any]]:
    """
    Алкотестеры депо — для «Путевого» (25.09.2026): «Поверенная техника»,
    вид «Алкотестер», не списанные. Исправные — первыми.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.id, a.inventory_no, a.name, a.model, a.serial_no, a.status,
                   a.verified_until
              FROM app.asset a
              JOIN app.asset_category c ON c.id = a.category_id
             WHERE a.org_unit_id = %s AND a.status <> 'written_off'
               AND (c.code = 'breathalyzer' OR c.name ILIKE '%%алкотест%%')
             ORDER BY (a.status = 'ok') DESC, a.verified_until DESC NULLS LAST, a.id
            """, (unit_id,))
        rows = cur.fetchall()
    for r in rows:
        title = r["model"] or r["name"]
        r["label"] = f"{title}, зав. № {r['serial_no']}" if r["serial_no"] else title
    return rows


# ===========================================================================
#  База СИЗ на депо (вычитка LOGIKA_PROSTO 30.09.2026, подволна 4а)
# ===========================================================================
#  «В учётку депо во вкладку "Обеспечение" добавить вкладку "База СИЗ"».
#  Новые позиции — справочник из «Базовых настроек» с группой; сданные
#  «б/у» экземпляры — с зафиксированным при сдаче износом, показываются
#  раскрытым списком у своей позиции

PPE_BASE_GROUPS = [
    ("summer_suit", "Летние комплекты"),
    ("winter_suit", "Зимние комплекты"),
    ("winter_shoes", "Зимняя обувь"),
    ("summer_shoes", "Летняя обувь"),
    ("helmet", "Каски"),
    ("gloves", "Перчатки"),
]
PPE_BASE_GROUP_RU = dict(PPE_BASE_GROUPS)


def mbp_stock(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """
    Остатки МБП всех депо построчно (№1 документа «Путь СИЗ» от 07.10.2026).

    07.10.2026, вторая правка: позиции связаны с карточками Базы СИЗ по
    артикулу (код номенклатуры из файла сверяется с артикулами карточек
    в «Базовых настройках») — группировка свода идёт по карточкам, как по
    1С. Позиции без артикула в карточках (внесённые депо руками) — «Прочее».
    07.10.2026, третья правка: карточка «Иное» — перечень произвольной
    номенклатуры (ppe_other_item), её артикулы сводятся в строку «Иное».
    Количество живое: выдача списывает, загрузка файла обновляет.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT COALESCE(am.title, 'Прочее') AS group_title,
                   COALESCE(am.sort, 99) AS group_sort,
                   i.base_group, i.name, ou.code AS unit_code,
                   ou.name AS unit_name, SUM(s.qty) AS qty
              FROM app.ppe_base_stock s
              JOIN app.ppe_item i ON i.id = s.ppe_item_id
              JOIN app.org_unit ou ON ou.id = s.org_unit_id
              LEFT JOIN (
                   SELECT nullif(btrim(r.article), '') AS article,
                          c.title, c.sort
                     FROM app.ppe_size_row r
                     JOIN app.ppe_size_card c ON c.code = r.card_code
                   UNION
                   SELECT article, 'Иное', 7 FROM app.ppe_other_item
              ) am ON am.article = i.code
             WHERE s.qty > 0
             GROUP BY group_title, group_sort, i.base_group, i.name,
                      ou.code, ou.name
             ORDER BY group_sort, group_title, i.name
            """)
        return cur.fetchall()


def ppe_base(conn: psycopg.Connection, unit_id: int) -> list[dict[str, Any]]:
    """
    База СИЗ депо: новые экземпляры по позициям и сданные «б/у» с износом.

    Строка результата — позиция с размером: сколько новых и список б/у
    экземпляров (износ, когда сдан, кто). «Может быть одного комплекта
    несколько штук, но с разным % износа — показывать через раскрывающийся
    список»: б/у идут списком внутри строки, шаблон раскрывает их.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT s.id AS stock_id, it.id AS item_id, it.name, it.size,
                   it.base_group, s.size AS base_size, s.qty
            FROM app.ppe_base_stock s
            JOIN app.ppe_item it ON it.id = s.ppe_item_id
            WHERE s.org_unit_id = %s
            ORDER BY it.base_group NULLS LAST, it.name, s.size
            """,
            (unit_id,),
        )
        stock = cur.fetchall()
        cur.execute(
            """
            SELECT w.id, w.ppe_item_id, w.size, w.worn_pct, w.returned_at,
                   e.last_name || ' ' || e.first_name ||
                       coalesce(' ' || e.middle_name, '') AS employee_name,
                   it.base_group
            FROM app.ppe_base_worn w
            JOIN app.ppe_item it ON it.id = w.ppe_item_id
            LEFT JOIN app.employee e ON e.id = w.employee_id
            WHERE w.org_unit_id = %s
            ORDER BY w.returned_at DESC, w.id DESC
            """,
            (unit_id,),
        )
        worn = cur.fetchall()

    #  Группируем б/у к строкам стока по (позиция, размер); позиции без
    #  строки стока получают свою строку с нулём новых
    rows: dict[tuple, dict] = {}
    for s in stock:
        key = (s["item_id"], s["base_size"] or "")
        rows[key] = {"name": s["name"], "size": s["base_size"],
                     "base_group": s["base_group"],
                     "qty": int(s["qty"]), "stock_id": s["stock_id"],
                     "worn": []}
    for w in worn:
        key = (w["ppe_item_id"], w["size"] or "")
        row = rows.setdefault(
            key, {"name": None, "size": w["size"],
                  "base_group": w["base_group"], "qty": 0, "stock_id": None,
                  "worn": []})
        row["worn"].append(w)
    out = sorted(rows.values(),
                 key=lambda r: (r["base_group"] or "", r["name"] or "",
                                r["size"]))
    return out


def ppe_base_add(conn: psycopg.Connection, unit_id: int, item_id: int,
                 size: str, qty: int, user_id: int | None) -> None:
    """Внести позицию в базу депо: позиция справочника, размер, количество."""
    size = (size or "").strip()
    qty = int(qty or 0)
    if qty <= 0:
        raise ValueError("Количество должно быть больше нуля")
    with conn.cursor() as cur:
        cur.execute("SELECT is_active FROM app.ppe_item WHERE id = %s",
                    (item_id,))
        item = cur.fetchone()
        if item is None:
            raise ValueError("Выберите позицию из справочника")
        if not item["is_active"]:
            raise ValueError("Позиция закрыта в справочнике — выберите другую")
        cur.execute(
            """
            INSERT INTO app.ppe_base_stock
                (org_unit_id, ppe_item_id, size, qty, updated_by)
            VALUES (%s, %s, %s, %s, %s)
            ON CONFLICT (org_unit_id, ppe_item_id, size) DO UPDATE
               SET qty = ppe_base_stock.qty + EXCLUDED.qty,
                   updated_by = EXCLUDED.updated_by, updated_at = now()
            """,
            (unit_id, item_id, size, qty, user_id))
    conn.commit()


def ppe_base_set_qty(conn: psycopg.Connection, unit_id: int, stock_id: int,
                     qty: int) -> None:
    """Поправить количество: инвентаризация нашла лишнее или недостачу."""
    qty = int(qty or 0)
    if qty < 0:
        raise ValueError("Количество не может быть отрицательным")
    with conn.cursor() as cur:
        if qty == 0:
            cur.execute(
                "DELETE FROM app.ppe_base_stock "
                " WHERE id = %s AND org_unit_id = %s", (stock_id, unit_id))
        else:
            cur.execute(
                """
                UPDATE app.ppe_base_stock SET qty = %s, updated_at = now()
                 WHERE id = %s AND org_unit_id = %s
                """, (qty, stock_id, unit_id))
        if cur.rowcount == 0:
            raise ValueError("Строка базы не найдена — обновите страницу")
    conn.commit()


def ppe_base_delete(conn: psycopg.Connection, unit_id: int, stock_id: int) -> None:
    """Убрать строку базы целиком (например, завели ошибочную)."""
    with conn.cursor() as cur:
        cur.execute(
            "DELETE FROM app.ppe_base_stock WHERE id = %s AND org_unit_id = %s",
            (stock_id, unit_id))
        if cur.rowcount == 0:
            raise ValueError("Строка базы не найдена — обновите страницу")
    conn.commit()


def ppe_base_catalog(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """
    Позиции справочника «Базы СИЗ» для формы внесения: активные, с группой.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT it.id, it.name, it.base_group,
                   coalesce((SELECT sum(s.qty) FROM app.ppe_base_stock s
                              WHERE s.ppe_item_id = it.id), 0) AS total
            FROM app.ppe_item it
            WHERE it.base_group IS NOT NULL AND it.is_active
            ORDER BY it.base_group, it.name
            """)
        return cur.fetchall()


def take_ppe_from_base(conn: psycopg.Connection, stock_id: int,
                       org_unit_id: int) -> str | None:
    """
    Списать один экземпляр при выдаче из базы.

    Возвращает «наименование — размер» для сообщения, либо None, если
    строки не оказалось (выдали параллельно из двух окон).
    """
    with conn.cursor() as cur:
        cur.execute(
            "DELETE FROM app.ppe_base_stock "
            " WHERE id = %s AND org_unit_id = %s AND qty <= 1",
            (stock_id, org_unit_id))
        cur.execute(
            """
            UPDATE app.ppe_base_stock
               SET qty = qty - 1, updated_at = now()
             WHERE id = %s AND org_unit_id = %s AND qty > 1
            RETURNING (SELECT name FROM app.ppe_item
                        WHERE id = ppe_base_stock.ppe_item_id)
                       || ' ' || size AS taken
            """,
            (stock_id, org_unit_id))
        row = cur.fetchone()
    return row["taken"] if row else None
