"""
Вычитка LOGIKA_PROSTO, волна 3 (30.09.2026 — 01.10.2026): доска задач —
единое состояние «Выполнено» (без «Сделано»), новое «Просрочено», цвета,
иерархия состояний во всех режимах, кликабельная карточка «просрочено»,
возврат отложенных по дате переноса, автозакрытие отложенных при
исчезновении причины, кнопка «ВЫПОЛНИТЬ» и персональные задачи (6.4.1).
"""

import pathlib
from datetime import date, timedelta

ROOT = pathlib.Path(__file__).resolve().parents[2]
ENGINE = ROOT / "engine" / "timesheet"
T = ENGINE / "templates"
SQL = ROOT / "sql"
read = lambda p: p.read_text(encoding="utf-8")
WEB = read(ENGINE / "webapp.py")
KANBAN = read(ENGINE / "kanbandb.py")
BOARD_T = read(T / "kanban.html")
CSS = read(ENGINE / "static" / "app.css")
MIG = read(SQL / "96_personal_tasks.sql")

import sys
sys.path.insert(0, str(ROOT / "engine"))
from timesheet import kanbandb                       # noqa: E402


# ------------------------------------------------ состояния: единое «Выполнено»

def test_done_and_auto_done_are_both_vypolneno():
    assert kanbandb.STATUS_RU["done"] == "Выполнено"
    assert kanbandb.STATUS_RU["auto_done"] == "Выполнено"
    assert "Сделано" not in kanbandb.STATUS_RU.values()


def test_overdue_status_exists():
    assert kanbandb.STATUS_RU["overdue"] == "Просрочено"
    #  «Вернувшийся» перенос подписывается тем же «Отложено»: это оно и есть,
    #  просто его день настал
    assert kanbandb.STATUS_RU["returned"] == "Отложено"


# --------------------------------------------------- иерархия состояний (6.2)

def test_status_order_hierarchy():
    assert kanbandb.STATUS_ORDER == (
        "returned", "overdue", "open", "skipped", "done", "auto_done")


def test_effective_status_rules():
    today = date(2026, 10, 1)
    t = lambda **kw: {"status": kw.get("status", "open"),
                      "due_at": kw.get("due_at"),
                      "postponed_to": kw.get("postponed_to")}
    #  открытая: срок прошёл — просрочено, сегодня — работа
    assert kanbandb.effective_status(t(due_at=date(2026, 9, 30)), today) \
        == "overdue"
    assert kanbandb.effective_status(t(due_at=today), today) == "open"
    assert kanbandb.effective_status(t(due_at=date(2026, 10, 2)), today) \
        == "open"
    assert kanbandb.effective_status(t(due_at=None), today) == "open"
    #  отложенная: будущий перенос — отложено; сегодня — вернувшееся
    #  (наверх доски, без даты и «кто отложил»); вчера — просрочено
    assert kanbandb.effective_status(
        t(status="skipped", postponed_to=date(2026, 10, 2)), today) == "skipped"
    assert kanbandb.effective_status(
        t(status="skipped", postponed_to=today), today) == "returned"
    assert kanbandb.effective_status(
        t(status="skipped", postponed_to=date(2026, 9, 30)), today) == "overdue"
    #  отложенной без переноса не бывает — показываем работой
    assert kanbandb.effective_status(t(status="skipped"), today) == "open"
    #  закрытые не пересчитываются
    assert kanbandb.effective_status(
        t(status="done", due_at=date(2026, 9, 1)), today) == "done"
    assert kanbandb.effective_status(
        t(status="auto_done", due_at=date(2026, 9, 1)), today) == "auto_done"


def test_board_order_puts_returned_first_and_done_last():
    today = date(2026, 10, 1)
    rows = [
        {"status": "open", "due_at": date(2026, 10, 5), "kind": "a",
         "subject": "x"},
        {"status": "skipped", "postponed_to": today, "due_at": None,
         "kind": "b", "subject": "y"},
        {"status": "open", "due_at": date(2026, 9, 30), "kind": "c",
         "subject": "z"},
        {"status": "auto_done", "due_at": date(2026, 9, 1), "kind": "d",
         "subject": "w"},
    ]
    order = [r["kind"] for r in sorted(rows, key=lambda r: kanbandb.board_order(r, today))]
    #  вернувшийся перенос — в самом верху, дальше просроченное, работа,
    #  выполненное
    assert order == ["b", "c", "a", "d"]


# ------------------------------------- возврат переноса и автозакрытие (6.2)

def test_refresh_keeps_expired_postpone_rows():
    #  вернувшийся перенос больше не уходит в «open»: строка остаётся
    #  «skipped» с прошедшей датой — это и есть сигнал «вернулось/просрочено»
    at = KANBAN.index("Истёкшие записи переноса")
    assert "SET status = 'open'" not in KANBAN[at:at + 700]
    #  запись переноса удаляется, строка задачи остаётся
    assert "DELETE FROM app.kanban_postpone" in KANBAN[at:at + 400]


def test_refresh_auto_closes_postponed_when_cause_gone():
    #  сверка по отложенным: причина исчезла — «автоматом переводить в
    #  Выполнено» — и персональные (is_manual) правила не трогают
    at = KANBAN.index("сверка идёт и по отложенным")
    body = KANBAN[at:KANBAN.index("conn.commit()", at)]
    assert "status IN ('open', 'skipped')" in body
    assert "AND NOT is_manual" in body
    delete_at = body.index("DELETE FROM app.kanban_task")
    assert "status IN ('open', 'skipped')" in body[delete_at:]
    assert "AND NOT is_manual" in body[delete_at:]


def test_future_weeks_normalize_expired_postpone():
    #  прогноз будущих недель: перенос, кончившийся до их понедельника,
    #  к ним не относится — задача возвращается обычной работой
    at = KANBAN.index("Прогноз будущих недель")
    body = KANBAN[at:at + 900]
    assert "postponed_to IS NULL OR postponed_to < %s" in body
    assert "monday > week_start(date.today())" in KANBAN[at - 200:at + 900]


# --------------------------------------------------- персональные задачи (6.4.1)

def test_personal_kind_registered():
    assert kanbandb.KIND_RU["personal"] == "Персональная"
    #  персональная задача не относится ни к людям, ни к технике — она
    #  видна в «Все задачи» и на своей доске
    assert "personal" not in kanbandb.PEOPLE_KINDS
    assert "personal" not in kanbandb.TECH_KINDS


def test_personal_create_sql_details():
    at = KANBAN.index("def personal_create")
    body = KANBAN[at:]
    assert "'personal', %s, %s, %s, %s, 'open', true, %s" in body
    assert "app.default_assignee" in body
    assert "kanban_personal" in body


def test_personal_mirrored_on_hq_board():
    at = KANBAN.index("def personal_tasks")
    body = KANBAN[at:KANBAN.index("def postpones")]
    assert "k.kind = 'personal'" in body
    assert "ou.code AS unit_code" in body
    #  и доска «Минск» подтягивает копию
    assert "kanbandb.personal_tasks(conn, weeks)" in WEB


def test_migration_96_personal_columns():
    assert "ALTER TABLE app.kanban_task" in MIG
    for col in ("kind_label", "result_link", "result_file",
                "result_file_name"):
        assert f"ADD COLUMN IF NOT EXISTS {col} text" in MIG


def test_personal_report_saved_on_close():
    at = KANBAN.index("def close_task")
    body = KANBAN[at:]
    assert "result_link = %(rlink)s" in body
    assert "result_file = %(rfile)s" in body
    #  отчёт пишется только при закрытии — «Вернуть в работу» его стирает
    assert '"rlink": result_link if status == "done" else None' in body


# ------------------------------------------------------------- роуты (webapp)

def test_kanban_page_overdue_filter_and_sort():
    #  state=overdue — четвёртый кликабельный фильтр; все фильтры — по
    #  эффективному состоянию; сортировка — иерархией состояний
    assert '"open", "done", "skipped", "overdue"' in WEB
    assert 't["eff"] == "open"' in WEB
    assert 't["eff"] in ("skipped", "returned")' in WEB
    assert 't["eff"] == "overdue"' in WEB
    assert "kanbandb.effective_status(t, today)" in WEB
    assert "kanbandb.board_order(t, today)" in WEB
    #  счётчики — экранные состояния (сверяем без учёта переносов строк)
    at = WEB.index("effs = [t[\"eff\"] for t in all_tasks]")
    block = " ".join(WEB[at:WEB.index('ctx["personal_units"]', at)].split())
    assert '"overdue": sum(1 for e in effs if e == "overdue")' in block
    assert '"skipped": sum(1 for e in effs if e in ("skipped", "returned"))' \
        in block


def test_personal_routes_exist():
    assert '@app.post("/kanban/personal")' in WEB
    assert '@app.get("/kanban/task/{task_id}/file")' in WEB
    assert "kanban_personal_create" in WEB
    #  закрытие задачи принимает отчёт: ссылку и файл — через request.form(),
    #  чтобы urlencoded-формы («Отложить», «Вернуть») не ломались о File()
    at = WEB.index("async def kanban_task_close")
    body = WEB[at:WEB.index("@app.post(\"/kanban/personal\"")]
    assert "form = await request.form()" in body
    assert 'form.get("link")' in body
    assert "form.get(\"file\")" in body
    assert "isinstance(file, StarletteUpload)" in body
    assert 'filestore.save(data, area="kanban")' in body
    #  постановка — только Администрации (доступ больше чем к одному депо)
    pa = WEB.index("def kanban_personal_create")
    assert "доступ больше чем к одному депо" in WEB[pa:pa + 2500]
    #  операция для журнала
    assert '"kanban_personal": "Персональная задача поставлена"' in WEB


# ------------------------------------------------------------------ шаблон

def test_board_template_overdue_card_and_states():
    #  карточка «просрочено» — четвёртая, кликабельная, в цвете
    assert "state=overdue" in BOARD_T
    assert 'card st-overdue' in BOARD_T
    assert 'card st-open' in BOARD_T
    assert 'card st-done' in BOARD_T
    assert 'card st-skipped' in BOARD_T
    #  приписки «, просрочено N» у карточки «в работе» больше нет — число
    #  переехало в собственную карточку
    assert "просрочено {% if overdue %}" not in BOARD_T
    #  состояние строки — эффективное, в цвете; дата переноса — только у
    #  живого переноса
    assert 'data-state="{{ t.eff }}"' in BOARD_T
    assert "{% if t.postponed_to and t.eff == 'skipped' %}" in BOARD_T


def test_board_template_button_renamed():
    #  кнопка «Выполнено» переименована в «ВЫПОЛНИТЬ» (п. 6.5)
    assert ">ВЫПОЛНИТЬ</button>" in BOARD_T
    assert ">Выполнено</button>" not in BOARD_T


def test_board_template_personal_task():
    #  окно выполнения: условие постановки + обязательное примечание +
    #  необязательные ссылка и файл (multipart)
    assert 'enctype="multipart/form-data"' in BOARD_T
    assert "personal-brief" in BOARD_T
    assert "Примечание, что сделано" in BOARD_T
    assert 'name="link"' in BOARD_T
    assert 'name="file"' in BOARD_T
    #  вид персональной задачи — краткое описание от Администрации
    assert "t.kind_label" in BOARD_T
    #  форма постановки — в «Результате по депо»
    assert 'action="/kanban/personal"' in BOARD_T
    assert "Добавить задачу" in BOARD_T
    #  отчёт в истории: примечание, ссылка, файл
    assert "/kanban/task/{{ t.id }}/file" in BOARD_T
    assert "result_file_name" in BOARD_T
    #  справка больше не говорит, что отметки «сделано» нет
    assert "Отметки «сделано» здесь нет" not in BOARD_T


# ---------------------------------------------------------------------- CSS

def test_css_state_colors():
    for sel, hue in (
        ('table.list.kboard .state[data-state="open"]', "#eaf7ee"),
        ('table.list.kboard .state[data-state="auto_done"]', "#eef3ff"),
        ('table.list.kboard .state[data-state="returned"]', "#fff6e6"),
        ('table.list.kboard .state[data-state="overdue"]', "#ffeef1"),
    ):
        at = CSS.index(sel)
        assert hue in CSS[at:at + 200]
    #  карточки-счётчики — в цветах состояний
    assert ".count-filter .card.st-overdue .card-num" in CSS
    assert ".count-filter .card.st-open.active" in CSS


# --------------------------------------------- «Табель за сутки» (6.11): 1-е число

def test_timesheet_day_skips_first_and_can_be_overdue():
    #  задача за 1-е число не выдаётся — месяц закрывается своей сдачей;
    #  просроченность на второй день даёт effective_status
    at = KANBAN.index("def _unfilled_yesterday")
    body = KANBAN[at:KANBAN.index("def _documents")]
    assert "day.day == 1" in body
    assert "due_at=today" in body
