"""同一查询业务契约运行在内存与 SQLite 仓储上；可直接 mypy 检查。"""
from dataclasses import dataclass
import sqlite3
from typing import Protocol


@dataclass(frozen=True)
class Event:
    id: int
    path: str
    status: int


class EventRepository(Protocol):
    def add(self, event: Event) -> None: ...
    def page(self, after: int, limit: int) -> list[Event]: ...


class MemoryRepository:
    def __init__(self) -> None:
        self._events: dict[int, Event] = {}

    def add(self, event: Event) -> None:
        if event.id in self._events:
            raise ValueError("duplicate id")
        self._events[event.id] = event

    def page(self, after: int, limit: int) -> list[Event]:
        return [self._events[key] for key in sorted(self._events) if key > after][:limit]


class SQLiteRepository:
    def __init__(self) -> None:
        self.connection = sqlite3.connect(":memory:")
        self.connection.execute("CREATE TABLE events(id INTEGER PRIMARY KEY, path TEXT, status INTEGER)")

    def add(self, event: Event) -> None:
        try:
            with self.connection:
                self.connection.execute("INSERT INTO events VALUES(?,?,?)", (event.id, event.path, event.status))
        except sqlite3.IntegrityError as exc:
            raise ValueError("duplicate id") from exc

    def page(self, after: int, limit: int) -> list[Event]:
        rows = self.connection.execute("SELECT id,path,status FROM events WHERE id>? ORDER BY id LIMIT ?",
                                       (after, limit)).fetchall()
        return [Event(int(row[0]), str(row[1]), int(row[2])) for row in rows]

    def close(self) -> None:
        self.connection.close()


def query(repository: EventRepository, after: int, limit: int) -> list[Event]:
    # 业务边界负责合法性，仓储契约规定顺序、游标、重复键行为。
    if after < 0 or not 1 <= limit <= 100:
        raise ValueError("invalid page")
    return repository.page(after, limit)


def contract(repository: EventRepository) -> None:
    repository.add(Event(2, "/orders", 500))
    repository.add(Event(1, "/health", 200))
    assert query(repository, 0, 1) == [Event(1, "/health", 200)]
    assert query(repository, 1, 2) == [Event(2, "/orders", 500)]
    try:
        repository.add(Event(1, "/duplicate", 200))
    except ValueError as exc:
        assert str(exc) == "duplicate id"
    else:
        raise AssertionError("duplicate contract broken")
    assert len(query(repository, 0, 100)) == 2


def main() -> None:
    contract(MemoryRepository())
    database = SQLiteRepository()
    try:
        contract(database)
    finally:
        database.close()
    # object 表示未知类型；isinstance 收窄后才允许字符串方法。
    raw: object = " /orders "
    if not isinstance(raw, str):
        raise ValueError("path must be str")
    assert raw.strip() == "/orders"
    print("26 checks: memory/sqlite same contract; duplicate rejected; narrowing")


if __name__ == "__main__":
    main()
