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

Проверяется арифметика по действующей методике: стоимость часа и оклад,
сделка, премия руководителя по шкале с поправкой на неполный оклад,
срезание сделки кладовщику, доплата за ночные, пересчёт в «грязные».

Цифры взяты не из головы, а из разбора действующего файла (`zp_logic.md`,
разделы 4 и 4а): базовые оклады 1400 / 1000 / 900 / 800, фонды КПИ
Барановичей 1200 / 1350 / 1300, вес показателя 0,25, шкала переносов по
первому критерию, налоговые коэффициенты 1,16279 и 1,14942.

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

from decimal import Decimal

import pytest

from timesheet.payroll import (
    EmployeeInput,
    KpiInput,
    Params,
    PayrollError,
    PieceworkLine,
    ScaleStep,
    calculate_line,
    calculate_run,
    money,
    scale_step,
)


D = Decimal

#  Шкала переносов по первому критерию — из листа «Мотивация»
TRANSFER_STEPS = (
    ScaleStep(1, D("0.07"),  D("1.0"), D("1.00")),
    ScaleStep(2, D("0.09"),  D("0.8"), D("0.93")),
    ScaleStep(3, D("0.11"),  D("0.6"), D("0.86")),
    ScaleStep(4, D("0.14"),  D("0.4"), D("0.80")),
    ScaleStep(5, D("0.15"),  D("0.2"), D("0.75")),
    ScaleStep(6, D("0.151"), D("0.0"), D("0.70")),
)

NORM = D("168")  # норма августа 2026 при 40-часовой неделе


def kpi(fact, weight="0.25", fund="1200", steps=TRANSFER_STEPS):
    return KpiInput(
        kpi_id=1, code="transfer_1", name="Переносы, критерий 1",
        better_when="lower", steps=steps,
        weight=D(weight), fund=D(fund),
        fact=D(fact) if fact is not None else None,
    )


def head(hours_day="168", hours_night="0", **kw):
    """Начальник депо: оклад 1400, сделки нет."""
    base = dict(
        employment_id=1, employee_id=1, position_id=1, position_category_id=1,
        category_code="head", is_piecework=False,
        fio_short="Иванов И.И.", personnel_no="3014990001",
        position_name="Начальник",
        base_salary=D("1400"), norm_hours=NORM,
        hours_day=D(hours_day), hours_night=D(hours_night), worked_days=21,
    )
    base.update(kw)
    return EmployeeInput(**base)


def storekeeper(hours_day="168", piecework=(), **kw):
    base = dict(
        employment_id=2, employee_id=2, position_id=4, position_category_id=4,
        category_code="storekeeper", is_piecework=True,
        fio_short="Петров П.П.", personnel_no="3014990002",
        position_name="Кладовщик",
        base_salary=D("800"), norm_hours=NORM,
        hours_day=D(hours_day), worked_days=21, piecework=piecework,
    )
    base.update(kw)
    return EmployeeInput(**base)


# ---------------------------------------------------------------------------
#  Шкала
# ---------------------------------------------------------------------------

def test_scale_takes_first_threshold_the_fact_did_not_exceed():
    #  0,08 при порогах 0,07 и 0,09 попадает на вторую ступень
    assert scale_step(TRANSFER_STEPS, D("0.08")).step_no == 2
    #  Ровно порог — это ещё та же ступень, а не следующая
    assert scale_step(TRANSFER_STEPS, D("0.07")).step_no == 1
    assert scale_step(TRANSFER_STEPS, D("0.00")).step_no == 1


def test_scale_beyond_last_threshold_gives_zero_step():
    step = scale_step(TRANSFER_STEPS, D("0.9"))
    assert step.step_no == 6
    assert step.coef_manager == D("0.0")


def test_scale_for_higher_is_better():
    steps = (
        ScaleStep(1, D("99"), D("1.0"), D("1.0")),
        ScaleStep(2, D("97"), D("0.5"), D("1.0")),
        ScaleStep(3, D("0"),  D("0.0"), D("1.0")),
    )
    assert scale_step(steps, D("99.5"), "higher").step_no == 1
    assert scale_step(steps, D("98"),   "higher").step_no == 2
    assert scale_step(steps, D("50"),   "higher").step_no == 3


# ---------------------------------------------------------------------------
#  Оклад
# ---------------------------------------------------------------------------

def test_full_month_pays_the_base_salary():
    line = calculate_line(head(), [kpi("0.05")])
    #  168 часов при норме 168 — ровно оклад категории
    assert line.amount_salary == D("1400.00")
    assert money(line.hour_rate) == D("8.33")


def test_half_month_pays_half():
    line = calculate_line(head(hours_day="84"), [kpi("0.05")])
    assert line.amount_salary == D("700.00")


def test_norm_not_set_blocks_calculation():
    with pytest.raises(PayrollError, match="норма месяца"):
        calculate_line(head(norm_hours=D("0")), [kpi("0.05")])


def test_salary_not_set_blocks_calculation():
    with pytest.raises(PayrollError, match="оклад"):
        calculate_line(head(base_salary=D("0")), [kpi("0.05")])


# ---------------------------------------------------------------------------
#  Премия руководителя
# ---------------------------------------------------------------------------

def test_manager_premium_is_fund_by_weight_by_coefficient():
    #  Барановичи, начальник: 1200 × 0,25 × 1,0 = 300 при факте 0,05
    line = calculate_line(head(), [kpi("0.05")])
    assert line.amount_kpi == D("300.00")
    assert line.kpi[0].step_no == 1


def test_manager_premium_falls_with_the_indicator():
    #  Факт 0,10 — третья ступень, коэффициент 0,6: 1200 × 0,25 × 0,6 = 180
    line = calculate_line(head(), [kpi("0.10")])
    assert line.amount_kpi == D("180.00")


def test_manager_premium_is_zero_past_the_last_threshold():
    line = calculate_line(head(), [kpi("0.2")])
    assert line.amount_kpi == D("0.00")


def test_incomplete_month_scales_the_premium_down():
    #  Отработал половину месяца — премия уменьшается в той же доле:
    #  300 × (700 / 1400) = 150
    line = calculate_line(head(hours_day="84"), [kpi("0.05")])
    assert line.amount_kpi == D("150.00")


def test_overtime_does_not_inflate_the_premium():
    #  Оклад больше базового: поправка не растёт выше единицы
    line = calculate_line(head(hours_day="200"), [kpi("0.05")])
    assert line.amount_kpi == D("300.00")


def test_missing_indicator_blocks_the_calculation():
    #  В таблице на этом месте стоит текст «ну не посчитали пока», который
    #  дальше молча попадает в арифметику премии
    with pytest.raises(PayrollError, match="не задан"):
        calculate_line(head(), [kpi(None)])


def test_indicator_without_scale_blocks_the_calculation():
    with pytest.raises(PayrollError, match="шкала"):
        calculate_line(head(), [kpi("0.05", steps=())])


# ---------------------------------------------------------------------------
#  Сделка и её срезание
# ---------------------------------------------------------------------------

PICKING = PieceworkLine(1, "picking", "Отбор", "qty", D("10000"), D("0.052"))
CONTROL = PieceworkLine(2, "control", "Контроль", "qty", D("5000"), D("0.036"))


def test_piecework_is_quantity_by_rate():
    line = calculate_line(storekeeper(piecework=(PICKING, CONTROL)),
                          [kpi("0.05", weight="0")])
    #  10 000 × 0,052 + 5 000 × 0,036 = 520 + 180
    assert line.amount_piecework == D("700.00")


def test_indicator_cuts_the_piecework_instead_of_paying_a_premium():
    #  Факт 0,10 — третья ступень, коэффициент к сделке 0,86.
    #  Срезается 14% от 700 = 98, и это отрицательная величина
    line = calculate_line(storekeeper(piecework=(PICKING, CONTROL)),
                          [kpi("0.10", weight="0")])
    assert line.amount_kpi == D("-98.00")
    assert line.net_total == D("800.00") + D("700.00") - D("98.00")


def test_indicator_at_the_best_step_does_not_cut_anything():
    line = calculate_line(storekeeper(piecework=(PICKING,)),
                          [kpi("0.05", weight="0")])
    assert line.amount_kpi == D("0.00")


def test_managers_have_no_piecework_even_if_operations_slipped_in():
    line = calculate_line(head(piecework=(PICKING,)), [kpi("0.05")])
    assert line.amount_piecework == D("0.00")


def test_productivity_is_piecework_per_hour():
    line = calculate_line(storekeeper(piecework=(PICKING, CONTROL)),
                          [kpi("0.05", weight="0")])
    #  700 / 168
    assert line.productivity == D("4.1667")


# ---------------------------------------------------------------------------
#  Ночные
# ---------------------------------------------------------------------------

def test_night_premium_is_a_surcharge_not_a_second_payment():
    #  Ночные часы уже оплачены в окладе; доплата — 20% стоимости часа
    line = calculate_line(head(hours_day="118", hours_night="50"),
                          [kpi("0.05")])
    assert line.amount_salary == D("1400.00")
    #  50 × (1400 / 168) × 0,2 = 83,33
    assert line.amount_night == D("83.33")


def test_night_premium_coefficient_comes_from_parameters():
    line = calculate_line(head(hours_day="118", hours_night="50"),
                          [kpi("0.05")],
                          Params(night_premium=D("1.4")))
    assert line.amount_night == D("166.67")


# ---------------------------------------------------------------------------
#  Работа в выходной и сверхурочные
# ---------------------------------------------------------------------------

def test_weekend_and_overtime_stay_out_of_the_net_total():
    """
    Так устроен действующий расчёт: эти часы оплачиваются приказом через
    бухгалтерию, а не строкой расчётного листа. В итог они не входят, но
    показываются справочно — иначе приказ не с чем сверить.
    """
    plain = calculate_line(head(), [kpi("0.05")])
    with_extra = calculate_line(
        head(hours_weekend=D("8"), hours_overtime=D("4")), [kpi("0.05")])

    assert with_extra.net_total == plain.net_total
    assert with_extra.amount_weekend_ref == D("66.67")   # 8 × 8,3333
    assert with_extra.amount_overtime_ref == D("33.33")  # 4 × 8,3333
    #  Колонка «за месяц без вычетов» их содержит
    assert with_extra.amount_no_deductions > plain.amount_no_deductions


# ---------------------------------------------------------------------------
#  Вычеты, доплаты, топливо
# ---------------------------------------------------------------------------

def test_deductions_and_additions_move_the_net_total():
    line = calculate_line(
        head(additions=D("50"), deductions=D("30"), fuel_excess=D("12.50")),
        [kpi("0.05")])
    assert line.amount_additions == D("50.00")
    assert line.amount_deductions == D("30.00")
    assert line.amount_fuel == D("12.50")
    assert line.net_total == D("1400") + D("300") + D("50") - D("30") - D("12.50")


def test_negative_fuel_excess_is_not_a_bonus():
    #  Израсходовал меньше нормы — это не доплата, а ноль
    line = calculate_line(head(fuel_excess=D("-40")), [kpi("0.05")])
    assert line.amount_fuel == D("0.00")


# ---------------------------------------------------------------------------
#  Пересчёт в «грязные»
# ---------------------------------------------------------------------------

def test_gross_uses_the_inverse_of_the_withholdings():
    line = calculate_line(head(), [kpi("0.05")])
    #  1400 × 1,16279
    assert line.gross_salary == D("1627.91")
    #  Премия: 300 × 1,16279
    assert line.gross_premium == D("348.84")
    assert line.gross_total == (line.gross_salary + line.gross_premium
                                + line.gross_night + line.gross_compensation)


def test_fuel_compensation_uses_its_own_coefficient():
    line = calculate_line(head(fuel_compensation=D("100")), [kpi("0.05")])
    #  100 × 1,14942
    assert line.gross_compensation == D("114.94")
    #  И вычитается из премии до пересчёта, чтобы не удвоиться в итоге
    assert line.gross_premium == money(
        (D("300") - D("114.94") / D("1.14942")) * D("1.16279"))


# ---------------------------------------------------------------------------
#  Округление
# ---------------------------------------------------------------------------

def test_every_saved_amount_is_rounded_to_kopecks():
    line = calculate_line(head(hours_day="167"), [kpi("0.05")])
    for value in (line.amount_salary, line.amount_kpi, line.amount_night,
                  line.net_total, line.gross_total):
        assert value == value.quantize(D("0.01"))


def test_half_kopeck_rounds_up_not_to_even():
    #  Банковское округление увело бы 0,005 вниз, и итог разошёлся бы с
    #  ведомостью на копейки
    assert money(D("2732.5565")) == D("2732.56")
    assert money(D("0.005")) == D("0.01")
    assert money(D("0.015")) == D("0.02")


# ---------------------------------------------------------------------------
#  Депо целиком
# ---------------------------------------------------------------------------

def test_run_calculates_every_person_with_the_kpis_of_their_category():
    people = [head(), storekeeper(piecework=(PICKING,))]
    kpis = {1: [kpi("0.10")], 4: [kpi("0.10", weight="0")]}
    run = calculate_run(people, kpis)

    assert len(run.lines) == 2
    #  Начальнику — премия, кладовщику — срезание сделки
    assert run.lines[0].amount_kpi > 0
    assert run.lines[1].amount_kpi < 0
    assert run.total("net_total") == money(
        run.lines[0].net_total + run.lines[1].net_total)


def test_piecework_distribution_needs_the_plan():
    people = [storekeeper(piecework=(PICKING,))]
    kpis = {4: [kpi("0.05", weight="0")]}

    without_plan = calculate_run(people, kpis)
    assert without_plan.piecework_gap is None

    with_plan = calculate_run(people, kpis, Params(piecework_plan=D("1000")))
    #  План на отработанные часы: 1000 / 168 × 168 = 1000, факт 520
    assert with_plan.piecework_gap == D("480.00")
    assert with_plan.piecework_share[2] == D("480.00")
