"""
Рабочее время сутками, две записи в клетке и обед по окнам.

Три правила заказчика, на которых держится и график, и табель:

1. Ведём сутками. Работа с 20:00 до 08:00 на стыке месяцев записывается
   двумя частями: «20:00 - 24:00» в закрываемом месяце и «00:00 - 08:00» в
   новом. Часы до полуночи попадают в закрываемый период, часы после — в
   новый.

2. В клетке бывает две записи. Если первого числа человек снова выходит в
   ночь, в клетке стоят обе: «00:00 - 08:00/20:00 - 08:00» — продолжение с
   прошлых суток и новая работа.

3. Обед — час, один раз, по окнам 11:00–14:00, 16:00–19:00 и 01:00–04:00.
   В графике стоит время присутствия (интервал содержит обед в себе), в
   табеле работник ставит время за вычетом часа.

Проверка на живом примере заказчика: клетка «00:00 - 08:00/20:00 - 08:00» за
1 сентября даёт в табеле 4 дневных и 7 ночных часов. Дневные: 06:00–08:00
первой записи плюс 20:00–22:00 второй. Ночные: 00:00–06:00 первой минус час
обеда (окно 01:00–04:00) плюс 22:00–24:00 второй.
"""

from datetime import date, time

import pytest

from timesheet.cells import CellError, PlanCell, format_plan_cell, parse_plan_cell
from timesheet.cells import format_plan_cell_short, plan_cell_kind, plan_cell_lines
from timesheet.rules import (
    LUNCH,
    NO_BREAK,
    LunchRule,
    NightWindow,
    ShiftRow,
    lunch_bucket,
    plan_and_worked,
    plan_hours,
    split_shift,
)

D = date(2026, 9, 1)


def hours(cell: PlanCell, lunch=None, work_date: date = D):
    """Часы клетки по календарным дням: {дата: (день, ночь)}."""
    row = ShiftRow(1, 1, work_date, cell.shift_start, cell.shift_end,
                   cell.day_code, cell.shift2_start, cell.shift2_end)
    out = {}
    for _, ph in plan_hours([row], break_rule=NO_BREAK, lunch=lunch):
        out[ph.work_date] = (ph.hours_day, ph.hours_night)
    return out


# ---------------------------------------------------------------------------
#  Разбор клетки: одна запись, две записи, ошибки
# ---------------------------------------------------------------------------

def test_single_entry_is_parsed_as_before():
    cell = parse_plan_cell("08:00-21:00")
    assert cell.intervals == [(time(8, 0), time(21, 0))]
    assert cell.shift2_start is None


def test_end_of_month_entry_ends_at_midnight():
    #  «20:00 - 24:00» за 31 августа: часы до полуночи — в августе
    cell = parse_plan_cell("20:00-24:00")
    assert cell.intervals == [(time(20, 0), time(0, 0))]
    assert hours(cell, work_date=date(2026, 8, 31)) == {date(2026, 8, 31): (2.0, 2.0)}


def test_two_entries_in_one_cell():
    cell = parse_plan_cell("00:00 - 08:00/20:00 - 08:00")
    assert cell.intervals == [(time(0, 0), time(8, 0)), (time(20, 0), time(8, 0))]


def test_two_entries_survive_the_round_trip():
    text = "00:00-08:00/20:00-08:00"
    assert format_plan_cell(parse_plan_cell(text)) == text
    assert format_plan_cell_short(parse_plan_cell(text)) == "0–8/20–8"
    assert plan_cell_lines(parse_plan_cell(text)) == ["00:00-08:00", "20:00-08:00"]


def test_single_entry_still_shows_two_lines():
    #  У одной записи начало и конец стоят друг под другом — так столбец
    #  читается сверху вниз
    assert plan_cell_lines(parse_plan_cell("06:00-18:00")) == ["06:00 -", "18:00"]


def test_three_entries_are_refused():
    with pytest.raises(CellError, match="двух записей"):
        parse_plan_cell("00:00-06:00/10:00-14:00/20:00-08:00")


def test_second_entry_must_start_later():
    #  Порядок смысловой: сначала то, что дорабатывается с прошлых суток
    with pytest.raises(CellError, match="дорабатывается"):
        parse_plan_cell("20:00-08:00/00:00-08:00")


def test_cell_with_night_in_any_entry_is_night():
    assert plan_cell_kind(parse_plan_cell("00:00-08:00/20:00-08:00")) == "night"
    assert plan_cell_kind(parse_plan_cell("08:00-17:00")) == "shift"


# ---------------------------------------------------------------------------
#  Часы клетки: присутствие
# ---------------------------------------------------------------------------

def test_hours_of_two_entries_are_summed_per_day():
    #  1 сентября: 8 ч первой записи и 4 ч второй; 2 сентября — хвост второй
    got = hours(parse_plan_cell("00:00-08:00/20:00-08:00"))
    assert got[date(2026, 9, 1)] == (4.0, 8.0)
    assert got[date(2026, 9, 2)] == (2.0, 6.0)


def test_crossing_entry_lands_on_two_days():
    got = hours(parse_plan_cell("20:00-08:00"))
    assert got[date(2026, 9, 1)] == (2.0, 2.0)
    assert got[date(2026, 9, 2)] == (2.0, 6.0)


# ---------------------------------------------------------------------------
#  Обед: час, один раз, по окнам
# ---------------------------------------------------------------------------

def test_day_work_loses_an_hour_from_day_hours():
    #  08:00–21:00 задевает окно 11:00–14:00: 13 ч присутствия, 12 отработано
    assert hours(parse_plan_cell("08:00-21:00")) == {D: (13.0, 0.0)}
    assert hours(parse_plan_cell("08:00-21:00"), lunch=LUNCH) == {D: (12.0, 0.0)}


def test_night_work_loses_an_hour_from_night_hours():
    #  00:00–08:00 задевает окно 01:00–04:00 — час снимается с ночных
    assert hours(parse_plan_cell("00:00-08:00")) == {D: (2.0, 6.0)}
    assert hours(parse_plan_cell("00:00-08:00"), lunch=LUNCH) == {D: (2.0, 5.0)}


def test_work_outside_the_windows_keeps_all_hours():
    #  «20:00 - 24:00» не попадает ни в одно окно: обеда не было
    assert hours(parse_plan_cell("20:00-24:00"), lunch=LUNCH) == {D: (2.0, 2.0)}


def test_lunch_is_taken_once_even_when_two_windows_fit():
    #  06:00–20:00 задевает и 11:00–14:00, и 16:00–19:00 — обед один
    presence = hours(parse_plan_cell("06:00-20:00"))
    worked = hours(parse_plan_cell("06:00-20:00"), lunch=LUNCH)
    assert presence[D][0] - worked[D][0] == 1.0


def test_lunch_of_a_crossing_shift_lands_on_the_second_day():
    #  У работы с 20:00 до 08:00 обед приходится на 01:00–04:00, то есть на
    #  вторые сутки: час снимается с них, а не с первых
    worked = hours(parse_plan_cell("20:00-08:00"), lunch=LUNCH)
    assert worked[date(2026, 9, 1)] == (2.0, 2.0)
    assert worked[date(2026, 9, 2)] == (2.0, 5.0)


def test_customer_example_first_of_september():
    #  Пример заказчика целиком: в табеле за 1 сентября 4 дневных и 7 ночных
    worked = hours(parse_plan_cell("00:00-08:00/20:00-08:00"), lunch=LUNCH)
    assert worked[date(2026, 9, 1)] == (4.0, 7.0)


def test_lunch_window_decides_day_or_night():
    night = NightWindow().intervals(days=3)
    #  08:00–21:00 в минутах от начала суток
    assert lunch_bucket((8 * 60, 21 * 60), night, LUNCH) == (0, "day")
    #  00:00–08:00 — обед в 01:00, это ночное время
    assert lunch_bucket((0, 8 * 60), night, LUNCH) == (0, "night")
    #  20:00–24:00 — смена ровно 4 часа, обеда не положено
    assert lunch_bucket((20 * 60, 24 * 60), night, LUNCH) is None


# ---------------------------------------------------------------------------
#  Обед считается по смене, а не по календарным суткам
# ---------------------------------------------------------------------------
#
#  Разбор случая Кулевнича за 7 августа 2026. Смена 18:00–06:00 задевает два
#  окна: 16:00–19:00 первым часом и 01:00–04:00 серединой. Пока брали первое
#  по времени, час снимался с 7-го числа, а в подписанном табеле депо он снят
#  с 8-го: 7-е — 4/2 = 6 ч без вычета, 8-е — 4/7 = 11 ч при 12 присутствия.
#  Сверка показывала «в табеле 6 ч при плане 5 ч: не оформлено 1 ч» на дне,
#  где всё было в порядке.

def test_lunch_of_a_long_shift_lands_in_the_window_nearest_the_middle():
    worked = hours(parse_plan_cell("18:00-06:00"), lunch=LUNCH,
                   work_date=date(2026, 8, 7))
    #  Первые сутки целые: обедали не в 18:00–19:00, а посреди смены
    assert worked[date(2026, 8, 7)] == (4.0, 2.0)
    #  Час снят со вторых суток, с ночных часов — окно 01:00–04:00
    assert worked[date(2026, 8, 8)] == (0.0, 5.0)


def test_a_shift_of_exactly_four_hours_has_no_lunch():
    #  «Если смена 4 часа, обеда быть не может» — решение заказчика: перерыв
    #  положен, когда смена дольше четырёх часов
    assert hours(parse_plan_cell("11:00-15:00"), lunch=LUNCH)[D] == (4.0, 0.0)
    assert hours(parse_plan_cell("06:00-10:00"), lunch=LUNCH)[D] == (4.0, 0.0)


def test_a_shift_longer_than_four_hours_has_lunch():
    assert hours(parse_plan_cell("11:00-16:00"), lunch=LUNCH)[D] == (4.0, 0.0)
    assert hours(parse_plan_cell("11:00-17:00"), lunch=LUNCH)[D] == (5.0, 0.0)


def test_a_short_shift_keeps_all_its_hours():
    #  Трёхчасовые смены в табеле депо стоят целиком: Мотылевич 13.08,
    #  Романюк 17.08, Борисик 05.08 — по 3 часа
    assert hours(parse_plan_cell("06:00-09:00"), lunch=LUNCH)[D] == (3.0, 0.0)


def test_lunch_without_any_window_is_still_deducted():
    #  Время перерыва работник согласовывает с руководителем; окна — про то,
    #  когда он обычно приходится. Смена мимо всех окон обед всё равно имеет
    assert hours(parse_plan_cell("05:00-11:00"), lunch=LUNCH)[D] == (4.0, 1.0)


def test_a_shift_split_by_the_month_boundary_gets_one_lunch():
    #  Так закрывается период: 18:00–00:00 последним числом августа и
    #  00:00–06:00 первым сентября — одна смена, и обед у неё один.
    #  Он попадает в окно 01:00–04:00, то есть в сентябрь; август остаётся
    #  целым — 4/2 = 6 часов, как в подписанном табеле у Кулевнича
    rows = [row("18:00-00:00", date(2026, 8, 31)),
            row("00:00-06:00", date(2026, 9, 1))]
    got = {ph.work_date: ph for _, ph in plan_and_worked(rows)}
    august = got[date(2026, 8, 31)]
    assert (august.worked_day, august.worked_night) == (4.0, 2.0)
    september = got[date(2026, 9, 1)]
    assert (september.worked_day, september.worked_night) == (0.0, 5.0)


def test_the_same_halves_apart_are_two_shifts_with_two_lunches():
    #  Если половины не стыкуются по времени, это две разные смены: у каждой
    #  свой обед. Склейка — только про непрерывную работу
    rows = [row("18:00-00:00", date(2026, 8, 31)),
            row("02:00-08:00", date(2026, 9, 1))]
    got = {ph.work_date: ph for _, ph in plan_and_worked(rows)}
    assert got[date(2026, 8, 31)].worked_total == 5.0
    assert got[date(2026, 9, 1)].worked_total == 5.0


def test_two_shifts_in_one_day_get_two_lunches():
    #  Клетка «00:00 - 08:00/20:00 - 08:00»: хвост прошлой смены и новая
    #  работа. Это две смены, обедов два — но в разных сутках
    rows = [row("00:00-08:00/20:00-08:00", D)]
    got = {ph.work_date: ph for _, ph in plan_and_worked(rows)}
    assert (got[D].worked_day, got[D].worked_night) == (4.0, 7.0)
    assert got[date(2026, 9, 2)].worked_total == 7.0


def test_windows_can_be_changed_without_touching_the_code():
    #  Окна — данные, а не код: у другого депо они могут быть другими
    rule = LunchRule(hours=1.0, windows=((20, 22),))
    assert hours(parse_plan_cell("18:00-23:00"), lunch=rule)[D] == (3.0, 1.0)


# ---------------------------------------------------------------------------
#  Две цифры сразу: присутствие и к отработке
# ---------------------------------------------------------------------------

def row(text: str, work_date: date = D) -> ShiftRow:
    cell = parse_plan_cell(text)
    return ShiftRow(1, 1, work_date, cell.shift_start, cell.shift_end,
                    cell.day_code, cell.shift2_start, cell.shift2_end)


def test_plan_and_worked_returns_both_figures():
    got = {ph.work_date: ph for _, ph in plan_and_worked([row("08:00-21:00")])}
    ph = got[D]
    assert (ph.hours_day, ph.hours_night) == (13.0, 0.0)
    assert (ph.worked_day, ph.worked_night) == (12.0, 0.0)
    assert ph.total == 13.0 and ph.worked_total == 12.0


def test_plan_and_worked_on_the_customer_cell():
    got = {ph.work_date: ph for _, ph in plan_and_worked([row("00:00-08:00/20:00-08:00")])}
    first = got[date(2026, 9, 1)]
    assert (first.hours_day, first.hours_night) == (4.0, 8.0)
    assert (first.worked_day, first.worked_night) == (4.0, 7.0)


def test_worked_total_falls_back_to_presence():
    #  Строки, посчитанные до появления правила обеда, читаются как
    #  присутствие: пустое «к отработке» не должно превращаться в ноль
    from timesheet.rules import PlanHours
    ph = PlanHours(work_date=D, hours_day=8.0, hours_night=0.0, source_date=D)
    assert ph.worked_total == 8.0


def test_day_code_has_no_hours_at_all():
    assert plan_and_worked([row("В")]) == []
