"""
Загрузка операций кладовщиков из выгрузки 1С УТ — пункт 2 плана.

Выработка — это деньги, и разбор файла не имеет права ошибаться молча.
Поэтому проверяется не только то, что читается правильно, но и то, что
сомнительное откладывается, а не додумывается: учётка без имени, человек,
которого нет в базе, операция вне справочника.

Лист подделан вручную, а не взят из файла: настоящая выгрузка — 3195 строк
на 129 колонок с персональными данными, держать её в репозитории незачем.
Геометрия подделки повторяет настоящую, включая неровную ширину групп: у
«Браковки» метрики стоят через одну колонку, у «Контроля» подряд — из-за
объединённых ячеек 1С.
"""

import pathlib
import sys
from datetime import date

import pytest

LF = chr(10)

sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / "tools"))

import import_ops as imp  # noqa: E402

#  Разбор живёт в приложении: им пользуются и кнопка «Загрузить операции», и
#  командная строка. `tools/import_ops.py` — только запуск и печать отчёта
CORE = (pathlib.Path(__file__).resolve().parents[1]
        / "timesheet" / "opsimport.py")


class FakeSheet:
    """Лист как его отдаёт xlrd: строки, колонки и cell_value."""

    def __init__(self, rows):
        width = max(len(r) for r in rows)
        self._rows = [list(r) + [""] * (width - len(r)) for r in rows]
        self.nrows = len(self._rows)
        self.ncols = width

    def cell_value(self, row, col):
        return self._rows[row][col]


def sheet_like_the_real_one():
    """
    Подделка настоящего файла: шапка отчёта, верхняя таблица по дням,
    пустая строка и нижняя — за месяц.
    """
    blank = [""] * 14
    return FakeSheet([
        [""],
        ["Количество выполненных операций по складу сотрудников склада"],
        [""],
        ["Параметры:", "", "Период: 01.08.2026 - 31.08.2026"],
        ["Производственный календарь: Республика Беларусь"],
        ["", "", "Список складов: ДЕПО Барановичи; ДЕПО Брест;..."],
        [""],
        #  верхняя таблица: та же «ФИО», но колонки — даты
        ["ФИО", "", "", "01.08.2026", "", "", "02.08.2026"],
        ["Операция", "", "", "Количество", "Вес, кг.", "Объем, м3.", "Количество"],
        ["Иванов Иван Иванович", "", "", 8, 10.03, 0.03],
        ["Отбор", "", "", 8, 10.03, 0.03],
        blank,
        blank,
        #  нижняя таблица: за месяц. Группы неровные — как в настоящем файле
        ["ФИО", "", "", "", "", "", "Браковка", "", "", "", "",
         "Контроль", "", "", "Отбор", "", "", "Итого"],
        ["", "", "", "", "", "", "Количество", "", "Вес, кг.", "", "Объем, м3.",
         "Количество", "Вес, кг.", "Объем, м3.",
         "Количество", "Вес, кг.", "Объем, м3.",
         "Количество", "Вес, кг.", "Объем, м3."],
        # учётка без имени, но с выработкой
        ["", "", "", "", "", "", 5, "", 0, "", 0,
         "", "", "", "", "", "", 5, 0, 0],
        ["Иванов Иван Иванович", "", "", "", "", "", 3, "", 0, "", 0,
         "", "", "", "", "", "", 3, 0, 0],
        ["Иванов Иван Иванович (ТСД)", "", "", "", "", "", "", "", "", "", "",
         12, 0, 0, 7, 15.5, 0.25, 19, 15.5, 0.25],
        ["Петров Пётр Петрович (ТСД)", "", "", "", "", "", "", "", "", "", "",
         "", "", "", 4, 8.25, 0.1, 4, 8.25, 0.1],
        ["Итого", "", "", "", "", "", 8, "", 0, "", 0,
         12, 0, 0, 11, 23.75, 0.35, 31, 23.75, 0.35],
    ])


SHEET = sheet_like_the_real_one()


# --- сравнение названий ------------------------------------------------------

def test_names_compare_without_case_and_yo():
    #  В выгрузке «Пересчет» и «Приемка» без «ё», в справочнике — с ней.
    #  Без этого не сошлась бы ни одна операция
    assert imp.norm("Пересчёт") == imp.norm("Пересчет")
    assert imp.norm("Приёмка") == imp.norm("ПРИЕМКА")
    assert imp.norm("  Отбор  ") == "отбор"


def test_tsd_account_is_split_from_the_person():
    assert imp.split_account("Иванов Иван Иванович (ТСД)") == ("Иванов Иван Иванович", True)
    assert imp.split_account("Иванов Иван Иванович") == ("Иванов Иван Иванович", False)


def test_empty_account_stays_empty():
    assert imp.split_account("") == ("", False)
    assert imp.split_account(None) == ("", False)


def test_tsd_mark_is_found_regardless_of_spacing():
    assert imp.split_account("Иванов  Иван   Иванович  (ТСД)")[0] == "Иванов Иван Иванович"


# --- геометрия файла ---------------------------------------------------------

def test_period_comes_from_the_report_parameters():
    assert imp.read_period(SHEET) == date(2026, 8, 1)


def test_a_file_without_the_period_line_is_refused():
    with pytest.raises(ValueError, match="Период"):
        imp.read_period(FakeSheet([["что-то другое"]]))


def test_the_monthly_table_is_the_lower_one():
    #  Шапок в файле две, и обе начинаются с «ФИО». Взять надо нижнюю:
    #  у верхней колонки — даты
    head, sub = imp.find_monthly_table(SHEET)
    assert SHEET.cell_value(head, 6) == "Браковка"
    assert SHEET.cell_value(sub, 6) == "Количество"


def test_a_file_without_the_monthly_table_is_refused():
    with pytest.raises(ValueError, match="месячной таблицы"):
        imp.find_monthly_table(FakeSheet([
            ["ФИО", "01.08.2026"],
            ["Операция", "Количество"],
        ]))


def test_columns_follow_uneven_groups():
    #  Ширина групп в файле неровная из-за объединённых ячеек: у «Браковки»
    #  метрики в 6, 8 и 10 колонках, у «Контроля» подряд. Операция берётся
    #  ближайшей слева, а не шагом
    head, sub = imp.find_monthly_table(SHEET)
    cols = imp.column_map(SHEET, head, sub)
    assert (6, "Браковка", "qty") in cols
    assert (8, "Браковка", "weight_kg") in cols
    assert (10, "Браковка", "volume_m3") in cols
    assert (11, "Контроль", "qty") in cols
    assert (14, "Отбор", "qty") in cols


def test_the_total_column_is_not_loaded():
    #  «Итого» — контрольная колонка файла. Загрузи её как операцию, и
    #  выработка удвоится
    head, sub = imp.find_monthly_table(SHEET)
    assert all(op != "Итого" for _, op, _ in imp.column_map(SHEET, head, sub))


# --- разбор строк ------------------------------------------------------------

def rows():
    head, sub = imp.find_monthly_table(SHEET)
    return imp.read_rows(SHEET, head, imp.column_map(SHEET, head, sub))


def test_reading_stops_at_the_total_row():
    assert all(r.account != "Итого" for r in rows())
    assert len(rows()) == 4


def test_values_land_on_the_right_operation():
    row = next(r for r in rows() if r.account == "Иванов Иван Иванович (ТСД)")
    assert row.from_tsd is True
    assert row.values["Контроль"] == {"qty": 12}
    assert row.values["Отбор"] == {"qty": 7, "weight_kg": 15.5, "volume_m3": 0.25}
    #  Пустых операций в строке нет: нулей в базе быть не должно
    assert "Браковка" not in row.values


def test_the_same_person_can_have_two_accounts():
    people = [r for r in rows() if r.person == "Иванов Иван Иванович"]
    assert len(people) == 2
    assert sorted(r.from_tsd for r in people) == [False, True]


def test_a_nameless_account_is_kept_for_the_report():
    #  В августе 2026 таких пятнадцать, и с настоящей выработкой. В базу они
    #  не пойдут, но потеряться молча не должны
    nameless = [r for r in rows() if not r.person]
    assert len(nameless) == 1
    assert nameless[0].values["Браковка"] == {"qty": 5}


def test_parsed_quantities_match_the_control_row():
    #  Сумма разобранного обязана сойтись с контрольной строкой файла —
    #  иначе часть выработки прочиталась мимо
    head, sub = imp.find_monthly_table(SHEET)
    cols = imp.column_map(SHEET, head, sub)
    parsed = sum(v.get("qty", 0) for r in imp.read_rows(SHEET, head, cols)
                 for v in r.values.values())
    total_col = next(c for c in range(SHEET.ncols)
                     if SHEET.cell_value(head, c) == "Итого")
    assert parsed == SHEET.cell_value(SHEET.nrows - 1, total_col)


# --- правила, из-за которых это делалось -------------------------------------

def test_piecework_counts_only_the_tsd_account():
    #  Решение заказчика от 14.09.2026: в расчёт ЗП идёт только выработка с
    #  терминала сбора данных. Правило держится одним условием в запросе
    src = (pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "payrolldb.py").read_text(encoding="utf-8")
    body = src[src.find("def piecework_by_employee("):]
    body = body[:body.find("def ", 10)]
    assert "AND f.from_tsd" in body


def test_both_accounts_are_still_stored():
    #  Грузим обе: картина работы депо должна быть целой. Правило про деньги
    #  живёт в расчёте, а не в загрузке
    src = CORE.read_text(encoding="utf-8")
    assert "from_tsd" in src
    assert "row.from_tsd" in src


def test_the_parser_is_shared_between_the_button_and_the_console():
    #  Два одинаковых разбора одного файла разошлись бы на первой же правке
    assert CORE.is_file()
    cli = (pathlib.Path(__file__).resolve().parents[2]
           / "tools" / "import_ops.py").read_text(encoding="utf-8")
    assert "from timesheet.opsimport import" in cli
    #  В консольной части разбора не осталось
    assert "def read_rows(" not in cli
    assert "class OpsImporter" not in cli


def test_migration_lets_two_accounts_coexist():
    #  Прежний ключ уникальности не различал учётки, и вторая строка того же
    #  человека, дня и операции просто не записалась бы
    sql = (pathlib.Path(__file__).resolve().parents[2]
           / "sql" / "28_operations_tsd.sql").read_text(encoding="utf-8")
    assert "UNIQUE (load_id, work_date, employee_id, operation_type_id, from_tsd)" in sql
    assert "ADD COLUMN IF NOT EXISTS from_tsd" in sql


def test_monthly_rows_land_on_the_first_day_of_the_month():
    #  Месячная таблица дней не знает. Расчёт суммирует операции за месяц,
    #  поэтому дата внутри месяца на деньги не влияет — но она должна быть
    #  одна и та же, иначе повторная загрузка размножит строки
    src = CORE.read_text(encoding="utf-8")
    body = src[src.find("def _write("):]
    body = body[:body.find("def ", 10)]
    assert '"day": self.period' in body

# --- окно загрузки в приложении ---------------------------------------------

TEMPLATES = pathlib.Path(__file__).resolve().parents[1] / "timesheet" / "templates"
WEBAPP = pathlib.Path(__file__).resolve().parents[1] / "timesheet" / "webapp.py"


def test_the_window_asks_for_a_file_and_writes_it():
    #  Заказчик просил кнопку в приложении: выбрать файл в проводнике, а не
    #  перетаскивать его на .cmd
    html = (TEMPLATES / "operations.html").read_text(encoding="utf-8")
    assert 'enctype="multipart/form-data"' in html
    assert 'type="file"' in html and 'accept=".xls"' in html
    src = WEBAPP.read_text(encoding="utf-8")
    assert '@app.post("/operations", response_class=HTMLResponse)' in src


def test_the_window_can_check_without_writing():
    #  Выработка — это деньги: посмотреть, что получится, до записи полезно
    html = (TEMPLATES / "operations.html").read_text(encoding="utf-8")
    assert 'name="check_only"' in html
    src = WEBAPP.read_text(encoding="utf-8")
    assert "dry_run=bool(check_only)" in src


def test_loading_is_for_the_administration_only():
    #  Выгрузка приходит сразу по всем депо: класть её по частям нельзя, и
    #  начальник РЦ записал бы чужие города
    src = WEBAPP.read_text(encoding="utf-8")
    body = src[src.find("def operations_page("):]
    body = body[:body.find("@app.post")]
    assert 'webdb.has_perm(conn, "reference.write")' in body


def test_a_broken_file_is_explained_not_dumped():
    #  Человеку показывается, что не так с файлом, а не текст исключения
    src = (ENGINE_CORE := pathlib.Path(__file__).resolve().parents[1]
           / "timesheet" / "opsimport.py").read_text(encoding="utf-8")
    assert "class OpsFileError" in src
    assert "Не получилось открыть файл как книгу Excel" in src
    web = WEBAPP.read_text(encoding="utf-8")
    assert "except opsimport.OpsFileError as e:" in web


def test_the_report_stays_on_the_page():
    #  В отчёте списки на сотни строк — потерять их редиректом нельзя
    src = WEBAPP.read_text(encoding="utf-8")
    body = src[src.find("async def operations_upload("):]
    #  Режем по пустой строке между блоками верхнего уровня, а не по
    #  следующему «@app.get»: между ними успел появиться целый раздел, и
    #  проверка ловила чужой RedirectResponse
    body = body.split(LF * 3)[0]
    assert "RedirectResponse" not in body
    assert 'templates.TemplateResponse(request, "operations.html", ctx)' in body


def test_an_oversized_file_is_refused_before_parsing():
    src = WEBAPP.read_text(encoding="utf-8")
    assert "OPS_MAX_BYTES" in src


def test_the_history_of_loads_is_visible():
    #  Действующий набор месяца один, и человек должен видеть, какой именно
    html = (TEMPLATES / "operations.html").read_text(encoding="utf-8")
    assert "Что загружали раньше" in html
    assert "действующий" in html and "в архиве" in html


def test_there_is_a_way_in_from_the_payroll_page():
    #  Когда сделка нулевая, первый вопрос — «а операции загружены?»
    assert 'href="/operations"' in (TEMPLATES / "payroll.html").read_text(encoding="utf-8")
    assert 'href="/operations"' in (TEMPLATES / "base.html").read_text(encoding="utf-8")
