"""Validate embedded PDFs and render their pages inside the request encoder."""

from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from PIL import Image

import base64
import binascii
import math
import re

from .embedded import MAX_IMAGE_BYTES, MAX_IMAGES
from pydantic import BaseModel, ConfigDict, StrictStr, model_validator


class ClairDocument(BaseModel):
    model_config = ConfigDict(extra="forbid", frozen=True)

    content_type: StrictStr
    base64: StrictStr

    @model_validator(mode="before")
    @classmethod
    def parse_document(cls, value: object) -> dict[str, str]:
        if isinstance(value, str):
            match = re.fullmatch(
                r"data:application/pdf;base64,([A-Za-z0-9+/]*={0,2})",
                value,
                re.IGNORECASE,
            )
            if match is None:
                raise ValueError("document must be an embedded PDF data URI")
            value = {"content_type": "application/pdf", "base64": match[1]}
        if type(value) is not dict or set(value) != {"content_type", "base64"}:
            raise ValueError("document object must contain content_type and base64")
        if value["content_type"] != "application/pdf" or not isinstance(
            value["base64"], str
        ):
            raise ValueError("document content type must be application/pdf")
        try:
            data = base64.b64decode(value["base64"], validate=True)
        except (binascii.Error, ValueError) as error:
            raise ValueError("document base64 is malformed") from error
        if not data.startswith(b"%PDF-") or len(data) > MAX_IMAGE_BYTES:
            raise ValueError("document must be a PDF within the decoded byte limit")
        return {
            "content_type": "application/pdf",
            "base64": base64.b64encode(data).decode("ascii"),
        }

    def render(self, available_pages: int = MAX_IMAGES) -> list[Image.Image]:
        import pypdfium2 as pdfium

        from .orientation import orient_document

        try:
            pdf = pdfium.PdfDocument(base64.b64decode(self.base64))
            try:
                if not 0 < len(pdf) <= available_pages:
                    raise ValueError(
                        f"PDF pages and images together must not exceed {MAX_IMAGES}"
                    )
                images = []
                for index in range(len(pdf)):
                    page = pdf[index]
                    try:
                        width, height = page.get_size()
                        if not (
                            math.isfinite(width * height) and width > 0 and height > 0
                        ):
                            raise ValueError("PDF page has invalid dimensions")
                        scale = min(2.0, math.sqrt(4_000_000 / (width * height)))
                        bitmap = page.render(scale=scale)
                        try:
                            images.append(
                                orient_document(bitmap.to_pil().convert("RGB"))
                            )
                        finally:
                            bitmap.close()
                    finally:
                        page.close()
                return images
            finally:
                pdf.close()
        except pdfium.PdfiumError as error:
            raise ValueError(
                "PDF cannot be opened or rendered; encrypted PDFs are unsupported"
            ) from error
