from abc import ABCMeta, abstractmethod
from collections import namedtuple

from six import add_metaclass


class Repository(namedtuple('Repository', ['id', 'name', 'namespace_name', 'description',
                                           'is_public', 'kind'])):
  """
  Repository represents a namespaced collection of tags.
  :type id: int
  :type name: string
  :type namespace_name: string
  :type description: string
  :type is_public: bool
  :type kind: string
  """


@add_metaclass(ABCMeta)
class DockerRegistryV1DataInterface(object):
  """
  Interface that represents all data store interactions required by a Docker Registry v1.
  """

  @abstractmethod
  def placement_locations_and_path_docker_v1(self, namespace_name, repo_name, image_id):
    """
    Returns all the placements for the image with the given V1 Docker ID, found under the given
    repository or None if no image was found.
    """
    pass

  @abstractmethod
  def docker_v1_metadata(self, namespace_name, repo_name, image_id):
    """
    Returns various pieces of metadata associated with an image with the given V1 Docker ID,
    including the checksum and its V1 JSON metadata.
    """
    pass

  @abstractmethod
  def update_docker_v1_metadata(self, namespace_name, repo_name, image_id, created_date_str,
                                comment, command, compat_json, parent_image_id=None):
    """
    Updates various pieces of V1 metadata associated with a particular image.
    """
    pass

  @abstractmethod
  def storage_exists(self, namespace_name, repo_name, image_id):
    """
    Returns whether storage already exists for the image with the V1 Docker ID under the given
    repository.
    """
    pass

  @abstractmethod
  def store_docker_v1_checksums(self, namespace_name, repo_name, image_id, checksum,
                                content_checksum):
    """
    Stores the various V1 checksums for the image with the V1 Docker ID.
    """
    pass

  @abstractmethod
  def is_image_uploading(self, namespace_name, repo_name, image_id):
    """
    Returns whether the image with the V1 Docker ID is currently marked as uploading.
    """
    pass

  @abstractmethod
  def update_image_uploading(self, namespace_name, repo_name, image_id, is_uploading):
    """
    Marks the image with the V1 Docker ID with the given uploading status.
    """
    pass

  @abstractmethod
  def update_image_sizes(self, namespace_name, repo_name, image_id, size, uncompressed_size):
    """
    Updates the sizing information for the image with the given V1 Docker ID.
    """
    pass

  @abstractmethod
  def get_image_size(self, namespace_name, repo_name, image_id):
    """
    Returns the wire size of the image with the given Docker V1 ID.
    """
    pass

  @abstractmethod
  def create_bittorrent_pieces(self, namespace_name, repo_name, image_id, pieces_bytes):
    """
    Saves the BitTorrent piece hashes for the image with the given Docker V1 ID.
    """
    pass

  @abstractmethod
  def image_ancestry(self, namespace_name, repo_name, image_id):
    """
    Returns a list containing the full ancestry of Docker V1 IDs, in order, for the image with the
    given Docker V1 ID.
    """
    pass

  @abstractmethod
  def repository_exists(self, namespace_name, repo_name):
    """
    Returns whether the repository with the given name and namespace exists.
    """
    pass

  @abstractmethod
  def create_or_link_image(self, username, namespace_name, repo_name, image_id, storage_location):
    """
    Adds the given image to the given repository, by either linking to an existing image visible to
    the user with the given username, or creating a new one if no existing image matches.
    """
    pass

  @abstractmethod
  def create_temp_hidden_tag(self, namespace_name, repo_name, image_id, expiration):
    """
    Creates a hidden tag under the matching namespace pointing to the image with the given V1 Docker
    ID.
    """
    pass

  @abstractmethod
  def list_tags(self, namespace_name, repo_name):
    """
    Returns all the tags defined in the repository with the given namespace and name.
    """
    pass

  @abstractmethod
  def create_or_update_tag(self, namespace_name, repo_name, image_id, tag_name):
    """
    Creates or updates a tag under the matching repository to point to the image with the given
    Docker V1 ID.
    """
    pass

  @abstractmethod
  def find_image_id_by_tag(self, namespace_name, repo_name, tag_name):
    """
    Returns the Docker V1 image ID for the HEAD image for the tag with the given name under the
    matching repository, or None if none.
    """
    pass

  @abstractmethod
  def delete_tag(self, namespace_name, repo_name, tag_name):
    """
    Deletes the given tag from the given repository.
    """
    pass

  @abstractmethod
  def load_token(self, token):
    """
    Loads the data associated with the given (deprecated) access token, and, if
    found returns True.
    """
    pass

  @abstractmethod
  def verify_robot(self, username, token):
    """
    Returns True if the given robot username and token match an existing robot
    account.
    """
    pass

  @abstractmethod
  def change_user_password(self, user, new_password):
    """
    Changes the password associated with the given user.
    """
    pass

  @abstractmethod
  def get_repository(self, namespace_name, repo_name):
    """
    Returns the repository with the given name under the given namespace or None
    if none.
    """
    pass

  @abstractmethod
  def create_repository(self, namespace_name, repo_name, user=None):
    """
    Creates a new repository under the given namespace with the given name, for
    the given user.
    """
    pass

  @abstractmethod
  def repository_is_public(self, namespace_name, repo_name):
    """
    Returns whether the repository with the given name under the given namespace
    is public. If no matching repository was found, returns False.
    """
    pass

  @abstractmethod
  def validate_oauth_token(self, token):
    """ Returns whether the given OAuth token validates. """
    pass

  @abstractmethod
  def get_sorted_matching_repositories(self, search_term, filter_username=None, offset=0, limit=25):
    """
    Returns a sorted list of repositories matching the given search term.
    """
    pass