"""
Учётная запись выдаётся из карточки сотрудника (уточнение от 15.09.2026).

«В карточке сотрудника присваивается логин и пароль от учётной записи, а также
фиксируется роль по приложению; если есть необходимость забрать или изменить
роль, отозвать доступ — это возможно выполнить через карточку сотрудника. При
увольнении особенно важно содержать в приложении только активных
пользователей».

До этой правки учётки и роли заводились единственным способом — запросом в
базу; за всё время их завели три, все из сида. Таблицы были готовы давно: у
`app_user` есть `employee_id`, у `user_role` — `granted_by`, `granted_at` и
`revoked_at`. Не хватало места, где этим можно распорядиться, и правил,
которые бы это сторожили.

Проверено на живой базе, 32 проверки в транзакции с откатом: выдача, вход
выданным паролем, право от роли, смена роли, смена пароля, отзыв, возврат,
увольнение — и все запреты. Отдельно проверены обработчики: начальник РЦ,
у которого нет права «Управление пользователями и ролями», отозвать доступ не
смог, и учётная запись осталась нетронутой.
"""

import pathlib
import re

ROOT = pathlib.Path(__file__).resolve().parents[2]
ENGINE = ROOT / "engine" / "timesheet"
SQL = ROOT / "sql"


def read(path):
    return path.read_text(encoding="utf-8")


MIGRATION = read(SQL / "43_app_access_from_card.sql")
GUARD = read(SQL / "45_login_edit_and_admin_guard.sql")
DB = read(ENGINE / "staffdb.py")
WEBAPP = read(ENGINE / "webapp.py")
CARD = read(ENGINE / "templates" / "staff_card.html")
CSS = read(ENGINE / "static" / "app.css")


def sql_body(text):
    #  Пояснения в шапке пересказывают правило словами заказчика, и проверка
    #  «этого нет в коде» ловила бы их, а не код
    return re.sub(r"--[^\n]*", "", text)


BODY = sql_body(MIGRATION)
GUARD_BODY = sql_body(GUARD)


def fn(name, src=None):
    """
    Тело функции. Ищем в последней миграции, где она переписана: функцию
    правят `CREATE OR REPLACE`, и проверять надо ту редакцию, что работает.
    """
    src = src if src is not None else (GUARD_BODY if f"FUNCTION {name}(" in GUARD_BODY
                                       else BODY)
    at = src.index(f"FUNCTION {name}(")
    end = src.index("$fn$;", at)
    return src[at:end]


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_every_action_checks_the_right_in_the_database():
    """
    Право проверяется там же, где действие происходит.

    Проверка, стоящая только в обработчике, обходится вторым путём к той же
    таблице — а он появится: экран ролей уже пишет в `role_permission`.
    """
    for name in ("grant_app_access", "set_user_role"):
        assert "has_perm('user.manage')" in fn(name), name
    #  Отзыв и возврат спрашивают то же самое через общую проверку
    for name in ("revoke_app_access", "restore_app_access"):
        assert "check_can_touch_user" in fn(name), name
    assert "has_perm('user.manage')" in fn("check_can_touch_user")


def test_the_password_function_stopped_being_open_to_everyone():
    #  Была `SECURITY DEFINER` и сразу UPDATE, без единой проверки. Пока её
    #  звали только из сида, последствий не было; с формой в карточке — были бы
    body = fn("set_password")
    assert "check_can_touch_user" in body
    #  Своему паролю человек хозяин и без права `user.manage`
    assert "p_user_id <> current_user_id()" in body
    assert "length(p_password) < 10" in body


def test_the_seed_can_still_set_a_password_without_a_session():
    #  Учётки заводит сид, где пользователя сессии нет вовсе. Проверка,
    #  забывшая про этот случай, сломала бы установку на чистую базу
    assert "current_user_id() IS NOT NULL" in fn("set_password")


def test_a_dismissed_person_gets_no_access():
    #  «В приложении только активные» — правило, а не пожелание
    assert "Сотрудник уволен" in fn("grant_app_access")
    assert "Сотрудник уволен" in fn("restore_app_access")


def test_dismissal_closes_the_account_by_itself():
    """
    Учётку ТСД увольнение закрывало с самого начала, учётку приложения — никто:
    их и заводить было негде.

    Триггером на `employment`, а не строчкой внутри `terminate_employment`:
    дату увольнения ставит не только она.
    """
    body = fn("close_app_access_on_termination")
    assert "is_active = false" in body
    assert "revoked_at = now()" in body
    assert "AFTER UPDATE OF terminated_at ON employment" in BODY


def test_dismissal_looks_at_every_assignment():
    #  У человека может быть несколько назначений: перевод внутри отдела
    #  закрывает одно и открывает другое, и доступ при этом терять не за что
    body = fn("close_app_access_on_termination")
    assert "NOT EXISTS" in body and "terminated_at IS NULL" in body


def test_one_person_has_one_account():
    #  Опечатка в почте завела бы вторую запись незаметно, и «отозвать доступ»
    #  отозвало бы одну из двух
    assert "CREATE UNIQUE INDEX IF NOT EXISTS app_user_employee_uq" in BODY
    assert "У сотрудника уже есть учётная запись" in MIGRATION


def test_one_role_at_a_time():
    """
    Прежняя роль закрывается датой, а не удаляется: на вопрос «кто и когда дал
    ему доступ к расчёту» иначе нет ответа.
    """
    body = fn("set_user_role")
    assert "UPDATE user_role SET revoked_at = now()" in body
    assert "granted_by" in body


def test_setting_the_same_role_again_writes_nothing():
    #  Иначе каждое открытие формы клало бы в журнал отзыв и выдачу одного и
    #  того же
    body = fn("set_user_role")
    assert "IS NOT DISTINCT FROM p_org_unit_id" in body
    assert "RETURN;" in body


def test_revoking_access_also_takes_the_role():
    #  Роль, оставшаяся действующей, всплыла бы при восстановлении учётки — и
    #  человек получил бы обратно ровно те права, которые у него забирали
    body = fn("revoke_app_access")
    assert "is_active = false" in body
    assert "UPDATE user_role SET revoked_at = now()" in body


def test_nobody_locks_themselves_out():
    assert "Себе доступ не отзывают" in MIGRATION


# --- хэш пароля не расходится по копиям --------------------------------------

def test_the_password_hash_stays_out_of_the_audit_log():
    """
    Журнал писал строку целиком через `to_jsonb(NEW)`, а каждый вход обновляет
    время последнего входа — то есть каждый вход клал в журнал ещё одну копию
    хэша. На момент правки их там было 136.

    Это не утечка пароля: bcrypt обратно не разворачивается. Но журнал живёт
    вечно и уезжает в каждую резервную копию, а хэш подбирают офлайн.
    """
    assert "audit_scrub" in BODY
    assert "audit_scrub(to_jsonb(NEW))" in BODY
    assert "audit_scrub(to_jsonb(OLD))" in BODY
    #  И уже записанное затёрто
    assert "UPDATE audit_log" in BODY


# --- слой приложения ---------------------------------------------------------

def test_the_python_layer_only_calls_the_database():
    #  Тонкий намеренно: правило, переписанное сюда, разошлось бы с базой
    for name in ("grant_access", "set_role", "revoke_access", "restore_access"):
        body = block(DB, f"def {name}(")
        assert "SELECT app." in body, name
        assert "has_perm" not in body, name


def test_the_admin_role_is_not_handed_out_from_the_card():
    #  Роль «может всё» выдаётся не между делом на вкладке «Личное»
    body = block(DB, "def roles_for_grant(")
    assert "r.code <> 'admin'" in body


def test_the_card_shows_who_granted_the_role_and_when():
    body = block(DB, "def app_account(")
    assert "granted_at" in body and "granted_by" in body
    assert "ur.revoked_at IS NULL" in body


def test_the_history_of_roles_is_kept():
    body = block(DB, "def role_history(")
    assert "revoked_at" in body
    assert "ORDER BY ur.granted_at DESC" in body


def test_the_handlers_report_the_database_refusal_as_is():
    #  «Сотрудник уволен — доступ не выдаётся» человеку понятнее, чем
    #  «ошибка сохранения»
    for name in ("staff_access_grant", "staff_access_role",
                 "staff_access_password", "staff_access_revoke",
                 "staff_access_restore"):
        body = block(WEBAPP, f"def {name}(")
        assert "_access_error(e)" in body, name
        assert "conn.rollback()" in body, name


def test_an_empty_depot_means_all_depots():
    body = block(WEBAPP, "def _access_unit(")
    assert "return int(value) if value else None" in body


# --- экран -------------------------------------------------------------------

def test_the_block_lives_next_to_the_tsd_login():
    #  Оба логина этого человека в одном месте: искать их по разным вкладкам
    #  незачем
    assert 'id="access"' in CARD
    assert CARD.index('id="access"') > CARD.index("Логин ТСД")
    assert CARD.index('id="access"') < CARD.index('id="fuel"')


def test_the_password_is_not_typed_by_a_human_at_all():
    """
    Правка от 16.09.2026: пароль придумывает приложение и отправляет письмом.

    Поля для пароля в карточке больше нет — а значит, нет и пароля, набранного
    руками, повторённого для второго сотрудника и оставшегося на экране за
    спиной у того, кто его вводил.
    """
    at = CARD.index('id="access"')
    body = CARD[at:CARD.index('id="fuel"')]
    assert 'name="password"' not in body
    assert "new_password()" in WEBAPP
    #  Алфавит без похожих знаков: пароль передают в том числе голосом
    assert "PASSWORD_ALPHABET" in DB
    assert "0" not in read(ENGINE / "staffdb.py").split(
        "PASSWORD_ALPHABET = ")[1].split(chr(10))[0]


def test_the_screen_says_where_the_password_goes():
    #  В отличие от учётки ТСД, где пароль лежит открытым текстом по решению
    #  заказчика: рядом стоят два разных порядка, и разницу надо назвать
    assert "письмом на" in CARD
    assert "хранится только отпечаток" in CARD


def test_without_the_right_the_block_explains_itself():
    #  Политика базы прячет чужие учётные записи, и пустое место читалось бы
    #  как «учётки нет»
    at = CARD.index('id="access"')
    body = CARD[at:CARD.index('id="fuel"')]
    assert "{% if not can_users %}" in body
    assert "закрыты политикой базы" in body


def test_the_context_is_only_loaded_for_those_who_may_use_it():
    body = block(WEBAPP, "def staff_card(")
    assert 'ctx["can_users"] = webdb.has_perm(conn, "user.manage")' in body
    assert 'if ctx["can_users"]:' in body


def test_the_dismissed_card_offers_no_form():
    at = CARD.index('id="access"')
    body = CARD[at:CARD.index('id="fuel"')]
    assert "уволенным не выдаётся" in body
    assert "{% elif person.terminated_at %}" in body


def test_a_role_is_chosen_and_not_accepted_by_default():
    """
    Первой в списке ролей стоит пустая.

    Иначе выбранной по умолчанию оказывается первая же роль — в нынешнем
    порядке это «Аналитик ООУРЦ» с пятнадцатью правами. Пятнадцать прав одним
    промахом мыши.
    """
    at = CARD.index('id="access"')
    body = CARD[at:CARD.index('id="fuel"')]
    #  В формах выдачи и возврата роль выбирается с нуля
    assert body.count('<option value="" selected disabled>') == 2
    #  А в форме смены роли выбрана нынешняя — подставлять там нечего
    assert '{% if r.code == account.role_code %}selected{% endif %}' in body


def test_the_revoke_button_is_separated_from_the_rest():
    #  «Отозвать доступ» не должно оказаться соседом «Записать роль» на
    #  расстоянии промаха мыши
    assert ".access-form" in CSS
    body = CSS[CSS.index(".access-form {"):]
    assert "border-top" in body[:200]


# --- правка логина и защита учётки администратора (15.09.2026) ---------------

def test_the_login_can_be_corrected_without_losing_the_history():
    """
    Повод был будничный: в заведённой учётке оказалась опечатка в домене —
    `e.shehin@21vek.bytest`. Войти по такому нельзя.

    Единственным выходом было отозвать доступ и завести заново, то есть
    выбросить историю ролей человека ради одной буквы.
    """
    body = fn("set_user_email")
    assert "lower(btrim(" in body
    assert "position('@' in v_email) < 2" in body
    assert "уже занят" in GUARD


def test_changing_the_login_clears_the_failed_attempts():
    #  Счётчик копился на прежний логин, и человек с новым упёрся бы в чужой
    #  запрет
    body = fn("set_user_email")
    assert "failed_logins = 0" in body
    assert "locked_until = NULL" in body


def test_writing_the_same_login_again_changes_nothing():
    #  Иначе каждое нажатие «Записать логин» клало бы в журнал правку, в
    #  которой ничего не поменялось
    body = fn("set_user_email")
    assert "v_email = v_now" in body
    assert "RETURN;" in body


def test_nobody_but_an_admin_touches_an_admin_account():
    """
    Дыра, вскрытая при этой правке. Накануне право `user.manage` получила роль
    «Администрация ООУРЦ» — иначе она не могла раздавать роли. Но это же право
    открывало `set_password` на любую учётную запись, включая администратора:
    не можешь выдать себе его роль — поменяй ему пароль и зайди под ним.

    Проверено прямым запросом до правки: и смена пароля администратору, и
    отзыв ему доступа проходили.
    """
    body = fn("check_can_touch_user")
    assert "is_admin(p_user_id) AND NOT is_admin()" in body
    #  И проверка стоит во всех четырёх дверях, а не в одной
    for name in ("set_password", "set_user_email",
                 "revoke_app_access", "restore_app_access"):
        assert "check_can_touch_user" in fn(name), name


def test_the_guard_is_one_function_not_four_copies():
    #  Копии расходятся молча: пятая функция, написанная через полгода, просто
    #  забудет условие
    #  Считаем именно определения: строка с GRANT называет ту же функцию
    assert GUARD_BODY.count('CREATE OR REPLACE FUNCTION check_can_touch_user(') == 1


def test_an_admin_still_manages_their_own_account():
    #  Иначе администратор не сменил бы себе пароль
    assert "p_user_id = current_user_id()" in fn("check_can_touch_user")


def test_the_login_field_is_in_the_card():
    at = CARD.index('id="access"')
    body = CARD[at:CARD.index('id="fuel"')]
    assert "/access/email" in body
    assert 'value="{{ account.email }}"' in body
    #  У отозванной учётки логин видно, но не правят: возвращать надо сперва
    assert "после возврата доступа" in body


def test_the_card_warns_that_the_old_login_stops_working():
    assert "прежний перестанет работать сразу" in CARD
