"""
Сверка планового графика с фактическим табелем.

Аналог действующей функции compareSchedule, но с двумя отличиями:
  * результат возвращается структурой и сохраняется в базу, а не только
    показывается в модальном окне и теряется;
  * плановые часы берутся из общего движка правил (rules.py), поэтому
    граница ночи и правило перерыва одни и те же везде.
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import date
from typing import Iterable, Mapping

from .rules import NORM_EXCUSING_CODES, PlanHours
from .totals import FactDay

DEFAULT_TOLERANCE = 0.1

#  Как называется вид привлечения в тексте расхождения. Тот же словарь есть в
#  orderdb, но тянуть его оттуда значило бы завести круг: orderdb ходит в
#  webapp за правилом обеда, а webapp — сюда
ORDER_KIND_RU = {
    "weekend": "работа в выходной день",
    "overtime": "сверхурочная работа",
}

#  Дни законного отсутствия: отпуска, нетрудоспособность, командировка,
#  госдела. Тот же список, по которому уменьшается персональная норма —
#  держать два разных было бы источником расхождений.
EXCUSING_CODES = NORM_EXCUSING_CODES
#  Отпуска: у них своё оформление работы — отзыв из отпуска (ст. 174 ТК РБ).
#  «А» — отпуск без сохранения заработной платы (решение от 14.09.2026),
#  прежде то же самое обозначалось «ОБ»
VACATION_CODES = frozenset({"О", "А", "ОБ", "У", "Р", "ОЖ"})


@dataclass(frozen=True)
class Discrepancy:
    work_date: date
    plan_day: float | None
    plan_night: float | None
    fact_day: float | None
    fact_night: float | None
    fact_code: str | None
    reason: str
    # Что именно не сходится — от этого зависит, чем это лечится:
    #   missing   нет строки в табеле
    #   coded     в графике смена, в табеле код
    #   coded_work работа в день, закрытый кодом отсутствия
    #   unplanned работа в день без смены в графике
    #   over      больше плана, и превышение не оформлено
    #   under     меньше плана
    #   split     часы сошлись, а день с ночью разошлись
    #   ordered_missing оформлено привлечение, а часов в табеле нет
    #   unordered в табеле «РВ» или «С», а привлечение не оформлено
    #   empty     день не заполнен: ни часов, ни «В», ни другого кода
    kind: str = "over"
    # Сколько заявлено сверхурочными и работой в выходной за этот день
    declared: float = 0.0
    # Сколько часов сверх графика осталось ничем не оформлено
    undeclared: float = 0.0

    @property
    def delta_day(self) -> float:
        return round((self.fact_day or 0) - (self.plan_day or 0), 2)

    @property
    def delta_night(self) -> float:
        return round((self.fact_night or 0) - (self.plan_night or 0), 2)

    @property
    def plan_total(self) -> float:
        return round((self.plan_day or 0) + (self.plan_night or 0), 2)

    @property
    def fact_total(self) -> float:
        return round((self.fact_day or 0) + (self.fact_night or 0), 2)


def aggregate_plan(plan: Iterable[PlanHours]) -> dict[date, tuple[float, float]]:
    """
    Свести часы графика по календарным дням — те, что нужно отработать.

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

    Берутся часы **к отработке**, а не присутствие: в графике интервал
    содержит в себе час обеда, и в табель работник ставит время за вычетом
    этого часа. Сравнивать факт с присутствием значило бы показывать
    расхождение −1 час в каждый рабочий день — то есть закапывать настоящие
    расхождения в шуме.
    """
    acc: dict[date, tuple[float, float]] = {}
    for ph in plan:
        d, n = acc.get(ph.work_date, (0.0, 0.0))
        day = ph.hours_day if ph.worked_day is None else ph.worked_day
        night = ph.hours_night if ph.worked_night is None else ph.worked_night
        acc[ph.work_date] = (round(d + day, 2), round(n + night, 2))
    return acc


def _kinds(value: str | None) -> set[str]:
    """Виды привлечения на дату: «weekend», «overtime» или оба."""
    return {k for k in (value or "").split("+") if k}


def _kinds_ru(value: str | None) -> str:
    return ", ".join(ORDER_KIND_RU.get(k, k) for k in sorted(_kinds(value)))


def _fmt(value: float) -> str:
    v = round(float(value), 2)
    return str(int(v)) if abs(v - int(v)) < 1e-9 else f"{v:g}"


def compare(
    plan: Iterable[PlanHours],
    fact: Iterable[FactDay],
    tolerance: float = DEFAULT_TOLERANCE,
    skip_coded: bool = True,
    ordered: Mapping[date, str] | None = None,
    days: Iterable[date] | None = None,
    today: date | None = None,
) -> list[Discrepancy]:
    """
    Сравнить план и факт по дням месяца.

    Главное правило сверки: **отработать больше запланированного можно, но
    превышение должно быть оформлено.** Если по графику смена 11 часов, а в
    табеле 12, то этот час обязан быть заявлен сверхурочными или работой в
    выходной — их оформляют отдельно приказом. Ничем не прикрытый лишний час
    в табеле означает либо ошибку ввода, либо неоформленную переработку;
    и то и другое надо увидеть до сдачи табеля.

    Поэтому сравниваются не просто часы с часами: превышение над планом
    сопоставляется с заявленными признаками дня (РВ и С). Сколько именно
    часов осталось без оформления, лежит в поле undeclared.

    skip_coded=True пропускает дни, где в факте стоит код (больничный, отпуск
    и т.п.) — это галочка «Исключить текстовые расхождения» в нынешнем диалоге.

    `ordered` — дни, на которые оформлена докладная о привлечении к работе в
    выходной день или к сверхурочной работе (решение заказчика от
    22.09.2026). Табель наперёд не ведут, поэтому оформление не проставляет
    часы само — оно меняет сверку, и сразу в две стороны:

      * **часы такого дня считаются оформленными.** Докладная с согласием
        работника и есть то оформление, которого сверка требует, и требовать
        сверх неё ещё и признака в клетке незачем;
      * **день без часов становится расхождением.** Человека вызвали
        документом, а смена в табеле не отражена: либо забыли внести, либо
        вызов не состоялся и докладную надо убрать.

    Замечания начальника РЦ от 24.09.2026:

      * `days` — дни, которые уже должны быть заполнены (прошедшие, в
        пределах работы человека). День из них без часов и без кода —
        расхождение: выходной тоже проставляется, буквой «В»;
      * часы «РВ» и «С» в клетке сами по себе больше не считаются
        оформлением: нужна докладная (привлечение во вкладке «Табель»).
        Иначе можно поставить «РВ 11» и ничего не оформить, а сверка молчит.

    07.10.2026 (правка заказчика): `today` — граница «настоявшего» времени.
    Будущих дней табель не касается по определению: смена ещё не была, и
    «нет строки в табеле» (как и «оформлено привлечение, а часов нет») по
    завтрашнему дню — не расхождение, а шум. Передаётся из вызывающей
    страницы; без него сверка ведёт себя по-старому.
    """
    ordered = dict(ordered or {})
    plan_map = aggregate_plan(plan)
    fact_map = {f.work_date: f for f in fact}

    out: list[Discrepancy] = []
    #  Оформленный день проверяется, даже если его нет ни в графике, ни в
    #  табеле: вызов в выходной как раз и означает работу вне графика
    required = set(days or ())
    for day in sorted(set(plan_map) | set(fact_map) | set(ordered) | required):
        p_day, p_night = plan_map.get(day, (None, None))
        f = fact_map.get(day)

        #  Оформлено привлечение, а часов нет. Проверяем до всего прочего:
        #  это не расхождение плана с фактом, а незакрытый документ.
        #  День в будущем — смены ещё не было, и требовать часы рано
        #  (07.10.2026, правка заказчика)
        if (day in ordered and (f is None or f.worked <= 0)
                and (today is None or day <= today)):
            out.append(Discrepancy(
                day, p_day, p_night,
                f.hours_day if f else None, f.hours_night if f else None,
                f.day_code if f else None,
                f"оформлено привлечение ({_kinds_ru(ordered[day])}), "
                f"а часов в табеле нет: внесите смену или уберите оформление",
                kind="ordered_missing",
            ))
            continue

        planned = round((p_day or 0) + (p_night or 0), 2) > 0
        if f is None or (not f.day_code and f.worked <= 0
                         and not f.hours_weekend and not f.hours_overtime):
            #  07.10.2026 (правка заказчика): «нет строки в табеле» — только
            #  по прошедшим и текущим дням. Если сегодня 7-е, будущего «нет
            #  данных по 8-е» быть не должно: смена 8-го ещё не наступила
            if planned and (today is None or day <= today):
                out.append(Discrepancy(
                    day, p_day, p_night, None, None, None,
                    "нет строки в табеле", kind="missing",
                ))
            elif day in required:
                out.append(Discrepancy(
                    day, p_day, p_night, None, None, None,
                    "день не заполнен: нет ни часов, ни выходного «В»",
                    kind="empty",
                ))
            continue

        #  «РВ» и «С» без оформленного привлечения. Вид должен совпасть:
        #  на работу в выходной — докладная о выходном, на сверхурочные —
        #  о сверхурочной работе
        #  02.10.2026 (вычитка 3.22): на одну дату бывает и докладная о
        #  выходном, и о сверхурочных — у них разные пакеты документов, и
        #  каждая закрывает свои часы
        kinds = _kinds(ordered.get(day))
        need = []
        if f.hours_weekend > tolerance and "weekend" not in kinds:
            need.append(f"«РВ» {_fmt(f.hours_weekend)} ч")
        if f.hours_overtime > tolerance and "overtime" not in kinds:
            need.append(f"«С» {_fmt(f.hours_overtime)} ч")
        if need:
            flagged = round(f.hours_weekend + f.hours_overtime, 2)
            out.append(Discrepancy(
                day, p_day, p_night, f.hours_day, f.hours_night, f.day_code,
                f"в табеле {' и '.join(need)}, а привлечение не оформлено: "
                f"оформите его во вкладке «Табель» кнопкой «Оформить "
                f"привлечение»",
                kind="unordered", declared=0.0, undeclared=flagged,
            ))
            continue

        if f.day_code and f.worked <= 0:
            if day not in plan_map or skip_coded:
                continue
            out.append(Discrepancy(
                day, p_day, p_night, 0.0, 0.0, f.day_code,
                f"в графике смена, в табеле код «{f.day_code}»", kind="coded",
            ))
            continue

        #  День закрыт законным отсутствием, но часы в нём есть.
        #
        #  Учёт идёт календарными сутками: отпуск занимает день целиком, до
        #  24:00, и плановые часы внутри этого дня не требуются — смена
        #  начинается с 00:00 следующих суток, и её хвост считается уже там.
        #  Требовать план с дня отпуска значит показывать недоработку у
        #  человека, который в отпуске: так у Слинко за 29.08.2026 выходила
        #  «недоработка 4 ч» при плане 6 ч и двух отработанных часах.
        #
        #  А вот сами отработанные часы показать надо: работа в день отпуска
        #  или больничного без оформления — нарушение, и в отклонении месяца
        #  эти часы видны.
        if f.day_code in EXCUSING_CODES:
            declared = round(f.hours_weekend + f.hours_overtime, 2)
            if declared + tolerance >= f.worked:
                continue
            out.append(Discrepancy(
                day, None, None, f.hours_day, f.hours_night, f.day_code,
                #  Решение заказчика от 21.09.2026: учёт в календарных днях, и
                #  код с часами в одних сутках несовместим. Законодательство
                #  это подтверждает: за день, в который начислена зарплата,
                #  пособие не назначается (подп. 9.5 Положения № 569), значит
                #  день отработан, а «Б» начинается со следующего.
                f"в табеле код «{f.day_code}» и {_fmt(f.worked)} ч работы в "
                f"одних сутках: либо код, либо часы. "
                + ("Работа в день отпуска — это отзыв приказом, и тогда код "
                   "снимается" if f.day_code in VACATION_CODES
                   else "Если день отработан, код ставится со следующего дня"),
                kind="coded_work",
                declared=declared,
                undeclared=round(f.worked - declared, 2),
            ))
            continue

        declared = round(f.hours_weekend + f.hours_overtime, 2)
        #  02.10.2026 (вычитка 3.22): докладная больше не делает «оформленными»
        #  все часы дня. В оплату и в годовые пределы идут только часы с
        #  признаком «РВ» или «С» — поэтому без признака сверка просит его
        #  поставить, а не молчит
        marks_hint = (" — привлечение оформлено, отметьте эти часы в клетке "
                      "признаком «РВ» или «С»" if day in ordered else "")

        # День без смены в графике: вызов или подмена. Сам факт работы это не
        # нарушение — нарушение, если он никак не оформлен.
        if day not in plan_map or round((p_day or 0) + (p_night or 0), 2) <= 0:
            if f.worked <= 0:
                continue
            if declared + tolerance >= f.worked:
                continue
            out.append(Discrepancy(
                day, p_day, p_night, f.hours_day, f.hours_night, f.day_code,
                f"работа в день без смены в графике: {_fmt(f.worked)} ч, "
                f"из них не оформлено {_fmt(f.worked - declared)} ч — "
                f"нужен «РВ» или сверхурочные{marks_hint}",
                kind="unplanned",
                declared=declared,
                undeclared=round(f.worked - declared, 2),
            ))
            continue

        plan_total = round((p_day or 0) + (p_night or 0), 2)
        excess = round(f.worked - plan_total, 2)

        if excess > tolerance:
            # Оформленного может быть и больше превышения — например смену
            # целиком объявили работой в выходной. Это не расхождение.
            undeclared = round(excess - declared, 2)
            if undeclared > tolerance:
                out.append(Discrepancy(
                    day, p_day, p_night, f.hours_day, f.hours_night, f.day_code,
                    f"в табеле {_fmt(f.worked)} ч при плане {_fmt(plan_total)} ч, "
                    f"а сверхурочными и работой в выходной заявлено "
                    f"{_fmt(declared)} ч: не оформлено {_fmt(undeclared)} ч"
                    f"{marks_hint}",
                    kind="over",
                    declared=declared,
                    undeclared=undeclared,
                ))
            # Превышение разобрано — оформленное или нет. Дальше проверять
            # разбивку по дню и ночи незачем: она и должна отличаться от
            # графика, если сверх смены отработали ещё несколько часов.
            continue
        elif excess < -tolerance:
            out.append(Discrepancy(
                day, p_day, p_night, f.hours_day, f.hours_night, f.day_code,
                f"в табеле {_fmt(f.worked)} ч при плане {_fmt(plan_total)} ч: "
                f"недоработка {_fmt(-excess)} ч",
                kind="under", declared=declared,
            ))
            continue

        # Часы за сутки сошлись — но день с ночью могли разойтись, а ночные
        # оплачиваются иначе, поэтому это тоже расхождение.
        if (abs((f.hours_day or 0) - (p_day or 0)) > tolerance
                or abs((f.hours_night or 0) - (p_night or 0)) > tolerance):
            out.append(Discrepancy(
                day, p_day, p_night, f.hours_day, f.hours_night, f.day_code,
                f"часы за сутки сошлись, но по графику "
                f"{_fmt(p_day or 0)} д / {_fmt(p_night or 0)} н, "
                f"а в табеле {_fmt(f.hours_day)} д / {_fmt(f.hours_night)} н",
                kind="split", declared=declared,
            ))
    return out


@dataclass
class CompareSummary:
    days_checked: int
    discrepancies: int
    plan_hours: float
    fact_hours: float
    # Разрез по всему месяцу: из чего сложились отработанные часы
    night_hours: float = 0.0
    weekend_hours: float = 0.0
    overtime_hours: float = 0.0
    undeclared_hours: float = 0.0

    @property
    def delta_hours(self) -> float:
        return round(self.fact_hours - self.plan_hours, 2)


def summarize(
    plan: Iterable[PlanHours],
    fact: Iterable[FactDay],
    found: Iterable[Discrepancy],
) -> CompareSummary:
    plan_map = aggregate_plan(plan)
    fact_list = list(fact)
    found_list = list(found)
    plan_total = round(sum(d + n for d, n in plan_map.values()), 2)
    fact_total = round(sum(f.worked for f in fact_list), 2)
    return CompareSummary(
        days_checked=len(set(plan_map) | {f.work_date for f in fact_list}),
        discrepancies=len(found_list),
        plan_hours=plan_total,
        fact_hours=fact_total,
        night_hours=round(sum(f.hours_night for f in fact_list), 2),
        weekend_hours=round(sum(f.hours_weekend for f in fact_list), 2),
        overtime_hours=round(sum(f.hours_overtime for f in fact_list), 2),
        undeclared_hours=round(sum(d.undeclared for d in found_list), 2),
    )


@dataclass
class MonthRow:
    """
    Строка месячного разреза по сотруднику.

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

    plan_hours: float = 0.0
    plan_night: float = 0.0
    fact_hours: float = 0.0
    fact_night: float = 0.0
    weekend_hours: float = 0.0
    overtime_hours: float = 0.0
    worked_days: int = 0
    days_by_code: dict[str, int] = None  # type: ignore[assignment]
    discrepancies: int = 0
    undeclared: float = 0.0
    norm_hours: float = 0.0
    norm_excused: float = 0.0

    @property
    def delta_plan(self) -> float:
        """Факт минус план: столько отработано сверх графика или меньше него."""
        return round(self.fact_hours - self.plan_hours, 2)

    @property
    def deviation(self) -> float:
        """Факт минус персональная норма месяца."""
        return round(self.fact_hours - self.norm_hours, 2)

    @property
    def declared(self) -> float:
        return round(self.weekend_hours + self.overtime_hours, 2)


def month_row(
    plan: Iterable[PlanHours],
    fact: Iterable[FactDay],
    found: Iterable[Discrepancy],
    norm_hours: float = 0.0,
    norm_excused: float = 0.0,
) -> MonthRow:
    """Собрать месячный разрез одного сотрудника."""
    plan_map = aggregate_plan(plan)
    fact_list = list(fact)
    found_list = list(found)

    codes: dict[str, int] = {}
    for f in fact_list:
        if f.day_code:
            codes[f.day_code] = codes.get(f.day_code, 0) + 1

    return MonthRow(
        plan_hours=round(sum(d + n for d, n in plan_map.values()), 2),
        plan_night=round(sum(n for _, n in plan_map.values()), 2),
        fact_hours=round(sum(f.worked for f in fact_list), 2),
        fact_night=round(sum(f.hours_night for f in fact_list), 2),
        weekend_hours=round(sum(f.hours_weekend for f in fact_list), 2),
        overtime_hours=round(sum(f.hours_overtime for f in fact_list), 2),
        worked_days=sum(1 for f in fact_list if f.worked > 0),
        days_by_code=codes,
        discrepancies=len(found_list),
        undeclared=round(sum(d.undeclared for d in found_list), 2),
        norm_hours=round(norm_hours, 2),
        norm_excused=round(norm_excused, 2),
    )
