from __future__ import annotations

import time
from collections import OrderedDict
from typing import Literal


class ClaimableDedupe:
    def __init__(self, ttl_ms: int = 300_000, max_size: int = 2000):
        self.ttl_ms = ttl_ms
        self.max_size = max_size
        self._store: OrderedDict[str, float] = OrderedDict()

    def claim(self, key: str) -> Literal["claimed", "duplicate"]:
        self._evict_expired()
        if key in self._store:
            return "duplicate"
        self._store[key] = time.monotonic() * 1000
        while len(self._store) > self.max_size:
            self._store.popitem(last=False)
        return "claimed"

    def commit(self, key: str) -> None:
        pass

    def release(self, key: str) -> None:
        self._store.pop(key, None)

    def _evict_expired(self) -> None:
        now = time.monotonic() * 1000
        expired = [k for k, v in self._store.items() if now - v > self.ttl_ms]
        for k in expired:
            self._store.pop(k, None)

    def is_duplicate(self, key: str) -> bool:
        return self.claim(key) == "duplicate"

    def reset(self) -> None:
        self._store.clear()

    def __len__(self) -> int:
        return len(self._store)