"""Bounded, request-local reuse of unchanged complete image-feature batches."""

from __future__ import annotations

import copy
from collections import OrderedDict
from collections.abc import Callable
from dataclasses import dataclass
from typing import Any

import torch


def _signature(value: torch.Tensor) -> tuple[Any, ...]:
    return (
        id(value),
        value._version,
        tuple(value.shape),
        tuple(value.stride()),
        str(value.dtype),
        str(value.device),
    )


def _options(value: Any) -> Any:
    if isinstance(value, dict):
        return tuple((key, _options(item)) for key, item in sorted(value.items()))
    if isinstance(value, (list, tuple)):
        return tuple(_options(item) for item in value)
    if type(value) in (str, bool, int, float, type(None)):
        return value
    raise TypeError("Unsupported image-feature option")


def _output_bytes(value: Any) -> int:
    storages: dict[tuple[str, int], int] = {}

    def visit(item: Any) -> None:
        if isinstance(item, torch.Tensor):
            storage = item.untyped_storage()
            storages[(str(item.device), storage.data_ptr())] = storage.nbytes()
        elif isinstance(item, dict):
            for child in item.values():
                visit(child)
        elif isinstance(item, (list, tuple)):
            for child in item:
                visit(child)

    visit(value)
    return sum(storages.values())


@dataclass
class _ImageBatch:
    key: tuple[Any, ...]
    references: tuple[torch.Tensor, ...]
    signatures: tuple[tuple[Any, ...], ...]
    pixels: torch.Tensor
    grid: torch.Tensor


@dataclass
class _Features:
    output: Any
    references: tuple[torch.Tensor, ...]
    bytes: int


class VisionBatchCache:
    """Keep full-batch image features until the admitted request is drained."""

    def __init__(self, max_bytes: int = 256 * 2**20, max_entries: int = 8) -> None:
        if max_bytes < 0 or max_entries < 1:
            raise ValueError("Invalid image-feature cache bounds")
        self.max_bytes = max_bytes
        self.max_entries = max_entries
        self.active = False
        self.bytes = 0
        self.entries: OrderedDict[Any, _Features] = OrderedDict()
        self.current: _ImageBatch | None = None

    def begin(self) -> None:
        if self.active:
            raise RuntimeError("An image-feature request is already active")
        self.clear()
        self.active = True

    def clear(self) -> None:
        self.entries.clear()
        self.current = None
        self.bytes = 0
        self.active = False

    def prepare(
        self,
        mappings: list[dict[str, Any]],
        inputs: dict[str, torch.Tensor],
        visual_dtype: torch.dtype,
    ) -> None:
        self.current = None
        if (
            not self.active
            or "pixel_values" not in inputs
            or "pixel_values_videos" in inputs
        ):
            return
        references = []
        ordered = []
        try:
            for item in mappings:
                if item.get("format") != "processor_output":
                    return
                pixels, grid = item["pixel_values"], item["image_grid_thw"]
                if pixels.device.type != "cpu" or grid.device.type != "cpu":
                    return
                references.extend((pixels, grid))
                ordered.append(
                    (
                        item.get("clair_media_digest"),
                        _signature(pixels),
                        _signature(grid),
                        _options(grid.tolist()),
                    )
                )
            pixels, grid = inputs["pixel_values"], inputs["image_grid_thw"]
            layout = (
                tuple(pixels.shape),
                tuple(pixels.stride()),
                str(pixels.dtype),
                str(pixels.device),
                tuple(grid.shape),
                tuple(grid.stride()),
                str(grid.dtype),
                str(grid.device),
                str(visual_dtype),
            )
            self.current = _ImageBatch(
                (tuple(ordered), layout),
                tuple(references),
                tuple(_signature(value) for value in references),
                pixels,
                grid,
            )
        except (KeyError, AttributeError, RuntimeError, TypeError):
            self.current = None

    def features(
        self,
        original: Callable[..., Any],
        visual: Any,
        pixel_values: torch.Tensor,
        image_grid_thw: torch.Tensor | None,
        **kwargs: Any,
    ) -> Any:
        current = self.current
        eligible = (
            self.active
            and current is not None
            and not visual.training
            and not torch.is_grad_enabled()
            and image_grid_thw is not None
            and pixel_values is current.pixels
            and image_grid_thw is current.grid
        )
        if eligible:
            try:
                eligible = current.signatures == tuple(
                    _signature(value) for value in current.references
                )
                options = _options(kwargs)
                autocast = (
                    torch.is_autocast_enabled("cpu"),
                    torch.is_autocast_enabled("cuda"),
                    str(torch.get_autocast_dtype("cpu")),
                    str(torch.get_autocast_dtype("cuda")),
                )
            except (TypeError, RuntimeError):
                eligible = False
        if not eligible:
            return original(pixel_values, image_grid_thw, **kwargs)
        key = (current.key, options, autocast)
        if key in self.entries:
            self.entries.move_to_end(key)
            return copy.copy(self.entries[key].output)
        output = original(pixel_values, image_grid_thw, **kwargs)
        size = _output_bytes(output)
        if size > self.max_bytes:
            return output
        while self.entries and (
            len(self.entries) >= self.max_entries or self.bytes + size > self.max_bytes
        ):
            _, removed = self.entries.popitem(last=False)
            self.bytes -= removed.bytes
        # The mutable result shell is separate; its tensor values are read-only.
        self.entries[key] = _Features(copy.copy(output), current.references, size)
        self.bytes += size
        return output
