from __future__ import annotations

from typing import Any, Dict, List, Optional

from .persistence import PersistenceBackend


class PersistenceService:
    """Shared persistence service that owns the backend lifecycle."""

    def __init__(self, backend: PersistenceBackend):
        self._backend = backend

    @property
    def backend(self) -> PersistenceBackend:
        return self._backend

    async def initialize(self) -> None:
        await self._backend.initialize()

    def view(self, scope: str) -> "ScopedPersistenceView":
        return ScopedPersistenceView(self._backend, scope=scope)

    async def close(self) -> None:
        await self._backend.close()


class ScopedPersistenceView:
    """Thin scope-bound persistence view used by project runtimes."""

    def __init__(self, backend: PersistenceBackend, *, scope: str):
        self._backend = backend
        self.scope = scope

    @property
    def backend(self) -> PersistenceBackend:
        return self._backend

    async def load_nodes(
        self,
        collection_id: str,
        *,
        exclude_node_types: Optional[List[str]] = None,
    ) -> List[Dict[str, Any]]:
        return await self._backend.load_nodes(
            collection_id,
            self.scope,
            exclude_node_types=exclude_node_types,
        )

    async def save_node(self, collection_id: str, node) -> None:
        await self._backend.save_node(collection_id, self.scope, node)

    async def save_nodes_bulk(self, collection_id: str, nodes) -> None:
        await self._backend.save_nodes_bulk(collection_id, self.scope, nodes)

    async def delete_node(self, collection_id: str, node_id: str) -> None:
        await self._backend.delete_node(collection_id, self.scope, node_id)

    async def delete_nodes_bulk(self, collection_id: str, node_ids: List[str]) -> None:
        await self._backend.delete_nodes_bulk(collection_id, self.scope, node_ids)

    async def load_bindings(self, node_type: str) -> List[Dict[str, Any]]:
        return await self._backend.load_bindings(self.scope, node_type)

    async def save_binding(self, node_type: str, local_id: str, payload_dict: Dict[str, Any]) -> None:
        await self._backend.save_binding(self.scope, node_type, local_id, payload_dict)

    async def save_bindings_bulk(self, node_type: str, bindings: Dict[str, Optional[str]]) -> None:
        await self._backend.save_bindings_bulk(self.scope, node_type, bindings)

    async def delete_binding(self, node_type: str, local_id: str) -> None:
        await self._backend.delete_binding(self.scope, node_type, local_id)

    async def delete_bindings_bulk(self, node_type: str, local_ids: List[str]) -> None:
        await self._backend.delete_bindings_bulk(self.scope, node_type, local_ids)

    async def load_bind_data_id_overrides(self, node_type: str) -> Dict[str, Optional[str]]:
        return await self._backend.load_bind_data_id_overrides(node_type, self.scope)

    async def delete_scope_node_types(self, *, node_types: List[str]) -> None:
        await self._backend.delete_scope_node_types(scope=self.scope, node_types=node_types)

    async def close(self) -> None:
        return None