"""
Слой данных раздела «Мотивация».

Здесь только запросы: собрать вход для расчёта, сохранить версию расчёта,
прочитать сохранённое, вести доплаты и вычеты, факты показателей и топливо.
Вся арифметика — в `payroll.py`, чтобы её можно было прогнать без базы.

Три вещи, которые в действующей системе устроены иначе и здесь сделаны
намеренно по-другому:

*   **расчёт читается из снимка, а не считается на лету.** Сохранённая
    версия — это то, что было выплачено. Пересчёт справочника завтра не
    должен менять зарплату за прошлый год;
*   **повторный расчёт открытого месяца переписывает черновик целиком**, а
    не дописывает строки. «Выгрузка» в старой системе дописывала, и двойной
    клик удваивал месяц в архиве вместе с ФОТ в показателях;
*   **факт показателя читается функцией `kpi_fact_value`**, потому что
    текучесть лежит на сводном объекте ООУРЦ, к которому у депо нет доступа.
"""

from __future__ import annotations

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

import psycopg

from .payroll import (
    EmployeeInput,
    KpiInput,
    Params,
    PayrollError,
    PayrollRun,
    PieceworkLine,
    ScaleStep,
    calculate_run,
    dec,
    scale_step,
)

RUN_STATUS_RU = {
    "draft": "Черновик",
    "confirmed": "Подтверждён депо",
    "closed": "Закрыт",
    "superseded": "Заменён перерасчётом",
}


#  Границы месяца берём из `rules`: раньше их было три штуки — своя здесь,
#  своя в `budgetdb` и та, что в `rules`. Вели они себя одинаково, но
#  одинаково только пока: расходятся такие копии молча.
from .rules import month_bounds


# ---------------------------------------------------------------------------
#  Справочники на дату
# ---------------------------------------------------------------------------

def params(conn: psycopg.Connection, period: date) -> Params:
    """
    Коэффициенты расчёта, действующие в этом месяце.

    Берутся по дате, а не «как сейчас в ячейке»: при изменении ставки
    налога прошлые месяцы обязаны остаться со своим коэффициентом.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT code, value
            FROM app.payroll_param
            WHERE valid_from <= %(d)s AND (valid_to IS NULL OR valid_to > %(d)s)
            """,
            {"d": period},
        )
        found = {r["code"]: r["value"] for r in cur.fetchall()}

    default = Params()
    plan = found.get("piecework_plan")
    return Params(
        gross_coef_salary=dec(found.get("gross_coef_salary") or default.gross_coef_salary),
        gross_coef_compensation=dec(
            found.get("gross_coef_compensation") or default.gross_coef_compensation),
        night_premium=dec(found.get("night_premium") or default.night_premium),
        piecework_plan=dec(plan) if plan is not None else None,
    )


def base_salaries(conn: psycopg.Connection, period: date) -> dict[int, Decimal]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT position_category_id, amount
            FROM app.position_base_salary
            WHERE valid_from <= %(d)s AND (valid_to IS NULL OR valid_to > %(d)s)
            """,
            {"d": period},
        )
        return {r["position_category_id"]: dec(r["amount"]) for r in cur.fetchall()}


def month_norm(conn: psycopg.Connection, period: date) -> Decimal:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT norm_hours_40 FROM app.production_calendar
            WHERE year = %s AND month = %s
            """,
            (period.year, period.month),
        )
        row = cur.fetchone()
    return dec(row["norm_hours_40"]) if row else Decimal("0")


# ---------------------------------------------------------------------------
#  Показатели
# ---------------------------------------------------------------------------

def kpi_catalog(conn: psycopg.Connection, period: date) -> list[dict[str, Any]]:
    """Действующие показатели со шкалой на дату месяца."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT k.id, k.code, k.name, k.description, k.better_when, k.scope,
                   coalesce(json_agg(json_build_object(
                       'step_no', s.step_no, 'threshold', s.threshold,
                       'coef_manager', s.coef_manager,
                       'coef_piecework', s.coef_piecework)
                       ORDER BY s.step_no)
                       FILTER (WHERE s.id IS NOT NULL), '[]') AS steps
            FROM app.kpi k
            LEFT JOIN app.kpi_scale s
                   ON s.kpi_id = k.id
                  AND s.valid_from <= %(d)s
                  AND (s.valid_to IS NULL OR s.valid_to > %(d)s)
            WHERE k.is_active
            GROUP BY k.id
            ORDER BY k.id
            """,
            {"d": period},
        )
        return cur.fetchall()


def kpi_facts(conn: psycopg.Connection, unit_id: int, period: date) -> dict[int, Decimal]:
    """
    Факты показателей за месяц с учётом области каждого.

    Функция `kpi_fact_value` объявлена SECURITY DEFINER: текучесть считается
    по сводному объекту ООУРЦ, а у начальника РЦ доступа к нему нет — без неё
    премия по текучести молча посчиталась бы от отсутствующего факта.
    """
    out: dict[int, Decimal] = {}
    with conn.cursor() as cur:
        for k in kpi_catalog(conn, period):
            cur.execute(
                "SELECT app.kpi_fact_value(%s, %s, %s) AS v",
                (unit_id, period, k["id"]),
            )
            row = cur.fetchone()
            if row and row["v"] is not None:
                out[k["id"]] = dec(row["v"])
    return out


def kpi_fact_rows(conn: psycopg.Connection, unit_id: int, period: date) -> list[dict[str, Any]]:
    """
    Показатели с фактом и подсвеченной ступенью шкалы — для экрана ввода.

    Ступень считается здесь, а не в шаблоне: правило выбора («первый порог,
    который факт не превысил») — часть методики расчёта, и держать его в
    двух местах значит однажды разойтись.
    """
    facts = kpi_facts(conn, unit_id, period)
    rows = []
    for k in kpi_catalog(conn, period):
        fact = facts.get(k["id"])
        step_no = None
        if fact is not None and k["steps"]:
            steps = tuple(
                ScaleStep(
                    step_no=int(s["step_no"]), threshold=dec(s["threshold"]),
                    coef_manager=dec(s["coef_manager"]),
                    coef_piecework=dec(s["coef_piecework"]),
                )
                for s in k["steps"]
            )
            match = scale_step(steps, fact, k["better_when"])
            step_no = match.step_no if match else None
        rows.append({**k, "fact": fact, "step_no": step_no})
    return rows


def set_kpi_fact(conn: psycopg.Connection, unit_id: int, period: date,
                 kpi_id: int, value: Decimal | None, comment: str | None = None) -> None:
    """
    Записать или стереть факт показателя ровно в указанное подразделение.

    Подразделение задаётся явно и не подменяется: экран показателей — это
    таблица «депо × показатель», и клетка знает, в какую строку пишет.
    Показатель с областью «отдел» база примет только в строку ООУРЦ.

    Транзакция не закрывается: таблица сохраняется целиком, и сорваться на
    одной клетке, оставив половину строк новыми, а половину старыми, было бы
    хуже, чем не сохранить ничего. Коммит делает вызывающий.
    """
    with conn.cursor() as cur:
        if value is None:
            cur.execute("SELECT app.clear_kpi_fact(%s, %s, %s)",
                        (unit_id, period, kpi_id))
        else:
            cur.execute("SELECT app.set_kpi_fact(%s, %s, %s, %s, %s)",
                        (unit_id, period, kpi_id, value, comment))


def kpi_matrix(conn: psycopg.Connection, period: date,
               current_unit_id: int | None = None) -> dict[str, Any]:
    """
    Таблица показателей за месяц: строка на депо плюс строка по отделу.

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

    Что видно кому: администрация — все строки, начальник РЦ — свою. Строка
    отдела ему недоступна, поэтому значение показателя с областью «отдел»
    возвращается отдельно, `org_values`: от него зависит его же премия, и не
    показать его значило бы оставить человека без объяснения цифры.
    """
    catalog = kpi_catalog(conn, period)
    first = period.replace(day=1)

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, code, name, kind
            FROM app.org_unit
            WHERE kind IN ('rc', 'ooucr') AND is_active AND app.has_unit_access(id)
            ORDER BY kind DESC, name
            """
        )
        units = cur.fetchall()

        cur.execute(
            """
            SELECT f.org_unit_id, f.kpi_id, f.value, f.entered_at, f.comment,
                   u.full_name AS entered_by_name
            FROM app.kpi_fact f
            LEFT JOIN app.app_user u ON u.id = f.entered_by
            WHERE f.period_month = %s
            """,
            (first,),
        )
        values = {(r["org_unit_id"], r["kpi_id"]): r for r in cur.fetchall()}

    rows = []
    for u in units:
        is_org = u["kind"] == "ooucr"
        cells = {}
        for k in catalog:
            #  Показатель отдела в клетке депо не заполняется, показатель депо
            #  в строке отдела — заполняется: это сводное значение, оно есть и
            #  в действующей таблице.
            applicable = is_org or k["scope"] != "org"
            cells[k["id"]] = {
                "applicable": applicable,
                "row": values.get((u["id"], k["id"])),
            }
        rows.append({
            "unit": u,
            "is_org": is_org,
            "is_current": u["id"] == current_unit_id,
            "cells": cells,
        })

    #  Значение по отделу для того, кому строка отдела не видна
    org_values: list[dict[str, Any]] = []
    if current_unit_id and not any(r["is_org"] for r in rows):
        with conn.cursor() as cur:
            for k in catalog:
                if k["scope"] != "org":
                    continue
                cur.execute("SELECT app.kpi_fact_value(%s, %s, %s) AS v",
                            (current_unit_id, period, k["id"]))
                row = cur.fetchone()
                org_values.append({
                    "name": k["name"],
                    "value": dec(row["v"]) if row and row["v"] is not None else None,
                })

    return {"catalog": catalog, "rows": rows, "org_values": org_values}


def kpi_inputs(conn: psycopg.Connection, unit_id: int,
               period: date) -> dict[int, list[KpiInput]]:
    """
    Показатели, разложенные по категориям должностей.

    Шкала и факт у показателя общие, а вес и фонд — свои у каждой категории:
    у руководителей вес 0,25 и фонд пары «депо + должность», у кладовщиков
    вес нулевой, и показатель работает не премией, а коэффициентом к сделке.
    """
    catalog = kpi_catalog(conn, period)
    facts = kpi_facts(conn, unit_id, period)

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT kpi_id, position_category_id, weight
            FROM app.kpi_weight
            WHERE valid_from <= %(d)s AND (valid_to IS NULL OR valid_to > %(d)s)
            """,
            {"d": period},
        )
        weights = {(r["kpi_id"], r["position_category_id"]): dec(r["weight"])
                   for r in cur.fetchall()}

        cur.execute(
            """
            SELECT position_category_id, amount
            FROM app.kpi_fund
            WHERE org_unit_id = %(u)s
              AND valid_from <= %(d)s AND (valid_to IS NULL OR valid_to > %(d)s)
            """,
            {"u": unit_id, "d": period},
        )
        funds = {r["position_category_id"]: dec(r["amount"]) for r in cur.fetchall()}

        cur.execute("SELECT id FROM app.position_category")
        categories = [r["id"] for r in cur.fetchall()]

    out: dict[int, list[KpiInput]] = {}
    for cat in categories:
        items = []
        for k in catalog:
            steps = tuple(
                ScaleStep(
                    step_no=int(s["step_no"]),
                    threshold=dec(s["threshold"]),
                    coef_manager=dec(s["coef_manager"]),
                    coef_piecework=dec(s["coef_piecework"]),
                )
                for s in k["steps"]
            )
            items.append(KpiInput(
                kpi_id=k["id"], code=k["code"], name=k["name"],
                better_when=k["better_when"], steps=steps,
                weight=weights.get((k["id"], cat), Decimal("0")),
                fund=funds.get(cat, Decimal("0")),
                fact=facts.get(k["id"]),
            ))
        out[cat] = items
    return out


# ---------------------------------------------------------------------------
#  Выработка, доплаты и вычеты, топливо
# ---------------------------------------------------------------------------

def piecework_by_employee(conn: psycopg.Connection, unit_id: int,
                          period: date) -> dict[int, list[PieceworkLine]]:
    """
    Выработка за месяц по каждому сотруднику, помноженная на действующие ставки.

    Берётся только активный набор загрузки: повторная загрузка месяца
    помечает прежний `superseded`, и удвоения операций, как при двойном
    клике по «Выгрузить» в старой системе, здесь не бывает.

    И только выработка с терминала сбора данных (`from_tsd`). В выгрузке 1С УТ
    у человека бывает две учётные записи — «Иванов И.И.» и «Иванов И.И.
    (ТСД)»; в сделку идёт вторая. Решение заказчика от 14.09.2026. Обе учётки
    в базе лежат: картина работы депо должна быть целой, а правило про деньги
    держится здесь, одним условием.
    """
    first, last = month_bounds(period)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT f.employee_id, ot.id AS operation_type_id, ot.code, ot.name,
                   sum(f.qty)       AS qty,
                   sum(f.weight_kg) AS weight_kg,
                   sum(f.volume_m3) AS volume_m3
            FROM app.operation_fact f
            JOIN app.operation_load l  ON l.id = f.load_id AND l.status = 'active'
            JOIN app.operation_type ot ON ot.id = f.operation_type_id
            WHERE f.org_unit_id = %(u)s
              AND f.work_date BETWEEN %(a)s AND %(b)s
              AND f.is_own
              AND f.from_tsd
              AND f.employee_id IS NOT NULL
            GROUP BY f.employee_id, ot.id
            """,
            {"u": unit_id, "a": first, "b": last},
        )
        facts = cur.fetchall()

        cur.execute(
            """
            SELECT operation_type_id, unit, rate
            FROM app.operation_rate
            WHERE valid_from <= %(d)s AND (valid_to IS NULL OR valid_to > %(d)s)
              AND (org_unit_id IS NULL OR org_unit_id = %(u)s)
            ORDER BY org_unit_id NULLS FIRST
            """,
            {"d": period, "u": unit_id},
        )
        #  Ставка депо, если она заведена, перекрывает общую: сортировка
        #  ставит NULL первым, и словарь перезаписывается частным значением.
        rates = {(r["operation_type_id"], r["unit"]): dec(r["rate"])
                 for r in cur.fetchall()}

    out: dict[int, list[PieceworkLine]] = {}
    for f in facts:
        for unit_kind, qty in (("qty", f["qty"]),
                               ("weight", f["weight_kg"]),
                               ("volume", f["volume_m3"])):
            rate = rates.get((f["operation_type_id"], unit_kind))
            if rate is None or not qty:
                continue
            out.setdefault(f["employee_id"], []).append(PieceworkLine(
                operation_type_id=f["operation_type_id"],
                code=f["code"], name=f["name"], unit=unit_kind,
                qty=dec(qty), rate=rate,
            ))
    return out


def adjustment_totals(conn: psycopg.Connection, unit_id: int,
                      period: date) -> dict[int, tuple[Decimal, Decimal]]:
    """Согласованные доплаты и вычеты по сотрудникам: (доплаты, вычеты)."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT employee_id, kind, sum(coalesce(amount, 0)) AS total
            FROM app.adjustment
            WHERE org_unit_id = %s AND period_month = %s AND status = 'approved'
            GROUP BY employee_id, kind
            """,
            (unit_id, period),
        )
        rows = cur.fetchall()
    out: dict[int, tuple[Decimal, Decimal]] = {}
    for r in rows:
        add, ded = out.get(r["employee_id"], (Decimal("0"), Decimal("0")))
        if r["kind"] == "addition":
            add += dec(r["total"])
        else:
            ded += dec(r["total"])
        out[r["employee_id"]] = (add, ded)
    return out


def adjustments(conn: psycopg.Connection, unit_id: int,
                period: date) -> list[dict[str, Any]]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT a.id, a.employee_id, a.kind, a.amount, a.hours, a.status,
                   a.explanation, a.reject_reason, a.created_at, a.approved_at,
                   r.name AS reason_name,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio_short,
                   e.personnel_no,
                   au.full_name AS created_by_name,
                   ap.full_name AS approved_by_name
            FROM app.adjustment a
            JOIN app.employee e            ON e.id = a.employee_id
            LEFT JOIN app.adjustment_reason r ON r.id = a.reason_id
            LEFT JOIN app.app_user au      ON au.id = a.created_by
            LEFT JOIN app.app_user ap      ON ap.id = a.approved_by
            WHERE a.org_unit_id = %s AND a.period_month = %s
            ORDER BY a.kind DESC, e.last_name, a.id
            """,
            (unit_id, period),
        )
        return cur.fetchall()


def pending_adjustment_count(conn: psycopg.Connection, unit_ids: list[int],
                             period: date) -> int:
    """
    Сколько доплат и вычетов ждёт решения — для отметки на вкладке.

    Считаем по всем депо, которые человек видит: администрация согласует
    записи всех городов, и отметка должна звать её туда, где есть работа.
    """
    if not unit_ids:
        return 0
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT count(*) AS n FROM app.adjustment
            WHERE org_unit_id = ANY(%s) AND period_month = %s
              AND status IN ('draft', 'pending')
            """,
            (unit_ids, period),
        )
        return int(cur.fetchone()["n"])


def adjustment_reasons(conn: psycopg.Connection) -> list[dict[str, Any]]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, kind, name FROM app.adjustment_reason
            WHERE is_active ORDER BY kind DESC, name
            """
        )
        return cur.fetchall()


def add_adjustment(conn: psycopg.Connection, unit_id: int, period: date,
                   employee_id: int, kind: str, reason_id: int | None,
                   amount: Decimal, explanation: str, user_id: int) -> None:
    """
    Подать доплату или вычет. Статус — «подана»: в расчёт запись попадёт
    только после согласования администрацией.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            INSERT INTO app.adjustment
                (employee_id, org_unit_id, kind, reason_id, period_month,
                 amount, explanation, status, created_by)
            VALUES (%s, %s, %s, %s, %s, %s, %s, 'pending', %s)
            """,
            (employee_id, unit_id, kind, reason_id, period,
             amount, explanation or None, user_id),
        )
    conn.commit()


def decide_adjustment(conn: psycopg.Connection, adjustment_id: int,
                      approve: bool, reason: str | None = None) -> None:
    with conn.cursor() as cur:
        cur.execute("SELECT app.decide_adjustment(%s, %s, %s)",
                    (adjustment_id, approve, reason))
    conn.commit()


def delete_adjustment(conn: psycopg.Connection, adjustment_id: int) -> None:
    """
    Убрать поданную запись. Согласованную не трогаем: она уже могла попасть
    в расчёт, и её судьба решается отклонением, а не удалением.
    """
    with conn.cursor() as cur:
        cur.execute(
            "DELETE FROM app.adjustment WHERE id = %s AND status IN ('draft','pending')",
            (adjustment_id,),
        )
    conn.commit()


def delete_approved_adjustment(conn: psycopg.Connection, adjustment_id: int,
                               reason: str) -> None:
    """
    Убрать согласованную доплату или вычет — только администратор и только с
    причиной (пункт 7).

    Правило целиком живёт в базе: право, причина, запрет для закрытого месяца
    и запись в журнал до удаления. Приложение сюда ничего не добавляет —
    иначе то же удаление, сделанное скриптом мимо экрана, прошло бы без следа.
    """
    with conn.cursor() as cur:
        cur.execute("SELECT app.delete_approved_adjustment(%s, %s)",
                    (adjustment_id, reason))
    conn.commit()


def fuel_rows(conn: psycopg.Connection, unit_id: int,
              period: date) -> list[dict[str, Any]]:
    """Топливо за месяц: норма из карточки и внесённый факт."""
    first, last = month_bounds(period)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT em.id AS employment_id, e.id AS employee_id, e.personnel_no,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio_short,
                   n.liters_month, n.amount_month,
                   f.liters_fact, f.cost_per_liter, f.amount_excess
            FROM app.employment em
            JOIN app.employee e ON e.id = em.employee_id
            LEFT JOIN LATERAL (
                SELECT liters_month, amount_month
                FROM app.employee_fuel_norm fn
                WHERE fn.employee_id = e.id
                  AND fn.valid_from <= %(b)s
                  AND (fn.valid_to IS NULL OR fn.valid_to > %(b)s)
                ORDER BY fn.valid_from DESC LIMIT 1
            ) n ON true
            LEFT JOIN app.fuel_compensation f
                   ON f.employee_id = e.id AND f.period_month = %(a)s
            WHERE em.org_unit_id = %(u)s
              AND em.hired_at <= %(b)s
              AND (em.terminated_at IS NULL OR em.terminated_at >= %(a)s)
              AND coalesce(n.liters_month, 0) > 0
            ORDER BY e.last_name
            """,
            {"u": unit_id, "a": first, "b": last},
        )
        return cur.fetchall()


def set_fuel(conn: psycopg.Connection, unit_id: int, period: date,
             employee_id: int, liters_fact: Decimal,
             cost_per_liter: Decimal | None) -> None:
    """
    Внести фактический расход топлива и посчитать вычет за перерасход.

    Формула действующего файла: стоимость литра берётся из отношения суммы
    компенсации к норме литров, перерасход — превышение факта над нормой.
    Деление на 1,2 в исходной формуле — это выделение стоимости без НДС;
    здесь оно вынесено в цену литра, чтобы было видно, что именно делится.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT liters_month, amount_month
            FROM app.employee_fuel_norm
            WHERE employee_id = %s AND valid_from <= %s
              AND (valid_to IS NULL OR valid_to > %s)
            ORDER BY valid_from DESC LIMIT 1
            """,
            (employee_id, period, period),
        )
        norm = cur.fetchone()
        liters_norm = dec(norm["liters_month"]) if norm else Decimal("0")
        amount_norm = dec(norm["amount_month"]) if norm else Decimal("0")

        price = dec(cost_per_liter) if cost_per_liter else (
            amount_norm / liters_norm if liters_norm else Decimal("0"))
        excess_liters = max(dec(liters_fact) - liters_norm, Decimal("0"))
        excess = excess_liters * price

        cur.execute(
            """
            INSERT INTO app.fuel_compensation
                (employee_id, org_unit_id, period_month, liters_norm, liters_fact,
                 cost_per_liter, amount_excess, amount_comp)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
            ON CONFLICT (employee_id, period_month) DO UPDATE
               SET liters_norm = excluded.liters_norm,
                   liters_fact = excluded.liters_fact,
                   cost_per_liter = excluded.cost_per_liter,
                   amount_excess = excluded.amount_excess,
                   amount_comp = excluded.amount_comp,
                   computed_at = now()
            """,
            (employee_id, unit_id, period, liters_norm, dec(liters_fact),
             price, excess, amount_norm),
        )
    conn.commit()


def fuel_totals(conn: psycopg.Connection, unit_id: int,
                period: date) -> dict[int, tuple[Decimal, Decimal]]:
    """По сотруднику: (вычет за перерасход, месячная компенсация в рублях)."""
    _, last = month_bounds(period)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT e.id AS employee_id,
                   coalesce(f.amount_excess, 0) AS excess,
                   coalesce(n.amount_month, 0)  AS comp
            FROM app.employment em
            JOIN app.employee e ON e.id = em.employee_id
            LEFT JOIN app.fuel_compensation f
                   ON f.employee_id = e.id AND f.period_month = %(a)s
            LEFT JOIN LATERAL (
                SELECT amount_month FROM app.employee_fuel_norm fn
                WHERE fn.employee_id = e.id AND fn.valid_from <= %(b)s
                  AND (fn.valid_to IS NULL OR fn.valid_to > %(b)s)
                ORDER BY fn.valid_from DESC LIMIT 1
            ) n ON true
            WHERE em.org_unit_id = %(u)s
            """,
            {"u": unit_id, "a": period, "b": last},
        )
        return {r["employee_id"]: (dec(r["excess"]), dec(r["comp"]))
                for r in cur.fetchall()}


# ---------------------------------------------------------------------------
#  Вход расчёта
# ---------------------------------------------------------------------------

def employee_inputs(conn: psycopg.Connection, unit_id: int, period: date,
                    employment_id: int | None = None) -> list[EmployeeInput]:
    """
    Собрать вход расчёта по действующим в месяце назначениям депо.

    Часы берутся из представления `v_timesheet_totals` — той же сводной
    части, что печатается в табеле. Считать их здесь заново значило бы
    завести второй источник правды по отработанному времени.

    `employment_id` сужает выборку до одного человека — так собирается
    окончательный расчёт при увольнении (пункт 27). Правила остаются те же:
    два разных ответа на вопрос «сколько человек заработал» недопустимы.
    """
    first, last = month_bounds(period)
    norm = month_norm(conn, period)
    salaries = base_salaries(conn, period)
    pieces = piecework_by_employee(conn, unit_id, period)
    adj = adjustment_totals(conn, unit_id, period)
    fuel = fuel_totals(conn, unit_id, period)

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT em.id AS employment_id, e.id AS employee_id,
                   em.position_id, p.category_id AS position_category_id,
                   pc.code AS category_code, pc.is_piecework,
                   e.personnel_no, p.name AS position_name,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio_short,
                   coalesce(t.hours_day, 0)      AS hours_day,
                   coalesce(t.hours_night, 0)    AS hours_night,
                   coalesce(t.hours_weekend, 0)  AS hours_weekend,
                   coalesce(t.hours_overtime, 0) AS hours_overtime,
                   coalesce(t.worked_days, 0)    AS worked_days
            FROM app.employment em
            JOIN app.employee e           ON e.id = em.employee_id
            JOIN app.position p           ON p.id = em.position_id
            JOIN app.position_category pc ON pc.id = p.category_id
            LEFT JOIN app.v_timesheet_totals t
                   ON t.employment_id = em.id AND t.period_month = %(a)s
            WHERE em.org_unit_id = %(u)s
              AND em.hired_at <= %(b)s
              AND (em.terminated_at IS NULL OR em.terminated_at >= %(a)s)
              AND (%(one)s::bigint IS NULL OR em.id = %(one)s)
            ORDER BY pc.sort_order, e.last_name, e.first_name
            """,
            {"u": unit_id, "a": first, "b": last, "one": employment_id},
        )
        rows = cur.fetchall()

    out: list[EmployeeInput] = []
    for r in rows:
        add, ded = adj.get(r["employee_id"], (Decimal("0"), Decimal("0")))
        excess, comp = fuel.get(r["employee_id"], (Decimal("0"), Decimal("0")))
        out.append(EmployeeInput(
            employment_id=r["employment_id"],
            employee_id=r["employee_id"],
            position_id=r["position_id"],
            position_category_id=r["position_category_id"],
            category_code=r["category_code"],
            is_piecework=r["is_piecework"],
            fio_short=r["fio_short"],
            personnel_no=r["personnel_no"],
            position_name=r["position_name"],
            base_salary=salaries.get(r["position_category_id"], Decimal("0")),
            norm_hours=norm,
            hours_day=dec(r["hours_day"]),
            hours_night=dec(r["hours_night"]),
            hours_weekend=dec(r["hours_weekend"]),
            hours_overtime=dec(r["hours_overtime"]),
            worked_days=int(r["worked_days"]),
            piecework=tuple(pieces.get(r["employee_id"], [])),
            additions=add,
            deductions=ded,
            fuel_excess=excess,
            fuel_compensation=comp,
        ))
    return out


# ---------------------------------------------------------------------------
#  Версии расчёта
# ---------------------------------------------------------------------------

def open_run(conn: psycopg.Connection, unit_id: int,
             period: date) -> dict[str, Any] | None:
    """
    Незакрытая версия расчёта месяца — черновик или подтверждённая.

    Окончательные расчёты при увольнении сюда не попадают: они по одному
    человеку и живут рядом, не мешая месячному (пункт 27).
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.*, uc.full_name AS calculated_by_name,
                   uf.full_name AS confirmed_by_name,
                   ul.full_name AS closed_by_name
            FROM app.payroll_run r
            LEFT JOIN app.app_user uc ON uc.id = r.calculated_by
            LEFT JOIN app.app_user uf ON uf.id = r.confirmed_by
            LEFT JOIN app.app_user ul ON ul.id = r.closed_by
            WHERE r.org_unit_id = %s AND r.period_month = %s
              AND r.status IN ('draft','confirmed')
              AND r.kind = 'monthly'
            """,
            (unit_id, period),
        )
        return cur.fetchone()


def latest_run(conn: psycopg.Connection, unit_id: int,
               period: date) -> dict[str, Any] | None:
    """
    Версия, которую показываем: незакрытая, а если её нет — последняя
    закрытая. Заменённые перерасчётом остаются в истории.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.*, uc.full_name AS calculated_by_name,
                   uf.full_name AS confirmed_by_name,
                   ul.full_name AS closed_by_name
            FROM app.payroll_run r
            LEFT JOIN app.app_user uc ON uc.id = r.calculated_by
            LEFT JOIN app.app_user uf ON uf.id = r.confirmed_by
            LEFT JOIN app.app_user ul ON ul.id = r.closed_by
            WHERE r.org_unit_id = %s AND r.period_month = %s
              AND r.status <> 'superseded'
              AND r.kind = 'monthly'
            ORDER BY r.version DESC
            LIMIT 1
            """,
            (unit_id, period),
        )
        return cur.fetchone()


def run_history(conn: psycopg.Connection, unit_id: int,
                period: date) -> list[dict[str, Any]]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.id, r.version, r.status, r.calculated_at, r.confirmed_at,
                   r.closed_at, r.reason,
                   uc.full_name AS calculated_by_name,
                   uf.full_name AS confirmed_by_name,
                   ul.full_name AS closed_by_name
            FROM app.payroll_run r
            LEFT JOIN app.app_user uc ON uc.id = r.calculated_by
            LEFT JOIN app.app_user uf ON uf.id = r.confirmed_by
            LEFT JOIN app.app_user ul ON ul.id = r.closed_by
            WHERE r.org_unit_id = %s AND r.period_month = %s
              AND r.kind = 'monthly'
            ORDER BY r.version DESC
            """,
            (unit_id, period),
        )
        return cur.fetchall()


def _write_lines(conn: psycopg.Connection, run_id: int,
                 result: PayrollRun) -> None:
    """
    Записать строки расчёта в версию.

    Вынесено отдельно, потому что писателей у строк двое: месячный расчёт
    депо и окончательный расчёт при увольнении (пункт 27). Две копии этой
    записи разошлись бы на первой же новой колонке.
    """
    with conn.cursor() as cur:
        for line in result.lines:
            p = line.person
            cur.execute(
                """
                INSERT INTO app.payroll_line
                    (run_id, employee_id, employment_id, position_id,
                     position_category_id, base_salary, norm_hours,
                     hours_day, hours_night, hours_weekend, hours_overtime,
                     amount_salary, amount_piecework, amount_night, amount_weekend,
                     amount_kpi, amount_additions, amount_deductions, amount_fuel,
                     net_total, gross_salary, gross_premium, gross_night,
                     gross_compensation, gross_total)
                VALUES (%s, %s, %s, %s, %s, %s, %s,
                        %s, %s, %s, %s,
                        %s, %s, %s, %s,
                        %s, %s, %s, %s,
                        %s, %s, %s, %s, %s, %s)
                RETURNING id
                """,
                (run_id, p.employee_id, p.employment_id, p.position_id,
                 p.position_category_id, p.base_salary, p.norm_hours,
                 p.hours_day, p.hours_night, p.hours_weekend, p.hours_overtime,
                 line.amount_salary, line.amount_piecework, line.amount_night,
                 line.amount_weekend_ref,
                 line.amount_kpi, line.amount_additions, line.amount_deductions,
                 line.amount_fuel, line.net_total, line.gross_salary,
                 line.gross_premium, line.gross_night, line.gross_compensation,
                 line.gross_total),
            )
            line_id = cur.fetchone()["id"]

            for k in line.kpi:
                cur.execute(
                    """
                    INSERT INTO app.payroll_line_kpi
                        (line_id, kpi_id, fact_value, scale_step_no, weight,
                         coef, fund, amount)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                    """,
                    (line_id, k.kpi_id, k.fact, k.step_no, k.weight,
                     k.coef, k.fund, k.amount),
                )
            for w in line.piecework:
                cur.execute(
                    """
                    INSERT INTO app.payroll_line_piecework
                        (line_id, operation_type_id, unit, qty, rate, amount)
                    VALUES (%s, %s, %s, %s, %s, %s)
                    """,
                    (line_id, w.operation_type_id, w.unit, w.qty, w.rate, w.amount),
                )


def save_run(conn: psycopg.Connection, unit_id: int, period: date,
             result: PayrollRun, user_id: int) -> int:
    """
    Записать расчёт в открытую версию месяца.

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

    Закрытая версия сюда не попадёт: незакрытая версия одна по частичному
    индексу, а правку закрытой запрещает триггер `payroll_closed_guard`.
    """
    run = open_run(conn, unit_id, period)
    with conn.cursor() as cur:
        if run is None:
            #  07.10.2026: открытой версии нет, но история может быть
            #  (все прежние версии замещены перерасчётами и скрыты). База
            #  требует у версий после первой причину — без неё кнопка
            #  «Рассчитать» падала с ошибкой pr_recalc_reason
            cur.execute(
                """
                SELECT coalesce(max(version), 0) + 1 AS v
                  FROM app.payroll_run
                 WHERE org_unit_id = %s AND period_month = %s
                """,
                (unit_id, period),
            )
            version = cur.fetchone()["v"]
            reason = (f"Повторный расчёт, версия {version}: открытой "
                      f"версии не осталось"
                      if version > 1 else None)
            cur.execute(
                """
                INSERT INTO app.payroll_run
                    (org_unit_id, period_month, version, status,
                     calculated_by, reason)
                VALUES (%s, %s, %s, 'draft', %s, %s)
                RETURNING id
                """,
                (unit_id, period, version, user_id, reason),
            )
            run_id = cur.fetchone()["id"]
        else:
            run_id = run["id"]
            if run["status"] != "draft":
                raise ValueError(
                    "Расчёт уже подтверждён депо. Чтобы пересчитать, верните "
                    "его в черновик или оформите перерасчёт новой версией."
                )
            cur.execute(
                """
                UPDATE app.payroll_run
                   SET calculated_at = now(), calculated_by = %s,
                       stale_since = NULL, stale_reason = NULL
                 WHERE id = %s
                """,
                (user_id, run_id),
            )
            cur.execute("DELETE FROM app.payroll_line WHERE run_id = %s", (run_id,))

        #  Строки пишет общая функция: тем же кодом пишется окончательный
        #  расчёт при увольнении. Свой курсор внутри — так и задумано,
        #  вложенные курсоры одного соединения работают
        _write_lines(conn, run_id, result)

        cur.execute(
            """
            INSERT INTO app.operation_log
                (user_id, operation, org_unit_id, period_month, status, message)
            VALUES (%s, 'payroll_calc', %s, %s, 'ok', %s)
            """,
            (user_id, unit_id, period,
             f"Расчёт выполнен, строк: {len(result.lines)}"),
        )
    conn.commit()
    return run_id


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

def final_blockers(conn: psycopg.Connection, unit_id: int, period: date,
                   employment_id: int) -> list[str]:
    """
    Чего не хватает для окончательного расчёта.

    Список короче, чем у месячного: показатели депо за незакрытый месяц ещё
    не выставлены, и требовать их от увольняющегося значило бы держать
    человека без расчёта до конца месяца. Премия по показателям в таком
    случае просто не начислится, и об этом сказано прямо.
    """
    out: list[str] = []
    if not month_norm(conn, period):
        out.append("не задана норма рабочего времени месяца "
                   "(«Базовые настройки» → «Норма рабочего времени»)")
    if not base_salaries(conn, period):
        out.append("не заданы оклады категорий должностей "
                   "(«Базовые настройки» → «Оклады»)")

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT em.terminated_at, em.org_unit_id,
                   coalesce(t.worked_days, 0) AS worked_days
            FROM app.employment em
            LEFT JOIN app.v_timesheet_totals t
                   ON t.employment_id = em.id AND t.period_month = %s
            WHERE em.id = %s
            """,
            (period, employment_id),
        )
        row = cur.fetchone()
    if row is None:
        out.append("назначение не найдено")
        return out
    if row["org_unit_id"] != unit_id:
        out.append("сотрудник числится в другом депо")
    if not row["worked_days"]:
        out.append("в табеле за этот месяц нет ни одного отработанного дня — "
                   "внесите часы до дня увольнения")
    return out


def final_preview(conn: psycopg.Connection, unit_id: int, period: date,
                  employment_id: int) -> dict[str, Any]:
    """
    Посчитать окончательный расчёт, ничего не записывая.

    Смотреть до записи здесь важнее, чем в месячном: расчёт делается один раз
    и сразу идёт на выплату, а исходные данные — часы, операции, вычеты —
    вносят в тот же день.
    """
    people = employee_inputs(conn, unit_id, period, employment_id)
    if not people:
        raise PayrollError("Сотрудник не найден в этом месяце")
    kpis = kpi_inputs(conn, unit_id, period)
    prm = params(conn, period)
    #  Считаем ровно тем же вызовом, что и запись: предпросмотр, который
    #  показывает не ту сумму, которая запишется, хуже, чем никакого
    run = calculate_run(people, kpis, prm)
    return {"person": people[0], "line": run.lines[0], "kpis": kpis}


def save_final_run(conn: psycopg.Connection, unit_id: int, period: date,
                   employment_id: int, result: PayrollRun,
                   user_id: int) -> int:
    """
    Записать окончательный расчёт отдельной версией.

    Месячному расчёту депо он не мешает: у них разный вид, и незакрытая
    версия считается по виду отдельно. Повторный расчёт до подтверждения
    переписывает свой черновик целиком — как и месячный.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, status FROM app.payroll_run
             WHERE employment_id = %s AND period_month = %s
               AND kind = 'final' AND status IN ('draft', 'confirmed')
            """,
            (employment_id, period),
        )
        run = cur.fetchone()
        if run and run["status"] != "draft":
            raise PayrollError(
                "Окончательный расчёт уже подтверждён. Чтобы пересчитать, "
                "верните его в черновик")

        if run is None:
            #  Повторное увольнение (24.09.2026): прежний окончательный
            #  расчёт при отмене увольнения помечен «заменён», и новый идёт
            #  второй версией. База требует у второй и следующих версий
            #  причину — без неё запись падала с ошибкой pr_recalc_reason
            cur.execute(
                """
                SELECT max(version) AS v,
                       (array_agg(id ORDER BY version DESC))[1] AS last_id
                  FROM app.payroll_run
                 WHERE employment_id = %s AND period_month = %s AND kind = 'final'
                """,
                (employment_id, period),
            )
            prev = cur.fetchone()
            version = (prev["v"] or 0) + 1
            reason = None
            if version > 1:
                reason = ("Повторный окончательный расчёт: прежний отменён "
                          "вместе с увольнением")
            cur.execute(
                """
                INSERT INTO app.payroll_run
                    (org_unit_id, period_month, kind, employment_id,
                     version, status, calculated_by, reason, supersedes_id)
                VALUES (%s, %s, 'final', %s, %s, 'draft', %s, %s, %s)
                RETURNING id
                """,
                (unit_id, period, employment_id, version, user_id, reason,
                 prev["last_id"] if version > 1 else None),
            )
            run_id = cur.fetchone()["id"]
        else:
            run_id = run["id"]
            cur.execute("DELETE FROM app.payroll_line WHERE run_id = %s", (run_id,))
            cur.execute(
                "UPDATE app.payroll_run SET calculated_at = now(), "
                "calculated_by = %s, stale_since = NULL, stale_reason = NULL "
                "WHERE id = %s",
                (user_id, run_id),
            )

    _write_lines(conn, run_id, result)
    conn.commit()
    return run_id


def final_run(conn: psycopg.Connection, employment_id: int,
              period: date) -> dict[str, Any] | None:
    """Действующий окончательный расчёт человека за месяц, если он есть."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT r.*, uc.full_name AS calculated_by_name,
                   uf.full_name AS confirmed_by_name,
                   ul.full_name AS closed_by_name
            FROM app.payroll_run r
            LEFT JOIN app.app_user uc ON uc.id = r.calculated_by
            LEFT JOIN app.app_user uf ON uf.id = r.confirmed_by
            LEFT JOIN app.app_user ul ON ul.id = r.closed_by
            WHERE r.employment_id = %s AND r.period_month = %s
              AND r.kind = 'final' AND r.status <> 'superseded'
            ORDER BY r.version DESC LIMIT 1
            """,
            (employment_id, period),
        )
        return cur.fetchone()


def run_lines(conn: psycopg.Connection, run_id: int) -> list[dict[str, Any]]:
    """Сохранённые строки расчёта — то, что показывает экран."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT l.*, e.personnel_no,
                   e.last_name || ' ' || left(e.first_name, 1) || '.' ||
                       coalesce(left(e.middle_name, 1) || '.', '') AS fio_short,
                   --  Во вкладке расчёта ФИО пишется полностью, а табельный
                   --  и должность идут своими столбцами (пункт 6): по этой
                   --  таблице сверяются с расчётным листком, и «Иванов И.И.»
                   --  там не годится
                   e.last_name || ' ' || e.first_name ||
                       coalesce(' ' || e.middle_name, '') AS fio_full,
                   p.name AS position_name, pc.code AS category_code,
                   pc.is_piecework, pc.sort_order,
                   CASE WHEN l.hours_day + l.hours_night > 0
                        THEN round(l.amount_piecework / (l.hours_day + l.hours_night), 4)
                   END AS productivity,
                   CASE WHEN l.norm_hours > 0
                        THEN round(l.base_salary / l.norm_hours, 4)
                   END AS hour_rate
            FROM app.payroll_line l
            JOIN app.employee e           ON e.id = l.employee_id
            JOIN app.position p           ON p.id = l.position_id
            JOIN app.position_category pc ON pc.id = l.position_category_id
            WHERE l.run_id = %s
            ORDER BY pc.sort_order, e.last_name
            """,
            (run_id,),
        )
        return cur.fetchall()


def run_kpi(conn: psycopg.Connection, run_id: int) -> dict[int, list[dict[str, Any]]]:
    """Расшифровка премий по строкам расчёта."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT lk.line_id, lk.kpi_id, lk.fact_value, lk.scale_step_no,
                   lk.weight, lk.coef, lk.fund, lk.amount, k.code, k.name
            FROM app.payroll_line_kpi lk
            JOIN app.payroll_line l ON l.id = lk.line_id
            JOIN app.kpi k          ON k.id = lk.kpi_id
            WHERE l.run_id = %s
            ORDER BY k.id
            """,
            (run_id,),
        )
        out: dict[int, list[dict[str, Any]]] = {}
        for r in cur.fetchall():
            out.setdefault(r["line_id"], []).append(r)
        return out


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


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


def supersede_run(conn: psycopg.Connection, run_id: int, reason: str) -> int:
    with conn.cursor() as cur:
        cur.execute("SELECT app.supersede_payroll_run(%s, %s) AS v",
                    (run_id, reason))
        version = cur.fetchone()["v"]
    conn.commit()
    return int(version)


def reopen_run(conn: psycopg.Connection, run_id: int) -> None:
    """
    Вернуть подтверждённый расчёт в черновик — чтобы пересчитать до закрытия.

    Отдельной функции в базе для этого нет намеренно: правка идёт по тем же
    политикам RLS, что и остальная работа с расчётом, а закрытую версию
    вернуть всё равно не даст триггер.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            UPDATE app.payroll_run
               SET status = 'draft', confirmed_by = NULL, confirmed_at = NULL
             WHERE id = %s AND status = 'confirmed'
            """,
            (run_id,),
        )
    conn.commit()


# ---------------------------------------------------------------------------
#  Расчётные показатели депо
# ---------------------------------------------------------------------------

#  Из чего складывается начисление. Порядок и названия — те же, что в
#  колонках таблицы расчёта: метрики не должны заводить свой словарь.
ACCRUAL_PARTS = (
    ("amount_salary", "Оклад за отработанные часы"),
    ("amount_piecework", "Сделка по операциям"),
    ("amount_kpi", "Премия по показателям"),
    ("amount_night", "Доплата за ночные"),
    #  Работа в выходной в базе своей суммой лежит, а сверхурочные — нет:
    #  они считаются справочно от стоимости часа и в строке расчёта не
    #  хранятся. Выдумывать им колонку в метриках незачем
    ("amount_weekend", "Работа в выходной"),
    ("amount_additions", "Согласованные доплаты"),
    ("amount_deductions", "Согласованные вычеты"),
    ("amount_fuel", "Вычет за перерасход топлива"),
)


#  Расчёт считается финальным, когда его подтвердило депо. Черновик
#  листком не оформляем: он ещё пересчитается, а на руках у человека
#  останется бумага с другой суммой.
FINAL_RUN_STATUSES = ("confirmed", "closed")


def payslips_of(conn: psycopg.Connection, employee_id: int) -> list[dict[str, Any]]:
    """
    Расчётные листки человека — история, к которой можно вернуться (пункт 26).

    Только подтверждённые и закрытые расчёты: черновик ещё пересчитается.
    Заменённые версии не показываем вовсе — сумма в них уже неверна.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT l.id AS line_id, r.period_month, r.status, r.version,
                   r.confirmed_at, r.closed_at,
                   l.net_total, l.gross_total,
                   ou.name AS unit_name
            FROM app.payroll_line l
            JOIN app.payroll_run r  ON r.id = l.run_id
            JOIN app.org_unit ou    ON ou.id = r.org_unit_id
            WHERE l.employee_id = %s
              AND r.status = ANY(%s)
            ORDER BY r.period_month DESC, r.version DESC
            """,
            (employee_id, list(FINAL_RUN_STATUSES)),
        )
        return cur.fetchall()


def payslip(conn: psycopg.Connection, line_id: int) -> dict[str, Any] | None:
    """
    Один расчётный листок: строка расчёта, её показатели и сделка по операциям.

    Собирается из сохранённого расчёта, а не пересчитывается заново: листок —
    документ о том, что было начислено, и меняться задним числом он не должен.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT l.*, r.period_month, r.status AS run_status, r.version,
                   r.calculated_at, r.confirmed_at, r.closed_at,
                   ou.name AS unit_name, ou.code AS unit_code,
                   e.personnel_no, e.id AS employee_id,
                   e.last_name || ' ' || e.first_name ||
                       coalesce(' ' || e.middle_name, '') AS fio_full,
                   p.name AS position_name, pc.name AS category_name,
                   em.id AS employment_id,
                   CASE WHEN l.norm_hours > 0
                        THEN round(l.base_salary / l.norm_hours, 4)
                   END AS hour_rate
            FROM app.payroll_line l
            JOIN app.payroll_run r        ON r.id = l.run_id
            JOIN app.org_unit ou          ON ou.id = r.org_unit_id
            JOIN app.employee e           ON e.id = l.employee_id
            JOIN app.position p           ON p.id = l.position_id
            JOIN app.position_category pc ON pc.id = l.position_category_id
            JOIN app.employment em        ON em.id = l.employment_id
            WHERE l.id = %s
            """,
            (line_id,),
        )
        row = cur.fetchone()
        if not row:
            return None

        cur.execute(
            """
            SELECT k.name, lk.fact_value, lk.scale_step_no, lk.weight,
                   lk.coef, lk.fund, lk.amount
            FROM app.payroll_line_kpi lk
            JOIN app.kpi k ON k.id = lk.kpi_id
            WHERE lk.line_id = %s
            ORDER BY k.name
            """,
            (line_id,),
        )
        row["kpi"] = cur.fetchall()

        cur.execute(
            """
            SELECT ot.name, lp.unit, lp.qty, lp.rate, lp.amount
            FROM app.payroll_line_piecework lp
            JOIN app.operation_type ot ON ot.id = lp.operation_type_id
            WHERE lp.line_id = %s
            ORDER BY ot.name, lp.unit
            """,
            (line_id,),
        )
        row["piecework"] = cur.fetchall()
    return row


def accrual_metrics(conn: psycopg.Connection, unit_ids: list[int],
                    period: date) -> dict[str, Any]:
    """
    Итоги расчётного периода — вкладка «Метрики начисления» (пункт 10).

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

    Берётся последний незаменённый расчёт депо — тот же, что показывает
    таблица. Замененные версии в итоги не идут: иначе месяц, пересчитанный
    трижды, был бы начислен трижды.
    """
    def totals_for(months: date) -> dict[str, Any]:
        if not unit_ids:
            return {"parts": {}, "net": Decimal("0"), "gross": Decimal("0"),
                    "people": 0, "hours": Decimal("0")}
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT coalesce(sum(l.amount_salary), 0)     AS amount_salary,
                       coalesce(sum(l.amount_piecework), 0)  AS amount_piecework,
                       coalesce(sum(l.amount_kpi), 0)        AS amount_kpi,
                       coalesce(sum(l.amount_night), 0)      AS amount_night,
                       coalesce(sum(l.amount_weekend), 0)    AS amount_weekend,
                       coalesce(sum(l.amount_additions), 0)  AS amount_additions,
                       coalesce(sum(l.amount_deductions), 0) AS amount_deductions,
                       coalesce(sum(l.amount_fuel), 0)       AS amount_fuel,
                       coalesce(sum(l.net_total), 0)         AS net,
                       coalesce(sum(l.gross_total), 0)       AS gross,
                       coalesce(sum(l.hours_day + l.hours_night), 0) AS hours,
                       count(*) AS people
                FROM app.payroll_line l
                JOIN app.payroll_run r ON r.id = l.run_id
                WHERE r.org_unit_id = ANY(%s) AND r.period_month = %s
                  AND r.status <> 'superseded'
                """,
                (unit_ids, months),
            )
            row = cur.fetchone()
        return {
            "parts": {code: dec(row[code]) for code, _ in ACCRUAL_PARTS},
            "net": dec(row["net"]),
            "gross": dec(row["gross"]),
            "hours": dec(row["hours"]),
            "people": int(row["people"]),
        }

    now = totals_for(period)
    prev_month = (period.replace(day=1) - timedelta(days=1)).replace(day=1)
    was = totals_for(prev_month)

    #  По категориям должностей: «средняя по должности» — то, что смотрят
    #  первым делом, и считать её в уме по таблице расчёта неудобно
    by_category: list[dict[str, Any]] = []
    if unit_ids:
        with conn.cursor() as cur:
            cur.execute(
                """
                SELECT pc.name, pc.sort_order,
                       count(*) AS people,
                       coalesce(sum(l.net_total), 0) AS net,
                       coalesce(sum(l.hours_day + l.hours_night), 0) AS hours
                FROM app.payroll_line l
                JOIN app.payroll_run r        ON r.id = l.run_id
                JOIN app.position_category pc ON pc.id = l.position_category_id
                WHERE r.org_unit_id = ANY(%s) AND r.period_month = %s
                  AND r.status <> 'superseded'
                GROUP BY pc.name, pc.sort_order
                ORDER BY pc.sort_order
                """,
                (unit_ids, period),
            )
            for r in cur.fetchall():
                people = int(r["people"])
                by_category.append({
                    "name": r["name"],
                    "people": people,
                    "net": dec(r["net"]),
                    "hours": dec(r["hours"]),
                    "average": (dec(r["net"]) / people) if people else Decimal("0"),
                })

    parts = []
    for code, name in ACCRUAL_PARTS:
        value = now["parts"][code]
        before = was["parts"].get(code, Decimal("0"))
        parts.append({
            "code": code, "name": name, "amount": value, "was": before,
            "delta": value - before,
            #  Доля считается от начислений, а не от итога: вычет с итогом
            #  сравнивать нечего, он его уменьшает
            "share": (value / now["net"] * 100) if now["net"] else None,
        })

    return {
        "period": period,
        "prev_period": prev_month,
        "parts": parts,
        "net": now["net"],
        "gross": now["gross"],
        "hours": now["hours"],
        "people": now["people"],
        "average": (now["net"] / now["people"]) if now["people"] else Decimal("0"),
        "per_hour": (now["net"] / now["hours"]) if now["hours"] else Decimal("0"),
        "was_net": was["net"],
        "was_people": was["people"],
        "delta_net": now["net"] - was["net"],
        "delta_people": now["people"] - was["people"],
        "by_category": by_category,
    }


def indicators(conn: psycopg.Connection, unit_id: int,
               period: date) -> dict[str, Any]:
    """
    Показатели депо за месяц, которые считаются из данных системы.

    В центральном файле это лист «Показатели»: там каждая колонка — формула
    `MAP` на весь лист, тянущая из архива ЗП, отчёта УТ и листа численности.
    Здесь считается из своих таблиц; числа хранятся числами, а не строками
    вида «12 / 16 (75,00%)», из которых другая формула достаёт штат
    регуляркой.
    """
    first, last = month_bounds(period)
    out: dict[str, Any] = {}

    with conn.cursor() as cur:
        #  Отработанное время и сверхурочка по категориям
        cur.execute(
            """
            SELECT pc.code, pc.name, pc.sort_order,
                   count(*)                          AS people,
                   --  Факт на конец месяца: с ним сравнивается плановая
                   --  численность. Работавшие в течение месяца и работающие
                   --  на последнее число — разные числа, и укомплектованность
                   --  считают по второму: принятый и уволенный в одном месяце
                   --  иначе давал бы полторы ставки
                   count(*) FILTER (
                       WHERE em.terminated_at IS NULL OR em.terminated_at >= %(b)s
                   )                                 AS people_end,
                   coalesce(sum(t.hours_total), 0)   AS hours,
                   coalesce(sum(t.hours_night), 0)   AS hours_night,
                   coalesce(sum(t.hours_overtime), 0) AS hours_overtime,
                   coalesce(sum(t.hours_weekend), 0)  AS hours_weekend
            FROM app.employment em
            JOIN app.position p           ON p.id = em.position_id
            JOIN app.position_category pc ON pc.id = p.category_id
            LEFT JOIN app.v_timesheet_totals t
                   ON t.employment_id = em.id AND t.period_month = %(a)s
            WHERE em.org_unit_id = %(u)s
              AND em.hired_at <= %(b)s
              AND (em.terminated_at IS NULL OR em.terminated_at >= %(a)s)
            GROUP BY pc.code, pc.name, pc.sort_order
            ORDER BY pc.sort_order
            """,
            {"u": unit_id, "a": first, "b": last},
        )
        by_category = cur.fetchall()

        #  Плановая численность — управленческая, из действующего плана на
        #  год («Базовые настройки» → «Бюджет» → «План на год»).
        #
        #  Читалось это из `headcount_plan` — таблицы, в которую ничего не
        #  пишет ни один экран: заведённая в плане численность на показателях
        #  не появлялась, и страница честно сообщала «план не заведён».
        #  Две таблицы про одно и то же; осталась та, которую заполняют.
        cur.execute(
            """
            SELECT l.line_code AS code, l.headcount_managerial AS headcount
            FROM app.budget_plan_line l
            JOIN app.budget_plan bp ON bp.id = l.plan_id
            WHERE bp.status = 'current'
              AND l.org_unit_id = %s AND l.period_month = %s
              AND l.headcount_managerial IS NOT NULL
            """,
            (unit_id, first),
        )
        plan = {r["code"]: dec(r["headcount"]) for r in cur.fetchall()}

        #  Уволенные за месяц — для текучести
        cur.execute(
            """
            SELECT count(*) AS n
            FROM app.employment
            WHERE org_unit_id = %s AND terminated_at BETWEEN %s AND %s
            """,
            (unit_id, first, last),
        )
        left_month = int(cur.fetchone()["n"])

        #  Фонд оплаты труда по последнему незаменённому расчёту месяца
        cur.execute(
            """
            SELECT coalesce(sum(l.net_total), 0)        AS fot,
                   coalesce(sum(l.amount_piecework), 0) AS piecework,
                   count(*)                             AS lines
            FROM app.payroll_line l
            JOIN app.payroll_run r ON r.id = l.run_id
            WHERE r.org_unit_id = %s AND r.period_month = %s
              AND r.status <> 'superseded'
            """,
            (unit_id, first),
        )
        money_row = cur.fetchone()

        #  Операции по активной загрузке: свои и чужие
        cur.execute(
            """
            SELECT f.is_own, coalesce(sum(f.qty), 0) AS qty
            FROM app.operation_fact f
            JOIN app.operation_load l ON l.id = f.load_id AND l.status = 'active'
            WHERE f.org_unit_id = %s AND f.work_date BETWEEN %s AND %s
            GROUP BY f.is_own
            """,
            (unit_id, first, last),
        )
        ops = {bool(r["is_own"]): dec(r["qty"]) for r in cur.fetchall()}

    norm = month_norm(conn, period)
    staff_total = sum(int(r["people"]) for r in by_category)

    rows = []
    for r in by_category:
        planned = plan.get(r["code"])
        rows.append({
            "code": r["code"],
            "name": r["name"],
            "people": int(r["people"]),
            "people_end": int(r["people_end"]),
            "plan": planned,
            "hours": dec(r["hours"]),
            "hours_night": dec(r["hours_night"]),
            "hours_overtime": dec(r["hours_overtime"]),
            "hours_weekend": dec(r["hours_weekend"]),
            "plan_hours": (planned * norm) if planned is not None else None,
        })

    out["by_category"] = rows
    out["norm_hours"] = norm
    out["hours_fact"] = sum((r["hours"] for r in rows), Decimal("0"))
    out["hours_plan"] = sum(
        (r["plan_hours"] for r in rows if r["plan_hours"] is not None), Decimal("0")
    ) or None
    out["fot"] = dec(money_row["fot"])
    out["piecework"] = dec(money_row["piecework"])
    out["payroll_lines"] = int(money_row["lines"])
    out["operations_own"] = ops.get(True, Decimal("0"))
    out["operations_other"] = ops.get(False, Decimal("0"))
    out["left_month"] = left_month
    out["staff_total"] = staff_total
    out["staff_end"] = sum(r["people_end"] for r in rows)

    #  Укомплектованность — решение заказчика от 15.09.2026: «считаем общую,
    #  то есть сравниваем факт на конец месяца с управленческой численностью,
    #  и укомплектованность кладовщиков — факт на конец месяца и
    #  управленческая численность».
    #
    #  Две цифры, а не столбец по каждой категории: начальник депо один, и
    #  строка «100 %» или «0 %» против него ничего не сообщает. Смысл несут
    #  укомплектованность депо целиком и укомплектованность кладовщиков — тех,
    #  кем депо работает.
    def staffing(fact, planned):
        if not planned:
            return None
        return (Decimal(fact) / planned * 100).quantize(Decimal("0.1"))

    plan_total = sum(plan.values()) if plan else Decimal("0")
    keeper = next((r for r in rows if r["code"] == "storekeeper"), None)
    out["plan_total"] = plan_total or None
    out["staffing"] = staffing(out["staff_end"], plan_total)
    out["staffing_keepers"] = staffing(
        keeper["people_end"], keeper["plan"]) if keeper else None
    out["keepers_end"] = keeper["people_end"] if keeper else None
    out["keepers_plan"] = keeper["plan"] if keeper else None
    #  Текучесть депо — по той же формуле, что в центральном файле:
    #  уволенные за месяц к сумме уволенных и работающих на конец месяца.
    #  В премию идёт не она, а текучесть по отделу целиком: так устроена
    #  действующая методика, и признак области стоит у самого показателя.
    base = left_month + staff_total
    out["turnover"] = (Decimal(left_month) / base * 100).quantize(Decimal("0.01")) \
        if base else None
    return out
