"""Flatten canonical annotation data into a PDF with PyMuPDF."""

import logging
import math
import re
import uuid
from collections.abc import Callable, Mapping, Sequence
from pathlib import Path
from typing import Any

import pymupdf

logger = logging.getLogger(__name__)
Annotation = Mapping[str, Any]
Handler = Callable[[pymupdf.Page, Annotation, Path], None]


def _rect(annotation: Annotation) -> pymupdf.Rect | None:
    value = annotation.get("rect")
    if not isinstance(value, Mapping):
        return None
    try:
        x = float(value["x"])
        y = float(value["y"])
        width = float(value["width"])
        height = float(value["height"])
    except (KeyError, TypeError, ValueError):
        return None
    if width < 0 or height < 0:
        return None
    return pymupdf.Rect(x, y, x + width, y + height)


def _props(annotation: Annotation) -> Mapping[str, Any]:
    value = annotation.get("props")
    return value if isinstance(value, Mapping) else {}


def _color(
    value: Any,
    fallback: tuple[float, float, float] = (0.0, 0.0, 0.0),
) -> tuple[float, float, float]:
    if not isinstance(value, str):
        return fallback
    text = value.strip().lstrip("#")
    if len(text) == 3:
        text = "".join(char * 2 for char in text)
    if len(text) != 6:
        return fallback
    try:
        return tuple(int(text[index : index + 2], 16) / 255 for index in (0, 2, 4))  # type: ignore[return-value]
    except ValueError:
        return fallback


def _opacity(value: Any, fallback: float = 1.0) -> float:
    try:
        return max(0.0, min(1.0, float(value)))
    except (TypeError, ValueError):
        return fallback


def _font_name(family: Any, bold: Any = False, italic: Any = False) -> str:
    name = str(family or "Liberation Sans").lower()
    is_serif = "times" in name or "serif" in name
    is_mono = "courier" in name or "mono" in name
    if is_serif:
        normal, bold_name, italic_name, bold_italic_name = "tiro", "tibo", "tiit", "tibi"
    elif is_mono:
        normal, bold_name, italic_name, bold_italic_name = "cour", "cobo", "coit", "cobi"
    else:
        normal, bold_name, italic_name, bold_italic_name = "helv", "hebo", "heit", "hebi"
    if bold and italic:
        return bold_italic_name
    if bold:
        return bold_name
    if italic:
        return italic_name
    return normal


_SIGNATURE_FONT_FILES = {
    "great vibes": "GreatVibes-Regular.ttf",
    "allura": "allura.ttf",
    "sacramento": "sacramento.ttf",
    "dancing script": "dancing-script.ttf",
    "caveat": "caveat.ttf",
}


def _signature_font_file(family: Any) -> Path | None:
    filename = _SIGNATURE_FONT_FILES.get(str(family or "").strip().lower())
    if not filename:
        return None
    path = Path(__file__).parents[2] / "assets" / "fonts" / filename
    return path if path.is_file() else None


def _signature_font_size(
    rect: pymupdf.Rect, text: str, font_file: Path | None, font_name: str
) -> float:
    size = max(1.0, min(48.0, rect.height * 0.55))
    try:
        font = (
            pymupdf.Font(fontfile=str(font_file)) if font_file else pymupdf.Font(fontname=font_name)
        )
        text_width = font.text_length(text, fontsize=size)
        if text_width > rect.width and text_width > 0:
            size *= max(0.1, rect.width / text_width) * 0.95
    except Exception:
        # A missing optional font must not prevent a PDF export.
        pass
    return max(1.0, size)


def _points_from_props(annotation: Annotation, rect: pymupdf.Rect) -> list[pymupdf.Point]:
    props = _props(annotation)
    raw_points = props.get("paths")
    points: list[pymupdf.Point] = []
    if isinstance(raw_points, Sequence) and not isinstance(raw_points, (str, bytes)):
        for raw_point in raw_points:
            if isinstance(raw_point, Sequence) and len(raw_point) == 2:
                try:
                    points.append(
                        pymupdf.Point(
                            rect.x0 + float(raw_point[0]),
                            rect.y0 + float(raw_point[1]),
                        )
                    )
                except (TypeError, ValueError):
                    continue
    if len(points) >= 2:
        return points

    # Older clients stored a Fabric SVG path. Approximate its command end
    # points and normalize them into the canonical annotation rectangle.
    svg_path = props.get("svgPath")
    if not isinstance(svg_path, str):
        return []
    raw = [float(value) for value in re.findall(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?", svg_path)]
    if len(raw) < 4:
        return []
    pairs = list(zip(raw[::2], raw[1::2], strict=False))
    min_x = min(point[0] for point in pairs)
    max_x = max(point[0] for point in pairs)
    min_y = min(point[1] for point in pairs)
    max_y = max(point[1] for point in pairs)
    source_width = max(max_x - min_x, 1e-6)
    source_height = max(max_y - min_y, 1e-6)
    return [
        pymupdf.Point(
            rect.x0 + (x - min_x) / source_width * rect.width,
            rect.y0 + (y - min_y) / source_height * rect.height,
        )
        for x, y in pairs
    ]


def _draw_polyline(
    page: pymupdf.Page,
    points: list[pymupdf.Point],
    *,
    color: tuple[float, float, float],
    width: float,
    opacity: float,
) -> None:
    if len(points) < 2:
        return
    shape = page.new_shape()
    shape.draw_polyline(points)
    shape.finish(color=color, width=max(0.1, width), stroke_opacity=opacity)
    shape.commit(overlay=True)


def _style_at(styles: Any, line_number: int, character_number: int) -> Mapping[str, Any]:
    if not isinstance(styles, Mapping):
        return {}
    line_styles = styles.get(str(line_number), styles.get(line_number))
    if not isinstance(line_styles, Mapping):
        return {}
    character_style = line_styles.get(str(character_number), line_styles.get(character_number))
    return character_style if isinstance(character_style, Mapping) else {}


def _render_styled_text(
    page: pymupdf.Page,
    rect: pymupdf.Rect,
    text: str,
    props: Mapping[str, Any],
    styles: Any,
) -> bool:
    if not isinstance(styles, Mapping) or not styles:
        return False

    base_size = max(1.0, float(props.get("fontSize", 14)))
    line_height = max(0.5, float(props.get("lineHeight", 1.2)))
    lines = text.split("\n")
    y = rect.y0
    for line_number, line in enumerate(lines):
        measured: list[tuple[str, float, str, tuple[float, float, float], float, str | None]] = []
        for character_number, character in enumerate(line):
            style = _style_at(styles, line_number, character_number)
            font_size = max(1.0, float(style.get("fontSize", base_size)))
            font_family = style.get("fontFamily", props.get("fontFamily"))
            font_name = _font_name(
                font_family,
                style.get("fontWeight") == "bold",
                style.get("fontStyle") == "italic",
            )
            color = _color(style.get("fill", props.get("color")))
            font = pymupdf.Font(fontname=font_name)
            width = float(font.text_length(character, fontsize=font_size))
            background = style.get("textBackgroundColor", props.get("highlightColor"))
            measured.append((character, font_size, font_name, color, width, background))

        total_width = sum(item[4] for item in measured)
        align = str(props.get("align", "left"))
        x = rect.x0
        if align == "center":
            x += max(0.0, (rect.width - total_width) / 2)
        elif align == "right":
            x += max(0.0, rect.width - total_width)

        max_size = max((item[1] for item in measured), default=base_size)
        for character, font_size, font_name, color, width, background in measured:
            if (
                isinstance(background, str)
                and background.lower() not in {"", "transparent", "none"}
            ):
                page.draw_rect(
                    pymupdf.Rect(x, y, x + width, y + max_size * 1.15),
                    color=None,
                    fill=_color(background),
                    fill_opacity=0.3,
                    overlay=True,
                )
            if character != " ":
                page.insert_text(
                    pymupdf.Point(x, y + font_size),
                    character,
                    fontsize=font_size,
                    fontname=font_name,
                    color=color,
                    overlay=True,
                )
            x += width
        y += max_size * line_height

    return True


def render_text(page: pymupdf.Page, annotation: Annotation, _assets_dir: Path) -> None:
    rect = _rect(annotation)
    if rect is None:
        return
    props = _props(annotation)
    text = str(props.get("text", ""))
    if not text:
        return
    highlight = props.get("highlightColor")
    if isinstance(highlight, str) and highlight and highlight.lower() != "transparent":
        page.draw_rect(rect, color=None, fill=_color(highlight), fill_opacity=0.3, overlay=True)
    if _render_styled_text(page, rect, text, props, props.get("styles")):
        return
    align = {"left": 0, "center": 1, "right": 2}.get(str(props.get("align", "left")), 0)
    page.insert_textbox(
        rect,
        text,
        fontsize=max(1.0, float(props.get("fontSize", 14))),
        fontname=_font_name(props.get("fontFamily"), props.get("bold"), props.get("italic")),
        color=_color(props.get("color")),
        align=align,
        overlay=True,
    )


def render_draw(page: pymupdf.Page, annotation: Annotation, _assets_dir: Path) -> None:
    rect = _rect(annotation)
    if rect is None:
        return
    props = _props(annotation)
    _draw_polyline(
        page,
        _points_from_props(annotation, rect),
        color=_color(props.get("strokeColor")),
        width=float(props.get("strokeWidth", 2)),
        opacity=_opacity(props.get("opacity")),
    )


def _asset_path(assets_dir: Path, ref: Any) -> Path | None:
    if not isinstance(ref, str):
        return None
    try:
        safe_ref = str(uuid.UUID(ref))
    except ValueError:
        return None
    path = assets_dir / safe_ref
    return path if path.is_file() else None


def render_image(page: pymupdf.Page, annotation: Annotation, assets_dir: Path) -> None:
    rect = _rect(annotation)
    asset = _asset_path(assets_dir, _props(annotation).get("ref"))
    if rect is None or asset is None:
        return
    page.insert_image(rect, filename=str(asset), keep_proportion=False, overlay=True)


def render_signature(page: pymupdf.Page, annotation: Annotation, assets_dir: Path) -> None:
    rect = _rect(annotation)
    props = _props(annotation)
    if rect is None:
        return
    if props.get("mode") == "draw":
        asset = _asset_path(assets_dir, props.get("ref"))
        if asset is not None:
            page.insert_image(rect, filename=str(asset), keep_proportion=False, overlay=True)
        return
    text = str(props.get("text", ""))
    if text:
        font_file = _signature_font_file(props.get("fontFamily"))
        font_name = _font_name(props.get("fontFamily"), False, False)
        options: dict[str, Any] = {
            # Script fonts have a taller ascender than the built-in PDF fonts;
            # leave room inside the editor's saved bounding rectangle so a
            # valid signature is never silently dropped for not fitting.
            "fontsize": _signature_font_size(rect, text, font_file, font_name),
            "color": _color(props.get("color")),
            "overlay": True,
        }
        if font_file:
            options["fontname"] = f"paperjet-{font_file.stem.lower()}"
            options["fontfile"] = str(font_file)
        else:
            options["fontname"] = font_name
        page.insert_textbox(rect, text, **options)


def render_highlight(page: pymupdf.Page, annotation: Annotation, _assets_dir: Path) -> None:
    rect = _rect(annotation)
    if rect is None:
        return
    props = _props(annotation)
    page.draw_rect(
        rect,
        color=None,
        fill=_color(props.get("color"), (1.0, 0.92, 0.1)),
        fill_opacity=_opacity(props.get("opacity"), 0.3),
        overlay=True,
    )


def render_shape(page: pymupdf.Page, annotation: Annotation, _assets_dir: Path) -> None:
    rect = _rect(annotation)
    if rect is None:
        return
    props = _props(annotation)
    kind = str(props.get("kind", "rect"))
    stroke = _color(props.get("strokeColor"))
    fill_value = props.get("fillColor")
    fill = None if fill_value in (None, "", "transparent", "none") else _color(fill_value)
    width = max(0.1, float(props.get("strokeWidth", 2)))
    if kind == "ellipse":
        page.draw_oval(rect, color=stroke, fill=fill, width=width, overlay=True)
    elif kind in {"line", "arrow"}:
        start = props.get("start")
        end = props.get("end")
        if (
            isinstance(start, Sequence)
            and not isinstance(start, (str, bytes))
            and len(start) == 2
            and isinstance(end, Sequence)
            and not isinstance(end, (str, bytes))
            and len(end) == 2
        ):
            try:
                start_point = pymupdf.Point(
                    rect.x0 + float(start[0]) * rect.width,
                    rect.y0 + float(start[1]) * rect.height,
                )
                end_point = pymupdf.Point(
                    rect.x0 + float(end[0]) * rect.width,
                    rect.y0 + float(end[1]) * rect.height,
                )
            except (TypeError, ValueError):
                start_point, end_point = rect.tl, rect.br
        else:
            start_point, end_point = rect.tl, rect.br
        page.draw_line(start_point, end_point, color=stroke, width=width, overlay=True)
        if kind == "arrow":
            angle = math.atan2(end_point.y - start_point.y, end_point.x - start_point.x)
            length = min(
                12.0,
                max(
                    5.0, math.hypot(end_point.x - start_point.x, end_point.y - start_point.y) * 0.2
                ),
            )
            left = pymupdf.Point(
                end_point.x - length * math.cos(angle - math.pi / 6),
                end_point.y - length * math.sin(angle - math.pi / 6),
            )
            right = pymupdf.Point(
                end_point.x - length * math.cos(angle + math.pi / 6),
                end_point.y - length * math.sin(angle + math.pi / 6),
            )
            page.draw_polyline([left, end_point, right], color=stroke, width=width, overlay=True)
    else:
        page.draw_rect(rect, color=stroke, fill=fill, width=width, overlay=True)


HANDLERS: dict[str, Handler] = {
    "text": render_text,
    "draw": render_draw,
    "signature": render_signature,
    "image": render_image,
    "highlight": render_highlight,
    "shape": render_shape,
}


def export_annotations(
    pdf_path: Path,
    annotations: Sequence[Annotation],
    assets_dir: Path,
) -> bytes:
    """Return a flattened PDF while preserving the source page rotations."""
    with pymupdf.open(pdf_path) as document:
        rotations = [page.rotation for page in document]
        try:
            for page in document:
                if page.rotation:
                    page.set_rotation(0)
            page_annotations: dict[int, list[Annotation]] = {}
            for annotation in annotations:
                try:
                    page_number = int(annotation.get("page", -1))
                except (TypeError, ValueError):
                    logger.warning("Skipping annotation with invalid page: %r", annotation)
                    continue
                if 0 <= page_number < len(document):
                    page_annotations.setdefault(page_number, []).append(annotation)
                else:
                    logger.warning("Skipping annotation outside document pages: %r", annotation)

            for page_number, page in enumerate(document):
                ordered = sorted(
                    page_annotations.get(page_number, []),
                    key=lambda item: int(item.get("z", 0)),
                )
                for annotation in ordered:
                    annotation_type = annotation.get("type")
                    handler = HANDLERS.get(str(annotation_type))
                    if handler is None:
                        logger.warning("Skipping unsupported annotation type %r", annotation_type)
                        continue
                    try:
                        handler(page, annotation, assets_dir)
                    except Exception:
                        logger.exception("Skipping malformed %s annotation", annotation_type)
        finally:
            for page, rotation in zip(document, rotations, strict=True):
                if page.rotation != rotation:
                    page.set_rotation(rotation)
        return document.tobytes(garbage=4, deflate=True)