"""
Движок расчёта заработной платы.

Чистая арифметика: на входе — уже собранные данные сотрудника и месяца, на
выходе — расчётная строка. Ни базы, ни запросов: только так расчёт можно
прогнать на закрытом месяце и сверить с тем, что фактически выплачено.

Алгоритм повторяет лист «Расчет ЗП» файла депо (реконструкция в
`zp_logic.md`, разделы 4 и 4а), с исправлениями, которые в таблице сделать
было нельзя:

*   **ключ — назначение, а не ФИО.** В таблице все `XLOOKUP` и `SUMIFS` идут
    по текстовому ФИО: опечатка или однофамилец теряют или склеивают
    начисления;
*   **категория должности — поле справочника**, а не первое слово строки
    должности и не `REGEXMATCH(должность; "Кладовщик")`;
*   **округление есть.** В таблице нет ни одного `ROUND`, и в итог уходит
    2732,5565. Здесь каждая сохраняемая сумма округляется до копеек;
*   **показатель без факта блокирует расчёт.** В таблице на его месте стоит
    текст «ну не посчитали пока», который дальше попадает в арифметику
    премии;
*   **ставки и коэффициенты приходят с датой действия** — прошлый месяц не
    пересчитывается после правки справочника.

Чего здесь сознательно нет:

*   **часов на штабелере.** Исключены из проекта решением заказчика,
    миграция `06_drop_stacker.sql`;
*   **контроля минимальной ЗП.** Оклады категорий перекрывают минимальную
    зарплату по РБ при полностью отработанном месяце, поэтому доводить
    начисление до минимума расчёт не должен: это было бы решением за
    нанимателя. Поле `min_wage_applied` в схеме остаётся незаполненным;
*   **оплаты работы в выходной и сверхурочных в итоге.** Так же, как в
    действующем файле: эти часы проходят по бухгалтерскому учёту отдельно,
    на основании приказа. Расчёт показывает их справочно — часами и суммой по
    одинарной стоимости часа, — чтобы приказ было с чем сверить.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from decimal import Decimal, ROUND_HALF_UP
from typing import Iterable, Sequence

#  Округление денег. Именованная константа, а не «round(x, 2)» по коду:
#  правило округления — часть алгоритма расчёта, и оно должно быть в одном
#  месте, чтобы его можно было и найти, и изменить целиком.
CENT = Decimal("0.01")


def money(value: object) -> Decimal:
    """
    Сумма к копейкам, полукруглением вверх.

    Банковское округление (его использует `round` в Python) на .005 уводит
    половину сумм вниз, и итог расходится с ведомостью на копейки. В
    зарплате принято привычное арифметическое: 0,005 → 0,01.
    """
    if value is None:
        return Decimal("0.00")
    if not isinstance(value, Decimal):
        value = Decimal(str(value))
    return value.quantize(CENT, rounding=ROUND_HALF_UP)


def dec(value: object) -> Decimal:
    """Число в Decimal без округления — для промежуточных величин."""
    if value is None:
        return Decimal("0")
    if isinstance(value, Decimal):
        return value
    return Decimal(str(value))


# ---------------------------------------------------------------------------
#  Вход
# ---------------------------------------------------------------------------

@dataclass(frozen=True)
class ScaleStep:
    """Ступень шкалы показателя."""

    step_no: int
    threshold: Decimal
    coef_manager: Decimal    # доля премии руководителю
    coef_piecework: Decimal  # коэффициент к сделке кладовщика


@dataclass(frozen=True)
class KpiInput:
    """Показатель со шкалой, весом, фондом и фактом за месяц."""

    kpi_id: int
    code: str
    name: str
    better_when: str                 # 'lower' | 'higher'
    steps: tuple[ScaleStep, ...]
    weight: Decimal                  # вес показателя у этой категории должностей
    fund: Decimal                    # фонд КПИ пары «депо + должность»
    fact: Decimal | None             # None — показатель за месяц не задан


@dataclass(frozen=True)
class PieceworkLine:
    """Строка выработки: операция, единица измерения, количество и ставка."""

    operation_type_id: int
    code: str
    name: str
    unit: str                        # 'qty' | 'weight' | 'volume'
    qty: Decimal
    rate: Decimal

    @property
    def amount(self) -> Decimal:
        return self.qty * self.rate


@dataclass(frozen=True)
class Params:
    """Коэффициенты расчёта на дату месяца."""

    gross_coef_salary: Decimal = Decimal("1.16279")
    gross_coef_compensation: Decimal = Decimal("1.14942")
    night_premium: Decimal = Decimal("1.2")
    #  Плановая сделка на одного кладовщика за месяц. Нужна только для
    #  распределения план-факта сделки; пока не заведена — колонка пустая.
    piecework_plan: Decimal | None = None


@dataclass(frozen=True)
class EmployeeInput:
    """Всё, что нужно для расчёта одного человека за месяц."""

    employment_id: int
    employee_id: int
    position_id: int
    position_category_id: int
    category_code: str               # head | deputy | master | storekeeper
    is_piecework: bool
    fio_short: str
    personnel_no: str
    position_name: str

    base_salary: Decimal             # оклад категории на месяц расчёта
    norm_hours: Decimal              # норма месяца при 40-часовой неделе

    hours_day: Decimal = Decimal("0")
    hours_night: Decimal = Decimal("0")
    hours_weekend: Decimal = Decimal("0")
    hours_overtime: Decimal = Decimal("0")
    worked_days: int = 0

    piecework: tuple[PieceworkLine, ...] = ()
    additions: Decimal = Decimal("0")      # согласованные доплаты
    deductions: Decimal = Decimal("0")     # согласованные вычеты
    fuel_excess: Decimal = Decimal("0")    # вычет за перерасход топлива
    fuel_compensation: Decimal = Decimal("0")  # месячная норма компенсации, руб.

    @property
    def hours_total(self) -> Decimal:
        return self.hours_day + self.hours_night


# ---------------------------------------------------------------------------
#  Выход
# ---------------------------------------------------------------------------

@dataclass
class KpiResult:
    kpi_id: int
    code: str
    name: str
    fact: Decimal | None
    step_no: int | None
    weight: Decimal
    coef: Decimal
    fund: Decimal
    amount: Decimal


@dataclass
class PieceworkResult:
    operation_type_id: int
    code: str
    name: str
    unit: str
    qty: Decimal
    rate: Decimal
    amount: Decimal


@dataclass
class PayrollLine:
    """Расчётная строка — то, что ложится в payroll_line."""

    person: EmployeeInput

    hour_rate: Decimal = Decimal("0")
    amount_salary: Decimal = Decimal("0")
    amount_piecework: Decimal = Decimal("0")
    amount_night: Decimal = Decimal("0")
    amount_kpi: Decimal = Decimal("0")
    amount_additions: Decimal = Decimal("0")
    amount_deductions: Decimal = Decimal("0")
    amount_fuel: Decimal = Decimal("0")
    net_total: Decimal = Decimal("0")

    #  Справочно: работа в выходной и сверхурочные по одинарной стоимости
    #  часа. В итог не входят — оплачиваются приказом через бухгалтерию.
    amount_weekend_ref: Decimal = Decimal("0")
    amount_overtime_ref: Decimal = Decimal("0")
    amount_no_deductions: Decimal = Decimal("0")

    gross_salary: Decimal = Decimal("0")
    gross_premium: Decimal = Decimal("0")
    gross_night: Decimal = Decimal("0")
    gross_compensation: Decimal = Decimal("0")
    gross_total: Decimal = Decimal("0")

    productivity: Decimal | None = None       # сделка на час, у кладовщиков

    kpi: list[KpiResult] = field(default_factory=list)
    piecework: list[PieceworkResult] = field(default_factory=list)
    notes: list[str] = field(default_factory=list)


class PayrollError(Exception):
    """Расчёт невозможен: не хватает исходных данных."""


# ---------------------------------------------------------------------------
#  Шкала показателя
# ---------------------------------------------------------------------------

def scale_step(steps: Sequence[ScaleStep], fact: Decimal,
               better_when: str = "lower") -> ScaleStep | None:
    """
    Ступень шкалы по факту показателя.

    В таблице это `XLOOKUP` с приблизительным совпадением. Для показателя,
    где меньше — лучше (все четыре действующих такие), берётся первая
    ступень, порог которой факт не превысил: 0,08 при порогах 0,07 / 0,09
    попадает на 0,09. Факт хуже последнего порога — последняя ступень, у неё
    коэффициент нулевой.

    Показатель «чем больше, тем лучше» в действующей модели не встречается,
    но справочник его допускает, поэтому правило описано и для него: берётся
    первая ступень сверху, порог которой факт перекрыл.
    """
    if not steps:
        return None
    if better_when == "higher":
        ordered = sorted(steps, key=lambda s: s.threshold, reverse=True)
        for s in ordered:
            if fact >= s.threshold:
                return s
        return ordered[-1]
    ordered = sorted(steps, key=lambda s: s.threshold)
    for s in ordered:
        if fact <= s.threshold:
            return s
    return ordered[-1]


# ---------------------------------------------------------------------------
#  Расчёт одного человека
# ---------------------------------------------------------------------------

def calculate_line(person: EmployeeInput, kpis: Iterable[KpiInput],
                   params: Params = Params()) -> PayrollLine:
    """
    Расчётная строка одного сотрудника за месяц.

    Порядок шагов — как в листе «Расчет ЗП»: стоимость часа и оклад, сделка,
    премии за показатели, доплата за ночные, вычеты и доплаты, итог чистыми,
    пересчёт в «грязные» для бухгалтерии.
    """
    line = PayrollLine(person=person)

    if person.norm_hours <= 0:
        raise PayrollError(
            f"{person.fio_short}: норма месяца не задана — стоимость часа "
            f"не из чего посчитать. Норма вносится в «Базовых настройках»."
        )
    if person.base_salary <= 0:
        raise PayrollError(
            f"{person.fio_short}: не задан оклад категории «{person.category_code}». "
            f"Оклады вносятся в «Базовых настройках»."
        )

    # --- Шаг 1. Стоимость часа и оклад ------------------------------------
    #  Стоимость часа считается от нормы месяца, а не от персональной нормы
    #  работника: так устроен действующий расчёт, и так час стоит одинаково
    #  у всех в категории независимо от отпусков. Отпуск влияет на оклад
    #  через отработанные часы, которых в этом месяце меньше.
    line.hour_rate = person.base_salary / person.norm_hours
    line.amount_salary = money(person.hours_total * line.hour_rate)

    # --- Шаг 2. Сделка ----------------------------------------------------
    #  Только у категорий со сдельной частью — признак берётся из справочника
    #  должностей, а не из совпадения строки «Кладовщик» в названии.
    piecework_total = Decimal("0")
    if person.is_piecework:
        for pl in person.piecework:
            amount = money(pl.amount)
            piecework_total += amount
            line.piecework.append(PieceworkResult(
                operation_type_id=pl.operation_type_id, code=pl.code,
                name=pl.name, unit=pl.unit, qty=pl.qty, rate=pl.rate,
                amount=amount,
            ))
    line.amount_piecework = money(piecework_total)

    # --- Шаг 3. Премии за показатели --------------------------------------
    kpi_total = Decimal("0")
    for k in kpis:
        if k.fact is None:
            raise PayrollError(
                f"Показатель «{k.name}» за этот месяц не задан. "
                f"Внесите его на вкладке «Показатели» — без факта премия "
                f"посчиталась бы от нуля, и это было бы незаметно."
            )
        step = scale_step(k.steps, k.fact, k.better_when)
        if step is None:
            raise PayrollError(
                f"У показателя «{k.name}» не заведена шкала. "
                f"Шкала вносится в «Базовых настройках»."
            )

        if person.is_piecework:
            #  Кладовщику премия по КПИ не начисляется: вес у него нулевой.
            #  Вместо неё показатель срезает сделку — и только вниз.
            coef = step.coef_piecework
            amount = money(-(Decimal("1") - coef) * line.amount_piecework)
        else:
            coef = step.coef_manager
            base = k.fund * k.weight * coef
            #  Поправка на неполный оклад: отработал меньше месяца — премия
            #  уменьшается в той же доле. Больше единицы поправка не растёт:
            #  переработка премию не увеличивает.
            share = Decimal("1")
            if person.base_salary > 0 and line.amount_salary < person.base_salary:
                share = line.amount_salary / person.base_salary
            amount = money(base * share)

        kpi_total += amount
        line.kpi.append(KpiResult(
            kpi_id=k.kpi_id, code=k.code, name=k.name, fact=k.fact,
            step_no=step.step_no, weight=k.weight, coef=coef,
            fund=k.fund, amount=amount,
        ))
    line.amount_kpi = money(kpi_total)

    # --- Шаг 4. Доплата за ночные -----------------------------------------
    #  Надбавка, а не полная стоимость: сами ночные часы уже оплачены в
    #  окладе. При коэффициенте 1,2 это 20% стоимости часа.
    night_extra = person.hours_night * line.hour_rate * (params.night_premium - Decimal("1"))
    line.amount_night = money(night_extra)

    # --- Шаг 5. Вычеты, доплаты, топливо ----------------------------------
    line.amount_additions = money(person.additions)
    line.amount_deductions = money(person.deductions)
    line.amount_fuel = money(max(person.fuel_excess, Decimal("0")))

    # --- Шаг 6. Итог чистыми ----------------------------------------------
    line.net_total = money(
        line.amount_salary
        + line.amount_piecework
        + line.amount_kpi
        - line.amount_deductions
        + line.amount_additions
        - line.amount_fuel
        + line.amount_night
    )

    #  Справочно: часы работы в выходной и сверхурочные по одинарной
    #  стоимости часа. Это колонка K действующего файла — «за месяц без
    #  вычетов»; в итог чистыми она не входит ни там, ни здесь.
    line.amount_weekend_ref = money(person.hours_weekend * line.hour_rate)
    line.amount_overtime_ref = money(person.hours_overtime * line.hour_rate)
    line.amount_no_deductions = money(
        line.amount_weekend_ref + line.amount_overtime_ref
        + line.amount_salary + line.amount_piecework
        + line.amount_kpi + line.amount_night
    )

    # --- Шаг 7. Пересчёт в «грязные» для бухгалтерии -----------------------
    #  Информативно и приближённо: точные суммы приходят ведомостью от
    #  бухгалтерии. Коэффициенты — обратные к удержаниям: 1/0,86 по зарплате
    #  (13% подоходный и 1% ФСЗН) и 1/0,87 по компенсации (только 13%).
    line.gross_compensation = money(person.fuel_compensation * params.gross_coef_compensation)
    line.gross_salary = money(line.amount_salary * params.gross_coef_salary)
    line.gross_night = money(line.amount_night * params.gross_coef_salary)
    premium_net = (
        line.amount_piecework + line.amount_kpi
        + line.amount_additions - line.amount_deductions
        - (line.gross_compensation / params.gross_coef_compensation
           if params.gross_coef_compensation else Decimal("0"))
    )
    line.gross_premium = money(premium_net * params.gross_coef_salary)
    line.gross_total = money(
        line.gross_salary + line.gross_premium
        + line.gross_night + line.gross_compensation
    )

    # --- Шаг 8. Производительность ----------------------------------------
    if person.is_piecework and person.hours_total > 0:
        line.productivity = (line.amount_piecework / person.hours_total).quantize(
            Decimal("0.0001"), rounding=ROUND_HALF_UP)

    if person.hours_total == 0 and not person.worked_days:
        line.notes.append("часов в табеле нет")

    return line


# ---------------------------------------------------------------------------
#  Расчёт депо за месяц
# ---------------------------------------------------------------------------

@dataclass
class PayrollRun:
    """Расчёт депо за месяц: строки и итоги."""

    lines: list[PayrollLine] = field(default_factory=list)
    #  План-факт сделки по депо и его распределение между кладовщиками.
    #  Считается, только когда заведена плановая сделка на кладовщика.
    piecework_gap: Decimal | None = None
    piecework_share: dict[int, Decimal] = field(default_factory=dict)

    def total(self, attr: str) -> Decimal:
        return money(sum((getattr(l, attr) for l in self.lines), Decimal("0")))

    def hours(self, attr: str) -> Decimal:
        return sum((getattr(l.person, attr) for l in self.lines), Decimal("0"))


def calculate_run(people: Sequence[EmployeeInput],
                  kpis_by_category: dict[int, list[KpiInput]],
                  params: Params = Params()) -> PayrollRun:
    """
    Расчёт по всему депо за месяц.

    `kpis_by_category` — показатели с весами и фондами, разобранные по
    категориям должностей: вес и фонд у начальника и кладовщика разные, а
    шкала и факт общие.
    """
    run = PayrollRun()
    for person in people:
        kpis = kpis_by_category.get(person.position_category_id, [])
        run.lines.append(calculate_line(person, kpis, params))

    _piecework_distribution(run, params)
    return run


def _piecework_distribution(run: PayrollRun, params: Params) -> None:
    """
    План-факт сделки кладовщиков и его распределение.

    В действующем файле это колонки Y2 и X. Формула там записана как
    `(U2 × план) / (Н × U2) × Σчасов − Σсделки`, где `U2` — численность
    кладовщиков; она сокращается, поэтому численность в расчёте не нужна
    вовсе, хотя ради неё файл ходит в центральную таблицу по захардкоженному
    ключу.

    Считается, только когда заведена плановая сделка на кладовщика: пока
    операции из 1С не загружаются, сделка нулевая, и распределять нечего.
    """
    if params.piecework_plan is None:
        return
    piece_lines = [l for l in run.lines if l.person.is_piecework]
    if not piece_lines:
        return
    hours = sum((l.person.hours_total for l in piece_lines), Decimal("0"))
    norm = piece_lines[0].person.norm_hours
    if hours <= 0 or norm <= 0:
        return

    planned = params.piecework_plan / norm * hours
    fact = sum((l.amount_piecework for l in piece_lines), Decimal("0"))
    run.piecework_gap = money(planned - fact)

    total_productivity = sum(
        (l.productivity or Decimal("0")) for l in piece_lines)
    if total_productivity <= 0:
        return
    for l in piece_lines:
        share = (l.productivity or Decimal("0")) / total_productivity
        run.piecework_share[l.person.employment_id] = money(run.piecework_gap * share)
