"""Доступ к базе. Тонкий слой: SQL здесь, бизнес-правила — в rules/totals/compare."""

from __future__ import annotations

import os
from contextlib import contextmanager
from datetime import date
from typing import Iterator

import psycopg
from psycopg.rows import dict_row

from .rules import PlanHours, RULE_VERSION, ShiftRow
from .totals import FactDay


def _next_month(first: date) -> date:
    if first.month == 12:
        return first.replace(year=first.year + 1, month=1)
    return first.replace(month=first.month + 1)


def dsn() -> str:
    """
    Строка подключения к базе — единственная на всё приложение.

    Умолчания здесь намеренно нет. Раньше их было два — своё в `repo` и своё
    в `webapp`, — и оба вели на порт, которого у нас нет. Пока `DATABASE_URL`
    задан, этого не видно; стоит запустить утилиту из другой папки или
    перенести приложение на сервер — и причину будут искать в базе, а не в
    двух разных строках по умолчанию.

    Поэтому лучше громко отказаться и сказать, что делать.
    """
    url = os.environ.get("DATABASE_URL")
    if not url:
        raise RuntimeError(
            "Не задана переменная DATABASE_URL — приложению неизвестно, к какой "
            "базе подключаться. Запускайте через start_local.ps1 (или через "
            "*.cmd в корне проекта): они задают её сами."
        )
    return url


@contextmanager
def connect(user_id: int | None = None) -> Iterator[psycopg.Connection]:
    """Открыть соединение и выставить контекст пользователя для политик доступа."""
    with psycopg.connect(dsn(), row_factory=dict_row) as conn:
        uid = user_id if user_id is not None else os.environ.get("APP_USER_ID")
        if uid:
            with conn.cursor() as cur:
                cur.execute("SELECT set_config('app.user_id', %s, false)", (str(uid),))
        yield conn


# ---------------------------------------------------------------------------
#  Справочники и месяц
# ---------------------------------------------------------------------------

def org_unit_id(conn: psycopg.Connection, code: str) -> int:
    with conn.cursor() as cur:
        cur.execute("SELECT id FROM app.org_unit WHERE code = %s", (code,))
        row = cur.fetchone()
    if not row:
        raise LookupError(f"Подразделение с кодом {code!r} не найдено")
    return row["id"]


def month_norm(conn: psycopg.Connection, period: date, hours_col: str = "norm_hours_40") -> float:
    with conn.cursor() as cur:
        cur.execute(
            f"SELECT {hours_col} AS norm FROM app.v_month_norm WHERE period_month = %s",
            (period.replace(day=1),),
        )
        row = cur.fetchone()
    if not row:
        raise LookupError(f"Производственный календарь за {period:%m.%Y} не заполнен")
    return float(row["norm"])


def timesheet_id(conn: psycopg.Connection, unit_id: int, period: date) -> int:
    with conn.cursor() as cur:
        cur.execute(
            "SELECT id FROM app.timesheet WHERE org_unit_id = %s AND period_month = %s",
            (unit_id, period.replace(day=1)),
        )
        row = cur.fetchone()
    if not row:
        raise LookupError("Табель на этот месяц не открыт — выполните open-month")
    return row["id"]


def open_month(conn: psycopg.Connection, period: date, unit_id: int | None = None) -> int:
    with conn.cursor() as cur:
        cur.execute(
            "SELECT app.open_month(%s, %s) AS n", (period.replace(day=1), unit_id)
        )
        n = cur.fetchone()["n"]
    conn.commit()
    return n


# ---------------------------------------------------------------------------
#  Плановый график
# ---------------------------------------------------------------------------

def fetch_schedule(
    conn: psycopg.Connection,
    unit_id: int,
    period: date,
    margin_days: int = 0,
) -> list[ShiftRow]:
    """
    Записи графика месяца, при желании — с запасом по краям.

    margin_days нужен обеду: смена на стыке месяцев записана двумя частями,
    18:00–00:00 последним числом и 00:00–06:00 первым, а обед у неё один. Без
    соседнего дня в выборке половина смены выглядит самостоятельной сменой и
    получает свой обед — час уходил не в те сутки, где его брали.
    """
    first = period.replace(day=1)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT sp.employment_id, sp.org_unit_id, sp.work_date,
                   sp.shift_start, sp.shift_end, sp.day_code,
                   sp.shift2_start, sp.shift2_end
            FROM app.schedule_plan sp
            WHERE sp.org_unit_id = %s
              AND sp.work_date >= (%s::date - make_interval(days => %s))
              AND sp.work_date <  (%s::date + interval '1 month'
                                   + make_interval(days => %s))
            ORDER BY sp.employment_id, sp.work_date
            """,
            (unit_id, first, margin_days, first, margin_days),
        )
        rows = cur.fetchall()
    return [
        ShiftRow(
            employment_id=r["employment_id"],
            org_unit_id=r["org_unit_id"],
            work_date=r["work_date"],
            shift_start=r["shift_start"],
            shift_end=r["shift_end"],
            day_code=r["day_code"],
            shift2_start=r["shift2_start"],
            shift2_end=r["shift2_end"],
        )
        for r in rows
    ]


def save_plan_hours(
    conn: psycopg.Connection,
    unit_id: int,
    period: date,
    computed: list[tuple[ShiftRow, PlanHours]],
) -> int:
    """Переписать плановые часы месяца результатом движка."""
    first = period.replace(day=1)
    with conn.cursor() as cur:
        cur.execute(
            """
            DELETE FROM app.schedule_plan_hours
            WHERE org_unit_id = %s
              AND source_date >= %s
              AND source_date <  (%s::date + interval '1 month')
            """,
            (unit_id, first, first),
        )
        cur.executemany(
            """
            INSERT INTO app.schedule_plan_hours
                (employment_id, org_unit_id, work_date, hours_day, hours_night,
                 worked_day, worked_night, source_date, rule_version)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
            ON CONFLICT (employment_id, work_date, source_date) DO UPDATE
               SET hours_day = EXCLUDED.hours_day,
                   hours_night = EXCLUDED.hours_night,
                   worked_day = EXCLUDED.worked_day,
                   worked_night = EXCLUDED.worked_night,
                   rule_version = EXCLUDED.rule_version,
                   computed_at = now()
            """,
            [
                (
                    row.employment_id, row.org_unit_id, ph.work_date,
                    ph.hours_day, ph.hours_night,
                    #  Пустое «к отработке» читается как присутствие: так
                    #  ведут себя строки, посчитанные до правила обеда
                    ph.hours_day if ph.worked_day is None else ph.worked_day,
                    ph.hours_night if ph.worked_night is None else ph.worked_night,
                    ph.source_date, RULE_VERSION,
                )
                for row, ph in computed
                #  Соседние месяцы попадают в расчёт ради обеда переходящей
                #  смены, но хранит их свой месяц: иначе строку запишут двое
                if first <= ph.source_date < _next_month(first)
            ],
        )
    conn.commit()
    return len(computed)


def fetch_plan_hours(
    conn: psycopg.Connection, unit_id: int, period: date
) -> dict[int, list[PlanHours]]:
    first = period.replace(day=1)
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT employment_id, work_date, hours_day, hours_night, source_date
            FROM app.schedule_plan_hours
            WHERE org_unit_id = %s
              AND work_date >= %s
              AND work_date <  (%s::date + interval '1 month')
            ORDER BY employment_id, work_date
            """,
            (unit_id, first, first),
        )
        rows = cur.fetchall()
    out: dict[int, list[PlanHours]] = {}
    for r in rows:
        out.setdefault(r["employment_id"], []).append(
            PlanHours(
                work_date=r["work_date"],
                hours_day=float(r["hours_day"]),
                hours_night=float(r["hours_night"]),
                source_date=r["source_date"],
            )
        )
    return out


# ---------------------------------------------------------------------------
#  Фактический табель
# ---------------------------------------------------------------------------

def fetch_fact(conn: psycopg.Connection, ts_id: int) -> dict[int, list[FactDay]]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT employment_id, work_date, day_code,
                   hours_day, hours_night, hours_weekend, hours_overtime
            FROM app.timesheet_day
            WHERE timesheet_id = %s
            ORDER BY employment_id, work_date
            """,
            (ts_id,),
        )
        rows = cur.fetchall()
    out: dict[int, list[FactDay]] = {}
    for r in rows:
        out.setdefault(r["employment_id"], []).append(
            FactDay(
                work_date=r["work_date"],
                day_code=r["day_code"],
                hours_day=float(r["hours_day"]),
                hours_night=float(r["hours_night"]),
                hours_weekend=float(r["hours_weekend"]),
                hours_overtime=float(r["hours_overtime"]),
            )
        )
    return out


def fetch_people(conn: psycopg.Connection, ts_id: int) -> list[dict]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT employment_id, personnel_no, fio_full, fio_short, position_name,
                   worked_days, hours_day, hours_night, hours_total, hours_night,
                   days_business_trip, days_sick, days_vacation, days_maternity,
                   days_childcare, days_off, days_holiday, days_unpaid
            FROM app.v_timesheet_totals
            WHERE timesheet_id = %s
            ORDER BY fio_full
            """,
            (ts_id,),
        )
        return cur.fetchall()


def save_discrepancies(
    conn: psycopg.Connection,
    unit_id: int,
    period: date,
    items: list[tuple[int, object]],
) -> int:
    """items — список (employment_id, Discrepancy)."""
    first = period.replace(day=1)
    with conn.cursor() as cur:
        cur.execute(
            """
            DELETE FROM app.schedule_discrepancy
            WHERE org_unit_id = %s AND period_month = %s AND resolved_at IS NULL
            """,
            (unit_id, first),
        )
        cur.executemany(
            """
            INSERT INTO app.schedule_discrepancy
                (org_unit_id, period_month, employment_id, work_date,
                 plan_day, plan_night, fact_day, fact_night, fact_code)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
            """,
            [
                (
                    unit_id, first, emp_id, d.work_date,
                    d.plan_day, d.plan_night, d.fact_day, d.fact_night,
                    (d.fact_code or d.reason)[:200],
                )
                for emp_id, d in items
            ],
        )
    conn.commit()
    return len(items)


def completeness(conn: psycopg.Connection, ts_id: int) -> list[dict]:
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT personnel_no, from_date, to_date, days_expected, days_filled
            FROM app.v_timesheet_completeness
            WHERE timesheet_id = %s AND days_filled < days_expected
            ORDER BY personnel_no
            """,
            (ts_id,),
        )
        return cur.fetchall()
