"""
Разбор выгрузки операций 1С УТ и запись выработки в базу — пункт 2 плана.

Живёт здесь, а не в `tools/`, потому что пользователей у этого разбора двое:
кнопка «Загрузить операции» в приложении и командная строка
`tools/import_ops.py`. Два одинаковых разбора одного файла разошлись бы на
первой же правке.

Про сам файл
------------

**В нём две таблицы.** Верхняя — разрез по дням: 129 колонок, на каждый день
по три метрики, под каждым человеком девять строк операций. Нижняя — то же
самое за месяц одной строкой на учётную запись. Берём нижнюю: расчёт
заработной платы всё равно суммирует операции за месяц
(`piecework_by_employee` группирует по месяцу), так что разрез по дням ничего
к деньгам не добавляет, а разбирается втрое сложнее.

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

**Учётных записей больше, чем людей.** У человека бывает две: «Иванов Иван
Иванович» и «Иванов Иван Иванович (ТСД)» — работа с компьютера и с терминала
сбора данных. Грузим обе, помечая признаком `from_tsd`. В сделку по решению
заказчика от 14.09.2026 идёт только выработка с ТСД.

**Справочник операций из семи.** В выгрузке восемь: добавилась «Разбраковка».
Заводить её пока не стали (решение от 14.09.2026), поэтому такие строки
пропускаются и считаются в отчёте — пропуск должен быть виден.

Повторная загрузка месяца не удваивает данные: прежний набор помечается
`superseded`, новый становится активным. За этим следит уникальный индекс
`operation_load_one_active`.
"""

from __future__ import annotations

import argparse
import os
import pathlib
import re
import sys
from collections import Counter, defaultdict
from dataclasses import dataclass, field
from datetime import date, datetime
from typing import Any

import psycopg
from psycopg.rows import dict_row

ROOT = pathlib.Path(__file__).resolve().parent.parent

#  Метрики выгрузки и колонки operation_fact, в которые они ложатся
METRICS = {
    "количество": "qty",
    "вес, кг.": "weight_kg",
    "объем, м3.": "volume_m3",
}

#  Строка с параметрами отчёта: «Период: 01.08.2026 - 31.08.2026»
PERIOD_RE = re.compile(r"Период:\s*(\d{2}\.\d{2}\.\d{4})")

#  Признак работы с терминала сбора данных в имени учётной записи
TSD_SUFFIX = "(тсд)"


# ---------------------------------------------------------------------------
#  Разбор имён и названий
# ---------------------------------------------------------------------------

def norm(text: Any) -> str:
    """
    Ключ для сравнения названий: регистр, «ё» и лишние пробелы значения не
    имеют. В выгрузке «Пересчет» и «Приемка» без «ё», а в справочнике с ней —
    без этого не сошлась бы ни одна операция.
    """
    return " ".join(str(text or "").replace("ё", "е").replace("Ё", "Е").split()).lower()


def split_account(name: Any) -> tuple[str, bool]:
    """
    Учётная запись → человек и признак ТСД.

    «Иванов Иван Иванович (ТСД)» → («Иванов Иван Иванович», True).
    Пустое имя остаётся пустым: такие строки в базу не идут.
    """
    text = " ".join(str(name or "").split())
    if text.lower().endswith(TSD_SUFFIX):
        return text[: -len(TSD_SUFFIX)].strip(), True
    return text, False


def _is_number(value: Any) -> bool:
    #  bool — тоже int, а «истина» вместо количества операций нам не нужна
    return isinstance(value, (int, float)) and not isinstance(value, bool)


def cell_text(sheet, row: int, col: int) -> str:
    value = sheet.cell_value(row, col)
    if _is_number(value):
        return str(int(value)) if value == int(value) else str(value)
    return str(value).strip()


def cell_number(sheet, row: int, col: int) -> float:
    """
    Число из клетки; всё прочее — ноль.

    xlrd числовые клетки отдаёт float, но полагаться на это не будем: пустая
    клетка приходит строкой, а ноль вместо текста здесь безопаснее разбора.
    """
    value = sheet.cell_value(row, col)
    return float(value) if _is_number(value) else 0.0


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

def read_period(sheet) -> date:
    """Месяц выгрузки — из строки параметров отчёта."""
    for row in range(min(20, sheet.nrows)):
        for col in range(sheet.ncols):
            found = PERIOD_RE.search(cell_text(sheet, row, col))
            if found:
                return datetime.strptime(found.group(1), "%d.%m.%Y").date().replace(day=1)
    raise ValueError(
        "В файле нет строки «Период: дд.мм.гггг - дд.мм.гггг». "
        "Это точно отчёт по операциям из 1С УТ?"
    )


def find_monthly_table(sheet) -> tuple[int, int]:
    """
    Найти нижнюю таблицу — ту, что за месяц.

    Шапок в файле две, и обе начинаются с «ФИО». Различаем по второй строке
    шапки: у месячной под каждой операцией стоят метрики, а сами колонки
    названы операциями, а не датами. Берём последнюю подходящую — она и есть
    нижняя.
    """
    found = None
    for row in range(sheet.nrows - 1):
        if norm(cell_text(sheet, row, 0)) != "фио":
            continue
        heads = [norm(cell_text(sheet, row, c)) for c in range(1, sheet.ncols)]
        # даты в верхней таблице выглядят как 01.08.2026 — операций там нет
        if any(h in ("отбор", "приемка", "контроль") for h in heads):
            found = row
    if found is None:
        raise ValueError(
            "В файле нет месячной таблицы: шапки «ФИО · Отбор · Приёмка …» не "
            "нашлось. Нужна нижняя часть отчёта, табличный вариант за месяц."
        )
    return found, found + 1


def column_map(sheet, head_row: int, sub_row: int) -> list[tuple[int, str, str]]:
    """
    Колонки метрик: (колонка, операция, поле operation_fact).

    Ширина групп в файле неровная — у «Браковки» метрики стоят в 6, 8 и 11
    колонках, у «Контроля» в 14, 16 и 18. Поэтому операция не вычисляется
    шагом, а берётся ближайшей слева.
    """
    ops = {c: cell_text(sheet, head_row, c)
           for c in range(1, sheet.ncols) if cell_text(sheet, head_row, c)}
    out: list[tuple[int, str, str]] = []
    for col in range(1, sheet.ncols):
        metric = METRICS.get(norm(cell_text(sheet, sub_row, col)))
        if not metric:
            continue
        owner = max((c for c in ops if c <= col), default=None)
        if owner is None:
            continue
        operation = ops[owner]
        #  «Итого» — контрольная колонка файла, в базу она не идёт
        if norm(operation) == "итого":
            continue
        out.append((col, operation, metric))
    if not out:
        raise ValueError("В шапке месячной таблицы нет колонок «Количество · Вес · Объём»")
    return out


@dataclass
class AccountRow:
    """Строка месячной таблицы: одна учётная запись."""

    row: int
    account: str                      # как записано в файле
    person: str                       # без пометки «(ТСД)»
    from_tsd: bool
    #  операция (как в файле) → {qty|weight_kg|volume_m3: число}
    values: dict[str, dict[str, float]] = field(default_factory=dict)

    @property
    def is_empty(self) -> bool:
        return not self.values


def read_rows(sheet, head_row: int, cols: list[tuple[int, str, str]]) -> list[AccountRow]:
    """
    Строки месячной таблицы — до контрольной строки «Итого».

    Строки без имени тоже возвращаются: в августе 2026 их пятнадцать, и с
    настоящей выработкой. В базу они не попадут, но в отчёте о загрузке
    должны быть видны — это чья-то работа, потерявшая владельца.
    """
    rows: list[AccountRow] = []
    for r in range(head_row + 2, sheet.nrows):
        name = cell_text(sheet, r, 0)
        if norm(name) == "итого":
            break
        person, from_tsd = split_account(name)
        item = AccountRow(row=r, account=name, person=person, from_tsd=from_tsd)
        for col, operation, metric in cols:
            value = cell_number(sheet, r, col)
            if value:
                item.values.setdefault(operation, {})[metric] = value
        if not item.is_empty or person:
            rows.append(item)
    return rows


# ---------------------------------------------------------------------------
#  Загрузка в базу
# ---------------------------------------------------------------------------

class OpsImporter:
    """
    Перенос разобранных строк в базу.

    Всё, что не удалось сопоставить, не выдумывается, а откладывается в
    отчёт: выработка — это деньги, и приписать её не тому человеку или не
    тому депо хуже, чем не загрузить вовсе.
    """

    def __init__(self, conn: psycopg.Connection, period: date):
        self.conn = conn
        self.period = period
        self.report: Counter[str] = Counter()
        self.unknown_people: list[str] = []
        self.unknown_ops: Counter[str] = Counter()
        self.ambiguous: list[str] = []
        self.no_name: list[str] = []
        self.without_tsd: list[str] = []
        self.load_id: int | None = None

        self.operations = self._operations()
        self.people = self._people()

    # -- справочники --------------------------------------------------------

    def _operations(self) -> dict[str, int]:
        with self.conn.cursor() as cur:
            cur.execute("SELECT id, name FROM app.operation_type")
            return {norm(r["name"]): r["id"] for r in cur.fetchall()}

    def _people(self) -> dict[str, list[dict[str, Any]]]:
        """
        ФИО → действующие в этом месяце назначения.

        Список, а не одна запись: однофамильцев с совпадающим отчеством в
        разных депо система обязана заметить, а не выбрать наугад.
        """
        last = _month_end(self.period)
        with self.conn.cursor() as cur:
            cur.execute(
                """
                SELECT e.id AS employee_id, em.org_unit_id,
                       e.last_name, e.first_name, e.middle_name
                FROM app.employment em
                JOIN app.employee e ON e.id = em.employee_id
                WHERE em.hired_at <= %(last)s
                  AND (em.terminated_at IS NULL OR em.terminated_at >= %(first)s)
                """,
                {"first": self.period, "last": last},
            )
            out: dict[str, list[dict[str, Any]]] = defaultdict(list)
            for r in cur.fetchall():
                key = norm(" ".join(
                    x for x in (r["last_name"], r["first_name"], r["middle_name"]) if x))
                out[key].append(r)
        return out

    # -- загрузка -----------------------------------------------------------

    def open_load(self, note: str) -> int:
        """Новый набор загрузки; прежний активный за этот месяц — в архив."""
        with self.conn.cursor() as cur:
            cur.execute(
                """
                UPDATE app.operation_load SET status = 'superseded'
                 WHERE period_month = %s AND status = 'active'
                """,
                (self.period,),
            )
            self.report["прежних наборов отправлено в архив"] += cur.rowcount
            cur.execute(
                """
                INSERT INTO app.operation_load (period_month, loaded_by, note, status)
                VALUES (%s, nullif(current_setting('app.user_id', true), '')::bigint,
                        %s, 'active')
                RETURNING id
                """,
                (self.period, note),
            )
            self.load_id = cur.fetchone()["id"]
        return self.load_id

    def run(self, rows: list[AccountRow]) -> None:
        #  Ключ — сравнимое написание, значение — как человек записан в файле:
        #  в отчёте имена должны выглядеть так же, как в выгрузке, а не в
        #  нижнем регистре, в который их приводит сравнение
        seen_people: dict[str, str] = {}
        tsd_people: set[str] = set()

        for row in rows:
            self.report["строк в файле"] += 1

            if not row.person:
                self.no_name.append(
                    f"строка {row.row + 1}: учётная запись без имени, "
                    f"операций — {sum(len(v) for v in row.values.values())}")
                self.report["строк без имени — пропущено"] += 1
                continue

            seen_people.setdefault(norm(row.person), row.person)
            if row.from_tsd:
                tsd_people.add(norm(row.person))

            found = self.people.get(norm(row.person), [])
            if not found:
                self.unknown_people.append(row.account)
                self.report["людей нет в базе — пропущено"] += 1
                continue
            units = {f["org_unit_id"] for f in found}
            if len(units) > 1:
                self.ambiguous.append(
                    f"{row.account}: назначений в разных депо — {len(units)}")
                self.report["неоднозначных — пропущено"] += 1
                continue

            self._write(row, found[0])

        #  Кого не будет в сделке: правило «считаем только ТСД» оставляет без
        #  выработки тех, у кого учётки ТСД нет вовсе
        self.without_tsd = sorted(name for key, name in seen_people.items()
                                  if key not in tsd_people)
        self.report["людей без учётки ТСД — в сделку не войдут"] = len(self.without_tsd)

    def _write(self, row: AccountRow, person: dict[str, Any]) -> None:
        for operation, metrics in row.values.items():
            op_id = self.operations.get(norm(operation))
            if not op_id:
                self.unknown_ops[operation] += 1
                self.report["операций нет в справочнике — пропущено"] += 1
                continue
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO app.operation_fact
                        (load_id, work_date, employee_id, org_unit_id,
                         operation_type_id, qty, weight_kg, volume_m3,
                         is_own, from_tsd)
                    VALUES (%(load)s, %(day)s, %(emp)s, %(unit)s, %(op)s,
                            %(qty)s, %(weight)s, %(volume)s, true, %(tsd)s)
                    ON CONFLICT (load_id, work_date, employee_id,
                                 operation_type_id, from_tsd)
                    DO UPDATE SET qty       = app.operation_fact.qty + EXCLUDED.qty,
                                  weight_kg = app.operation_fact.weight_kg
                                              + EXCLUDED.weight_kg,
                                  volume_m3 = app.operation_fact.volume_m3
                                              + EXCLUDED.volume_m3
                    """,
                    {
                        "load": self.load_id,
                        #  Месячная таблица дней не знает, поэтому вся выработка
                        #  ложится на первое число месяца. Расчёт всё равно
                        #  суммирует операции за месяц — суммы не меняются
                        "day": self.period,
                        "emp": person["employee_id"],
                        "unit": person["org_unit_id"],
                        "op": op_id,
                        "qty": metrics.get("qty", 0),
                        "weight": metrics.get("weight_kg", 0),
                        "volume": metrics.get("volume_m3", 0),
                        "tsd": row.from_tsd,
                    },
                )
            self.report["записей выработки"] += 1

    def finish(self) -> None:
        """Итоги набора — в саму загрузку, чтобы отчёт можно было поднять позже."""
        with self.conn.cursor() as cur:
            cur.execute(
                """
                UPDATE app.operation_load
                   SET rows_total = %s, rows_rejected = %s
                 WHERE id = %s
                """,
                (
                    self.report["строк в файле"],
                    self.report["строк без имени — пропущено"]
                    + self.report["людей нет в базе — пропущено"]
                    + self.report["неоднозначных — пропущено"],
                    self.load_id,
                ),
            )


def _month_end(period: date) -> date:
    import calendar

    return date(period.year, period.month,
                calendar.monthrange(period.year, period.month)[1])

# ---------------------------------------------------------------------------
#  Единая точка входа
#
#  Ею пользуются оба: кнопка «Загрузить операции» в приложении и командная
#  строка. Разбор файла и запись в базу не должны расходиться от того, откуда
#  их позвали.
# ---------------------------------------------------------------------------

class OpsFileError(ValueError):
    """Файл не тот или разобрать его нельзя. Текст годится показать человеку."""


def open_sheet(*, path: str | None = None, data: bytes | None = None):
    """
    Первый лист выгрузки. Принимает путь (консоль) или байты (загрузка через
    браузер) — в остальном одно и то же.
    """
    try:
        import xlrd
    except ImportError as e:                       # pragma: no cover
        raise OpsFileError(
            "Нет библиотеки xlrd — она читает старый формат .xls. "
            "Запустите update_db.cmd: он доустановит зависимости."
        ) from e

    try:
        book = (xlrd.open_workbook(path) if path
                else xlrd.open_workbook(file_contents=data))
    except Exception as e:
        raise OpsFileError(
            "Не получилось открыть файл как книгу Excel старого формата "
            f"(.xls): {e}. Выгрузка из 1С УТ приходит именно в нём — "
            "пересохранение в .xlsx здесь не подойдёт."
        ) from e
    if not book.nsheets:
        raise OpsFileError("В книге нет ни одного листа")
    return book.sheet_by_index(0)


def parse(sheet, period: date | None = None) -> tuple[date, list[AccountRow], int]:
    """
    Разобрать лист: месяц, строки месячной таблицы и номер строки её шапки.

    Ошибки разбора поднимаются как OpsFileError — их текст показывается
    человеку, поэтому он объясняет, что не так с файлом, а не что упало.
    """
    try:
        month = period or read_period(sheet)
        head_row, sub_row = find_monthly_table(sheet)
        cols = column_map(sheet, head_row, sub_row)
        rows = read_rows(sheet, head_row, cols)
    except ValueError as e:
        raise OpsFileError(str(e)) from e
    if not rows:
        raise OpsFileError(
            "В месячной таблице нет ни одной строки с учётными записями"
        )
    return month, rows, head_row


def load(conn, sheet, *, note: str, period: date | None = None,
         dry_run: bool = False) -> tuple[OpsImporter, date, int]:
    """
    Разобрать и записать. Возвращает загрузчик с отчётом, месяц и число строк.

    Коммит и откат делаются здесь: у кнопки и у консоли это одно и то же
    решение — либо месяц загрузился целиком, либо не загрузился вовсе.
    """
    month, rows, _ = parse(sheet, period)
    imp = OpsImporter(conn, month)
    imp.open_load(note)
    imp.run(rows)
    imp.finish()
    if dry_run:
        conn.rollback()
    else:
        conn.commit()
    return imp, month, len(rows)

def loads(conn, limit: int = 20) -> list[dict[str, Any]]:
    """
    История загрузок операций — что, когда и кто грузил.

    Нужна на экране загрузки: «активная» загрузка месяца одна, и человек
    должен видеть, какая именно сейчас в деле, а какие ушли в архив.
    """
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT l.id, l.period_month, l.loaded_at, l.status, l.note,
                   l.rows_total, l.rows_rejected,
                   u.full_name AS loaded_by_name,
                   (SELECT count(*) FROM app.operation_fact f
                     WHERE f.load_id = l.id) AS facts,
                   (SELECT count(DISTINCT f.employee_id) FROM app.operation_fact f
                     WHERE f.load_id = l.id) AS people
            FROM app.operation_load l
            LEFT JOIN app.app_user u ON u.id = l.loaded_by
            ORDER BY l.period_month DESC, l.loaded_at DESC
            LIMIT %s
            """,
            (limit,),
        )
        return cur.fetchall()
