#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
分栏布局（MVP）
- 行分栏 col：columnType=1 超过 maxCol 行分列 / columnType=2 分 N 栏
- 列分栏 row：columnType=1 超过 maxRow 列分行 / columnType=2 分 N 行
- fillEmptyRows：每栏数据不足时补空行/列
"""
from __future__ import annotations

import copy
import math
import re
from typing import Any, Dict, List, Optional, Set, Tuple


def _col_letter_to_index(col: str) -> int:
    col = col.upper()
    n = 0
    for ch in col:
        n = n * 26 + (ord(ch) - ord("A") + 1)
    return n - 1


def parse_cell_range(addr: str) -> Optional[Tuple[int, int, int, int]]:
    """A2:D10 -> (r0, r1, c0, c1) 0-based 闭区间"""
    if not addr or not isinstance(addr, str):
        return None
    m = re.match(r"^([A-Za-z]+)(\d+):([A-Za-z]+)(\d+)$", addr.strip())
    if not m:
        return None
    c0 = _col_letter_to_index(m.group(1))
    r0 = int(m.group(2)) - 1
    c1 = _col_letter_to_index(m.group(3))
    r1 = int(m.group(4)) - 1
    if r0 > r1:
        r0, r1 = r1, r0
    if c0 > c1:
        c0, c1 = c1, c0
    return r0, r1, c0, c1


def parse_index_list(spec: Optional[str]) -> Set[int]:
    """1,2-3,6 -> 0-based 索引集合"""
    result: Set[int] = set()
    if not spec:
        return result
    for part in str(spec).split(","):
        part = part.strip()
        if not part:
            continue
        if "-" in part:
            a, b = part.split("-", 1)
            try:
                start, end = int(a) - 1, int(b) - 1
                for i in range(min(start, end), max(start, end) + 1):
                    result.add(i)
            except ValueError:
                pass
        else:
            try:
                result.add(int(part) - 1)
            except ValueError:
                pass
    return result


def _get_column_config_for_sheet(
    layout_list: List[Any],
    sheet_id: str,
) -> Optional[Dict[str, Any]]:
    for item in layout_list or []:
        if isinstance(item, dict) and str(item.get("sheet")) == str(sheet_id):
            cfg = item.get("columnList")
            return cfg if isinstance(cfg, dict) else None
    return None


def _extract_region_cells(
    cell_data: Dict[str, Any],
    r0: int,
    r1: int,
    c0: int,
    c1: int,
) -> Dict[Tuple[int, int], Dict[str, Any]]:
    region: Dict[Tuple[int, int], Dict[str, Any]] = {}
    for rk in range(r0, r1 + 1):
        row = cell_data.get(str(rk))
        if not isinstance(row, dict):
            continue
        for ck in range(c0, c1 + 1):
            cell = row.get(str(ck))
            if isinstance(cell, dict):
                region[(rk, ck)] = copy.deepcopy(cell)
    return region


def _write_cell(cell_data: Dict[str, Any], row: int, col: int, cell: Dict[str, Any]) -> None:
    cell_data.setdefault(str(row), {})[str(col)] = cell


def _empty_cell() -> Dict[str, Any]:
    return {"v": ""}


def _resolve_col_fence(
    cfg: Dict[str, Any],
    data_size: int,
) -> Optional[Tuple[int, int]]:
    """返回 (fence_num, fence_data_size)"""
    if data_size < 1:
        return None
    column_type = str(cfg.get("columnType") or "2")
    if column_type == "1":
        per_fence = int(cfg.get("maxCol") or 0)
        if per_fence < 1:
            return None
        return math.ceil(data_size / per_fence), per_fence
    fence_num = int(cfg.get("rowCount") or 0)
    if fence_num < 2:
        return None
    return fence_num, math.ceil(data_size / fence_num)


def _resolve_row_fence(
    cfg: Dict[str, Any],
    data_size: int,
) -> Optional[Tuple[int, int]]:
    if data_size < 1:
        return None
    column_type = str(cfg.get("columnType") or "2")
    if column_type == "1":
        per_fence = int(cfg.get("maxRow") or 0)
        if per_fence < 1:
            return None
        return math.ceil(data_size / per_fence), per_fence
    fence_num = int(cfg.get("colCount") or 0)
    if fence_num < 2:
        return None
    return fence_num, math.ceil(data_size / fence_num)


def _apply_col_split(sheet: Dict[str, Any], cfg: Dict[str, Any]) -> None:
    if not cfg.get("columnState") or cfg.get("columnStyle") != "col":
        return

    bounds = parse_cell_range(cfg.get("columnData") or "")
    if not bounds:
        return
    r0, r1, c0, c1 = bounds
    width = c1 - c0 + 1
    cell_data = sheet.setdefault("cellData", {})
    region = _extract_region_cells(cell_data, r0, r1, c0, c1)
    data_row_indices = sorted({r for (r, _) in region.keys()}) or list(range(r0, r1 + 1))
    resolved = _resolve_col_fence(cfg, len(data_row_indices))
    if not resolved:
        return
    fence_num, fence_data_size = resolved
    fill_empty = bool(cfg.get("fillEmptyRows"))

    copy_rows = parse_index_list(cfg.get("copyCol"))

    for r in range(r0, r1 + 1):
        row_obj = cell_data.get(str(r))
        if not isinstance(row_obj, dict):
            continue
        for c in range(c0, c1 + 1):
            if (r, c) in region and str(c) in row_obj:
                del row_obj[str(c)]

    for block in range(fence_num):
        block_rows = data_row_indices[block * fence_data_size : (block + 1) * fence_data_size]
        target_c_base = c0 + block * width
        out_row = r0

        for copy_r in sorted(copy_rows):
            if copy_r < r0 or copy_r > r1:
                continue
            for dc in range(width):
                src = region.get((copy_r, c0 + dc))
                if src:
                    _write_cell(cell_data, out_row, target_c_base + dc, copy.deepcopy(src))
            out_row += 1

        header_offset = out_row - r0
        data_written = 0
        for local_i, src_r in enumerate(block_rows):
            if src_r in copy_rows:
                continue
            dst_r = r0 + header_offset + local_i
            data_written += 1
            for dc in range(width):
                src = region.get((src_r, c0 + dc))
                if src:
                    _write_cell(cell_data, dst_r, target_c_base + dc, copy.deepcopy(src))
        if fill_empty and data_written < fence_data_size:
            for pad_i in range(data_written, fence_data_size):
                dst_r = r0 + header_offset + pad_i
                for dc in range(width):
                    col_idx = target_c_base + dc
                    row_obj = cell_data.get(str(dst_r)) or {}
                    if str(col_idx) not in row_obj:
                        _write_cell(cell_data, dst_r, col_idx, _empty_cell())

    max_r, max_c = r1, c1
    for rk, row in cell_data.items():
        if not str(rk).isdigit() or not isinstance(row, dict):
            continue
        max_r = max(max_r, int(rk))
        for ck in row.keys():
            if str(ck).isdigit():
                max_c = max(max_c, int(ck))
    sheet["rowCount"] = max(int(sheet.get("rowCount") or 0), max_r + 5)
    sheet["columnCount"] = max(int(sheet.get("columnCount") or 0), max_c + 5)


def _apply_row_split(sheet: Dict[str, Any], cfg: Dict[str, Any]) -> None:
    """列分栏：将区域内列拆成多块，纵向堆叠"""
    if not cfg.get("columnState") or cfg.get("columnStyle") != "row":
        return

    bounds = parse_cell_range(cfg.get("columnData") or "")
    if not bounds:
        return
    r0, r1, c0, c1 = bounds
    height = r1 - r0 + 1
    cell_data = sheet.setdefault("cellData", {})
    region = _extract_region_cells(cell_data, r0, r1, c0, c1)
    data_col_indices = sorted({c for (_, c) in region.keys()}) or list(range(c0, c1 + 1))
    resolved = _resolve_row_fence(cfg, len(data_col_indices))
    if not resolved:
        return
    fence_num, fence_data_size = resolved
    fill_empty = bool(cfg.get("fillEmptyRows"))

    copy_cols = parse_index_list(cfg.get("copyRow"))

    for r in range(r0, r1 + 1):
        row_obj = cell_data.get(str(r))
        if not isinstance(row_obj, dict):
            continue
        for c in range(c0, c1 + 1):
            if (r, c) in region and str(c) in row_obj:
                del row_obj[str(c)]

    for block in range(fence_num):
        block_cols = data_col_indices[block * fence_data_size : (block + 1) * fence_data_size]
        target_r_base = r0 + block * height

        for copy_c in sorted(copy_cols):
            if copy_c < c0 or copy_c > c1:
                continue
            for dr in range(height):
                src_r = r0 + dr
                src = region.get((src_r, copy_c))
                if src:
                    _write_cell(cell_data, target_r_base + dr, copy_c, copy.deepcopy(src))

        written_cols = [c for c in block_cols if c not in copy_cols]
        for src_c in written_cols:
            for dr in range(height):
                src_r = r0 + dr
                dst_r = target_r_base + dr
                src = region.get((src_r, src_c))
                if src:
                    _write_cell(cell_data, dst_r, src_c, copy.deepcopy(src))
        if fill_empty and len(written_cols) < fence_data_size:
            pad_need = fence_data_size - len(written_cols)
            pad_candidates = [
                c
                for c in range(c0, c1 + 1)
                if c not in copy_cols and c not in written_cols
            ]
            for pad_c in pad_candidates[:pad_need]:
                for dr in range(height):
                    dst_r = target_r_base + dr
                    row_obj = cell_data.get(str(dst_r)) or {}
                    if str(pad_c) not in row_obj:
                        _write_cell(cell_data, dst_r, pad_c, _empty_cell())

    max_r = r0 + fence_num * height
    max_c = c1
    for rk, row in cell_data.items():
        if not str(rk).isdigit() or not isinstance(row, dict):
            continue
        max_r = max(max_r, int(rk))
        for ck in row.keys():
            if str(ck).isdigit():
                max_c = max(max_c, int(ck))
    sheet["rowCount"] = max(int(sheet.get("rowCount") or 0), max_r + 5)
    sheet["columnCount"] = max(int(sheet.get("columnCount") or 0), max_c + 5)


def apply_column_layout(
    snapshot: Dict[str, Any],
    layout_list: List[Any],
) -> Dict[str, Any]:
    if not snapshot or not layout_list:
        return snapshot or {}
    result = copy.deepcopy(snapshot)
    sheets = result.get("sheets") or {}
    for sheet_id in result.get("sheetOrder") or list(sheets.keys()):
        sheet = sheets.get(sheet_id)
        if not isinstance(sheet, dict):
            continue
        cfg = _get_column_config_for_sheet(layout_list, sheet_id)
        if not cfg or not cfg.get("columnState"):
            continue
        style = cfg.get("columnStyle")
        if style == "col":
            _apply_col_split(sheet, cfg)
        elif style == "row":
            _apply_row_split(sheet, cfg)
    result["sheets"] = sheets
    return result