"""
Удержание: журнал приказов о депремировании и удержаниях (23.09.2026).

Только учёт — в расчёт заработной платы записи не идут, для денег остаются
«Вычеты и доплаты». Кто что видит и правит, решают права и политики таблицы
`penalty_order` (миграция 74); здесь только запросы.
"""

from __future__ import annotations

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

import psycopg

from .staffdb import FIO_FULL

#  Виды — строго три, как в задании. Порядок — порядок списка на экране
PENALTY_KINDS = [
    ("depremiation", "Депремирование"),
    ("deduction", "Удержание"),
    ("none", "Без удержания"),
]
PENALTY_KIND_RU = dict(PENALTY_KINDS)

#  Сумма: рубли и, если есть, копейки через запятую — одна или две цифры.
#  То же правило проверяет форма в браузере (staff.html), до отправки
AMOUNT_RE = re.compile(r"\d+(,\d{1,2})?")
AMOUNT_ERROR = ("Введите верную сумму: рубли и копейки через запятую, "
                "например 125,50")

#  Сотрудник в общей вкладке — пока у него есть открытое назначение.
#  Уволили — строка уходит из общей вкладки, в карточке остаётся
_EMPLOYED = ("EXISTS (SELECT 1 FROM app.employment o "
             "WHERE o.employee_id = p.employee_id AND o.terminated_at IS NULL)")

_SELECT = f"""
    SELECT p.id, p.order_date, p.org_unit_id, u.code AS unit_code,
           u.name AS unit_name, p.employee_id, p.employment_id,
           {FIO_FULL} AS full_name, e.personnel_no,
           p.kind, p.amount, p.order_no, p.comment,
           p.created_at, cu.full_name AS created_by_name,
           p.updated_at, uu.full_name AS updated_by_name,
           {_EMPLOYED} AS is_employed,
           (SELECT o.id FROM app.employment o
             WHERE o.employee_id = p.employee_id
             ORDER BY (o.terminated_at IS NULL) DESC, o.hired_at DESC
             LIMIT 1) AS card_employment_id
      FROM app.penalty_order p
      JOIN app.employee e ON e.id = p.employee_id
      JOIN app.org_unit u ON u.id = p.org_unit_id
      LEFT JOIN app.app_user cu ON cu.id = p.created_by
      LEFT JOIN app.app_user uu ON uu.id = p.updated_by
"""

_ORDER = " ORDER BY p.order_date DESC, p.id DESC"


def parse_amount(raw: str | None) -> Decimal | None:
    """
    Сумма с копейками — только через запятую («125,50»), правило заказчика
    от 23.09.2026. Точку не принимаем: «1.200» одни читают как тысячу двести,
    другие как рубль двадцать. Пробелы между разрядами убираем. Пусто — None.
    """
    s = re.sub(r"[\s\u00a0]", "", raw or "")
    if not s:
        return None
    if not AMOUNT_RE.fullmatch(s):
        raise ValueError(AMOUNT_ERROR)
    try:
        value = Decimal(s.replace(",", "."))
    except InvalidOperation as exc:              # pragma: no cover
        raise ValueError("Сумма указана неверно") from exc
    if value >= Decimal("10000000000"):
        raise ValueError("Сумма слишком большая")
    return value


def check_fields(kind: str, amount: Decimal | None, order_no: str,
                 order_date: str) -> date:
    """То же, что проверит база, но с понятным текстом до записи."""
    if kind not in PENALTY_KIND_RU:
        raise ValueError("Вид удержания: Депремирование, Удержание или "
                         "Без удержания")
    if kind != "none" and not amount:
        raise ValueError("Для «%s» укажите сумму больше нуля"
                         % PENALTY_KIND_RU[kind])
    if not (order_no or "").strip():
        raise ValueError("Укажите номер приказа")
    try:
        return date.fromisoformat(order_date)
    except (TypeError, ValueError) as exc:
        raise ValueError("Укажите дату приказа") from exc


def penalties(conn: psycopg.Connection, unit_id: int | None = None,
              q: str | None = None) -> list[dict[str, Any]]:
    """Общая вкладка: только те, кто сейчас работает."""
    where = [_EMPLOYED]
    params: dict[str, Any] = {}
    if unit_id:
        where.append("p.org_unit_id = %(unit)s")
        params["unit"] = unit_id
    if q:
        where.append(f"({FIO_FULL} ILIKE %(q)s OR e.personnel_no ILIKE %(q)s "
                     "OR p.order_no ILIKE %(q)s)")
        params["q"] = f"%{q.strip()}%"
    with conn.cursor() as cur:
        cur.execute(_SELECT + " WHERE " + " AND ".join(where) + _ORDER, params)
        return list(cur.fetchall())


def penalty_count(conn: psycopg.Connection, unit_id: int | None = None) -> int:
    params: dict[str, Any] = {}
    unit_filter = ""
    if unit_id:
        unit_filter = "AND p.org_unit_id = %(unit)s"
        params["unit"] = unit_id
    with conn.cursor() as cur:
        cur.execute(f"SELECT count(*) AS n FROM app.penalty_order p "
                    f"WHERE {_EMPLOYED} {unit_filter}", params)
        return int(cur.fetchone()["n"] or 0)


def penalties_of(conn: psycopg.Connection,
                 employee_id: int) -> list[dict[str, Any]]:
    """Вкладка карточки: все записи человека, и после увольнения тоже."""
    with conn.cursor() as cur:
        cur.execute(_SELECT + " WHERE p.employee_id = %s" + _ORDER,
                    (employee_id,))
        return list(cur.fetchall())


def penalty(conn: psycopg.Connection, penalty_id: int) -> dict[str, Any] | None:
    with conn.cursor() as cur:
        cur.execute(_SELECT + " WHERE p.id = %s", (penalty_id,))
        return cur.fetchone()


def people_by_unit(conn: psycopg.Connection) -> dict[str, list[dict[str, Any]]]:
    """
    Для каскада «ДЕПО → ФИО»: работающие сотрудники по кодам депо. Только
    депо, которые пользователю открыты, — это решает политика `employment`.
    """
    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT u.code AS unit_code, e.id AS employee_id,
                   {FIO_FULL} AS full_name, e.personnel_no
              FROM app.employment em
              JOIN app.employee e ON e.id = em.employee_id
              JOIN app.org_unit u ON u.id = em.org_unit_id
             WHERE em.terminated_at IS NULL
             ORDER BY u.code, e.last_name, e.first_name, e.middle_name
            """
        )
        out: dict[str, list[dict[str, Any]]] = {}
        for r in cur.fetchall():
            out.setdefault(r["unit_code"], []).append({
                "id": r["employee_id"],
                "name": r["full_name"],
                "no": (r["personnel_no"] or "").strip(),
            })
        return out


def _unit_id(conn: psycopg.Connection, unit_code: str) -> int:
    with conn.cursor() as cur:
        cur.execute("SELECT id FROM app.org_unit WHERE code = %s", (unit_code,))
        row = cur.fetchone()
    if not row:
        raise ValueError("Выберите депо")
    return int(row["id"])


def add_penalty(conn: psycopg.Connection, *, order_date: date, unit_code: str,
                employee_id: int, kind: str, amount: Decimal | None,
                order_no: str, comment: str) -> int:
    with conn.cursor() as cur:
        cur.execute(
            """
            INSERT INTO app.penalty_order
                   (order_date, org_unit_id, employee_id, kind, amount,
                    order_no, comment)
            VALUES (%s, %s, %s, %s, %s, %s, %s)
            RETURNING id
            """,
            (order_date, _unit_id(conn, unit_code), employee_id, kind, amount,
             order_no.strip(), (comment or "").strip() or None),
        )
        return int(cur.fetchone()["id"])


def update_penalty(conn: psycopg.Connection, penalty_id: int, *,
                   order_date: date, unit_code: str, employee_id: int,
                   kind: str, amount: Decimal | None, order_no: str,
                   comment: str) -> bool:
    with conn.cursor() as cur:
        cur.execute(
            """
            UPDATE app.penalty_order
               SET order_date = %s, org_unit_id = %s, employee_id = %s,
                   kind = %s, amount = %s, order_no = %s, comment = %s
             WHERE id = %s
            """,
            (order_date, _unit_id(conn, unit_code), employee_id, kind, amount,
             order_no.strip(), (comment or "").strip() or None, penalty_id),
        )
        return cur.rowcount == 1


def delete_penalty(conn: psycopg.Connection, penalty_id: int) -> bool:
    with conn.cursor() as cur:
        cur.execute("DELETE FROM app.penalty_order WHERE id = %s",
                    (penalty_id,))
        return cur.rowcount == 1
