"""
Чек-лист выпуска на линию НБТ — «Путевой» (25.09.2026).

Кнопка «Путевой» в карточке складской техники. Шаблон заказчика —
`forms/cheklist_nbt.xlsx`. Два способа отдать его:

  * `render_pages` — печать прямо из приложения (решение 25.09.2026: «не
    сохранять файл, а распечатать сразу»). Лист шаблона переводится в HTML
    как есть: те же объединения, границы, заливки, шрифты, поворот текста,
    ширины и высоты, масштаб печати 80 %, A4 альбом, разрыв на лицевую и
    оборотную сторону. Вёрстка не рисуется руками — она читается из самого
    шаблона, поэтому правка шаблона сразу видна в печати;
  * `export_waybill` — тот же шаблон файлом Excel, если чек-лист нужно
    поправить руками.

Приложение подставляет только значения шапки:

  E4  — месяц, год (по запросу на печать);
  R4  — тип электротранспорта (вид и модель из карточки);
  J6  — инвентарный / регистрационный № (из карточки);
  AC6 — наименование прибора (алкотестера), заводской № (из «Поверенной
        техники» депо);
  D45 — месяц на оборотной стороне.
"""

from __future__ import annotations

import html
import pathlib
from typing import Any

from openpyxl import load_workbook
from openpyxl.utils import get_column_letter

TEMPLATE = pathlib.Path(__file__).resolve().parent / "forms" / "cheklist_nbt.xlsx"

MONTHS_NOM = ["январь", "февраль", "март", "апрель", "май", "июнь", "июль",
              "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

FIELDS = {"month_label": ("E4", "D45"), "vehicle_type": ("R4",),
          "inventory_no": ("J6",), "alcotester": ("AC6",)}


def _fill(ws, values: dict[str, str]) -> None:
    for key, cells in FIELDS.items():
        for c in cells:
            ws[c] = values.get(key) or ""


def export_waybill(path: str, *, month_label: str, vehicle_type: str,
                   inventory_no: str, alcotester: str) -> str:
    wb = load_workbook(TEMPLATE)
    ws = wb.active
    _fill(ws, dict(month_label=month_label, vehicle_type=vehicle_type,
                   inventory_no=inventory_no, alcotester=alcotester))
    wb.save(path)
    return path


# ---------------------------------------------------------------------------
#  Лист Excel → HTML для печати
# ---------------------------------------------------------------------------

_BORDER = {"thin": "1px solid #000", "hair": "1px solid #000",
           "medium": "2px solid #000", "thick": "3px solid #000",
           "double": "3px double #000", "dashed": "1px dashed #000",
           "dotted": "1px dotted #000", "mediumDashed": "2px dashed #000"}


def _col_px(width: float | None) -> int:
    """Ширина столбца Excel (в знаках) → пиксели, как считает сам Excel."""
    w = width if width else 8.43
    return int(w * 7 + 5)


def _col_widths(ws, ncols: int) -> list[int]:
    """
    Ширины столбцов в пикселях. В шаблоне ширина задана одной записью на
    диапазон столбцов (A:AJ), поэтому смотрим диапазоны min–max, а не букву:
    по букве openpyxl вернул бы ширину по умолчанию.
    """
    found: dict[int, float] = {}
    for dim in ws.column_dimensions.values():
        if dim.width and dim.min and dim.max:
            for c in range(dim.min, dim.max + 1):
                found[c] = dim.width
    return [_col_px(found.get(c)) for c in range(1, ncols + 1)]


def _row_px(height: float | None, default_pt: float) -> float:
    return round((height or default_pt) * 4 / 3, 2)


def _side(style) -> str | None:
    return _BORDER.get(style) if style else None


def _cell_css(cell, rng, ws) -> str:
    css: list[str] = []
    f = cell.font
    if f is not None:
        if f.b:
            css.append("font-weight:700")
        if f.i:
            css.append("font-style:italic")
        if f.u:
            css.append("text-decoration:underline")
        if f.sz:
            css.append(f"font-size:{float(f.sz):g}pt")
    a = cell.alignment
    h = a.horizontal if a is not None else None
    css.append("text-align:" + {"center": "center", "centerContinuous": "center",
                                "right": "right", "justify": "justify"}.get(h, "left"))
    v = a.vertical if a is not None else None
    css.append("vertical-align:" + {"top": "top", "center": "middle",
                                    "bottom": "bottom"}.get(v, "bottom"))
    css.append("white-space:" + ("normal" if (a is not None and a.wrap_text) else "nowrap"))
    if cell.fill is not None and cell.fill.fill_type == "solid":
        rgb = cell.fill.fgColor.rgb
        if isinstance(rgb, str) and len(rgb) == 8:
            css.append(f"background:#{rgb[2:]}")
    #  Границы объединённой ячейки — по краям всего диапазона: у Excel
    #  граница хранится в крайних клетках, а не в левой верхней
    r1, c1, r2, c2 = rng
    top = next((s for c in range(c1, c2 + 1)
                if (s := _side(ws.cell(r1, c).border.top.style))), None)
    bottom = next((s for c in range(c1, c2 + 1)
                   if (s := _side(ws.cell(r2, c).border.bottom.style))), None)
    left = next((s for r in range(r1, r2 + 1)
                 if (s := _side(ws.cell(r, c1).border.left.style))), None)
    right = next((s for r in range(r1, r2 + 1)
                  if (s := _side(ws.cell(r, c2).border.right.style))), None)
    #  Соседняя клетка тоже может нести ту же линию — учитываем её
    if not top and r1 > 1:
        top = _side(ws.cell(r1 - 1, c1).border.bottom.style)
    if not left and c1 > 1:
        left = _side(ws.cell(r1, c1 - 1).border.right.style)
    for name, val in (("top", top), ("bottom", bottom), ("left", left), ("right", right)):
        if val:
            css.append(f"border-{name}:{val}")
    return ";".join(css)


def _render_rows(ws, first: int, last: int, merged: dict, covered: set,
                 ncols: int, default_pt: float) -> str:
    widths = _col_widths(ws, ncols)
    #  Ширина таблицы задаётся явно: при фиксированной раскладке без неё
    #  браузер растягивает столбцы, и лист не влезает в страницу
    out = [f'<table class="wb-sheet" style="width:{sum(widths)}px"><colgroup>']
    for w in widths:
        out.append(f'<col style="width:{w}px">')
    out.append("</colgroup><tbody>")
    for r in range(first, last + 1):
        h = _row_px(ws.row_dimensions[r].height, default_pt)
        out.append(f'<tr style="height:{h}px">')
        for c in range(1, ncols + 1):
            if (r, c) in covered:
                continue
            rng = merged.get((r, c), (r, c, r, c))
            #  Объединение, начатое выше страницы, режем по её верху
            r2 = min(rng[2], last)
            cell = ws.cell(r, c)
            attrs = ""
            if rng[3] > c:
                attrs += f' colspan="{rng[3] - c + 1}"'
            if r2 > r:
                attrs += f' rowspan="{r2 - r + 1}"'
            val = cell.value
            text = "" if val is None else html.escape(str(val)).replace("\n", "<br>")
            rot = cell.alignment.textRotation if cell.alignment is not None else 0
            if rot and text:
                text = f'<span class="wb-rot">{text}</span>'
            style = _cell_css(cell, (r, c, r2, rng[3]), ws)
            #  Ширина — и у самой клетки: одних <col> некоторым движкам
            #  печати мало, когда в первой строке объединение на весь лист
            span_w = sum(widths[c - 1:rng[3]])
            style += f";width:{span_w}px;max-width:{span_w}px"
            out.append(f'<td{attrs} style="{style}">{text}</td>')
        out.append("</tr>")
    out.append("</tbody></table>")
    return "".join(out)


def render_pages(*, month_label: str, vehicle_type: str, inventory_no: str,
                 alcotester: str) -> list[str]:
    """
    Страницы чек-листа для печати из приложения: лицевая (до разрыва
    страницы шаблона) и оборотная. Каждая — готовый HTML таблицы.
    """
    wb = load_workbook(TEMPLATE)
    ws = wb.active
    _fill(ws, dict(month_label=month_label, vehicle_type=vehicle_type,
                   inventory_no=inventory_no, alcotester=alcotester))
    last_row, ncols = ws.max_row, ws.max_column
    merged: dict[tuple[int, int], tuple[int, int, int, int]] = {}
    covered: set[tuple[int, int]] = set()
    for m in ws.merged_cells.ranges:
        merged[(m.min_row, m.min_col)] = (m.min_row, m.min_col, m.max_row, m.max_col)
        for r in range(m.min_row, m.max_row + 1):
            for c in range(m.min_col, m.max_col + 1):
                if (r, c) != (m.min_row, m.min_col):
                    covered.add((r, c))
    default_pt = float(ws.sheet_format.defaultRowHeight or 15)
    breaks = sorted(b.id for b in (ws.row_breaks.brk or []))
    bounds, start = [], 1
    for b in breaks:
        bounds.append((start, b))
        start = b + 1
    bounds.append((start, last_row))
    def empty_row(r: int) -> bool:
        for c in range(1, ncols + 1):
            cell = ws.cell(r, c)
            b = cell.border
            if cell.value is not None or (r, c) in covered or any(
                    getattr(b, side).style for side in ("left", "right", "top", "bottom")):
                return False
        return True

    pages = []
    for first, last in bounds:
        #  Пустые строки в конце страницы (строка разрыва) не печатаем: они
        #  только выталкивают нижнюю границу таблицы на следующий лист
        while last > first and empty_row(last):
            last -= 1
        #  Объединение, начатое на прошлой странице, открываем заново сверху
        page_merged = dict(merged)
        page_covered = set(covered)
        for (r0, c0), (a, b, rr, cc) in merged.items():
            if a < first <= rr:
                for c in range(b, cc + 1):
                    page_covered.discard((first, c))
                page_merged[(first, b)] = (first, b, rr, cc)
                for r in range(first, rr + 1):
                    for c in range(b, cc + 1):
                        if (r, c) != (first, b):
                            page_covered.add((r, c))
        pages.append(_render_rows(ws, first, last, page_merged, page_covered,
                                  ncols, default_pt))
    return pages


def print_scale() -> int:
    """Масштаб печати из шаблона, в процентах (у чек-листа — 80)."""
    ws = load_workbook(TEMPLATE, read_only=False).active
    return int(ws.page_setup.scale or 100)
