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

from datetime import date, time

from timesheet.compare import aggregate_plan, compare, summarize
from timesheet.rules import LEGACY_BREAK, NO_BREAK, ShiftRow, plan_hours, split_shift
from timesheet.totals import FactDay


def d(n: int) -> date:
    return date(2026, 8, n)


def plan_for(days: list[int], start=time(9), end=time(18), rule=NO_BREAK):
    out = []
    for n in days:
        out.extend(split_shift(d(n), start, end, break_rule=rule))
    return out


def test_no_discrepancies_when_fact_matches_plan():
    plan = plan_for([1, 2, 3])
    fact = [FactDay(work_date=d(n), hours_day=9.0) for n in (1, 2, 3)]
    assert compare(plan, fact) == []


def test_detects_hours_difference():
    """Смена 9 часов, в табеле 11, и лишние 2 часа ничем не оформлены."""
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=11.0)]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "over"
    assert found[0].undeclared == 2.0
    assert "не оформлено 2 ч" in found[0].reason
    assert found[0].delta_day == 2.0


def test_excess_declared_as_overtime_is_not_a_discrepancy():
    """
    Те же 11 часов при плане 9, 2 часа заявлены сверхурочными и оформлено
    привлечение — сверка молчит: переработка оформлена приказом.
    """
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=11.0, hours_overtime=2.0)]
    assert compare(plan, fact, ordered={d(1): "overtime"}) == []


def test_a_flag_without_an_order_is_a_discrepancy():
    """
    24.09.2026: «С» или «РВ» в клетке без оформленного привлечения —
    расхождение. Иначе «РВ 11» без докладной сверка не замечала.
    """
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=11.0, hours_overtime=2.0),
            FactDay(work_date=d(2), hours_day=11.0, hours_weekend=11.0)]
    found = compare(plan, fact)
    assert [x.kind for x in found] == ["unordered", "unordered"]
    assert "«РВ» 11 ч" in found[1].reason and "Оформить привлечение" in found[1].reason


def test_the_order_must_be_of_the_same_kind():
    #  На «РВ» нужна докладная о работе в выходной, не о сверхурочной
    fact = [FactDay(work_date=d(2), hours_day=8.0, hours_weekend=8.0)]
    assert compare([], fact, ordered={d(2): "overtime"})[0].kind == "unordered"
    assert compare([], fact, ordered={d(2): "weekend"}) == []


def test_an_empty_past_day_needs_a_day_off_mark():
    """24.09.2026: выходной тоже проставляется — буквой «В»."""
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=9.0),
            FactDay(work_date=d(3), day_code="В")]
    found = compare(plan, fact, days=[d(1), d(2), d(3)])
    assert [(x.work_date, x.kind) for x in found] == [(d(2), "empty")]
    #  Без списка обязательных дней — как раньше
    assert compare(plan, fact) == []


def test_excess_declared_partially_leaves_the_rest_visible():
    """Признак без оформления: часы признака — неоформленные."""
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=11.0, hours_overtime=1.0)]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "unordered"
    assert found[0].undeclared == 1.0


def test_shortfall_against_plan_is_reported():
    """Меньше плана — недоработка, её тоже надо увидеть до сдачи."""
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=7.0)]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "under"
    assert "недоработка 2 ч" in found[0].reason
    assert found[0].undeclared == 0.0


def test_tolerance_absorbs_small_difference():
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), hours_day=9.05)]
    assert compare(plan, fact, tolerance=0.1) == []


def test_missing_day_in_timesheet():
    plan = plan_for([1, 2])
    fact = [FactDay(work_date=d(1), hours_day=9.0)]
    found = compare(plan, fact)
    assert [f.reason for f in found] == ["нет строки в табеле"]
    assert found[0].work_date == d(2)


def test_missing_row_is_not_reported_for_future_days():
    """07.10.2026, правка заказчика: если сегодня 7-е, «нет данных по 8-е»
    не выводится — смена ещё не наступила, табель будущего не касается."""
    plan = plan_for([1, 2, 3])          # 1, 2, 3 августа
    fact = [FactDay(work_date=d(1), hours_day=9.0)]
    #  today = 2-е: по 3-е «нет строки» не показывается, по 2-е — показывается
    found = compare(plan, fact, today=d(2))
    assert [(f.work_date, f.kind) for f in found] == [(d(2), "missing")]
    #  без границы — как раньше: видно всё, включая будущее
    assert len(compare(plan, fact)) == 2


def test_future_ordered_day_is_not_missing_yet():
    """Вызов оформлен на будущее — часов в табеле нет и не должно быть:
    расхождение появится, когда день наступит."""
    plan = plan_for([3])
    found = compare(plan, [], ordered={d(3): "weekend"}, today=d(2))
    assert found == []
    found = compare(plan, [], ordered={d(3): "weekend"}, today=d(3))
    assert [f.kind for f in found] == ["ordered_missing"]


def test_worked_without_shift_in_schedule():
    """Работа в день без смены: сама по себе не нарушение, а неоформленная — да."""
    plan = plan_for([1])
    fact = [
        FactDay(work_date=d(1), hours_day=9.0),
        FactDay(work_date=d(2), hours_day=8.0),
    ]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "unplanned"
    assert found[0].undeclared == 8.0


def test_call_out_declared_as_weekend_work_is_not_a_discrepancy():
    """Вызов в выходной: «РВ» и докладная — расхождением не считается."""
    plan = plan_for([1])
    fact = [
        FactDay(work_date=d(1), hours_day=9.0),
        FactDay(work_date=d(2), hours_day=8.0, hours_weekend=8.0),
    ]
    assert compare(plan, fact, ordered={d(2): "weekend"}) == []


def test_coded_day_skipped_by_default():
    """Больничный вместо смены — расхождение по умолчанию не показывается."""
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="Б")]
    assert compare(plan, fact) == []


def test_coded_day_reported_when_requested():
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="Б")]
    found = compare(plan, fact, skip_coded=False)
    assert len(found) == 1
    assert "в табеле код «Б»" in found[0].reason


# ---------------------------------------------------------------------------
#  День отсутствия, в котором есть часы
# ---------------------------------------------------------------------------
#
#  Случай Слинко за 29.08.2026. Учёт идёт календарными сутками: отпуск
#  занимает день целиком, до 24:00, а плановая смена начинается с 00:00
#  следующих суток — её хвост считается уже там. План с дня отпуска не
#  требуется, иначе у человека в отпуске выходила «недоработка 4 ч».
#  Отработанные в этот день часы, наоборот, показать надо: работа в отпуске
#  без отзыва — нарушение.

def test_vacation_day_does_not_demand_the_plan():
    plan = plan_for([1])              # смена 9 часов
    fact = [FactDay(work_date=d(1), day_code="О", hours_night=2.0)]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "coded_work"
    #  Недоработки нет: план с дня отпуска не спрашивают
    assert "недоработка" not in found[0].reason
    assert found[0].plan_day is None and found[0].plan_night is None


def test_work_on_a_vacation_day_is_an_error_not_a_note():
    """
    Решение заказчика от 21.09.2026: учёт в календарных днях, код и часы в
    одних сутках несовместимы. Работа в день отпуска — это отзыв приказом, и
    тогда код снимается, а не соседствует с часами.
    """
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="О", hours_night=2.0)]
    found = compare(plan, fact)
    assert "код «О» и 2 ч работы" in found[0].reason
    assert "либо код, либо часы" in found[0].reason
    assert "отзыв приказом" in found[0].reason
    assert found[0].undeclared == 2.0


def test_work_on_a_sick_day_moves_the_code_to_the_next_day():
    """
    Больничный: за день, в который начислена зарплата, пособие не назначается
    (подп. 9.5 Положения № 569) — день отработан, «Б» идёт со следующего.
    """
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="Б", hours_day=3.0)]
    found = compare(plan, fact)
    assert found[0].kind == "coded_work"
    assert "отзыв приказом" not in found[0].reason
    assert "код ставится со следующего дня" in found[0].reason


def test_declared_work_on_a_vacation_day_is_not_a_discrepancy():
    #  Часы оформлены работой в выходной — оформление и требовалось
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="О", hours_day=4.0,
                    hours_weekend=4.0)]
    assert compare(plan, fact, ordered={d(1): "weekend"}) == []


def test_a_vacation_day_without_hours_stays_silent():
    #  Обычный день отпуска расхождением не был и не станет
    plan = plan_for([1])
    fact = [FactDay(work_date=d(1), day_code="О")]
    assert compare(plan, fact) == []


def test_the_tail_of_a_shift_started_in_vacation_is_still_planned():
    #  Отпуск по 29-е включительно, смена в графике на 29-е с 18:00 до 06:00.
    #  Часы 30-го (00:00–06:00) требуются: 30-е — рабочий день
    plan = split_shift(d(29), time(18), time(6), break_rule=NO_BREAK)
    fact = [FactDay(work_date=d(29), day_code="О", hours_night=2.0),
            FactDay(work_date=d(30), hours_night=6.0)]
    found = compare(plan, fact)
    assert [f.work_date for f in found] == [d(29)]


def test_night_shift_plan_aggregates_two_days():
    """Смена 20:00–08:00 первого августа даёт часы на 1 и 2 августа."""
    plan = split_shift(d(1), time(20), time(8), break_rule=NO_BREAK)
    agg = aggregate_plan(plan)
    assert agg[d(1)] == (2.0, 2.0)
    assert agg[d(2)] == (2.0, 6.0)


def test_two_shifts_landing_on_same_day_are_summed():
    """Ночная смена 1-го и дневная 2-го складываются в плане на 2 августа."""
    plan = (
        split_shift(d(1), time(20), time(8), break_rule=NO_BREAK)
        + split_shift(d(2), time(9), time(18), break_rule=NO_BREAK)
    )
    agg = aggregate_plan(plan)
    assert agg[d(2)] == (11.0, 6.0)


def test_night_discrepancy_detected():
    plan = split_shift(d(1), time(20), time(8), break_rule=NO_BREAK)
    fact = [
        FactDay(work_date=d(1), hours_day=2.0, hours_night=2.0),
        FactDay(work_date=d(2), hours_day=2.0, hours_night=8.0),
    ]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].work_date == d(2)
    assert found[0].kind == "over"
    assert found[0].undeclared == 2.0
    assert found[0].delta_night == 2.0


def test_split_between_day_and_night_is_reported():
    """
    Часы за сутки сошлись, а день с ночью разошлись. Это тоже расхождение:
    ночные оплачиваются иначе, и подмена одних другими меняет сумму.
    """
    plan = split_shift(d(1), time(20), time(8), break_rule=NO_BREAK)
    fact = [
        FactDay(work_date=d(1), hours_day=2.0, hours_night=2.0),
        FactDay(work_date=d(2), hours_day=8.0, hours_night=0.0),
    ]
    found = compare(plan, fact)
    assert len(found) == 1
    assert found[0].kind == "split"
    assert found[0].undeclared == 0.0


def test_summary_counts_hours():
    plan = plan_for([1, 2, 3], rule=LEGACY_BREAK)
    fact = [FactDay(work_date=d(n), hours_day=8.0) for n in (1, 2, 3)]
    s = summarize(plan, fact, compare(plan, fact))
    assert s.plan_hours == 24.0
    assert s.fact_hours == 24.0
    assert s.delta_hours == 0.0
    assert s.discrepancies == 0


def test_plan_hours_skips_days_closed_by_code():
    rows = [
        ShiftRow(1, 1, d(1), time(9), time(18)),
        ShiftRow(1, 1, d(2), None, None, day_code="В"),
    ]
    computed = plan_hours(rows, break_rule=NO_BREAK)
    assert len(computed) == 1
    assert computed[0][1].work_date == d(1)


def test_a_coded_cell_shows_its_hours_in_the_grid():
    """
    Клетка «О» с ночными часами показывает и код, и часы.

    В подписанном табеле депо это две половины — «О» слева и «2» справа.
    Пока часы прятались за кодом, у Слинко за 29.08 в сетке стояло только
    «О», а в итогах месяца эти два часа были — и отклонение 2 ч объяснить по
    экрану было нечем.
    """
    from timesheet.cells import FactCell, fact_cell_parts
    parts = fact_cell_parts(FactCell(day_code="О", hours_night=2.0))
    assert parts["day"] == "О"
    assert parts["night"] == "2"
    assert "ночные 2 ч" in parts["title"]
