"""
Докладные и приказы на привлечение к работе — чтение и запись.

Таблицы заведены миграцией 58. Здесь только работа с ними: список
оформленного за месяц, сохранение нового пакета и подбор данных, которые
приложение подставляет в окно.

Подставляет — не значит решает: любое поле в окне правится руками
(требование от 22.09.2026), а часы и даты вводятся с нуля. Докладную пишут
до смены, когда в табеле ещё пусто.
"""

from __future__ import annotations

import calendar
from datetime import date, time, timedelta
from typing import Any

import psycopg

from .declension import (
    fio_genitive, position_genitive, short_fio, short_from_genitive,
)

KIND_RU = {
    "weekend": "Работа в выходной день",
    "overtime": "Сверхурочная работа",
}


def addressed_default(conn: psycopg.Connection) -> tuple[str, str]:
    """
    Кому адресуется докладная — из настроек.

    Управляющий один на всё общество, поэтому его имя лежит в настройках, а
    не вписывается в каждую докладную руками. В окне оформления оно правится:
    управляющий может быть в отпуске.
    """
    with conn.cursor() as cur:
        cur.execute(
            "SELECT code, value FROM app.app_setting "
            " WHERE code IN ('report_addressed_post', 'report_addressed_fio')"
        )
        got = {r["code"]: r["value"] for r in cur.fetchall()}
    return (got.get("report_addressed_post", "Управляющему ООО «Триовист»"),
            got.get("report_addressed_fio", ""))


def people(conn: psycopg.Connection, unit_id: int,
           on_day: date | None = None) -> list[dict[str, Any]]:
    """
    Кого можно привлечь и кто может подписать — действующие работники депо.

    Один запрос на оба списка: подписант тоже сотрудник этого депо, а
    отбирать его отдельным запросом значило бы дважды описать «кто здесь
    работает».
    """
    #  02.10.2026 (вычитка 3.22): кто работал хоть день в месяце. Раньше
    #  список строился на 1-е число, и принятого позже выбрать было нельзя
    day = on_day or date.today()
    first = day.replace(day=1)
    last = (first + timedelta(days=32)).replace(day=1) - timedelta(days=1)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT em.id AS employment_id, e.last_name, e.first_name,
                   coalesce(e.middle_name, '') AS middle_name,
                   p.name AS position_name, pc.code AS category,
                   pc.sort_order, em.hired_at, em.terminated_at
              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
             WHERE em.org_unit_id = %s
               AND em.hired_at <= %s
               AND (em.terminated_at IS NULL OR em.terminated_at >= %s)
             ORDER BY pc.sort_order, e.last_name, e.first_name
            """,
            (unit_id, last, first),
        )
        rows = cur.fetchall()

    for r in rows:
        r["fio_full"] = " ".join(
            x for x in (r["last_name"], r["first_name"], r["middle_name"]) if x)
        r["fio_genitive"] = fio_genitive(
            r["last_name"], r["first_name"], r["middle_name"])
        r["fio_short"] = short_fio(
            r["last_name"], r["first_name"], r["middle_name"])
        r["position_genitive"] = position_genitive(r["position_name"])
        #  Подписывают и подают докладную начальник и заместители: привлечение
        #  сверх графика — решение руководителя (матрица от 16.09.2026)
        r["can_sign"] = r["category"] in ("head", "deputy")
    return rows


def save(conn: psycopg.Connection, *, unit_id: int, kind: str,
         employment_id: int, report_date: date,
         author_position: str, author_fio: str,
         addressed_post: str, addressed_fio: str,
         periods: list[tuple[date, time, time]],
         with_order: bool = False, order_date: date | None = None,
         order_no: str = "", signer_position: str = "", signer_fio: str = "",
         pay_month: date | None = None, note: str = "",
         user_id: int | None = None) -> int:
    """
    Записать оформление. Возвращает номер записи.

    Приказ проверяется здесь, а не только в базе: человеку нужно объяснение,
    а не нарушение ограничения.
    """
    if kind not in KIND_RU:
        raise ValueError(f"Неизвестный вид привлечения: {kind}")
    if not periods:
        raise ValueError("Укажите хотя бы один день привлечения")
    if with_order and not (order_date and signer_fio.strip()):
        raise ValueError("Для приказа нужны дата и тот, кто его подписывает")
    for fld, val in (("кто подаёт докладную", author_fio),
                     ("должность подающего", author_position),
                     ("кому адресована докладная", addressed_post)):
        if not (val or "").strip():
            raise ValueError(f"Не заполнено: {fld}")

    #  02.10.2026: дни привлечения — только в периоде работы человека
    with conn.cursor() as cur:
        cur.execute("SELECT hired_at, terminated_at FROM app.employment "
                    "WHERE id = %s AND org_unit_id = %s",
                    (employment_id, unit_id))
        em = cur.fetchone()
    if not em:
        raise ValueError("Сотрудник не найден в этом депо")
    for work_date, _, _ in periods:
        if work_date < em["hired_at"] or (
                em["terminated_at"] and work_date > em["terminated_at"]):
            raise ValueError(
                f"{work_date:%d.%m.%Y} — вне периода работы сотрудника "
                f"(с {em['hired_at']:%d.%m.%Y}"
                + (f" по {em['terminated_at']:%d.%m.%Y}" if em["terminated_at"]
                   else "") + ")")

    with conn.cursor() as cur:
        cur.execute(
            """
            INSERT INTO app.work_order
                (org_unit_id, kind, employment_id, report_date,
                 author_position, author_fio, addressed_post, addressed_fio,
                 with_order, order_date, order_no, signer_position, signer_fio,
                 pay_month, note, created_by)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            RETURNING id
            """,
            (unit_id, kind, employment_id, report_date,
             author_position.strip(), author_fio.strip(),
             addressed_post.strip(), (addressed_fio or "").strip(),
             with_order, order_date, (order_no or "").strip() or None,
             (signer_position or "").strip() or None,
             (signer_fio or "").strip() or None,
             pay_month, (note or "").strip() or None, user_id),
        )
        order_id = cur.fetchone()["id"]
        for work_date, t_from, t_to in periods:
            cur.execute(
                """
                INSERT INTO app.work_order_day
                    (work_order_id, work_date, time_from, time_to)
                VALUES (%s, %s, %s, %s)
                ON CONFLICT (work_order_id, work_date, time_from) DO NOTHING
                """,
                (order_id, work_date, t_from, t_to),
            )
    conn.commit()
    return order_id


def listing(conn: psycopg.Connection, unit_id: int,
            period: date | None = None) -> list[dict[str, Any]]:
    """Что уже оформлено — за месяц или за всё время, если период не задан."""
    where = ["w.org_unit_id = %(unit)s"]
    args: dict[str, Any] = {"unit": unit_id}
    if period:
        first = period.replace(day=1)
        last = date(first.year, first.month,
                    calendar.monthrange(first.year, first.month)[1])
        #  02.10.2026: по дате привлечения, как и сверка, а не по дате
        #  докладной — иначе привлечение 1-го числа по докладной от 30-го
        #  попадало в прошлый месяц
        where.append("EXISTS (SELECT 1 FROM app.work_order_day d0 "
                     "WHERE d0.work_order_id = w.id "
                     "AND d0.work_date BETWEEN %(first)s AND %(last)s)")
        args |= {"first": first, "last": last}

    with conn.cursor() as cur:
        cur.execute(
            f"""
            SELECT w.*, e.last_name, e.first_name,
                   coalesce(e.middle_name, '') AS middle_name,
                   p.name AS position_name,
                   u.full_name AS created_by_name,
                   c.full_name AS cancelled_by_name,
                   (SELECT count(*) FROM app.work_order_day d
                     WHERE d.work_order_id = w.id) AS days
              FROM app.work_order w
              JOIN app.employment em ON em.id = w.employment_id
              JOIN app.employee e ON e.id = em.employee_id
              JOIN app.position p ON p.id = em.position_id
              LEFT JOIN app.app_user u ON u.id = w.created_by
              LEFT JOIN app.app_user c ON c.id = w.cancelled_by
             WHERE {' AND '.join(where)}
             ORDER BY w.report_date DESC, w.id DESC
            """,
            args,
        )
        rows = cur.fetchall()
    for r in rows:
        r["fio_short"] = short_fio(
            r["last_name"], r["first_name"], r["middle_name"])
        r["kind_ru"] = KIND_RU.get(r["kind"], r["kind"])
    return rows


def one(conn: psycopg.Connection, order_id: int) -> dict[str, Any] | None:
    """Одно оформление со всеми днями — для печати и для повторного показа."""
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT w.*, ou.name AS unit_name,
                   e.last_name, e.first_name,
                   coalesce(e.middle_name, '') AS middle_name,
                   p.name AS position_name
              FROM app.work_order w
              JOIN app.org_unit ou ON ou.id = w.org_unit_id
              JOIN app.employment em ON em.id = w.employment_id
              JOIN app.employee e ON e.id = em.employee_id
              JOIN app.position p ON p.id = em.position_id
             WHERE w.id = %s
            """,
            (order_id,),
        )
        row = cur.fetchone()
        if row is None:
            return None
        cur.execute(
            "SELECT work_date, time_from, time_to FROM app.work_order_day "
            " WHERE work_order_id = %s ORDER BY work_date, time_from",
            (order_id,),
        )
        row["days"] = cur.fetchall()

    row["fio_genitive"] = fio_genitive(
        row["last_name"], row["first_name"], row["middle_name"])
    row["fio_short"] = short_fio(
        row["last_name"], row["first_name"], row["middle_name"])
    row["position_genitive"] = position_genitive(row["position_name"])
    row["author_short"] = short_from_genitive(row["author_fio"])
    row["kind_ru"] = KIND_RU.get(row["kind"], row["kind"])
    return row


def cancel(conn: psycopg.Connection, order_id: int, unit_id: int,
           reason: str, user_id: int | None = None) -> None:
    """
    Аннулировать оформление.

    Заказчик 22.09.2026: «сотрудник может не выйти на работу, а при сверке
    будет требовать эти часы». Аннулированное перестаёт требовать часы, но
    остаётся в списке: докладную подписал работник, дав согласие, и стирать
    её значило бы потерять след принятого решения.

    Причина обязательна — иначе аннулированием было бы удобно закрывать
    любое расхождение.
    """
    if not (reason or "").strip():
        raise ValueError("Укажите, почему оформление аннулируется")
    with conn.cursor() as cur:
        cur.execute(
            """
            UPDATE app.work_order
               SET cancelled_at = now(), cancelled_by = %s, cancel_reason = %s
             WHERE id = %s AND org_unit_id = %s AND cancelled_at IS NULL
            """,
            (user_id, reason.strip(), order_id, unit_id),
        )
        if cur.rowcount == 0:
            raise ValueError(
                "Запись не найдена или уже аннулирована — обновите страницу")
    conn.commit()


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

def ordered_days(conn: psycopg.Connection, unit_id: int,
                 period: date) -> dict[int, dict[date, str]]:
    """
    Оформленные дни привлечения за месяц: по назначению — дата и вид.

    Вид нужен тексту расхождения: «оформлено привлечение (работа в выходной
    день), а часов в табеле нет».
    """
    first = period.replace(day=1)
    last = date(first.year, first.month,
                calendar.monthrange(first.year, first.month)[1])
    out: dict[int, dict[date, str]] = {}
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT w.employment_id, w.kind, d.work_date
              FROM app.work_order w
              JOIN app.work_order_day d ON d.work_order_id = w.id
             WHERE w.org_unit_id = %s
               AND d.work_date BETWEEN %s AND %s
               --  Аннулированное ничего не требует: человек не вышел, и
               --  часов за этот день быть не должно (22.09.2026)
               AND w.cancelled_at IS NULL
             ORDER BY d.work_date
            """,
            (unit_id, first, last),
        )
        for r in cur.fetchall():
            #  02.10.2026: на дату может быть и выходной, и сверхурочные —
            #  виды складываются через «+»
            days = out.setdefault(r["employment_id"], {})
            was = days.get(r["work_date"])
            kinds = set((was or "").split("+")) - {""}
            kinds.add(r["kind"])
            days[r["work_date"]] = "+".join(sorted(kinds))
    return out
