"""
Бюджетные данные: численность и ФОТ — пункт 1 плана от 14.09.2026.

Собирает то, ради чего вкладка и заводилась: «не вышли ли мы за предел
бюджета». В одной таблице сходятся три числа, которые до сих пор жили в
разных местах:

* **бюджетная численность** — из согласованного бюджета года;
* **управленческая численность** — план, по которому работают. Заказчик
  прямо сказал: она **не равна** бюджетной, потому что при недостатке работы
  численность занижают искусственно. Поэтому оба числа стоят рядом, а
  отклонение считается к обоим;
* **факт** — люди, которые в этом месяце действительно числились, и деньги,
  которые им действительно начислены.

Деньги факта берутся из последнего незаменённого расчёта месяца — того же,
что показывает вкладка «Расчёт ЗП». Черновик в сравнение идёт: пока месяц
не закрыт, это единственное, что есть, и увидеть перерасход лучше до
закрытия, чем после.
"""

from __future__ import annotations

from datetime import date
from decimal import Decimal
from typing import Any, Sequence

import psycopg

#  Служебная строка бюджета: резерв на отпускные. Не люди, но деньги
VACATION_CODE = "vacation"


def dec(value: Any) -> Decimal:
    return Decimal(str(value or 0))


from .rules import month_bounds   # границы месяца одни на весь пакет


def has_budget(conn: psycopg.Connection) -> bool:
    """Накатана ли миграция 30. Без неё вкладка открывается пустой, а не 500."""
    with conn.cursor() as cur:
        cur.execute("SELECT to_regclass('app.budget_fot') IS NOT NULL AS ok")
        return bool(cur.fetchone()["ok"])


def categories(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """Категории должностей — они же колонки таблицы бюджета."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, code, name FROM app.position_category
            ORDER BY sort_order
            """
        )
        return cur.fetchall()


def budget_months(conn: psycopg.Connection) -> list[date]:
    """Месяцы, на которые бюджет загружен, — для подсказки «что есть»."""
    if not has_budget(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            "SELECT DISTINCT period_month FROM app.budget_fot ORDER BY period_month"
        )
        return [r["period_month"] for r in cur.fetchall()]


def matrix(conn: psycopg.Connection, period: date) -> dict[str, Any]:
    """
    Таблица «депо × должность» за месяц: города слева, должности сверху.

    В клетке три численности — бюджет, управленческий план и факт, — а
    справа деньги: бюджет ФОТ, начислено и отклонение. Так и просили: видеть
    в одном месте, не вышли ли за предел.
    """
    first, last = month_bounds(period)
    cats = categories(conn)
    budget_on = has_budget(conn)

    with conn.cursor() as cur:
        cur.execute(
            """
            --  Только депо: администрация в Минске отложена решением от
            --  14.09.2026, её бюджет пока не ведём
            SELECT id, code, name FROM app.org_unit
            WHERE kind = 'rc' AND is_active AND app.has_unit_access(id)
            ORDER BY name
            """
        )
        units = cur.fetchall()

        #  Бюджет читается из годового плана — он единственный источник с
        #  15.09.2026. Сумма считается здесь, а не хранится: правило простое
        #  («численность × уровень дохода»), и хранить произведение значило бы
        #  однажды показать сумму, не отвечающую своим же множителям
        budget: dict[tuple[int, str], dict[str, Any]] = {}
        managerial: dict[tuple[int, str], Decimal] = {}
        if budget_on and has_plan(conn):
            cur.execute(
                """
                SELECT l.org_unit_id, l.line_code,
                       l.headcount_budget AS headcount,
                       l.headcount_managerial,
                       l.income_level,
                       l.headcount_budget * l.income_level
                           + l.amount_extra AS amount
                FROM app.budget_plan_line l
                JOIN app.budget_plan p ON p.id = l.plan_id AND p.status = 'current'
                WHERE l.period_month = %s
                """,
                (first,),
            )
            for r in cur.fetchall():
                budget[(r["org_unit_id"], r["line_code"])] = r
                if r["headcount_managerial"] is not None:
                    managerial[(r["org_unit_id"], r["line_code"])] =                         dec(r["headcount_managerial"])

        #  Факт по людям: кто числился в этом месяце хоть один день
        cur.execute(
            """
            SELECT em.org_unit_id, pc.code, count(*) AS people
            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
            WHERE em.hired_at <= %(last)s
              AND (em.terminated_at IS NULL OR em.terminated_at >= %(first)s)
            GROUP BY em.org_unit_id, pc.code
            """,
            {"first": first, "last": last},
        )
        fact_people = {(r["org_unit_id"], r["code"]): dec(r["people"])
                       for r in cur.fetchall()}

        #  Факт по деньгам: последний незаменённый расчёт месяца
        cur.execute(
            """
            SELECT r.org_unit_id, coalesce(sum(l.net_total), 0) AS net
            FROM app.payroll_line l
            JOIN app.payroll_run r ON r.id = l.run_id
            WHERE r.period_month = %s AND r.status <> 'superseded'
            GROUP BY r.org_unit_id
            """,
            (first,),
        )
        fact_money = {r["org_unit_id"]: dec(r["net"]) for r in cur.fetchall()}

    rows = []
    for unit in units:
        cells = []
        for cat in cats:
            line = budget.get((unit["id"], cat["code"]))
            cells.append({
                "code": cat["code"],
                "budget": dec(line["headcount"]) if line else None,
                "managerial": managerial.get((unit["id"], cat["code"])),
                "fact": fact_people.get((unit["id"], cat["code"]), Decimal("0")),
                "amount": dec(line["amount"]) if line else None,
                #  Из чего сложилась сумма: план хранит множители, а не
                #  готовое число, и подсказка отвечает «почему столько»
                "source": (f"{dec(line['headcount'])} × {dec(line['income_level'])}"
                           if line and line.get("income_level") is not None
                           else None),
            })

        vacation = budget.get((unit["id"], VACATION_CODE))
        #  Резерв на отпускные — деньги бюджета, но не люди. Отдельной
        #  колонкой, чтобы не путался с численностью
        vacation_amount = dec(vacation["amount"]) if vacation else None

        #  Всё, что не легло ни в одну из четырёх категорий депо и не
        #  отпускные: в бюджете сектора управления это ведущие специалисты.
        #  Своей колонки у них нет, но их деньги и люди — часть бюджета, и
        #  потерять их нельзя: без этой строки итог расходился с файлом
        other_amount = Decimal("0")
        other_people = Decimal("0")
        other_names: list[str] = []
        known = {c["code"] for c in cats} | {VACATION_CODE}
        for (bud_unit, code), line in budget.items():
            if bud_unit != unit["id"] or code in known:
                continue
            other_amount += dec(line["amount"])
            other_people += dec(line["headcount"])
            other_names.append(code)

        budget_total = sum((c["amount"] for c in cells if c["amount"] is not None),
                           Decimal("0"))
        if vacation_amount:
            budget_total += vacation_amount
        budget_total += other_amount
        fact_total = fact_money.get(unit["id"], Decimal("0"))

        rows.append({
            "unit": unit,
            "cells": cells,
            "vacation": vacation_amount,
            "other_amount": other_amount or None,
            "other_people": other_people,
            "other_names": ", ".join(other_names),
            "budget_people": sum((c["budget"] for c in cells
                                  if c["budget"] is not None),
                                 Decimal("0")) + other_people,
            "managerial_people": sum((c["managerial"] for c in cells
                                      if c["managerial"] is not None), Decimal("0")),
            "fact_people": sum((c["fact"] for c in cells), Decimal("0")),
            "budget_amount": budget_total,
            "fact_amount": fact_total,
            #  Отклонение: плюс — перерасход, минус — экономия. Считается
            #  только когда бюджет на месяц загружен: «минус весь ФОТ» вместо
            #  «бюджета нет» читалось бы как экономия
            "delta": (fact_total - budget_total) if budget_total else None,
        })

    def column(key: str) -> Decimal:
        return sum((r[key] for r in rows if r[key] is not None), Decimal("0"))

    #  Итог по каждой должности — отдельной строкой внизу таблицы. Считать
    #  это в шаблоне циклами по клеткам получалось нечитаемо
    by_category = []
    for i, cat in enumerate(cats):
        by_category.append({
            "code": cat["code"],
            "budget": sum((r["cells"][i]["budget"] for r in rows
                           if r["cells"][i]["budget"] is not None), Decimal("0")),
            "managerial": sum((r["cells"][i]["managerial"] for r in rows
                               if r["cells"][i]["managerial"] is not None),
                              Decimal("0")),
            "fact": sum((r["cells"][i]["fact"] for r in rows), Decimal("0")),
        })
    #  Прочие строки бюджета — тем же списком, чтобы итог сходился с файлом
    by_category.append({
        "code": "other",
        "budget": sum((r["other_people"] for r in rows), Decimal("0")),
        "managerial": Decimal("0"),
        "fact": Decimal("0"),
    })

    totals = {
        "by_category": by_category,
        "budget_people": column("budget_people"),
        "managerial_people": column("managerial_people"),
        "fact_people": column("fact_people"),
        "budget_amount": column("budget_amount"),
        "fact_amount": column("fact_amount"),
    }
    totals["delta"] = (totals["fact_amount"] - totals["budget_amount"]
                       if totals["budget_amount"] else None)

    #  Колонка «Прочие» показывается, только если в ней что-то есть. Сейчас
    #  таких строк нет — они были у сектора управления, а он отложен, — но
    #  сам механизм остаётся: без него деньги строки вне четырёх категорий
    #  снова исчезали бы из итога молча
    has_other = any(r["other_amount"] or r["other_people"] for r in rows)

    return {
        "categories": cats,
        "has_other": has_other,
        "rows": rows,
        "totals": totals,
        "loaded": budget_on and bool(budget),
        "budget_on": budget_on,
    }


# ---------------------------------------------------------------------------
#  Годовой план бюджета — уточнение по блоку D от 15.09.2026
#
#  Правило счёта, названное заказчиком:
#      плановый ФОТ = бюджетная численность × уровень дохода
#  Плюс отдельная строка «vacation» — резерв на отпускные, он от численности
#  не считается.
#
#  Перезапись создаёт новую версию, прежняя остаётся историей: план согласуют,
#  потом пересогласовывают, и вопрос «что было в прошлой редакции» возникает
#  всегда.
# ---------------------------------------------------------------------------

VACATION_CODE = "vacation"


def has_plan(conn: psycopg.Connection) -> bool:
    """Накатана ли миграция 39. Без неё страница открывается, а не падает."""
    with conn.cursor() as cur:
        cur.execute("SELECT to_regclass('app.budget_plan') IS NOT NULL AS ok")
        return bool(cur.fetchone()["ok"])


def plan_years(conn: psycopg.Connection) -> list[dict[str, Any]]:
    """Годы, на которые план заводили, — с номером действующей редакции."""
    if not has_plan(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT p.year,
                   max(p.version) FILTER (WHERE p.status = 'current') AS version,
                   count(*) AS versions,
                   max(p.created_at) AS changed_at
            FROM app.budget_plan p
            GROUP BY p.year ORDER BY p.year DESC
            """
        )
        return cur.fetchall()


def plan_versions(conn: psycopg.Connection, year: int) -> list[dict[str, Any]]:
    """История редакций года — от свежей к старой."""
    if not has_plan(conn):
        return []
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT p.id, p.year, p.version, p.note, p.status, p.created_at,
                   u.full_name AS created_by_name,
                   (SELECT count(*) FROM app.budget_plan_line l
                     WHERE l.plan_id = p.id) AS lines,
                   (SELECT coalesce(sum(l.headcount_budget * l.income_level
                                        + l.amount_extra), 0)
                      FROM app.budget_plan_line l WHERE l.plan_id = p.id) AS amount
            FROM app.budget_plan p
            LEFT JOIN app.app_user u ON u.id = p.created_by
            WHERE p.year = %s
            ORDER BY p.version DESC
            """,
            (year,),
        )
        return cur.fetchall()


def current_plan(conn: psycopg.Connection, year: int) -> dict[str, Any] | None:
    """Действующая редакция года, если она есть."""
    if not has_plan(conn):
        return None
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT p.*, u.full_name AS created_by_name
            FROM app.budget_plan p
            LEFT JOIN app.app_user u ON u.id = p.created_by
            WHERE p.year = %s AND p.status = 'current'
            """,
            (year,),
        )
        return cur.fetchone()


def plan_grid(conn: psycopg.Connection, year: int,
              month: int | None = None) -> dict[str, Any]:
    """
    Сетка для ввода: депо × категория.

    `month` — какой месяц показывать. Без него берётся январь: план вводят
    сразу на год, и январь здесь означает «то, что разольётся на все месяцы».
    """
    first = date(year, month or 1, 1)
    cats = categories(conn)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT id, code, name FROM app.org_unit
            WHERE kind = 'rc' AND is_active AND app.has_unit_access(id)
            ORDER BY name
            """
        )
        units = cur.fetchall()

        rows: dict[tuple[int, str], dict[str, Any]] = {}
        plan = current_plan(conn, year)
        if plan:
            cur.execute(
                """
                SELECT org_unit_id, line_code, headcount_budget,
                       headcount_managerial, income_level, amount_extra
                FROM app.budget_plan_line
                WHERE plan_id = %s AND period_month = %s
                """,
                (plan["id"], first),
            )
            rows = {(r["org_unit_id"], r["line_code"]): r for r in cur.fetchall()}

    grid = []
    for unit in units:
        cells = []
        for cat in cats:
            r = rows.get((unit["id"], cat["code"]))
            cells.append({
                "code": cat["code"],
                "name": cat["name"],
                "headcount_budget": r["headcount_budget"] if r else None,
                "headcount_managerial": r["headcount_managerial"] if r else None,
                "income_level": r["income_level"] if r else None,
                "amount": (dec(r["headcount_budget"]) * dec(r["income_level"])
                           if r else Decimal("0")),
            })
        extra = rows.get((unit["id"], VACATION_CODE))
        grid.append({
            "unit": unit,
            "cells": cells,
            "extra": extra["amount_extra"] if extra else None,
            "amount": sum((c["amount"] for c in cells), Decimal("0"))
                      + (dec(extra["amount_extra"]) if extra else Decimal("0")),
            "people": sum((dec(c["headcount_budget"]) for c in cells
                           if c["headcount_budget"] is not None), Decimal("0")),
        })
    return {"units": units, "cats": cats, "rows": grid, "plan": plan,
            "month": month or 1, "year": year}


def save_plan(conn: psycopg.Connection, year: int,
              values: dict[tuple[int, str], dict[str, Any]],
              extra: dict[int, Any], user_id: int | None,
              note: str = "", months: Sequence[int] | None = None) -> int:
    """
    Записать редакцию плана на год.

    Всегда новая версия, никогда правка на месте: «перезаписать с сохранением
    истории» — это и есть версии. Прежняя редакция помечается заменённой и
    остаётся целиком, вместе с тем, кто и когда её завёл.

    `months` — на какие месяцы разлить введённое. По умолчанию на все двенадцать:
    план вводят на год, и заполнять одно и то же двенадцать раз незачем. Правка
    отдельного месяца передаёт его одного — остальные месяцы переносятся из
    прежней редакции без изменений.
    """
    if not values:
        raise ValueError("План пустой: не заполнено ни одной строки")
    months = tuple(months) if months else tuple(range(1, 13))

    with conn.cursor() as cur:
        cur.execute(
            "SELECT id, version FROM app.budget_plan "
            "WHERE year = %s AND status = 'current'",
            (year,),
        )
        old = cur.fetchone()
        version = (old["version"] + 1) if old else 1

        if old:
            cur.execute(
                "UPDATE app.budget_plan SET status = 'superseded' WHERE id = %s",
                (old["id"],),
            )
        cur.execute(
            """
            INSERT INTO app.budget_plan (year, version, note, status, created_by)
            VALUES (%s, %s, %s, 'current', %s) RETURNING id
            """,
            (year, version, (note or "").strip() or None, user_id),
        )
        plan_id = cur.fetchone()["id"]

        #  Месяцы, которых правка не касалась, переносим из прежней редакции:
        #  иначе правка одного месяца обнулила бы остальные одиннадцать
        if old and len(months) < 12:
            cur.execute(
                """
                INSERT INTO app.budget_plan_line
                    (plan_id, org_unit_id, line_code, period_month,
                     headcount_budget, headcount_managerial, income_level,
                     amount_extra)
                SELECT %s, org_unit_id, line_code, period_month,
                       headcount_budget, headcount_managerial, income_level,
                       amount_extra
                FROM app.budget_plan_line
                WHERE plan_id = %s
                  AND extract(month FROM period_month)::int <> ALL(%s)
                """,
                (plan_id, old["id"], list(months)),
            )

        written = 0
        for month in months:
            first = date(year, month, 1)
            for (unit_id, code), cell in values.items():
                cur.execute(
                    """
                    INSERT INTO app.budget_plan_line
                        (plan_id, org_unit_id, line_code, period_month,
                         headcount_budget, headcount_managerial, income_level)
                    VALUES (%s, %s, %s, %s, %s, %s, %s)
                    """,
                    (plan_id, unit_id, code, first,
                     cell.get("headcount_budget") or 0,
                     cell.get("headcount_managerial"),
                     cell.get("income_level") or 0),
                )
                written += 1
            for unit_id, amount in extra.items():
                if not amount:
                    continue
                cur.execute(
                    """
                    INSERT INTO app.budget_plan_line
                        (plan_id, org_unit_id, line_code, period_month,
                         headcount_budget, income_level, amount_extra)
                    VALUES (%s, %s, %s, %s, 0, 0, %s)
                    """,
                    (plan_id, unit_id, VACATION_CODE, first, amount),
                )
                written += 1
    conn.commit()
    return plan_id


def restore_version(conn: psycopg.Connection, plan_id: int,
                    user_id: int | None) -> int:
    """
    Вернуться к прежней редакции.

    Копией, а не переключением флага: история должна оставаться линейной —
    «вернулись к редакции 2» это отдельное решение, а не отмена того, что
    было принято между ними.
    """
    with conn.cursor() as cur:
        cur.execute("SELECT year, version FROM app.budget_plan WHERE id = %s",
                    (plan_id,))
        src = cur.fetchone()
        if not src:
            raise ValueError("Редакция не найдена")

        cur.execute(
            "SELECT id, version FROM app.budget_plan "
            "WHERE year = %s AND status = 'current'",
            (src["year"],),
        )
        old = cur.fetchone()
        version = (old["version"] + 1) if old else 1
        if old:
            cur.execute(
                "UPDATE app.budget_plan SET status = 'superseded' WHERE id = %s",
                (old["id"],),
            )
        cur.execute(
            """
            INSERT INTO app.budget_plan (year, version, note, status, created_by)
            VALUES (%s, %s, %s, 'current', %s) RETURNING id
            """,
            (src["year"], version,
             f"Возврат к редакции №{src['version']}", user_id),
        )
        new_id = cur.fetchone()["id"]
        cur.execute(
            """
            INSERT INTO app.budget_plan_line
                (plan_id, org_unit_id, line_code, period_month,
                 headcount_budget, headcount_managerial, income_level, amount_extra)
            SELECT %s, org_unit_id, line_code, period_month,
                   headcount_budget, headcount_managerial, income_level, amount_extra
            FROM app.budget_plan_line WHERE plan_id = %s
            """,
            (new_id, plan_id),
        )
    conn.commit()
    return new_id

# ---------------------------------------------------------------------------
#  Заявки на численность — вопрос 9 второго круга (16.09.2026)
#
#  «Для приема сверх положенной нормы по бюджетной численности, должно быть
#   получено одобрение и изменена численность в бюджетных настройках. Заявка
#   должна быть подана на рассмотрение».
#
#  Одобрение правит план на год само: иначе между «одобрили» и «поправили в
#  настройках» остаётся зазор, в котором приём по-прежнему не проходит.
# ---------------------------------------------------------------------------

def headcount_requests(conn: psycopg.Connection, unit_id: int | None,
                       only_new: bool = False) -> list[dict[str, Any]]:
    where = []
    args: dict[str, Any] = {}
    if unit_id:
        where.append("r.org_unit_id = %(unit)s")
        args["unit"] = unit_id
    if only_new:
        where.append("r.status = 'new'")
    clause = ("WHERE " + " AND ".join(where)) if where else ""
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT r.*, o.name AS unit_name, pc.name AS category_name,
                   u.full_name AS created_by_name,
                   d.full_name AS decided_by_name,
                   hr.planned, hr.taken
            FROM app.headcount_request r
            JOIN app.org_unit o          ON o.id = r.org_unit_id
            JOIN app.position_category pc ON pc.id = r.position_category_id
            LEFT JOIN app.app_user u     ON u.id = r.created_by
            LEFT JOIN app.app_user d     ON d.id = r.decided_by
            LEFT JOIN LATERAL app.headcount_room(r.org_unit_id,
                                                 r.position_category_id,
                                                 r.period_month) hr ON true
            {clause}
            ORDER BY (r.status <> 'new'), r.created_at DESC
            """,
            args,
        )
        return cur.fetchall()


def add_headcount_request(conn: psycopg.Connection, unit_id: int,
                          category_id: int, period: date, want,
                          reason: str) -> None:
    with conn.cursor() as cur:
        cur.execute(
            """
            INSERT INTO app.headcount_request
                (org_unit_id, position_category_id, period_month, want,
                 reason, created_by)
            VALUES (%s, %s, %s, %s, %s, app.current_user_id())
            """,
            (unit_id, category_id, period, want, reason.strip()),
        )
    conn.commit()


def decide_headcount_request(conn: psycopg.Connection, request_id: int,
                             approve: bool, note: str | None) -> None:
    with conn.cursor() as cur:
        cur.execute("SELECT app.decide_headcount_request(%s, %s, %s)",
                    (request_id, approve, note))
    conn.commit()


def headcount_room(conn: psycopg.Connection, unit_id: int,
                   period: date) -> list[dict[str, Any]]:
    """Сколько положено и сколько занято — по каждой категории депо."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT pc.id, pc.name, pc.sort_order, hr.planned, hr.taken
            FROM app.position_category pc
            LEFT JOIN LATERAL app.headcount_room(%s, pc.id, %s) hr ON true
            ORDER BY pc.sort_order
            """,
            (unit_id, period),
        )
        return cur.fetchall()
