"""
Доска задач на неделю — блок G плана, пункт 24.

Базы в проверочной среде нет, поэтому проверяется то, что от неё не зависит:
границы недели, состав правил, поведение отметок и решения, которые легко
потерять при правке.

Главное из них: задачи недели материализуются, а не вычисляются каждый раз.
Вычислять проще, но тогда нечего показать в «результате работы» — исчезнувшая
причина неотличима от сделанной работы.
"""

import pathlib
import re
from datetime import date

import pytest

from timesheet.kanbandb import (
    KIND_RU,
    LEAD_DAYS,
    STATUS_RU,
    Task,
    close_task,
    week_start,
)

ENGINE = pathlib.Path(__file__).resolve().parents[1] / "timesheet"
TEMPLATES = ENGINE / "templates"
SQL = pathlib.Path(__file__).resolve().parents[2] / "sql"


def read(path):
    return path.read_text(encoding="utf-8")


SOURCE = read(ENGINE / "kanbandb.py")
MIGRATION = read(SQL / "35_kanban.sql")


# --- неделя ------------------------------------------------------------------

def test_the_week_starts_on_monday():
    #  «В начале рабочей недели» — значит понедельник, а не воскресенье и не
    #  день, когда человек зашёл
    assert week_start(date(2026, 9, 14)) == date(2026, 9, 14)   # понедельник
    assert week_start(date(2026, 9, 17)) == date(2026, 9, 14)   # четверг
    assert week_start(date(2026, 9, 20)) == date(2026, 9, 14)   # воскресенье
    assert week_start(date(2026, 9, 21)) == date(2026, 9, 21)   # новая неделя


def test_the_database_refuses_a_week_that_is_not_monday():
    assert "kt_week_is_monday" in MIGRATION
    assert "extract(isodow FROM week_start) = 1" in MIGRATION


def test_past_weeks_are_not_recalculated():
    #  Там уже история, и «закрылась сама» задним числом означало бы
    #  переписать чужой отчёт
    src = read(ENGINE / "webapp.py")
    body = src[src.find("def kanban_page("):]
    body = body.split(chr(10) * 3)[0]
    assert "if w >= this_week:" in body


def test_future_weeks_are_filled_with_what_is_coming():
    """
    «Последующие недели должны быть наполнены предстоящей работой».

    Считаются по последнему дню недели, а не по её понедельнику: неделя
    показывает всё, что за неё предстоит сделать. По понедельнику ТО,
    подошедшее в среду, в обзоре недели не появилось бы вовсе.
    """
    src = read(ENGINE / "webapp.py")
    body = src[src.find("def kanban_page("):]
    body = body.split(chr(10) * 3)[0]
    assert "monday + timedelta(days=6)" in body
    assert "week=w" in body


def test_a_future_week_is_a_forecast_not_a_report():
    """
    В будущей неделе исчезнувшая задача удаляется, а не отмечается
    выполненной.

    Иначе сделанная сегодня работа записалась бы на будущую неделю и раздула
    её отчёт: прогноз пересобирается при каждом взгляде, и задача, которую
    там ещё не выдавали, не может быть там выполнена.
    """
    body = SOURCE[SOURCE.index("def refresh("):]
    body = body[:body.index(chr(10) + "def ", 10)]
    assert "if monday > week_start(date.today()):" in body
    assert "DELETE FROM app.kanban_task" in body


def test_a_postponed_task_lands_on_the_week_it_was_moved_to():
    """
    Проверено на живых данных: задача, отложенная на среду следующей недели,
    на текущей неделе стоит отложенной, а на следующей — уже в работе.

    Решает сравнение с днём, по которому собирают неделю: для будущей недели
    это её последний день, и срок переноса в него уже попадает.
    """
    body = SOURCE[SOURCE.index("def refresh("):]
    body = body[:body.index(chr(10) + "def ", 10)]
    assert 'wait["postponed_to"] > day' in body


# --- правила: что система считает работой ------------------------------------

def test_tasks_come_from_data_the_system_already_has():
    #  Ничего придумывать не надо: всё это в базе есть, просто лежит по
    #  разным экранам
    for rule in ("_people_deadlines", "_new_cards", "_documents", "_equipment"):
        assert f"def {rule}(" in SOURCE, rule


@pytest.mark.parametrize("kind", [
    "medical", "briefing", "certificate", "contract",
    "card", "ppe", "timesheet", "schedule", "request", "repair",
])
def test_every_kind_has_a_human_name(kind):
    #  На доске человек читает слова, а не коды
    assert kind in KIND_RU and KIND_RU[kind]


def test_the_new_hire_task_counts_the_real_gaps():
    """
    Правка от 16.09.2026. Раньше задача перечисляла три вида — медосмотр,
    инструктаж, СИЗ — и гасла, если появилась хотя бы одна запись любого из
    них: один инструктаж закрывал вопрос и о медосмотре, и о СИЗ.

    Теперь пробелы считает база (`app.card_gaps`), и это тот же список,
    который показывает карточка: два списка «чего не хватает» неминуемо
    разошлись бы, и спорить пришлось бы о том, какой из них прав.
    """
    body = SOURCE[SOURCE.find("def _new_cards("):]
    body = body[:body.find("\ndef ", 10)]
    assert "app.card_gaps" in body
    assert "не хватает" in body


def test_the_gaps_become_separate_tasks_after_the_card_task_is_closed():
    #  «Задача „Заполнить карточку“ остаётся обобщённой; после её закрытия
    #  оставшиеся пробелы выводятся на доску отдельным списком»
    body = SOURCE[SOURCE.find("def _new_cards("):]
    body = body[:body.find("\ndef ", 10)]
    assert "status IN ('done', 'auto_done')" in body
    assert "if key in finished:" in body


def test_the_warning_window_is_two_weeks():
    #  Чтобы успеть записать человека на медосмотр и дождаться очереди
    assert LEAD_DAYS == 14


def test_task_keys_are_stable():
    #  По ключу задача узнаётся между обновлениями доски и не задваивается
    assert "UNIQUE (org_unit_id, week_start, task_key)" in MIGRATION
    #  24.09.2026: отложенная строка накладывается на уже созданную
    #  (прогноз), поэтому DO UPDATE, а не DO NOTHING — но не больше одной
    assert "ON CONFLICT (org_unit_id, week_start, task_key) DO UPDATE" in SOURCE


# --- отметки -----------------------------------------------------------------

def test_the_four_states_mean_different_things():
    """
    Задача, закрывшаяся внесением данных, — это выполненная работа.

    Уточнение заказчика от 15.09.2026: «закрыто само — это когда сотрудник
    исправил дату и выполнил действие, значит это статус выполнено». Прежнее
    название «Закрылась сама» обесценивало работу: выходило, будто задача
    рассосалась без человека. Код статуса оставлен прежним — по нему видно,
    чем задача закрыта: отметкой или самим делом.

    Волна 3 (вычитка 30.09.2026, п. 6.1): «Сделано» слито с «Выполнено»,
    добавлены экранное «Просрочено» и «вернувшийся» перенос — оба
    вычисляются на лету, поэтому их коды есть только в STATUS_RU.
    """
    from timesheet.kanbandb import DONE_STATUSES

    assert set(STATUS_RU) == {"open", "done", "auto_done", "skipped",
                              "overdue", "returned"}
    assert STATUS_RU["done"] == STATUS_RU["auto_done"] == "Выполнено"
    assert "Сделано" not in STATUS_RU.values()
    assert set(DONE_STATUSES) == {"done", "auto_done"}


def test_a_vanished_reason_closes_the_task_itself():
    #  «Как только внёс, задача закрыта успешно» — из задания.
    #  Волна 3 (п. 6.2): сверка идёт и по отложенным — причина исчезла,
    #  «автоматом переводить в Выполнено». Закрытые руками не трогаем:
    #  человек уже отчитался; персональные (is_manual) — дело человека
    body = SOURCE[SOURCE.find("def refresh("):]
    body = body[:body.find("\ndef ", 10)]
    assert "SET status = 'auto_done'" in body
    assert "status IN ('open', 'skipped')" in body
    assert "AND NOT is_manual" in body


class FakeConn:
    """Соединение, до которого проверка доходить не должна."""

    def cursor(self):
        raise AssertionError("отметка обязана отсеяться до записи")


def test_postponing_requires_a_reason():
    #  Доска не про то, чтобы прятать несделанное, а про то, чтобы было
    #  видно, почему не сделано
    with pytest.raises(ValueError, match="поясните"):
        close_task(FakeConn(), 1, "skipped", "", 1)


def test_an_unknown_mark_is_refused():
    with pytest.raises(ValueError, match="Неизвестная отметка"):
        close_task(FakeConn(), 1, "потом", None, 1)


def test_a_task_can_come_back_to_work():
    #  Отметили по ошибке — должно быть можно вернуть
    body = SOURCE[SOURCE.find("def close_task("):]
    body = body[:body.find("\ndef ", 10)]
    assert '"open"' in body
    assert "done_at = CASE WHEN %(status)s = 'open' THEN NULL" in body


# --- центральное окно администратора -----------------------------------------

def test_the_summary_answers_how_much_was_closed():
    #  «Оцифровка проделанной работы»: сколько выдано и сколько закрыто
    body = SOURCE[SOURCE.find("def summary("):]
    for field in ("done", "auto_done", "skipped", "overdue"):
        assert field in body, field
    assert '"share"' in body


def test_no_tasks_is_not_zero_percent():
    #  Ноль из нуля — это не «ничего не сделано»
    body = SOURCE[SOURCE.find("def summary("):]
    assert 'r["share"] = round(closed / total * 100) if total else None' in body


def test_the_admin_can_open_each_board():
    #  «Центральное окно, где он может посмотреть доску каждого из
    #  начальников отдельно»
    html = read(TEMPLATES / "kanban.html")
    assert "Результат по депо" in html
    assert 'href="/kanban?unit={{ r.code }}' in html


def test_the_board_is_the_first_section():
    #  С доски начинают неделю: она про то, что делать, а не про данные
    html = read(TEMPLATES / "base.html")
    nav = html[html.find('<nav class="tabs">'):]
    nav = nav[:nav.find("</nav>")]
    assert nav.find('href="/kanban"') < nav.find('href="/staff"')


def test_the_page_opens_without_the_migration():
    assert "def has_kanban(" in SOURCE
    assert "{% if not ready %}" in read(TEMPLATES / "kanban.html")


def test_the_board_explains_itself():
    #  Через полгода никто не вспомнит, откуда берутся задачи
    html = read(TEMPLATES / "kanban.html")
    #  22.09.2026 пояснения свёрнуты — «не нужно нагружать сразу при
    #  открытии». Свёрнуты, а не выброшены: текст на месте, под раскрытием.
    #  Волна 3 (30.09.2026, п. 6.11): справка переписана под состояния
    #  «ВЫПОЛНИТЬ» / «Просрочено» и персональные задачи
    assert "Как работает доска" in html
    flat = " ".join(html.split())
    #  И что выполненное считается выполненным, а не «рассосавшимся»
    assert "сделанная работа" in flat
    assert "Просрочено" in flat
    assert "Персональные задачи" in flat


def test_an_empty_board_is_not_an_error():
    html = read(TEMPLATES / "kanban.html")
    assert "Это нормальное состояние, а не ошибка." in html


def test_the_task_shape_is_simple():
    #  Правило отдаёт ровно то, что нужно доске, — ни объекта, ни запроса
    t = Task(key="medical:1", kind="medical", title="Медосмотр",
             subject="Иванов И.", due_at=date(2026, 9, 20))
    assert t.key == "medical:1" and t.due_at == date(2026, 9, 20)


# --- одна кнопка: отложить ---------------------------------------------------
#
#  Решение заказчика от 15.09.2026: «Убираем "сделано", положительный результат
#  это исправление в первоначальном документе сотрудником. Единственная кнопка
#  "Отложить" — она работает на перенос задачи на определённую дату и указание
#  причины. К примеру, необходимо выдать СИЗ, сотрудник на больничном».

MIGRATION_41 = read(SQL / "41_kanban_postpone.sql")


def test_the_done_button_is_a_request_to_check_not_a_promise():
    """
    Кнопка вернулась 16.09.2026 — вместе с проверкой, которую просил
    заказчик: «если дата не исправлена и задача не выполнена, то невозможно
    закрыть её нажав кнопку выполнено. Только если отложить с указанием
    причины».

    То есть нажатие не отмечает намерение, а запускает пересчёт правил.
    Прежнее возражение снято не отменой проверки, а тем, что проверка теперь
    происходит при нажатии: «подделать» выполнение по-прежнему можно только
    сделав работу.

    Волна 3 (30.09.2026, п. 6.5): кнопка переименована в «ВЫПОЛНИТЬ».
    """
    html = read(TEMPLATES / "kanban.html")
    markup = re.sub(r"\{#.*?#\}", "", html, flags=re.S)
    #  «Сделано» как обещания нет; есть «ВЫПОЛНИТЬ» как запрос на проверку
    assert ">Сделано<" not in markup
    assert 'name="status" value="done"' in markup
    assert "ВЫПОЛНИТЬ</button>" in markup


def test_the_server_checks_the_data_before_accepting_done():
    #  Проверка идёт в базу — значит до соединения дело доходит, и `FakeConn`
    #  тут уже не годится. Само правило проверено на живых данных: открытая
    #  задача «Провести ТО-2» отказалась закрываться словами «данные в
    #  документе не исправлены»
    body = SOURCE[SOURCE.find("def _check_really_done("):]
    body = body[:body.find(chr(10) + "def ", 10)]
    assert "collect(conn" in body
    assert "task_key" in body and "still" in body


def test_a_manual_task_needs_a_comment_instead():
    #  «У ручных должен быть обязателен комментарий, в котором сотрудник
    #  указывает что сделал»
    body = SOURCE[SOURCE.find("def _check_really_done("):]
    body = body[:body.find(chr(10) + "def ", 10)]
    assert 'task["is_manual"]' in body
    assert "Напишите, что сделано" in body


def test_postponing_needs_a_date():
    #  Без даты «отложено» означало бы «забыли навсегда»
    with pytest.raises(ValueError, match="дату"):
        close_task(FakeConn(), 1, "skipped", "на больничном", 1, None)


def test_postponing_still_needs_a_reason():
    #  Без причины — «прячем несделанное»
    with pytest.raises(ValueError, match="поясните"):
        close_task(FakeConn(), 1, "skipped", "", 1, date(2030, 1, 1))


def test_postponing_to_today_is_not_postponing():
    with pytest.raises(ValueError, match="в будущем"):
        close_task(FakeConn(), 1, "skipped", "на больничном", 1, date.today())


def test_the_database_insists_on_both():
    #  Та же проверка в базе: запись мимо приложения не должна пройти
    assert "kt_postponed_has_date" in MIGRATION_41
    assert "postponed_to IS NOT NULL" in MIGRATION_41
    assert "btrim(coalesce(note, '')) <> ''" in MIGRATION_41


def test_old_postponed_tasks_got_a_date():
    #  Их откладывали, когда поля не было; без даты они уронили бы проверку
    assert "postponed_to = week_start + 7" in MIGRATION_41
    #  И заполнение идёт раньше проверки, иначе миграция спотыкается
    #  о данные, которые сама же должна была впустить
    assert (MIGRATION_41.index("UPDATE kanban_task")
            < MIGRATION_41.index("ADD CONSTRAINT kt_postponed_has_date"))


# --- перенос живёт дольше недели ---------------------------------------------

def test_a_postponed_task_does_not_pop_up_next_monday():
    """
    Доска недельная: в понедельник задачи заводятся заново.

    Без переноса отложенная задача всплыла бы как новая, и откладывать её
    пришлось бы каждую неделю. Проверено на живых данных: отложенная до
    среды следующей недели задача завелась на той неделе сразу отложенной,
    с той же датой и причиной.
    """
    body = SOURCE[SOURCE.index("def refresh("):]
    body = body[:body.index(chr(10) + "def ", 10)]
    assert "parked" in body
    assert 'wait["postponed_to"] > day' in body
    assert "'skipped'" in body


def test_the_task_comes_back_on_the_date_by_itself():
    #  «Указываем дату выполнения» — к ней задача возвращается в работу сама
    body = SOURCE[SOURCE.index("def refresh("):]
    body = body[:body.index(chr(10) + "def ", 10)]
    assert "SET status = 'open'" in body
    assert "postponed_to <= %s" in body


def test_the_reason_survives_the_return():
    #  По ней видно, почему задачу откладывали
    body = SOURCE[SOURCE.index("def refresh("):]
    body = body[:body.index(chr(10) + "def ", 10)]
    at = body.index("SET status = 'open'")
    tail = body[at:at + 260]
    assert "note" not in tail, "причина стирается при возврате"


def test_the_board_asks_for_both_fields():
    html = read(TEMPLATES / "kanban.html")
    assert 'name="until"' in html and 'name="note"' in html
    #  Минимум — завтра: отложить на сегодня значит не отложить
    assert 'min="{{ tomorrow }}"' in html


def test_the_board_shows_where_the_task_was_moved_to():
    html = read(TEMPLATES / "kanban.html")
    assert "t.postponed_to.strftime" in html


def test_the_board_explains_why_there_is_no_done_button():
    #  Волна 3 (30.09.2026, п. 6.11): справка переписана — легенды «отметки
    #  "сделано" здесь нет» больше нет, вместо неё объяснение кнопки
    #  «ВЫПОЛНИТЬ» как запроса на проверку
    flat = " ".join(read(TEMPLATES / "kanban.html").split())
    assert "не отметка о намерении, а запрос на проверку" in flat
    assert "Отметки «сделано» здесь нет" not in flat

# --- причина отложенной задачи под кнопкой ------------------------------------

def test_the_reason_is_hidden_behind_a_button():
    """
    «Внесённую информацию при статусе отложено не нужно выводить в общий вид,
    пусть будет доп кнопка причина».

    В строке причина занимала три яруса у каждой отложенной задачи — сама
    причина, кто отложил и когда — и оттесняла то, ради чего на доску
    смотрят: что сделать и к какому сроку.

    Волна 3 (п. 6.4.1): у персональной задачи под этой же кнопкой —
    «Примечание» отчёта о выполнении.
    """
    html = read(TEMPLATES / "kanban.html")
    assert '<details class="reason">' in html
    assert "'Примечание' if t.kind == 'personal' else 'Причина'" in html
    assert "reason-box" in html


def test_the_reason_window_does_not_push_the_row_apart():
    #  Проверено в браузере: строка 58px и до, и после открытия
    css = read(ENGINE / "static" / "app.css")
    at = css.index(".reason-box {")
    rule = css[at:css.index("}", at)]
    assert "position: absolute" in rule
    assert "z-index" in rule


def test_the_reason_window_needs_no_script():
    #  Открывает и закрывает браузер сам: это `details`
    html = read(TEMPLATES / "kanban.html")
    block = html[html.index('<details class="reason">'):]
    block = block[:block.index("</details>")]
    assert "onclick" not in block


def test_the_date_stays_in_the_row():
    #  На когда отложено — это часть состояния, за кнопку её прятать незачем
    html = read(TEMPLATES / "kanban.html")
    assert "t.postponed_to.strftime" in html


# ---------------------------------------------------------------------------
#  Табель за прошедшие сутки
#
#  Решение заказчика от 21.09.2026: вместе с разрешением заполнять табель на
#  сутки вперёд появляется задача о незаполненных прошедших сутках. Видят её
#  только начальник и заместители.
# ---------------------------------------------------------------------------

def test_the_daily_timesheet_task_is_restricted_to_the_chief_and_deputies():
    from timesheet.kanbandb import RESTRICTED_KINDS
    assert RESTRICTED_KINDS["timesheet_day"] == "schedule.write"


def test_the_daily_timesheet_task_has_a_name_on_the_board():
    from timesheet.kanbandb import KIND_RU
    assert KIND_RU["timesheet_day"] == "Табель за сутки"


def test_the_board_hides_restricted_tasks_from_those_without_the_right():
    """
    Фильтр стоит в отрисовке доски: сама задача лежит в базе одна на депо, а
    показывается не всем. Без фильтра «заполнить табель» видели бы мастер и
    кладовщик, которых она не касается.
    """
    import pathlib
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "webapp.py").read_text(encoding="utf-8")
    at = src.index("RESTRICTED_KINDS[t[\"kind\"]]")
    #  Окно шире прежнего (1500): между board() и фильтром теперь стоит
    #  трансляция персональных задач и расчёт экранных состояний (волна 3)
    assert "kanbandb.board(" in src[at - 2600:at]


# ---------------------------------------------------------------------------
#  Столбец «Кого касается» кликабелен целиком (22.09.2026)
# ---------------------------------------------------------------------------

def test_every_kind_of_task_knows_where_it_leads():
    """
    «Сделать весь столбец кликабельным в соответствии с задачи: если это ТО-1
    или ТО-2 — переходить в карточку данной техники; если подходит срок
    выдачи СИЗ — в карточку сотрудника и во вкладку СИЗ».
    """
    from timesheet.kanbandb import KIND_RU, PERSON_TABS
    #  Каждый вид задачи ведёт либо в карточку человека, либо на свой экран.
    #  Если появится новый вид, этот тест напомнит дать ему адрес
    screens = {"timesheet", "timesheet_day", "schedule", "request", "hiring",
               "password", "maintenance", "repair",
               #  Поверка ведёт в карточку прибора (22.09.2026)
               "verification",
               #  Карточка ТУ, возвращённая на доработку, ведёт в подбор, в
               #  подвкладку «На проверке» (22.09.2026)
               "hire_draft",
               #  Доска «Минск» (24.09.2026): каждая задача ведёт туда, где
               #  администрация принимает решение
               "hq_request", "hq_hiring", "hq_settlement", "hq_timesheet",
               "hq_adjustment", "hq_headcount", "hq_repair",
               #  06.10.2026: заявка на комплект СИЗ — в карточку сотрудника
               "hq_ppe_request",
               #  06.10.2026 (вечер): предложение по доработке из коробки —
               #  прорабатывается на самой доске
               "hq_suggestion",
               #  ТО со специалистом и ремонт по ролям (24.09.2026)
               "maint_request", "maint_visit", "hq_maint", "hq_specialist",
               #  Финансы (24.09.2026): договор, начисления, курсы
               "fin_contract_end", "fin_payment", "fin_rate",
               #  Персональная задача (волна 3, 30.09.2026): ведёт на доску
               #  своего депо — адрес собран в шаблоне из t.unit_code
               "personal",
               #  Свободное место (волна 4б, 01.10.2026): ведёт в приёмку
               "space_update",
               #  02.10.2026: поставки ждут депо — ведёт в приёмку
               "supply_queue"}
    assert set(KIND_RU) == set(PERSON_TABS) | screens


def test_the_ppe_task_opens_the_ppe_tab():
    from timesheet.kanbandb import PERSON_TABS
    assert PERSON_TABS["ppe"] == "?tab=ppe"
    assert PERSON_TABS["briefing"] == "?tab=docs#briefings"
    assert PERSON_TABS["medical"] == "?tab=docs#exams"


def test_the_maintenance_task_opens_the_asset_card():
    import pathlib
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "kanbandb.py").read_text(encoding="utf-8")
    at = src.index("def subject_urls(")
    body = src[at:src.index("\ndef ", at + 10)]
    #  Ключ вида «maintenance:{номер техники}:{ТО-1}»
    assert '"/supply/asset/{asset}"' in body
    #  Заявка на ремонт ведёт туда же — через технику, по которой открыта
    assert "repair_request" in body


def test_open_tasks_follow_their_cause():
    """
    24.09.2026: срок задачи застывал — «ТО-1» показывала 22.06 при «ТО-1 до
    22.09» в карточке машины. Открытая задача пересчитывается вместе с
    причиной; отложенные и выполненные остаются как закрыли.
    """
    assert "DO UPDATE" in SOURCE
    assert "due_at      = EXCLUDED.due_at" in SOURCE
    assert "WHERE k.status = 'open'" in SOURCE
    assert "coalesce(k.assignee_id," in SOURCE
    assert '"refreshed": refreshed' in SOURCE


# --- доска «Минск» (24.09.2026) -------------------------------------------------

def test_minsk_board_collects_the_administration_queue():
    from timesheet import kanbandb
    body = SOURCE[SOURCE.index("def _hq_queue("):SOURCE.index("def collect(")]
    for table in ("staff_request", "confirmed_at IS NULL", "settlement_state = 'submitted'",
                  "t.status IN ('submitted', 'in_review')", "a.status = 'pending'",
                  "headcount_request", "'sent_to_hq', 'hq_received', 'in_repair', 'repaired'",
                  "password_reset_request"):
        assert table in body, table
    assert "if _is_hq(conn, unit_id):" in SOURCE
    assert kanbandb.HQ_KIND == "hq"


def test_depot_boards_no_longer_carry_administration_tasks():
    body = SOURCE[SOURCE.index("def _documents("):SOURCE.index("def _equipment(")]
    assert "password_reset_request" not in body
    assert "key=\"hiring:unconfirmed\"" not in body
    assert "key=\"request:new\"" not in body


def test_administration_opens_on_minsk_without_a_depot_picker():
    web = read(ENGINE / "webapp.py")
    assert 'if hq and unit in (None, "", hq["code"]):' in web
    board = read(ENGINE / "templates" / "kanban.html")
    assert "{% if can_all %}" in board and "← Минск" in board


def test_month_shows_each_task_once_and_fills_future_weeks():
    web = read(ENGINE / "webapp.py")
    assert 'if t["task_key"] not in seen:' in web
    assert "for w in weeks:" in web
    assert "def _kanban_window(" in web and "def _kanban_span_filter(" in web


def test_summary_follows_the_chosen_period():
    web = read(ENGINE / "webapp.py")
    assert "ut, _ = unit_tasks(u[\"id\"])" in web
    board = read(ENGINE / "templates" / "kanban.html")
    assert "{{ period_label }}</h2>" in board
