"""
Итоги табеля учёта рабочего времени.

Повторяет сводную часть действующего листа «Табель» (колонки BO..BY):
Раб. дней | К | Б | О | Р | ОЖ | Раб. часы | Раб. часы ночь | В | П | А

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

from __future__ import annotations

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

# Коды дней, считающиеся неявкой по уважительной причине
EXCUSED_CODES = ("О", "Б", "К", "Р", "ОЖ", "А")

# Порядок колонок сводной части печатной формы
SUMMARY_CODES = ("К", "Б", "О", "Р", "ОЖ", "В", "П", "А")


@dataclass(frozen=True)
class FactDay:
    """Строка фактического табеля за один день."""

    work_date: date
    day_code: str | None = None
    hours_day: float = 0.0
    hours_night: float = 0.0
    hours_weekend: float = 0.0
    hours_overtime: float = 0.0

    @property
    def worked(self) -> float:
        return round(self.hours_day + self.hours_night, 2)

    def validate(self) -> list[str]:
        errors: list[str] = []
        if self.day_code is None and self.worked <= 0:
            errors.append(f"{self.work_date}: не указаны ни часы, ни код дня")
        if self.day_code is not None and self.worked > 0 and self.day_code in EXCUSED_CODES:
            errors.append(
                f"{self.work_date}: код «{self.day_code}» вместе с отработанными часами"
            )
        for name in ("hours_weekend", "hours_overtime"):
            if getattr(self, name) > self.worked + 1e-9:
                errors.append(f"{self.work_date}: {name} больше отработанных часов")
        if self.worked > 24 + 1e-9:
            errors.append(f"{self.work_date}: больше 24 часов в сутки")
        return errors


@dataclass
class Totals:
    worked_days: int = 0
    hours_day: float = 0.0
    hours_night: float = 0.0
    hours_weekend: float = 0.0
    hours_overtime: float = 0.0
    days_by_code: dict[str, int] = field(default_factory=dict)

    @property
    def hours_total(self) -> float:
        return round(self.hours_day + self.hours_night, 2)

    def code(self, code: str) -> int:
        return self.days_by_code.get(code, 0)

    def as_summary_row(self) -> dict[str, float | int]:
        """Сводная часть в терминах печатной формы."""
        return {
            "Раб. дней": self.worked_days,
            "К": self.code("К"),
            "Б": self.code("Б"),
            "О": self.code("О"),
            "Р": self.code("Р"),
            "ОЖ": self.code("ОЖ"),
            "Раб. часы": self.hours_total,
            "Раб. часы ночь": self.hours_night,
            "В": self.code("В"),
            "П": self.code("П"),
            "А": self.code("А"),
        }


def compute_totals(days: Iterable[FactDay]) -> Totals:
    t = Totals()
    for d in days:
        if d.worked > 0:
            t.worked_days += 1
            t.hours_day += d.hours_day
            t.hours_night += d.hours_night
            t.hours_weekend += d.hours_weekend
            t.hours_overtime += d.hours_overtime
        if d.day_code:
            t.days_by_code[d.day_code] = t.days_by_code.get(d.day_code, 0) + 1
    t.hours_day = round(t.hours_day, 2)
    t.hours_night = round(t.hours_night, 2)
    t.hours_weekend = round(t.hours_weekend, 2)
    t.hours_overtime = round(t.hours_overtime, 2)
    return t


def validate_days(days: Iterable[FactDay]) -> list[str]:
    errors: list[str] = []
    seen: set[date] = set()
    for d in days:
        if d.work_date in seen:
            errors.append(f"{d.work_date}: день встречается дважды")
        seen.add(d.work_date)
        errors.extend(d.validate())
    return errors


@dataclass
class NormComparison:
    hours_total: float
    norm_hours: float
    deviation: float          # + переработка, − недоработка
    overtime_declared: float  # сверхурочные, заявленные в табеле

    @property
    def is_matched(self) -> bool:
        return abs(self.deviation) < 0.01


def compare_with_norm(
    totals: Totals,
    norm_hours: float,
) -> NormComparison:
    """Сравнить отработанное с нормой месяца."""
    deviation = round(totals.hours_total - norm_hours, 2)
    return NormComparison(
        hours_total=totals.hours_total,
        norm_hours=round(norm_hours, 2),
        deviation=deviation,
        overtime_declared=totals.hours_overtime,
    )


def parse_legacy_cell(value: object) -> FactDay | None:
    """
    Разобрать клетку табеля из старой таблицы.

    Понимает форматы, которые встречаются в действующих файлах:
      11        → 11 часов
      В / О / Б → код дня
      «РВ 4»    → 4 часа, из них 4 — работа в выходной
      «4 С»     → 4 часа, из них 4 — сверхурочные

    Используется только при миграции. Дата подставляется вызывающим кодом.
    """
    if value is None:
        return None
    if isinstance(value, (int, float)):
        return FactDay(work_date=date.min, hours_day=float(value))

    text = str(value).strip()
    if not text:
        return None

    upper = text.upper().replace("Ё", "Е")

    if upper.startswith("РВ"):
        rest = text[2:].strip().replace(",", ".")
        hours = float(rest) if rest else 0.0
        return FactDay(work_date=date.min, hours_day=hours, hours_weekend=hours)

    if upper.endswith("С") and upper[:-1].strip().replace(",", ".").replace(".", "").isdigit():
        hours = float(upper[:-1].strip().replace(",", "."))
        return FactDay(work_date=date.min, hours_day=hours, hours_overtime=hours)

    if upper.startswith("Ш"):
        rest = upper[1:].strip().replace(",", ".")
        hours = float(rest) if rest else 0.0
        return FactDay(work_date=date.min, hours_day=hours)

    try:
        return FactDay(work_date=date.min, hours_day=float(text.replace(",", ".")))
    except ValueError:
        return FactDay(work_date=date.min, day_code=text)
