"""DrawingML fill -> SVG fill conversion.

Handles:
- <a:solidFill>     -> fill="#XXXXXX" (+ fill-opacity)
- <a:noFill/>       -> fill="none"
- <a:gradFill>      -> linearGradient/radialGradient in <defs>, fill="url(#id)"
- <a:blipFill>      -> handled by pic_to_svg (this module short-circuits)

Returned FillResult is a struct of attribute dict + optional <defs> XML so the
slide assembler can collect gradient defs without conflicting IDs.
"""

from __future__ import annotations

import math
import re
from dataclasses import dataclass, field
from decimal import Decimal
from xml.etree import ElementTree as ET

from .color_resolver import (
    COLOR_TAGS,
    ColorPalette,
    find_color_elem,
    resolve_color,
    resolve_solid_fill_color,
    validate_no_fill,
)
from .emu_units import (
    ANGLE_UNIT,
    NS,
    PERCENT_UNIT,
    fmt_num,
    format_ooxml_alpha,
    format_ooxml_unit_ratio,
)


_OOXML_INTEGER_RE = re.compile(r"[+-]?[0-9]+")
_OOXML_PERCENT_LITERAL_RE = re.compile(
    r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)%"
)
_OOXML_FULL_CIRCLE = 360 * ANGLE_UNIT
_OOXML_PERCENTAGE_MIN = Decimal(-(2**31)) / Decimal(PERCENT_UNIT)
_OOXML_PERCENTAGE_MAX = Decimal(2**31 - 1) / Decimal(PERCENT_UNIT)
_SVG_RADIAL_FOCUS_TOLERANCE = Decimal(1) / Decimal(PERCENT_UNIT)
_DRAWINGML_FILL_NAMES = (
    "noFill",
    "solidFill",
    "gradFill",
    "blipFill",
    "pattFill",
    "grpFill",
)
_DRAWINGML_FILL_TAGS = {
    f"{{{NS['a']}}}{name}": name for name in _DRAWINGML_FILL_NAMES
}


@dataclass
class FillResult:
    """Resolved fill: SVG attributes to apply + optional <defs> entries."""

    attrs: dict[str, str] = field(default_factory=dict)
    defs: list[str] = field(default_factory=list)  # XML strings of <linearGradient>/<radialGradient>

    @classmethod
    def none_fill(cls) -> "FillResult":
        return cls(attrs={"fill": "none"})

    @classmethod
    def inherit(cls) -> "FillResult":
        # No fill resolved — let caller decide whether to default
        return cls()


def resolve_fill(
    sp_pr: ET.Element | None,
    palette: ColorPalette | None,
    *,
    id_prefix: str = "g",
    id_seq: list[int] | None = None,
    placeholder_hex: str | None = None,
) -> FillResult:
    """Inspect <p:spPr>'s fill children and emit an SVG fill descriptor.

    Args:
        sp_pr: <p:spPr> or any element that may directly hold a fill child.
        palette: ColorPalette for scheme color resolution.
        id_prefix: prefix for generated gradient IDs.
        id_seq: external counter (single-element list) so callers can share
            unique gradient IDs across the whole slide.

    Returns:
        FillResult. If no recognized fill is found, result.attrs is empty —
        the caller should apply its own default (typically transparent /
        inherit from the source SVG).
    """
    if sp_pr is None:
        return FillResult.inherit()

    handlers = {
        "noFill": _resolve_no_fill,
        "solidFill": _resolve_solid_fill,
        "gradFill": _resolve_grad_fill,
        "blipFill": _resolve_blip_fill,
        "pattFill": _resolve_patt_fill,
    }

    fill_name = _drawingml_fill_name(sp_pr)
    fill_elem = sp_pr if fill_name is not None else None
    if fill_elem is None:
        fill_children = []
        for child in sp_pr:
            child_name = _drawingml_fill_name(child)
            if child_name is not None:
                fill_children.append((child, child_name))
        if len(fill_children) > 1:
            raise ValueError(
                "DrawingML container must contain at most one fill"
            )
        if not fill_children:
            return FillResult.inherit()
        fill_elem, fill_name = fill_children[0]

    if fill_name == "grpFill":
        raise ValueError("Unsupported DrawingML fill: grpFill")
    return handlers[fill_name](
        fill_elem,
        palette,
        id_prefix,
        id_seq,
        placeholder_hex,
    )


def _drawingml_fill_name(elem: ET.Element) -> str | None:
    """Return one exact DrawingML fill tag name or reject a namespace alias."""
    name = _DRAWINGML_FILL_TAGS.get(elem.tag)
    if name is not None:
        return name
    local_name = (
        elem.tag.rsplit("}", 1)[-1]
        if isinstance(elem.tag, str)
        else ""
    )
    if local_name in _DRAWINGML_FILL_NAMES:
        raise ValueError(
            f"Invalid DrawingML fill element namespace: {local_name}"
        )
    return None


# ---------------------------------------------------------------------------
# Per-fill handlers
# ---------------------------------------------------------------------------

def _resolve_no_fill(elem, _palette, _prefix, _seq, _placeholder_hex) -> FillResult:
    validate_no_fill(elem)
    return FillResult.none_fill()


def _resolve_solid_fill(elem: ET.Element, palette: ColorPalette | None,
                        _prefix: str, _seq, placeholder_hex: str | None) -> FillResult:
    hex_, alpha = resolve_solid_fill_color(
        elem,
        palette,
        placeholder_hex=placeholder_hex,
    )
    attrs: dict[str, str] = {"fill": hex_}
    if alpha < 1.0:
        attrs["fill-opacity"] = format_ooxml_alpha(alpha)
    return FillResult(attrs=attrs)


def _resolve_grad_fill(elem: ET.Element, palette: ColorPalette | None,
                       prefix: str, seq, placeholder_hex: str | None) -> FillResult:
    """Convert <a:gradFill> to an SVG linearGradient or radialGradient."""
    _validate_gradient_attributes(elem)
    _validate_gradient_rotation(elem)
    _validate_gradient_flip(elem)
    _validate_gradient_tile_rect(elem)
    if seq is None:
        seq = [0]
    seq[0] += 1
    grad_id = f"{prefix}grad{seq[0]}"

    # Stops
    gs_lists = elem.findall("a:gsLst", NS)
    if len(gs_lists) != 1:
        raise ValueError(
            "DrawingML gradient fill requires exactly one gsLst"
        )
    gradient_stops = [
        (gs, _gradient_stop_position(gs))
        for gs in _gradient_stop_list(gs_lists[0])
    ]
    if any(
        current < previous
        for (_, previous), (_, current) in zip(
            gradient_stops,
            gradient_stops[1:],
        )
    ):
        message = "DrawingML gradient stop positions must be nondecreasing"
        if palette is None or palette.strict:
            raise ValueError(message)
        palette._diagnose(
            "gradient-stop-order-normalized",
            message,
            "sort gradient stops by position while preserving equal positions",
        )
        gradient_stops.sort(key=lambda item: item[1])
    stops_xml = []
    for gs, pos_pct in gradient_stops:
        color_elem = _gradient_stop_color(gs)
        hex_, alpha = resolve_color(
            color_elem,
            palette,
            placeholder_hex=placeholder_hex,
        )
        if hex_ is None:
            raise ValueError(
                "DrawingML gradient stop color cannot be resolved"
            )
        opacity_attr = (
            f' stop-opacity="{format_ooxml_alpha(alpha)}"'
            if alpha < 1.0
            else ""
        )
        stops_xml.append(
            f'<stop offset="{format_ooxml_unit_ratio(pos_pct)}" '
            f'stop-color="{hex_}"{opacity_attr}/>'
        )
    # Linear vs radial vs path
    linear_directions = elem.findall("a:lin", NS)
    path_directions = elem.findall("a:path", NS)
    if len(linear_directions) + len(path_directions) > 1:
        raise ValueError(
            "DrawingML gradient fill must contain at most one lin/path "
            "direction"
        )
    _validate_gradient_child_structure(elem)
    lin = linear_directions[0] if linear_directions else None
    rad = path_directions[0] if path_directions else None

    if lin is not None:
        # ang is 1/60000 deg. 0° = horizontal left-to-right.
        _validate_linear_gradient_structure(lin)
        angle = _linear_gradient_angle(lin)
        _validate_linear_gradient_scaling(lin, angle)
        angle_deg = angle / ANGLE_UNIT
        x1, y1, x2, y2 = _angle_to_unit_endpoints(angle_deg)
        defs_xml = (
            f'<linearGradient id="{grad_id}" '
            f'x1="{fmt_num(x1, 4)}" y1="{fmt_num(y1, 4)}" '
            f'x2="{fmt_num(x2, 4)}" y2="{fmt_num(y2, 4)}">'
            + "".join(stops_xml)
            + "</linearGradient>"
        )
    elif rad is not None:
        _validate_path_gradient_structure(rad)
        _validate_path_gradient_type(rad)
        focus = _validate_path_gradient_focus(rad)
        focus_attrs = ""
        if focus is not None:
            focus_x = focus["l"]
            focus_y = focus["t"]
            point_focus = (
                focus_x + focus["r"] == Decimal(1)
                and focus_y + focus["b"] == Decimal(1)
                and Decimal(0) <= focus_x <= Decimal(1)
                and Decimal(0) <= focus_y <= Decimal(1)
                and (
                    (focus_x - Decimal("0.5")) ** 2
                    + (focus_y - Decimal("0.5")) ** 2
                    <= Decimal("0.25") + _SVG_RADIAL_FOCUS_TOLERANCE
                )
            )
            if (
                point_focus
                and (
                    focus_x != Decimal("0.5")
                    or focus_y != Decimal("0.5")
                )
            ):
                focus_attrs = (
                    f' fx="{format_ooxml_unit_ratio(float(focus_x))}"'
                    f' fy="{format_ooxml_unit_ratio(float(focus_y))}"'
                )
            elif not point_focus and palette is not None:
                palette._diagnose(
                    "path-gradient-focus-normalized",
                    "DrawingML path gradient focus is not one point within "
                    "the canonical SVG radial circle",
                    "center the radial gradient while preserving its stops",
                )
        # Treat as radial regardless of path="circle" / "rect" / "shape" — SVG
        # only has circle/ellipse. Point-style fillToRect retains its focus;
        # the outer center and radius remain normalized.
        defs_xml = (
            f'<radialGradient id="{grad_id}" cx="0.5" cy="0.5" '
            f'r="0.5"{focus_attrs}>'
            + "".join(stops_xml)
            + "</radialGradient>"
        )
    else:
        # No direction specified — default to horizontal linear
        defs_xml = (
            f'<linearGradient id="{grad_id}" x1="0" y1="0" x2="1" y2="0">'
            + "".join(stops_xml)
            + "</linearGradient>"
        )

    return FillResult(
        attrs={"fill": f"url(#{grad_id})"},
        defs=[defs_xml],
    )


def _gradient_stop_position(gs: ET.Element) -> float:
    """Parse one required DrawingML fixed-percentage stop position."""
    raw = gs.get("pos")
    if raw is None:
        raise ValueError("DrawingML gradient stop requires a pos attribute")
    token = raw.strip()
    if _OOXML_INTEGER_RE.fullmatch(token) is None:
        raise ValueError(
            f"Invalid DrawingML gradient stop position: {raw!r}"
        )
    position = int(token)
    if not 0 <= position <= PERCENT_UNIT:
        raise ValueError(
            f"DrawingML gradient stop position={position} is outside "
            f"0..{PERCENT_UNIT}"
        )
    return position / PERCENT_UNIT


def _gradient_stop_list(gs_list: ET.Element) -> list[ET.Element]:
    """Validate one DrawingML gradient-stop list and return its stops."""
    stops = list(gs_list)
    stop_tag = f"{{{NS['a']}}}gs"
    if (
        gs_list.attrib
        or (gs_list.text or "").strip()
        or any(
            stop.tag != stop_tag or (stop.tail or "").strip()
            for stop in stops
        )
    ):
        raise ValueError("Invalid DrawingML gradient stop list structure")
    if len(stops) < 2:
        raise ValueError(
            "DrawingML gradient fill requires at least two color stops"
        )
    return stops


def _gradient_stop_color(gs: ET.Element) -> ET.Element:
    """Return the single registered color child of one gradient stop."""
    children = list(gs)
    color_tags = {f"{{{NS['a']}}}{name}" for name in COLOR_TAGS}
    if (
        set(gs.attrib) != {"pos"}
        or len(children) != 1
        or children[0].tag not in color_tags
        or (gs.text or "").strip()
        or (children[0].tail or "").strip()
    ):
        raise ValueError("Invalid DrawingML gradient stop structure")
    return children[0]


def _linear_gradient_angle(lin: ET.Element) -> int:
    """Parse one optional DrawingML positive fixed angle."""
    raw = lin.get("ang")
    if raw is None:
        return 0
    token = raw.strip()
    if _OOXML_INTEGER_RE.fullmatch(token) is None:
        raise ValueError(f"Invalid DrawingML linear gradient angle: {raw!r}")
    angle = int(token)
    if not 0 <= angle < _OOXML_FULL_CIRCLE:
        raise ValueError(
            f"DrawingML linear gradient angle={angle} is outside "
            f"0..{_OOXML_FULL_CIRCLE - 1}"
        )
    return angle


def _validate_linear_gradient_structure(lin: ET.Element) -> None:
    """Require one leaf a:lin with only the registered attributes."""
    unsupported = sorted(set(lin.attrib) - {"ang", "scaled"})
    if unsupported or list(lin) or (lin.text or "").strip():
        details = ", ".join(unsupported) if unsupported else "payload"
        raise ValueError(
            f"Invalid DrawingML linear gradient structure: {details}"
        )


def _validate_linear_gradient_scaling(
    lin: ET.Element,
    angle: int,
) -> None:
    """Require a scaling mode representable by unit-box SVG geometry."""
    scaled = _parse_ooxml_boolean(
        lin.get("scaled"),
        default=False,
        label="linear gradient scaled value",
    )
    quarter_turn = 90 * ANGLE_UNIT
    if not scaled and angle % quarter_turn:
        raise ValueError(
            "Unscaled non-cardinal DrawingML linear gradients are not "
            "representable by the normalized SVG mapping"
        )


def _validate_gradient_rotation(gradient: ET.Element) -> None:
    """Require a gradient that rotates with its containing shape."""
    rotates_with_shape = _parse_ooxml_boolean(
        gradient.get("rotWithShape"),
        default=True,
        label="gradient rotWithShape value",
    )
    if not rotates_with_shape:
        raise ValueError(
            "DrawingML gradients that do not rotate with their shape are "
            "not representable by the local SVG mapping"
        )


def _validate_gradient_attributes(gradient: ET.Element) -> None:
    """Reject attributes outside the registered gradient-fill contract."""
    unsupported = sorted(set(gradient.attrib) - {"flip", "rotWithShape"})
    if unsupported:
        raise ValueError(
            "Unsupported DrawingML gradient fill attribute(s): "
            + ", ".join(unsupported)
        )


def _validate_gradient_child_structure(gradient: ET.Element) -> None:
    """Require the registered DrawingML gradient-fill child sequence."""
    namespace = NS["a"]
    gs_list = f"{{{namespace}}}gsLst"
    linear = f"{{{namespace}}}lin"
    path = f"{{{namespace}}}path"
    tile_rect = f"{{{namespace}}}tileRect"
    child_tags = tuple(child.tag for child in gradient)
    allowed_sequences = {
        (gs_list,),
        (gs_list, linear),
        (gs_list, path),
        (gs_list, tile_rect),
        (gs_list, linear, tile_rect),
        (gs_list, path, tile_rect),
    }
    if (
        child_tags not in allowed_sequences
        or (gradient.text or "").strip()
        or any((child.tail or "").strip() for child in gradient)
    ):
        raise ValueError(
            "Invalid DrawingML gradient fill child structure"
        )


def _validate_gradient_flip(gradient: ET.Element) -> None:
    """Reject gradient tile flipping absent from project SVG."""
    flip = gradient.get("flip", "none")
    if flip != "none":
        raise ValueError(f"Unsupported DrawingML gradient flip: {flip!r}")


def _validate_gradient_tile_rect(gradient: ET.Element) -> None:
    """Accept only the full-area gradient tile rectangle."""
    tile_rects = gradient.findall("a:tileRect", NS)
    if len(tile_rects) > 1:
        raise ValueError(
            "DrawingML gradient fill must contain at most one tileRect"
        )
    if not tile_rects:
        return
    values = _relative_rect_values(
        tile_rects[0],
        label="gradient tileRect",
    )
    for value in values.values():
        if value != 0:
            raise ValueError(
                "Non-zero DrawingML gradient tileRect is not representable "
                "by the project SVG gradient mapping"
            )


def _validate_path_gradient_focus(
    path: ET.Element,
) -> dict[str, Decimal] | None:
    """Validate and return one path-gradient focus rectangle."""
    focus_rects = path.findall("a:fillToRect", NS)
    if len(focus_rects) > 1:
        raise ValueError(
            "DrawingML path gradient must contain at most one fillToRect"
        )
    if not focus_rects:
        return None
    values = _relative_rect_values(
        focus_rects[0],
        label="path gradient fillToRect",
    )
    return {
        edge: values.get(edge, Decimal(0))
        for edge in ("l", "t", "r", "b")
    }


def _relative_rect_values(
    rect: ET.Element,
    *,
    label: str,
) -> dict[str, Decimal]:
    """Validate one DrawingML relative-rectangle leaf and parse its edges."""
    if (
        set(rect.attrib) - {"l", "t", "r", "b"}
        or list(rect)
        or (rect.text or "").strip()
    ):
        raise ValueError(f"Invalid DrawingML {label} structure")
    return {
        edge: _parse_ooxml_percentage(raw, label=f"{label} {edge}")
        for edge, raw in rect.attrib.items()
    }


def _parse_ooxml_percentage(raw: str, *, label: str) -> Decimal:
    """Parse one DrawingML ST_Percentage as an exact normalized ratio."""
    token = raw.strip()
    if _OOXML_INTEGER_RE.fullmatch(token) is not None:
        value = Decimal(token) / Decimal(PERCENT_UNIT)
    elif _OOXML_PERCENT_LITERAL_RE.fullmatch(token) is not None:
        value = Decimal(token[:-1]) / Decimal(100)
    else:
        raise ValueError(f"Invalid DrawingML {label}: {raw!r}")
    if not _OOXML_PERCENTAGE_MIN <= value <= _OOXML_PERCENTAGE_MAX:
        raise ValueError(f"Invalid DrawingML {label}: {raw!r}")
    return value


def _parse_ooxml_boolean(
    raw: str | None,
    *,
    default: bool,
    label: str,
) -> bool:
    """Parse one W3C XML Schema boolean without permissive aliases."""
    if raw is None:
        return default
    token = raw.strip()
    if token in {"1", "true"}:
        return True
    if token in {"0", "false"}:
        return False
    raise ValueError(f"Invalid DrawingML {label}: {raw!r}")


def _validate_path_gradient_type(path: ET.Element) -> None:
    """Require one registered DrawingML path-shade enum value."""
    path_type = path.get("path", "rect")
    if path_type not in {"circle", "rect", "shape"}:
        raise ValueError(
            f"Unsupported DrawingML path gradient type: {path_type!r}"
        )


def _validate_path_gradient_structure(path: ET.Element) -> None:
    """Require only the registered path attribute and focus rectangle."""
    unsupported = sorted(set(path.attrib) - {"path"})
    children = list(path)
    fill_to_rect_tag = f"{{{NS['a']}}}fillToRect"
    has_invalid_payload = (
        (path.text or "").strip()
        or any(
            child.tag != fill_to_rect_tag or (child.tail or "").strip()
            for child in children
        )
    )
    if unsupported or has_invalid_payload:
        details = ", ".join(unsupported) if unsupported else "payload"
        raise ValueError(
            f"Invalid DrawingML path gradient structure: {details}"
        )


def _resolve_blip_fill(_elem, _palette, _prefix, _seq, _placeholder_hex) -> FillResult:
    """blipFill on <p:spPr> means a shape filled with an image — handled at
    pic_to_svg level. For now mark as transparent so the shape's outline
    still draws and pic_to_svg can layer the image on top.
    """
    return FillResult.none_fill()


def _resolve_patt_fill(elem: ET.Element, palette: ColorPalette | None,
                       prefix, seq, placeholder_hex: str | None) -> FillResult:
    """Pattern fills (<a:pattFill prst="..."/> with fg/bg colors)."""
    fg = elem.find("a:fgClr", NS)
    bg = elem.find("a:bgClr", NS)
    fg_hex, fg_alpha = resolve_color(
        find_color_elem(fg), palette, placeholder_hex=placeholder_hex,
    )
    bg_hex, bg_alpha = resolve_color(
        find_color_elem(bg), palette, placeholder_hex=placeholder_hex,
    )
    if fg_hex is None:
        return FillResult.inherit()

    prst = elem.attrib.get("prst", "")
    geom = _pattern_foreground(prst, fg_hex, fg_alpha)
    if geom is None:
        # Unsupported preset → degrade to solid fg color so the shape at
        # least carries the right tone. Round-trip will lose the texture.
        attrs: dict[str, str] = {"fill": fg_hex}
        if fg_alpha < 1.0:
            attrs["fill-opacity"] = format_ooxml_alpha(fg_alpha)
        return FillResult(attrs=attrs)
    tile_w, tile_h, fg_svg = geom

    if seq is None:
        seq = [0]
    seq[0] += 1
    pattern_id = f"{prefix}patt{seq[0]}"
    bg_rect = ""
    if bg_hex is not None:
        bg_opacity = (
            f' fill-opacity="{format_ooxml_alpha(bg_alpha)}"'
            if bg_alpha < 1.0 else ""
        )
        bg_rect = (
            f'<rect width="{tile_w}" height="{tile_h}" '
            f'fill="{bg_hex}"{bg_opacity}/>'
        )
    # Tag with data attributes so the reverse exporter can rebuild <a:pattFill>
    # faithfully (preset + fg/bg colors) instead of inferring from path geometry.
    bg_attr = f' data-pptx-bg="{bg_hex}"' if bg_hex is not None else ""
    pattern_xml = (
        f'<pattern id="{pattern_id}" patternUnits="userSpaceOnUse" '
        f'width="{tile_w}" height="{tile_h}" '
        f'data-pptx-pattern="{prst}" data-pptx-fg="{fg_hex}"{bg_attr}>'
        f'{bg_rect}{fg_svg}</pattern>'
    )
    return FillResult(
        attrs={"fill": f"url(#{pattern_id})"},
        defs=[pattern_xml],
    )


# ---------------------------------------------------------------------------
# Per-preset SVG geometry for <a:pattFill prst="...">
#
# Each handler returns (tile_w, tile_h, foreground_svg). The caller wraps with
# the background rect + <pattern> element. None means "unsupported preset" and
# the caller degrades to a solid fg color.
# ---------------------------------------------------------------------------

def _pattern_foreground(prst: str, fg: str,
                        fg_alpha: float) -> tuple[int, int, str] | None:
    stroke_op = (
        f' stroke-opacity="{format_ooxml_alpha(fg_alpha)}"'
        if fg_alpha < 1.0 else ""
    )
    fill_op = (
        f' fill-opacity="{format_ooxml_alpha(fg_alpha)}"'
        if fg_alpha < 1.0 else ""
    )

    # Diagonal stripes — tile size and stroke width pick the visual weight.
    diag = {
        "ltUpDiag":   (8,  1.0, "up", False),
        "dkUpDiag":   (8,  2.0, "up", False),
        "wdUpDiag":   (16, 1.0, "up", False),
        "dashUpDiag": (8,  1.0, "up", True),
        "ltDnDiag":   (8,  1.0, "dn", False),
        "dkDnDiag":   (8,  2.0, "dn", False),
        "wdDnDiag":   (16, 1.0, "dn", False),
        "dashDnDiag": (8,  1.0, "dn", True),
    }
    if prst in diag:
        tile, sw, direction, dashed = diag[prst]
        dash = ' stroke-dasharray="3 2"' if dashed else ""
        if direction == "up":
            d = f"M -2 {tile} L {tile} -2 M 0 {tile + 2} L {tile + 2} 0"
        else:
            d = f"M -2 0 L {tile} {tile + 2} M 0 -2 L {tile + 2} {tile}"
        return tile, tile, (
            f'<path d="{d}" stroke="{fg}"{stroke_op} '
            f'stroke-width="{fmt_num(sw)}" fill="none"{dash}/>'
        )

    # Horizontal / vertical lines.
    line_specs = {
        "horz":     ("h", 8, 1.0, False),
        "ltHorz":   ("h", 8, 0.5, False),
        "dkHorz":   ("h", 8, 2.0, False),
        "narHorz":  ("h", 4, 1.0, False),
        "dashHorz": ("h", 8, 1.0, True),
        "vert":     ("v", 8, 1.0, False),
        "ltVert":   ("v", 8, 0.5, False),
        "dkVert":   ("v", 8, 2.0, False),
        "narVert":  ("v", 4, 1.0, False),
        "dashVert": ("v", 8, 1.0, True),
    }
    if prst in line_specs:
        axis, tile, sw, dashed = line_specs[prst]
        dash = ' stroke-dasharray="3 2"' if dashed else ""
        mid = tile / 2.0
        if axis == "h":
            line = (
                f'<line x1="0" y1="{fmt_num(mid)}" '
                f'x2="{tile}" y2="{fmt_num(mid)}"'
            )
        else:
            line = (
                f'<line x1="{fmt_num(mid)}" y1="0" '
                f'x2="{fmt_num(mid)}" y2="{tile}"'
            )
        return tile, tile, (
            f'{line} stroke="{fg}"{stroke_op} '
            f'stroke-width="{fmt_num(sw)}"{dash}/>'
        )

    # Grids / crosses.
    if prst == "cross":
        return 8, 8, (
            f'<line x1="0" y1="4" x2="8" y2="4" stroke="{fg}"{stroke_op} stroke-width="1"/>'
            f'<line x1="4" y1="0" x2="4" y2="8" stroke="{fg}"{stroke_op} stroke-width="1"/>'
        )
    if prst == "diagCross":
        d = (
            "M -2 8 L 8 -2 M 0 10 L 10 0 "
            "M -2 0 L 8 10 M 0 -2 L 10 8"
        )
        return 8, 8, (
            f'<path d="{d}" stroke="{fg}"{stroke_op} stroke-width="1" fill="none"/>'
        )
    if prst in ("smGrid", "lgGrid"):
        tile = 4 if prst == "smGrid" else 16
        # Lines along top + left edges; tiles together produce a uniform grid.
        return tile, tile, (
            f'<path d="M 0 0 L {tile} 0 M 0 0 L 0 {tile}" '
            f'stroke="{fg}"{stroke_op} stroke-width="0.5" fill="none"/>'
        )
    if prst == "dotGrid":
        # Dots at corners → tiling yields a uniform dot grid.
        return 8, 8, (
            f'<circle cx="0" cy="0" r="1" fill="{fg}"{fill_op}/>'
        )
    if prst == "dotDmnd":
        return 8, 8, (
            f'<circle cx="0" cy="0" r="1" fill="{fg}"{fill_op}/>'
            f'<circle cx="4" cy="4" r="1" fill="{fg}"{fill_op}/>'
        )

    # Percentage shading — single centered dot whose area matches the target
    # density. Approximates PowerPoint's stipple without per-tile artwork.
    if prst.startswith("pct"):
        try:
            pct = float(prst[3:])
        except ValueError:
            return None
        pct = max(0.0, min(pct, 100.0))
        tile = 8
        radius = math.sqrt(pct / 100.0 * tile * tile / math.pi)
        radius = max(0.3, min(radius, tile / 2.0))
        return tile, tile, (
            f'<circle cx="{tile / 2}" cy="{tile / 2}" '
            f'r="{fmt_num(radius, 3)}" fill="{fg}"{fill_op}/>'
        )

    return None


def _hex_distance(a: str, b: str) -> float:
    """Euclidean distance between two #RRGGBB colors."""
    try:
        ar, ag, ab = int(a[1:3], 16), int(a[3:5], 16), int(a[5:7], 16)
        br, bg, bb = int(b[1:3], 16), int(b[3:5], 16), int(b[5:7], 16)
    except (ValueError, IndexError):
        return 255.0
    return math.sqrt((ar - br) ** 2 + (ag - bg) ** 2 + (ab - bb) ** 2)


# ---------------------------------------------------------------------------
# Geometry helpers
# ---------------------------------------------------------------------------

def _angle_to_unit_endpoints(angle_deg: float) -> tuple[float, float, float, float]:
    """Convert a DrawingML linear gradient angle to SVG x1/y1/x2/y2 in unit box.

    DrawingML 0° = horizontal pointing right; angle is clockwise.
    SVG default linearGradient is also unit-box (objectBoundingBox).
    """
    rad = math.radians(angle_deg % 360)
    cos_a = math.cos(rad)
    sin_a = math.sin(rad)
    # Center of unit box
    cx, cy = 0.5, 0.5
    # Half-extent in the direction of the angle vector.
    # We project the unit box onto the angle direction; the line endpoints are
    # the projections of the box corners.
    half = abs(cos_a) * 0.5 + abs(sin_a) * 0.5
    x1 = cx - cos_a * half
    y1 = cy - sin_a * half
    x2 = cx + cos_a * half
    y2 = cy + sin_a * half
    return x1, y1, x2, y2
