"""
Окончательный расчёт при увольнении — пункт 27 плана.

«В момент, когда проводим увольнение… рассчитать ЗП на основании имеющихся
данных по табелю, загрузить операции, выставить показатели и произвести
расчёт; в моменте может понадобиться инструмент вычетов и доплат».

Базы в проверочной среде нет, поэтому проверяется то, что от неё не зависит:
устройство таблиц и решения, которые легко потерять при следующей правке.

Главное из них: окончательный расчёт — не отдельный движок, а тот же расчёт
по одному человеку. Два разных ответа на вопрос «сколько человек заработал»
недопустимы, а отдельный движок рано или поздно разойдётся с основным.
"""

import pathlib

ENGINE = pathlib.Path(__file__).resolve().parents[1] / "timesheet"
TEMPLATES = ENGINE / "templates"
SQL = pathlib.Path(__file__).resolve().parents[2] / "sql"

LF = chr(10)


def read(path):
    return path.read_text(encoding="utf-8")


SOURCE = read(ENGINE / "payrolldb.py")
WEBAPP = read(ENGINE / "webapp.py")
MIGRATION = read(SQL / "36_final_settlement.sql")
PAGE = read(TEMPLATES / "settlement.html")
CARD = read(TEMPLATES / "staff_card.html")


def block(src, head):
    """Тело функции — до следующего определения на верхнем уровне."""
    body = src[src.index(head):]
    cut = body.find(LF + "def ", 10)
    return body if cut < 0 else body[:cut]


def index_body(name, skip=0):
    """
    Тело определения индекса из миграции — до точки с запятой.

    `skip` пропускает упоминания имени до нужного: у пересоздаваемого
    индекса первым идёт DROP, и без этого проверялась бы пустая строка.
    """
    at = -1
    for _ in range(skip + 1):
        at = MIGRATION.index(name, at + 1)
    return MIGRATION[at:][:MIGRATION[at:].index(";")]


# --- расчёт один, а не два ---------------------------------------------------

def test_the_settlement_is_not_a_second_payroll_engine():
    #  Считает тот же движок: иначе расчёт при увольнении и расчёт месяца
    #  рано или поздно дадут разные суммы по одному и тому же человеку
    body = block(SOURCE, "def final_preview(")
    assert "calculate_run(" in body
    assert "def calculate" not in body


def test_the_preview_shows_what_will_be_recorded():
    #  Предпросмотр, показывающий не ту сумму, которая запишется, хуже,
    #  чем никакого: по нему называют человеку сумму на руки
    preview = block(SOURCE, "def final_preview(")
    route = block(WEBAPP, "async def settlement_calc(")
    for step in ("employee_inputs(", "kpi_inputs(", "params(", "calculate_run("):
        assert step in preview, step
        assert step in route, step


def test_one_person_is_selected_in_sql_not_in_python():
    #  Отфильтровать список после выборки было бы проще, но тогда расчёт
    #  увольняемого собирал бы всё депо — и мог бы разойтись с записью
    body = block(SOURCE, "def employee_inputs(")
    assert "%(one)s::bigint IS NULL OR em.id = %(one)s" in body


# --- почему не отдельная таблица ---------------------------------------------

def test_the_settlement_reuses_the_payroll_run():
    #  Тогда он сам попадает в расчётные листки и в историю — ничего
    #  специально доучивать не нужно
    assert "ADD COLUMN IF NOT EXISTS kind text" in MIGRATION
    assert "CHECK (kind IN ('monthly', 'final'))" in MIGRATION


def test_a_final_run_names_a_person_and_a_monthly_one_does_not():
    #  Месячный расчёт — по всему депо, назначение в нём ничего не значило бы
    assert "pr_final_has_person" in MIGRATION
    assert "CHECK ((kind = 'final') = (employment_id IS NOT NULL))" in MIGRATION


def test_settlements_do_not_block_the_depot_payroll():
    #  Незакрытый расчёт депо по-прежнему один, но уволенные в него не лезут:
    #  иначе первый же увольняющийся закрыл бы депо расчёт на месяц
    assert "kind = 'monthly'" in index_body("payroll_run_one_open", 1)


def test_one_open_settlement_per_person():
    #  Два открытых расчёта по одному человеку — это не два расчёта,
    #  а путаница о том, какой из них пойдёт на выплату
    idx = index_body("payroll_run_one_final")
    assert "(employment_id, period_month)" in idx
    assert "kind = 'final'" in idx


def test_versions_are_numbered_within_a_kind():
    #  Иначе окончательные расчёты сбивали бы нумерацию версий месячного
    idx = index_body("CREATE UNIQUE INDEX IF NOT EXISTS payroll_run_version_key")
    assert "kind," in idx
    assert "coalesce(employment_id, 0), version" in idx


def test_the_monthly_views_ignore_settlements():
    #  «Расчёт депо за август» не должен вдруг показать расчёт уволенного
    for func in ("def open_run(", "def latest_run(", "def run_history("):
        assert "kind = 'monthly'" in block(SOURCE, func), func


def test_the_settlement_is_found_by_person_and_month():
    body = block(SOURCE, "def final_run(")
    assert "r.employment_id = %s" in body
    assert "r.kind = 'final'" in body
    #  Заменённый перерасчётом — это история, а не действующий расчёт
    assert "r.status <> 'superseded'" in body


# --- чего ждать, а чего не ждать ---------------------------------------------

def test_missing_hours_stop_the_settlement():
    #  Расчёт по пустому табелю — это расчёт на ноль, выданный как настоящий
    assert "нет ни одного отработанного дня" in block(SOURCE, "def final_blockers(")


def test_missing_norm_and_salaries_stop_the_settlement():
    body = block(SOURCE, "def final_blockers(")
    assert "month_norm(" in body
    assert "base_salaries(" in body


def test_a_leaver_is_not_held_until_the_month_closes():
    #  Показатели депо за незакрытый месяц ещё не выставлены. Требовать их
    #  значило бы держать человека без расчёта до конца месяца
    assert "kpi" not in block(SOURCE, "def final_blockers(").lower()
    assert "Премия по показателям нулевая" in PAGE


def test_a_settlement_in_another_depot_is_refused():
    assert "сотрудник числится в другом депо" in block(SOURCE, "def final_blockers(")


# --- пересчёт ----------------------------------------------------------------

def test_a_confirmed_settlement_is_not_recalculated_silently():
    #  Подтверждённый расчёт уже назван человеку и, возможно, выплачен
    body = block(SOURCE, "def save_final_run(")
    assert "уже подтверждён" in body
    assert 'run["status"] != "draft"' in body


def test_a_recalculated_draft_is_rewritten_whole():
    #  Дописать строки к старым значило бы удвоить начисление
    body = block(SOURCE, "def save_final_run(")
    assert "DELETE FROM app.payroll_line WHERE run_id = %s" in body
    assert "_write_lines(conn, run_id, result)" in body


def test_the_calculation_is_refused_when_something_is_missing():
    #  Кнопка на странице заблокирована, но и маршрут проверяет сам:
    #  запрос можно отправить и мимо страницы
    body = block(WEBAPP, "async def settlement_calc(")
    assert "final_blockers(" in body
    assert "Расчёт не запущен" in body
    assert "disabled" in PAGE


# --- где это в приложении ----------------------------------------------------

def test_the_button_lives_in_the_card_of_the_dismissed():
    #  Искать уволенного среди действующих сотрудников депо никто не станет
    assert 'href="/settlement/{{ person.employment_id }}"' in CARD
    assert "Окончательный расчёт" in CARD


def test_the_default_month_is_the_month_of_dismissal():
    #  Расчёт делают в тот же день, но вернуться к нему могут и позже —
    #  и тогда «текущий месяц» показал бы пустой табель
    body = block(WEBAPP, "def settlement_page(")
    assert 'person["terminated_at"] or date.today()' in body


def test_deductions_can_be_filed_right_here():
    #  «В моменте может понадобиться инструмент вычетов и доплат» —
    #  уходить за ними на другой экран в день увольнения некогда
    assert 'action="/payroll/adjustment/add"' in PAGE
    assert 'name="employee_id"' in PAGE


def test_only_approved_adjustments_reach_the_settlement():
    assert "В расчёт идут только согласованные записи" in PAGE


def test_the_page_says_where_the_piecework_comes_from():
    #  Нулевая сделка чаще всего значит «операции не загружены»,
    #  а не «человек ничего не сделал»
    assert "загружены ли операции" in PAGE
    assert "(ТСД)" in PAGE


def test_the_settlement_can_be_counted_before_the_dismissal_is_entered():
    #  Человеку называют сумму заранее — но предупреждаем, что это не то же,
    #  что провести расчёт
    assert "Сотрудник ещё не уволен" in PAGE


def test_the_confirmed_settlement_becomes_a_payslip():
    #  Пункт 26: расчётный листок — то, что сотрудник видит сам
    assert 'href="/payslip/{{ l.id }}"' in PAGE
