"""

Part of the BlackStar filesystem (bsfs) module.
A copy of the license is provided with the project.
Author: Matthias Baumgartner, 2022
"""
# imports
import abc
import typing

# inner-module imports
from bsfs.utils import URI, typename
import bsfs.schema  as _schema

# exports
__all__: typing.Sequence[str] = (
    'TripleStoreBase',
    )


## code ##

class TripleStoreBase(abc.ABC):
    """
    """

    # storage's URI. None implies a temporary location.
    uri: typing.Optional[URI] = None

    def __init__(self, uri: typing.Optional[URI] = None):
        self.uri = uri

    def __hash__(self) -> int:
        uri = self.uri if self.uri is not None else id(self)
        return hash((type(self), uri))

    def __eq__(self, other) -> bool:
        return isinstance(other, type(self)) \
           and (( self.uri is not None \
           and    other.uri is not None \
           and    self.uri == other.uri ) \
            or  id(self) == id(other))

    def __repr__(self) -> str:
        return f'{typename(self)}(uri={self.uri})'

    def __str__(self) -> str:
        return f'{typename(self)}(uri={self.uri})'

    def is_persistent(self) -> bool:
        """Return True if data is stored persistently."""
        return self.uri is not None


    @classmethod
    @abc.abstractmethod
    def Open(cls, **kwargs: typing.Any) -> 'TripleStoreBase': # pylint: disable=invalid-name # capitalized classmethod
        """Return a TripleStoreBase instance connected to *uri*."""

    @abc.abstractmethod
    def commit(self):
        """Commit the current transaction."""

    @abc.abstractmethod
    def rollback(self):
        """Undo changes since the last commit."""

    @property
    @abc.abstractmethod
    def schema(self) -> _schema.Schema:
        """Return the store's local schema."""

    @schema.setter
    @abc.abstractmethod
    def schema(self, schema: _schema.Schema):
        """Migrate to new schema by adding or removing class definitions.

        Commits before and after the migration.

        Instances of removed classes will be deleted irreversably.
        Note that modifying an existing class is not directly supported.
        Also, it is generally discouraged, since changing definitions may
        lead to inconsistencies across multiple clients in a distributed
        setting. Instead, consider introducing a new class under its own
        uri. Such a migration would look as follows:

        1. Add new class definitions.
        2. Create instances of the new classes and copy relevant data.
        3. Remove the old definitions.

        To modify a class, i.e., re-use a previous uri with a new
        class definition, you would have to migrate via temporary
        class definitions, and thus repeat the above procedure two times.

        """

    @abc.abstractmethod
    def exists(
            self,
            node_type: _schema.Node,
            guids: typing.Iterable[URI],
            ):
        """
        """

    @abc.abstractmethod
    def create(
            self,
            node_type: _schema.Node,
            guids: typing.Iterable[URI],
            ):
        """Create *guid* nodes with type *subject*."""

    @abc.abstractmethod
    def set(
            self,
            node_type: _schema.Node, # FIXME: is the node_type even needed? Couldn't I infer from the predicate?
            guids: typing.Iterable[URI],
            predicate: _schema.Predicate,
            values: typing.Iterable[typing.Any],
            ):
        """
        """

## EOF ##