"""
Печатная форма табеля учёта использования рабочего времени.

Раскладка снята с файла «Барановичи 08-26.xlsx» — того табеля, который в
ООУРЦ сдают сейчас. Воспроизведены не только колонки, но и вся обвязка:
блок «Утверждаю» справа сверху, шапка с организацией и подразделением,
строка «ИТОГО ЧАСОВ», ответственный за ведение табеля и легенда обозначений
внизу. Форму подписывают, поэтому она должна выглядеть привычно.

  A  — № п/п                      E..BN — числа месяца, по 2 колонки на день:
  B  — Фамилия И.О.                       слева часы дневные (или код дня),
  C  — Таб. №                             справа часы ночные
  D  — Должность                  BO    — Раб. дней
                                  BP..BT— К, Б, О, Р, ОЖ
                                  BU, BV— Раб. часы, Раб. часы ночь
                                  BW..BY— В, П, А

**Состав и порядок столбцов менять нельзя.** Файл забирает 1С ЗУП, и лишний
столбец — даже добавленный справа — сдвигает разбор. Поэтому колонки здесь
ровно те же и в том же порядке, что в исходном файле: A..D, две колонки на
каждый из 31 дня, BO..BY. Работа в выходной и сверхурочные в форме своих
колонок не имеют — они видны в сверке и оформляются отдельным приказом
(статьи 69, 120 и 142 ТК).

Отличия от исходного файла — только в оформлении, не в данных:

1. Клетка дня печатается числом, как в исходнике: «11», а не «11 С». Пометки
   на месте часов сбивают и сложение по столбцу, и разбор в 1С.
2. Шапка таблицы повторяется на каждой странице (print_title_rows), лист
   развёрнут поперёк и подогнан по ширине. В исходнике этого нет, и вторая
   страница печаталась без заголовков. На состав клеток это не влияет.

Легенда внизу — дословно из исходного файла, без дополнений: решение
заказчика. Полный список обозначений с расшифровками есть в приложении, в
справочнике обозначений табеля.
"""

from __future__ import annotations

import calendar
from dataclasses import dataclass, field
from datetime import date
from typing import Iterable, Sequence

from openpyxl import Workbook
from openpyxl.styles import Alignment, Border, Font, Side
from openpyxl.utils import get_column_letter

from .totals import Totals

# --- геометрия формы --------------------------------------------------------
COL_NO, COL_FIO, COL_PERS, COL_POS = 1, 2, 3, 4
FIRST_DAY_COL = 5              # E
DAY_SLOTS = 31                 # форма всегда рассчитана на 31 день
SUMMARY_COL = FIRST_DAY_COL + DAY_SLOTS * 2   # 67 = BO
HEAD_ROW = 13                  # первая строка шапки таблицы
FIRST_DATA_ROW = 15

# Сводная часть: (заголовок первой строки, заголовок второй, ключ итогов)
SUMMARY_HEADERS: list[tuple[str, str, str]] = [
    ("Раб. дней", "Раб. дней", "Раб. дней"),
    ("Коман-\nдировка, дней", "К", "К"),
    ("Боль-\nничн., дней", "Б", "Б"),
    ("Отпуск, дней", "О", "О"),
    ("Отпуск по беремен-\nности и родам, дней", "Р", "Р"),
    ("Отпуск по уходу за ребенком до 3-х лет", "ОЖ", "ОЖ"),
    ("Раб. часы", "Раб. часы", "Раб. часы"),
    ("Работа в ночное время", "Раб. часы ночь", "Раб. часы ночь"),
    ("Вых.дн.", "В", "В"),
    ("Празд. дни", "П", "П"),
    ("Отпуск без сохран. ЗП", "А", "А"),
]

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

# Легенда — дословно из исходного файла: её читают и по ней сверяются
LEGEND = [
    "ОЖ - отпуск, предоставляемый по уходу за ребенком до достижения им 3-х лет",
    "О - трудовой отпуск",
    "Р - отпуск по беременности и родам",
    "А - отпуск без сохранения заработной платы",
    "Б - временная нетрудоспособность и отпуск по уходу за больными и по "
    "карантину, оформленные листками нетрудоспособности",
    "П - праздничные дни",
    "8 и 4 - количество часов работы при работе на полную ставку и полставки "
    "соответственно.",
]
NIGHT_NOTE = (
    "например: отработал 6 часов в ночь - значит ставим 6"
    "                  НОЧНОЕ ВРЕМЯ : с 22.00 до 6.00"
)

ORGANIZATION = 'ООО"Триовист"'
# Формат табельного номера из исходного файла: десять цифр и отбивка справа
PERSONNEL_FORMAT = '0000000000"     "'
FONT_NAME = "Arial Narrow"
FONT_SIZE = 9

_thin = Side(style="thin", color="000000")
_medium = Side(style="medium", color="000000")
BORDER = Border(left=_thin, right=_thin, top=_thin, bottom=_thin)


@dataclass
class TabelDay:
    """Один день в строке табеля."""

    day: int
    day_code: str | None = None
    hours_day: float = 0.0
    hours_night: float = 0.0
    hours_weekend: float = 0.0
    hours_overtime: float = 0.0

    @property
    def worked(self) -> float:
        return round(self.hours_day + self.hours_night, 2)

    def cell_day(self) -> str | float | None:
        """
        Левая клетка дня: дневные часы, а если часов нет — обозначение.

        Числом, без пометок: по столбцу дня складывают часы, и «11 С» в
        сложение не попадает. Сверхурочные и работа в выходной посчитаны в
        своих колонках справа.
        """
        if self.worked <= 0:
            return self.day_code
        return _num(self.hours_day) if self.hours_day > 0 else None

    def cell_night(self) -> float | int | None:
        return _num(self.hours_night) if self.hours_night > 0 else None


@dataclass
class TabelRow:
    no: int
    fio: str
    personnel_no: str
    position: str
    days: list[TabelDay] = field(default_factory=list)
    totals: Totals | None = None


def _num(value: float | None) -> float | int:
    """Целое печатаем без дробной части: «11», а не «11.0»."""
    if value is None:
        return 0
    v = round(float(value), 2)
    return int(v) if abs(v - int(v)) < 1e-9 else v


def _f(bold: bool = False, italic: bool = False, size: float = FONT_SIZE) -> Font:
    return Font(name=FONT_NAME, size=size, bold=bold, italic=italic)


def _personnel(value: str) -> int | str:
    """
    Табельный номер для клетки C — числом, как в исходном файле.

    Так его и получала 1С ЗУП раньше. Единственное исключение — номер, у
    которого числовой вид теряет цифру: ведущий ноль или что-то нештатное
    вместо десяти цифр. Тогда пишем текстом: испорченный номер хуже
    непривычного формата.
    """
    text = (value or "").strip()
    if len(text) == 10 and text.isdigit() and not text.startswith("0"):
        return int(text)
    return text


def summary_values(row: TabelRow) -> dict[str, float | int]:
    """
    Сводная часть строки — ровно те колонки, что в форме.

    Ни одной колонки сверх формы: файл забирает 1С ЗУП, и лишний столбец
    справа сдвигает разбор. Часы работы в выходной и сверхурочные видны в
    сверке и пойдут в приказ отдельным документом.
    """
    if row.totals is None:
        return {}
    return dict(row.totals.as_summary_row())


def export_tabel(
    path: str,
    organization: str,
    org_unit: str,
    period_month: date,
    rows: Sequence[TabelRow],
    number: str | int | None = None,
    approver: str | None = None,
    responsible: str | None = None,
) -> str:
    """Собрать xlsx с печатной формой табеля и вернуть путь к файлу."""
    days_in_month = calendar.monthrange(period_month.year, period_month.month)[1]
    last_col = SUMMARY_COL + len(SUMMARY_HEADERS) - 1

    wb = Workbook()
    ws = wb.active
    ws.title = "Табель"
    ws.sheet_view.showGridLines = False

    center = Alignment(horizontal="center", vertical="center", wrap_text=True)
    center_flat = Alignment(horizontal="center", vertical="center")
    left = Alignment(horizontal="left", vertical="center")

    # --- шапка документа ----------------------------------------------------
    # Блок «Утверждаю» стоит над последними колонками сводной части, как в
    # исходной форме (BU..BY): там для подписи остаётся место на листе
    appr_col = SUMMARY_COL + 6
    _merge(ws, 2, appr_col, 2, appr_col + 4, "Утверждаю", _f(bold=True), center_flat)
    _merge(ws, 3, appr_col, 3, appr_col + 4, None, _f(), center_flat)
    _merge(ws, 4, appr_col, 4, appr_col + 4, approver, _f(), center_flat)

    _merge(ws, 6, 1, 6, 2, "Организация ", _f(), left)
    _merge(ws, 6, 4, 6, 21, organization, _f(), left)
    _merge(ws, 7, 1, 7, 2, "Подразделение  ", _f(), left)
    _merge(ws, 7, 4, 7, 21, org_unit, _f(), left)

    _put(ws, 9, 2, "Табель №", _f(bold=True), left)
    if number is not None:
        _put(ws, 9, 4, str(number), _f(), left)

    _merge(ws, 10, 2, 10, 4, "учета использования рабочего времени", _f(), left)

    _put(ws, 11, 1, "за ", _f(), left)
    #  24.09.2026: как в шаблонах («Барановичи 08-26», «Рудковский табель») —
    #  дата первого числа месяца в формате «мес-гг», а не слово
    _put(ws, 11, 2, date(period_month.year, period_month.month, 1), _f(bold=True), left)
    ws.cell(11, 2).number_format = "mmm-yy"
    _put(ws, 11, 4, f"{period_month.year} г.", _f(), left)

    # --- шапка таблицы ------------------------------------------------------
    for col, title in (
        (COL_NO, "№\nп/п"), (COL_FIO, "Фамилия  И.О."),
        (COL_PERS, "Таб. №"), (COL_POS, "Должность "),
    ):
        if col == COL_PERS:
            # «Таб. №» в исходном файле со второй строкой шапки не объединён,
            # в отличие от остальных трёх. Повторяем в точности: файл читает
            # 1С ЗУП, и расхождений в шапке лучше не вносить даже таких.
            _put(ws, HEAD_ROW, col, title, _f(bold=True), center)
        else:
            _merge(ws, HEAD_ROW, col, HEAD_ROW + 1, col, title,
                   _f(bold=True), center)

    _merge(
        ws, HEAD_ROW, FIRST_DAY_COL, HEAD_ROW, FIRST_DAY_COL + DAY_SLOTS * 2 - 1,
        "Числа месяца", _f(bold=True), center,
    )
    for i in range(1, DAY_SLOTS + 1):
        col = FIRST_DAY_COL + (i - 1) * 2
        _merge(
            ws, HEAD_ROW + 1, col, HEAD_ROW + 1, col + 1,
            i if i <= days_in_month else None, _f(bold=True), center_flat,
        )

    for idx, (long_title, short_title, _key) in enumerate(SUMMARY_HEADERS):
        col = SUMMARY_COL + idx
        _put(ws, HEAD_ROW, col, long_title, _f(bold=True), center)
        _put(ws, HEAD_ROW + 1, col, short_title, _f(bold=True), center)

    # --- данные -------------------------------------------------------------
    for r, row in enumerate(rows, start=FIRST_DATA_ROW):
        _put(ws, r, COL_NO, row.no, _f(), center_flat)
        _put(ws, r, COL_FIO, row.fio, _f(bold=True), left)
        # Табельный номер — числом с форматом исходника: именно в таком виде
        # его получает 1С ЗУП. Если номер не десять цифр (ведущий ноль или
        # что-то нештатное), пишем текстом — потерять цифру нельзя
        pers = _put(ws, r, COL_PERS, _personnel(row.personnel_no), _f(), center_flat)
        pers.number_format = PERSONNEL_FORMAT if isinstance(pers.value, int) else "@"
        _put(ws, r, COL_POS, row.position, _f(), left)

        by_day = {d.day: d for d in row.days}
        for i in range(1, days_in_month + 1):
            col = FIRST_DAY_COL + (i - 1) * 2
            d = by_day.get(i)
            if d is None:
                continue
            _put(ws, r, col, d.cell_day(), _f(bold=True), center_flat)
            _put(ws, r, col + 1, d.cell_night(), _f(bold=True), center_flat)

        values = summary_values(row)
        for idx, (_long, _short, key) in enumerate(SUMMARY_HEADERS):
            if key in values:
                _put(ws, r, SUMMARY_COL + idx, _num(values[key]), _f(), center_flat)

    last_data_row = FIRST_DATA_ROW + max(len(rows), 1) - 1

    # --- ИТОГО ЧАСОВ --------------------------------------------------------
    total_row = last_data_row + 1
    _put(ws, total_row, COL_POS, "ИТОГО ЧАСОВ", _f(bold=True), left)
    day_sums: dict[int, float] = {}
    night_sums: dict[int, float] = {}
    for row in rows:
        for d in row.days:
            day_sums[d.day] = day_sums.get(d.day, 0.0) + d.hours_day
            night_sums[d.day] = night_sums.get(d.day, 0.0) + d.hours_night
    for i in range(1, days_in_month + 1):
        col = FIRST_DAY_COL + (i - 1) * 2
        day_sum = round(day_sums.get(i, 0.0), 2)
        night_sum = round(night_sums.get(i, 0.0), 2)
        if day_sum:
            _put(ws, total_row, col, _num(day_sum), _f(), center_flat)
        if night_sum:
            _put(ws, total_row, col + 1, _num(night_sum), _f(), center_flat)

    if rows and all(r.totals is not None for r in rows):
        per_row = [summary_values(r) for r in rows]
        for idx, (_long, _short, key) in enumerate(SUMMARY_HEADERS):
            total = sum(float(v.get(key, 0)) for v in per_row)
            _put(ws, total_row, SUMMARY_COL + idx, _num(total), _f(), center_flat)

    # --- рамки --------------------------------------------------------------
    for r in range(HEAD_ROW, total_row + 1):
        for col in range(1, last_col + 1):
            ws.cell(r, col).border = BORDER
    _outline(ws, HEAD_ROW, 1, total_row, last_col)

    # --- ответственный и легенда -------------------------------------------
    sign_row = total_row + 3
    _put(ws, sign_row, COL_POS, "Ответственный ", _f(), left)
    _put(ws, sign_row + 1, COL_POS, "за ведение табеля", _f(), left)
    name_cell = _merge(
        ws, sign_row + 1, FIRST_DAY_COL, sign_row + 1, FIRST_DAY_COL + 28,
        responsible or "", _f(), center,
    )
    name_cell.border = Border(bottom=_thin)

    legend_row = sign_row + 3
    for i, line in enumerate(LEGEND):
        _put(ws, legend_row + i, COL_POS, line, _f(bold=True), left)
    note_row = legend_row + len(LEGEND)
    _merge(
        ws, note_row, FIRST_DAY_COL, note_row, FIRST_DAY_COL + 50,
        NIGHT_NOTE, _f(bold=True), center_flat,
    )

    # --- размеры и печать ---------------------------------------------------
    ws.column_dimensions["A"].width = 3.66
    ws.column_dimensions["B"].width = 25.66
    ws.column_dimensions["C"].width = 14.89
    ws.column_dimensions["D"].width = 38.66
    for col in range(FIRST_DAY_COL, SUMMARY_COL):
        ws.column_dimensions[get_column_letter(col)].width = 4.44
    for idx, (_long, short, _key) in enumerate(SUMMARY_HEADERS):
        width = 12.55 if short == "Раб. часы ночь" else (
            8.0 if short == "Раб. часы" else 7.66 if idx == 0 else 7.33)
        ws.column_dimensions[get_column_letter(SUMMARY_COL + idx)].width = width

    ws.row_dimensions[HEAD_ROW].height = 79.2
    ws.row_dimensions[HEAD_ROW + 1].height = 13.8

    ws.freeze_panes = ws.cell(FIRST_DATA_ROW, FIRST_DAY_COL)
    ws.print_title_rows = f"{HEAD_ROW}:{HEAD_ROW + 1}"
    ws.page_setup.orientation = "landscape"
    ws.page_setup.paperSize = ws.PAPERSIZE_A4
    ws.page_setup.fitToWidth = 1
    ws.page_setup.fitToHeight = 0
    ws.sheet_properties.pageSetUpPr.fitToPage = True

    wb.save(path)
    return path


def _put(ws, row: int, col: int, value, font: Font, alignment: Alignment):
    cell = ws.cell(row, col)
    if value is not None:
        cell.value = value
    cell.font = font
    cell.alignment = alignment
    return cell


def _merge(ws, r1: int, c1: int, r2: int, c2: int, value, font, alignment):
    if (r1, c1) != (r2, c2):
        ws.merge_cells(start_row=r1, start_column=c1, end_row=r2, end_column=c2)
    return _put(ws, r1, c1, value, font, alignment)


def _outline(ws, r1: int, c1: int, r2: int, c2: int) -> None:
    """
    Обвести блок жирной рамкой, сохранив тонкие линии внутри.

    Рамки в объединённых клетках openpyxl не хранит, поэтому границу ставим
    по каждой клетке края отдельно, дополняя уже проставленную тонкую сетку.
    """
    for col in range(c1, c2 + 1):
        top = ws.cell(r1, col)
        top.border = Border(left=top.border.left, right=top.border.right,
                            top=_medium, bottom=top.border.bottom)
        bottom = ws.cell(r2, col)
        bottom.border = Border(left=bottom.border.left, right=bottom.border.right,
                               top=bottom.border.top, bottom=_medium)
    for row in range(r1, r2 + 1):
        lft = ws.cell(row, c1)
        lft.border = Border(left=_medium, right=lft.border.right,
                            top=lft.border.top, bottom=lft.border.bottom)
        rgt = ws.cell(row, c2)
        rgt.border = Border(left=rgt.border.left, right=_medium,
                            top=rgt.border.top, bottom=rgt.border.bottom)


def build_rows(
    people: Iterable[tuple[str, str, str]],
    days_by_person: dict[str, list[TabelDay]],
    totals_by_person: dict[str, Totals],
) -> list[TabelRow]:
    """
    Собрать строки формы.

    people — последовательность (табельный, ФИО, должность).
    """
    rows: list[TabelRow] = []
    for i, (personnel_no, fio, position) in enumerate(people, start=1):
        rows.append(
            TabelRow(
                no=i,
                fio=fio,
                personnel_no=personnel_no,
                position=position,
                days=days_by_person.get(personnel_no, []),
                totals=totals_by_person.get(personnel_no),
            )
        )
    return rows
