"""
Техника и ТМЦ — разные вещи (уточнение по блоку F от 15.09.2026).

«В блоке обеспечение ТМЦ и Техника это разные вкладки, для техники должна
быть карточка и реестр история по проведенным ТО, для ТМЦ своя вкладка, на
которой можно отправить технику на ремонт, тогда она попадает в заявки на
ремонт и проходит путь, после чего возвращается обратно в общий список.
В заявках на ремонт история по ремонту записывается.»

Разница не в цене, а в том, как ведут. Технику — поштучно: у каждой единицы
серийный номер, счётчик моточасов, свои сроки ТО и своя история ремонтов, про
неё есть что рассказать на отдельной странице. ТМЦ — количеством: пятнадцать
тележек это пятнадцать тележек, и карточка у каждой была бы пустой.

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

import pathlib
import re
from datetime import date, timedelta

import pytest

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")


SUPPLY = read(TEMPLATES / "supply.html")
CARD = read(TEMPLATES / "asset_card.html")
DB = read(ENGINE / "supplydb.py")
WEBAPP = read(ENGINE / "webapp.py")
MIGRATION = read(SQL / "38_equipment_and_stock.sql")
KANBAN = read(ENGINE / "kanbandb.py")
KANBAN_HTML = read(TEMPLATES / "kanban.html")


def block(src, head):
    body = src[src.index(head):]
    cut = body.find(chr(10) + "def ", 10)
    return body if cut < 0 else body[:cut]


# --- признак стоит у вида, а не у единицы ------------------------------------

def test_the_kind_belongs_to_the_category():
    #  «Штабелёр» — техника всегда. Решать это заново для каждой машины
    #  значит однажды ошибиться
    assert "ALTER TABLE asset_category" in MIGRATION
    assert "is_equipment boolean NOT NULL DEFAULT false" in MIGRATION


def test_equipment_is_not_the_same_question_as_having_a_meter():
    """
    Отдельная колонка, хотя сегодня значения совпадают.

    `has_meter` отвечает «есть ли счётчик» и по нему считается ТО по
    наработке, `is_equipment` — «ведём ли поштучно». Если завтра ТСД решат
    вести поштучно, это не должно заставить систему требовать у них моточасы.
    """
    assert "UPDATE asset_category SET is_equipment = has_meter" in MIGRATION
    body = block(DB, "def set_category_kind(")
    assert "has_meter" not in body.split('"""')[2], "правка вида трогает счётчик"


def test_the_kind_is_switchable_without_touching_the_code():
    #  Обещали переключатель в «Базовых настройках» — он там
    assert '("asset_kinds", "Виды ТМЦ и техники")' in WEBAPP
    assert '@app.post("/settings/asset-kinds")' in WEBAPP
    assert "{% elif tab == 'asset_kinds' %}" in read(TEMPLATES / "settings.html")


# --- две вкладки -------------------------------------------------------------

def test_the_two_tabs_share_one_template():
    #  Таблица та же, разнятся колонки и то, куда ведёт строка. Три
    #  одинаковых куска разметки пришлось бы править трижды.
    #  22.09.2026 вкладок стало три: складская техника, поверенная, ТМЦ
    assert "{% if tab in ('equipment', 'verification', 'stock') %}" in SUPPLY
    assert "{% set is_ver = tab == 'verification' %}" in SUPPLY
    assert "{% set is_eq = tab in ('equipment', 'verification') %}" in SUPPLY


def test_each_tab_shows_the_column_that_means_something_there():
    #  У техники моточасы, у ТМЦ количество. На общей вкладке половина
    #  каждой колонки стояла пустой
    tab = SUPPLY[SUPPLY.index("{% if tab in ('equipment', 'verification', 'stock') %}"):
                 SUPPLY.index("{% elif tab == 'maintenance' %}")]
    assert "{% if is_ver %}" in tab
    assert "Моточасы" in tab and "Кол-во" in tab
    #  У поверочного ни того ни другого — у него срок поверки
    assert "Годна до" in tab


def test_the_add_form_offers_only_the_kinds_of_its_own_tab():
    #  Иначе тележка однажды окажется техникой по недосмотру
    body = block(WEBAPP, "def supply_page(")
    assert "supplydb.categories(conn, kind=tab)" in body


def test_only_equipment_rows_lead_to_a_card():
    #  В ТМЦ считают количество, а не разбирают каждую штуку
    tab = SUPPLY[SUPPLY.index("{% if tab in ('equipment', 'verification', 'stock') %}"):
                 SUPPLY.index("{% elif tab == 'maintenance' %}")]
    link = '<a href="/supply/asset/{{ a.id }}">'
    at = tab.index(link)
    assert "{% if is_eq %}" in tab[max(0, at - 120):at]


# --- карточка техники --------------------------------------------------------

def test_the_card_answers_what_happened_to_this_machine():
    #  Всё, что лежало по трём вкладкам, — на одной странице
    for heading in ("Единица", "Когда следующее ТО", "Проведённые ТО",
                    "Показания счётчика", "Ремонты"):
        assert heading in CARD, heading


def test_the_card_does_not_compute_the_due_date_its_own_way():
    #  Два способа считать «когда следующее ТО» однажды разойдутся
    body = block(WEBAPP, "def asset_card_page(")
    assert "supplydb.maintenance_due(conn, card[\"org_unit_id\"])" in body
    assert "d[\"asset_id\"] == asset_id" in body


def test_the_meter_history_shows_what_was_added():
    #  По этой колонке видно, работает машина или стоит, и она же объясняет,
    #  почему срок ТО подошёл раньше ожидаемого
    body = block(DB, "def meter_history(")
    assert "lag(m.engine_hours)" in body
    assert "AS added" in body


def test_who_did_the_maintenance_is_free_text():
    #  ТО-2 делает сторонний специалист, учётки у него нет
    for func in ("def maintenance_history(", "def maintenance_log("):
        body = block(DB, func)
        assert "m.performed_by AS performed_by_name" in body, func
        assert "app_user" not in body, func


# --- реестр проведённых ТО ---------------------------------------------------

def test_the_register_of_done_work_is_separate_from_the_plan():
    #  Один список отвечает, что делать, другой — что сделано. В одной
    #  таблице не выйдет ни спланировать, ни отчитаться
    assert "Проведённые ТО" in SUPPLY
    assert "Когда следующее ТО" in SUPPLY
    body = block(DB, "def maintenance_log(")
    assert "m.status = 'done'" in body


def test_the_register_is_indexed():
    assert "maintenance_done_idx" in MIGRATION
    assert "WHERE status = 'done'" in MIGRATION


# --- ремонт ------------------------------------------------------------------

def test_a_broken_unit_can_be_sent_to_repair_from_the_list():
    #  Ломается вещь в тот момент, когда на неё смотрят в списке, а не когда
    #  доберутся до вкладки заявок
    tab = SUPPLY[SUPPLY.index("{% if tab in ('equipment', 'verification', 'stock') %}"):
                 SUPPLY.index("{% elif tab == 'maintenance' %}")]
    assert 'action="/supply/repair/open"' in tab
    assert 'name="problem"' in tab and "required" in tab


def test_the_reason_is_asked_before_the_request_opens():
    #  По пустой заявке в Минске не поймут, что чинить
    body = block(DB, "def open_repair(")
    assert "Опишите, что сломалось" in body


def test_the_unit_leaves_the_working_list_while_it_is_being_repaired():
    #  «Тогда она попадает в заявки на ремонт и проходит путь»
    body = block(DB, "def open_repair(")
    assert "UPDATE app.asset SET status = 'repair'" in body


def test_the_unit_comes_back_by_itself_when_the_route_ends():
    #  «После чего возвращается обратно в общий список». Держать это руками
    #  в двух местах значит однажды разойтись — поэтому внутри функции
    #  перехода, рядом с самим переходом
    route = read(SQL / "34_repair_requests.sql")
    fn = route[route.index("CREATE OR REPLACE FUNCTION move_repair_request"):]
    assert "IF p_status = 'received' THEN" in fn
    assert "UPDATE asset SET status = 'ok'" in fn


def test_the_repair_history_is_recorded():
    #  «В заявках на ремонт история по ремонту записывается»
    route = read(SQL / "34_repair_requests.sql")
    assert "INSERT INTO repair_request_event" in route
    body = block(DB, "def repairs_of_asset(")
    assert "repair_request_event" in body, "в карточке не видно, сколько было шагов"


def test_the_form_returns_where_it_was_pressed():
    #  Заявку открывают из трёх мест: из списка, из карточки и со вкладки
    #  заявок. Возвращать всех на вкладку заявок значило бы уводить со
    #  страницы, на которой работали
    assert "def _back_from(" in WEBAPP
    body = block(WEBAPP, "def _back_from(")
    assert 'back == "card"' in body


# --- фильтр чисел ------------------------------------------------------------

def test_round_numbers_keep_their_zeros():
    """
    Незначащие нули убираются только после запятой.

    Нашли на показаниях счётчика: 120 моточасов выводились как «12».
    `rstrip("0")` шёл по всей строке, а при digits=0 дробной части нет вовсе —
    обрезались настоящие цифры. Портились ровно те числа, что кончаются
    нулём, поэтому на глаз это долго не замечали: 204 показывалось верно,
    а 200 — как «2». Страдали моточасы, количество и численность в бюджете.
    """
    from timesheet.webapp import num

    assert num(120, 0) == "120"
    assert num(200, 0) == "200"
    assert num(2000, 0) == "2000"
    assert num(10, 0) == "10"
    #  И при этом дробные по-прежнему без хвостов
    assert num(1.50, 2) == "1,5"
    assert num(0.07, 4) == "0,07"
    assert num(0, 0) == "0"
    assert num(None, 0) == ""


# --- сроки ТО ----------------------------------------------------------------

def test_the_counters_count_what_the_list_shows():
    """
    Над одной строкой техники висело «2 единицы».

    Вторым был терминал сбора данных с соседней вкладки: вкладки разделили,
    а счётчики остались общими. Счётчики стоят над списком и обязаны считать
    то же, что в нём.
    """
    body = block(DB, "def asset_counts(")
    assert "kind: str" in body
    #  Условие вкладки — одно на список, счётчики и виды для формы
    assert 'kind_filter(kind, "c")' in body
    route = block(WEBAPP, "def _supply_context(")
    assert "kind=tab if tab in" in route


def test_the_equipment_list_shows_both_due_dates():
    #  Чтобы узнать, не пора ли обслуживать машину, приходилось уходить
    #  на другую вкладку
    tab = SUPPLY[SUPPLY.index("{% if tab in ('equipment', 'verification', 'stock') %}"):
                 SUPPLY.index("{% elif tab == 'maintenance' %}")]
    assert "ТО-1 до" in tab and "ТО-2 до" in tab
    assert "due_by_asset" in tab


def test_the_due_dates_are_not_computed_a_second_time():
    #  Два ответа на вопрос «когда следующее ТО» однажды разойдутся
    body = block(WEBAPP, "def supply_page(")
    assert "supplydb.maintenance_due(conn, unit_id)" in body


def test_the_due_date_does_not_run_away_from_the_meter():
    """
    Ошибка, найденная 15.09.2026: срок отсчитывался от ПОСЛЕДНЕЙ наработки.

    Значит каждая новая отметка отодвигала срок, и по календарю ТО не
    наступало никогда, а «осталось моточасов» всегда показывало ровно 50 и
    250 — цель уезжала вместе с текущим значением.

    22.09.2026 источник наработки сменился: не отдельные замеры счётчика, а
    часы из отметок о проведённом ТО. Правило отсчёта то же — от последнего
    ТО этого вида, а пока его не было, от самой ранней известной наработки.
    """
    body = block(DB, "def maintenance_due(")
    assert "first_hours" in body and "first_meter_date" in body
    assert 'base = r["first_hours"]' in body
    assert 'r["last_done_at"] or r["first_meter_date"]' in body
    #  Наработка приходит из ТО, отдельных замеров счётчика больше нет
    assert "FROM app.maintenance" in body
    assert "meter_reading" not in body
    #  И порядок выборки: одна лямбда за последней отметкой, другая за первой
    assert "ORDER BY done_at ASC, id ASC LIMIT 1" in body
    assert "ORDER BY done_at DESC, id DESC LIMIT 1" in body


def test_a_machine_without_readings_counts_from_registration():
    #  Иначе у только что заведённой техники срока нет вовсе, и она молча
    #  выпадает из обслуживания
    body = block(DB, "def maintenance_due(")
    assert 'r["registered_at"]' in body


# --- ТО на доске задач -------------------------------------------------------

def test_maintenance_appears_on_the_board():
    #  До 15.09.2026 правила ТО на доске не было вовсе, хотя в пояснении
    #  к соседнему правилу оно уже упоминалось
    assert "def _maintenance(" in KANBAN
    assert "_maintenance(conn, unit_id, today)" in KANBAN


def test_the_board_does_not_compute_the_due_date_its_own_way():
    #  Срок берётся готовым из того же расчёта, что показывает список
    #  техники и вкладка ТО
    body = block(KANBAN, "def _maintenance(")
    assert "supplydb.maintenance_due" in body


@pytest.mark.parametrize("code, lead", [("ТО-1", 0), ("ТО-2", 7)])
def test_each_kind_of_service_has_its_own_warning(code, lead):
    """
    «ТО-1 появляется в списке задач день в день. ТО-2 появляется в начале
    недели за 7 дней до окончания ТО-2».

    Разница не в придирчивости: ТО-1 делают своими силами за полчаса, а на
    ТО-2 надо вызвать специалиста — о нём нужно узнать в начале недели.
    """
    from timesheet.kanbandb import MAINTENANCE_LEAD

    assert MAINTENANCE_LEAD[code] == lead


def test_service_one_shows_up_on_the_day_itself():
    from timesheet.kanbandb import maintenance_is_due, week_start

    today = date(2026, 9, 16)          # среда
    monday = week_start(today)
    assert maintenance_is_due("ТО-1", today, None, today, monday)
    assert maintenance_is_due("ТО-1", date(2026, 9, 15), None, today, monday)
    #  Завтрашнее ТО-1 сегодня не показываем: предупреждать заранее незачем
    assert not maintenance_is_due("ТО-1", date(2026, 9, 17), None, today, monday)


def test_service_two_shows_up_a_week_before():
    from timesheet.kanbandb import maintenance_is_due, week_start

    #  24.09.2026: ТО-2 (и ПОПГ, ЧТО) появляются 25-го числа — все, что
    #  приходятся на следующий месяц. До 25-го видно текущий месяц
    today = date(2026, 9, 16)
    monday = week_start(today)
    assert maintenance_is_due("ТО-2", date(2026, 9, 30), None, today, monday)
    assert not maintenance_is_due("ТО-2", date(2026, 10, 1), None, today, monday)
    today = date(2026, 9, 25)
    monday = week_start(today)
    assert maintenance_is_due("ТО-2", date(2026, 10, 31), None, today, monday)
    assert maintenance_is_due("ПОПГ", date(2026, 10, 15), None, today, monday)
    assert not maintenance_is_due("ЧТО", date(2026, 11, 1), None, today, monday)
    #  Декабрь → январь следующего года
    assert maintenance_is_due("ТО-2", date(2027, 1, 31), None,
                              date(2026, 12, 26), week_start(date(2026, 12, 26)))


def test_worked_hours_count_as_much_as_the_calendar():
    #  Пятьдесят моточасов могут набежать за три дня, и ждать седьмого дня
    #  в этом случае нельзя
    from timesheet.kanbandb import maintenance_is_due, week_start

    today = date(2026, 9, 16)
    monday = week_start(today)
    far = date(2026, 12, 31)
    assert maintenance_is_due("ТО-1", far, 0, today, monday)
    assert maintenance_is_due("ТО-2", far, -5, today, monday)
    assert not maintenance_is_due("ТО-1", far, 12, today, monday)


def test_marking_one_service_does_not_close_the_other():
    """
    Проверено на живых данных: отметка ТО-1 закрывала и задачу ТО-2.

    Причина была та же — срок считался от последнего замера, а отметка о ТО
    записывает замер. После правки отметка ТО-1 закрывает только ТО-1.
    Ключ задачи включает вид обслуживания, иначе они были бы одной задачей.
    """
    body = block(KANBAN, "def _maintenance(")
    assert "maintenance:{d['asset_id']}:{d['type_code']}" in body


def test_written_off_machines_are_not_serviced():
    body = block(KANBAN, "def _maintenance(")
    #  24.09.2026: и «требует замены» — тоже
    assert 'd["status"] in ("written_off", "needs_replacement")' in body


def test_the_board_survives_without_the_supply_migration():
    #  Доска — не про технику, и падать из-за неё она не должна
    body = block(KANBAN, "def _maintenance(")
    assert "except psycopg.Error" in body


# --- выполненное считается выполненным ---------------------------------------

def test_data_entry_counts_as_work_done():
    """
    «Закрыто само — это когда сотрудник исправил дату и выполнил действие,
    значит это статус выполнено. Нам важно фиксировать выполненные задачи».
    """
    from timesheet.kanbandb import DONE_STATUSES, STATUS_RU

    assert STATUS_RU["auto_done"] == "Выполнено"
    assert set(DONE_STATUSES) == {"done", "auto_done"}


def test_both_kinds_of_closing_add_up_in_the_report():
    body = block(KANBAN, "def summary(")
    assert 'int(r["done"]) + int(r["auto_done"])' in body


def test_the_two_ways_of_closing_stay_distinguishable():
    """
    Два способа закрытия различимы и складываются в доле: «Выполнено» — когда
    данные внесены и задача погасла сама, «отмечено» — когда человек нажал
    кнопку и система проверила, что причина исчезла.

    Показаны по отдельности: по ним видно, чем именно закрыта работа.
    """
    body = block(KANBAN, "def summary(")
    assert "AS done" in body and "AS auto_done" in body
    assert "Выполнено" in KANBAN_HTML
    #  24.09.2026: отдельный столбец «отмечено» в сводке убран — пустой, он
    #  читался как ошибка. Закрытые кнопкой складываются в «Выполнено»
    assert ">отмечено</th>" not in KANBAN_HTML
    assert "(r.auto_done or 0) + (r.done or 0)" in KANBAN_HTML


# ---------------------------------------------------------------------------
#  ОБ-10 (21.09.2026): «список ТМЦ нельзя ни исправить, ни удалить»
# ---------------------------------------------------------------------------

def test_the_stock_row_can_be_edited_in_place():
    """
    У техники правка идёт через карточку, а у ТМЦ карточки нет вовсе: строку
    заводили один раз и жили с опечаткой.
    """
    import pathlib
    tpl = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "templates" / "supply.html").read_text(encoding="utf-8")
    at = tpl.index("row-acts")
    row = tpl[at:at + 3000]
    assert 'name="asset_id" value="{{ a.id }}"' in row
    assert "Править" in row
    #  Вид тоже правится: ошибиться можно и в нём
    assert 'name="category_id"' in row


def test_deleting_keeps_anything_with_a_history():
    """
    Единицу с ремонтами, ТО, показаниями или движениями стирать нельзя: она в
    депо была, и след этого остаётся. Такую переводят в «списано».
    """
    import pathlib
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "supplydb.py").read_text(encoding="utf-8")
    at = src.index("def delete_asset(")
    body = src[at:src.index("\ndef ", at + 10)]
    for table in ("repair_request", "meter_reading", "maintenance", "asset_movement"):
        assert table in body, table
    assert "«списано»" in body


def test_the_delete_route_checks_the_unit_and_the_right():
    import pathlib
    web = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "webapp.py").read_text(encoding="utf-8")
    at = web.index("async def supply_asset_delete(")
    body = web[at:web.index("\n@app.", at)]
    assert "unit_or_403(conn, unit)" in body
    assert 'has_perm(conn, "asset.write")' in body


# ---------------------------------------------------------------------------
#  Обеспечение: заявки, ТО, показания (требования от 21.09.2026)
# ---------------------------------------------------------------------------

def test_the_repair_reasons_include_the_wheel_rebuild():
    from timesheet.supplydb import REPAIR_PROBLEMS
    assert "Наварка колёс" in REPAIR_PROBLEMS


def test_the_reason_list_is_a_hint_not_a_closed_list():
    """Неописанная поломка должна отправляться тоже."""
    import pathlib
    tpl = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "templates" / "supply.html").read_text(encoding="utf-8")
    assert '<datalist id="problems">' in tpl
    assert 'name="problem"' in tpl and 'list="problems"' in tpl
    #  Именно input, а не select: иначе список стал бы закрытым
    assert '<select name="problem"' not in tpl


def test_maintenance_shows_more_than_the_metered_equipment():
    """
    «Вкладка ТО по умолчанию показывает складскую и поверочную технику».
    Раньше в запросе стояло `AND c.has_meter`, и всё, кроме штабелёров,
    вкладка не показывала вовсе.
    """
    import pathlib
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "supplydb.py").read_text(encoding="utf-8")
    at = src.index("def maintenance_due(")
    body = src[at:src.index("\ndef ", at + 10)]
    assert "JOIN app.asset_category c ON c.id = a.category_id" in body
    assert "a.category_id AND c.has_meter" not in body


def test_the_meter_form_is_gone():
    """
    22.09.2026: «убрать строчки снять показания, брать наработку по часам
    с ТО-1 и ТО-2». Одно число вводилось в двух местах, значения
    расходились, и какое считать текущим — было непонятно.
    """
    import pathlib
    tpl = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "templates" / "supply.html").read_text(encoding="utf-8")
    card = (pathlib.Path(__file__).resolve().parents[1]
            / "timesheet" / "templates" / "asset_card.html").read_text(encoding="utf-8")
    for name, t in (("supply", tpl), ("card", card)):
        assert 'action="/supply/meter"' not in t, name
        assert "Снять показания" not in t, name


def test_a_done_maintenance_writes_the_meter_reading():
    """«Значения брать из ТО-1 и ТО-2» — дублировать их руками не нужно."""
    import pathlib
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "supplydb.py").read_text(encoding="utf-8")
    at = src.index("def mark_maintenance_done(")
    body = src[at:src.index("\ndef ", at + 10)]
    assert "INSERT INTO app.meter_reading" in body


def test_the_due_dates_open_the_asset_card():
    """«Сделать технику кликабельной для ТО-1 и ТО-2»."""
    import pathlib
    tpl = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "templates" / "supply.html").read_text(encoding="utf-8")
    at = tpl.index("for code in ['ТО-1', 'ТО-2']")
    assert '/supply/asset/{{ a.id }}' in tpl[at:at + 900]
