from collections import namedtuple

from namedlist import namedlist
from peewee import IntegrityError

from data import model, database
from data.model import DataModelException
from image.docker.v1 import DockerV1Metadata


_MEDIA_TYPE = "application/vnd.docker.distribution.manifest.v1+prettyjws"


class ManifestJSON(namedtuple('ManifestJSON', ['digest', 'json', 'media_type'])):
  """
  ManifestJSON represents a Manifest of any format.
  """


class Tag(namedtuple('Tag', ['name', 'repository'])):
  """
  Tag represents a user-facing alias for referencing a set of Manifests.
  """


class BlobUpload(namedlist('BlobUpload', ['uuid', 'byte_count', 'uncompressed_byte_count',
                                          'chunk_count', 'sha_state', 'location_name',
                                          'storage_metadata', 'piece_sha_state', 'piece_hashes',
                                          'repo_namespace_name', 'repo_name'])):
  """
  BlobUpload represents the current state of an Blob being uploaded.
  """


class Blob(namedtuple('Blob', ['uuid', 'digest', 'size', 'locations'])):
  """
  Blob represents an opaque binary blob saved to the storage system.
  """


class RepositoryReference(namedtuple('RepositoryReference', ['id', 'name', 'namespace_name'])):
  """
  RepositoryReference represents a reference to a Repository, without its full metadata.
  """


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


def _repository_for_repo(repo):
  """
  Returns a Repository object representing the repo data model instance given.
  """
  return Repository(
    id=repo.id,
    name=repo.name,
    namespace_name=repo.namespace_user.username,
    description=repo.description,
    is_public=model.repository.is_repository_public(repo)
  )


def _docker_v1_metadata(namespace_name, repo_name, repo_image):
  """
  Returns a DockerV1Metadata object for the given image under the repository with the given
  namespace and name. Note that the namespace and name are passed here as an optimization, and are
  *not checked* against the image.
  """
  return DockerV1Metadata(
    namespace_name=namespace_name,
    repo_name=repo_name,
    image_id=repo_image.docker_image_id,
    checksum=repo_image.v1_checksum,
    content_checksum=repo_image.storage.content_checksum,
    compat_json=repo_image.v1_json_metadata,
    created=repo_image.created,
    comment=repo_image.comment,
    command=repo_image.command,
    # TODO: make sure this isn't needed anywhere, as it is expensive to lookup
    parent_image_id=None,
  )


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

  @classmethod
  def create_repository(cls, namespace_name, repo_name, creating_user=None):
    """
    Creates a new repository under the specified namespace with the given name. The user supplied is
    the user creating the repository, if any.
    """
    raise NotImplementedError()

  @classmethod
  def repository_is_public(cls, namespace_name, repo_name):
    """
    Returns true if the repository with the given name under the given namespace has public
    visibility.
    """
    raise NotImplementedError()

  @classmethod
  def get_repository(cls, namespace_name, repo_name):
    """
    Returns a repository tuple for the repository with the given name under the given namespace.
    Returns None if no such repository was found.
    """
    raise NotImplementedError()

  @classmethod
  def has_active_tag(cls, namespace_name, repo_name, tag_name):
    """
    Returns whether there is an active tag for the tag with the given name under the matching
    repository, if any, or none if none.
    """
    raise NotImplementedError()

  @classmethod
  def get_manifest_by_tag(cls, namespace_name, repo_name, tag_name):
    """
    Returns the current manifest for the tag with the given name under the matching repository, if
    any, or None if none.
    """
    raise NotImplementedError()

  @classmethod
  def get_manifest_by_digest(cls, namespace_name, repo_name, digest):
    """
    Returns the manifest matching the given digest under the matching repository, if any, or None if
    none.
    """
    raise NotImplementedError()

  @classmethod
  def delete_manifest_by_digest(cls, namespace_name, repo_name, digest):
    """
    Deletes the manifest with the associated digest (if any) and returns all removed tags that
    pointed to that manifest. If the manifest was not found, returns an empty list.
    """
    raise NotImplementedError()

  @classmethod
  def get_docker_v1_metadata_by_tag(cls, namespace_name, repo_name, tag_name):
    """
    Returns the Docker V1 metadata associated with the tag with the given name under the matching
    repository, if any. If none, returns None.
    """
    raise NotImplementedError()

  @classmethod
  def get_docker_v1_metadata_by_image_id(cls, namespace_name, repo_name, docker_image_ids):
    """
    Returns a map of Docker V1 metadata for each given image ID, matched under the repository with
    the given namespace and name. Returns an empty map if the matching repository was not found.
    """
    raise NotImplementedError()

  @classmethod
  def get_parents_docker_v1_metadata(cls, namespace_name, repo_name, docker_image_id):
    """
    Returns an ordered list containing the Docker V1 metadata for each parent of the image with the
    given docker ID under the matching repository. Returns an empty list if the image was not found.
    """
    raise NotImplementedError()

  @classmethod
  def create_manifest_and_update_tag(cls, namespace_name, repo_name, tag_name, manifest_digest,
                                     manifest_bytes):
    """
    Creates a new manifest with the given digest and byte data, and assigns the tag with the given
    name under the matching repository to it.
    """
    raise NotImplementedError()

  @classmethod
  def synthesize_v1_image(cls, repository, storage, image_id, created, comment, command,
                          compat_json, parent_image_id):
    """
    Synthesizes a V1 image under the specified repository, pointing to the given storage and returns
    the V1 metadata for the synthesized image.
    """
    raise NotImplementedError()

  @classmethod
  def save_manifest(cls, namespace_name, repo_name, tag_name, leaf_layer_docker_id, manifest_digest,
                    manifest_bytes):
    """
    Saves a manifest pointing to the given leaf image, with the given manifest, under the matching
    repository as a tag with the given name.
    """
    raise NotImplementedError()

  @classmethod
  def repository_tags(cls, namespace_name, repo_name, limit, offset):
    """
    Returns the active tags under the repository with the given name and namespace.
    """
    raise NotImplementedError()

  @classmethod
  def get_visible_repositories(cls, username, limit, offset):
    """
    Returns the repositories visible to the user with the given username, if any.
    """
    raise NotImplementedError()

  @classmethod
  def create_blob_upload(cls, namespace_name, repo_name, upload_uuid, location_name,
                         storage_metadata):
    """
    Creates a blob upload under the matching repository with the given UUID and metadata.
    Returns whether the matching repository exists.
    """
    raise NotImplementedError()

  @classmethod
  def blob_upload_by_uuid(cls, namespace_name, repo_name, upload_uuid):
    """
    Searches for a blob upload with the given UUID under the given repository and returns it or None
    if none.
    """
    raise NotImplementedError()

  @classmethod
  def update_blob_upload(cls, blob_upload):
    """
    Saves any changes to the blob upload object given to the backing data store.
    Fields that can change:
      - uncompressed_byte_count
      - piece_hashes
      - piece_sha_state
      - storage_metadata
      - byte_count
      - chunk_count
      - sha_state
    """
    raise NotImplementedError()

  @classmethod
  def delete_blob_upload(cls, namespace_name, repo_name, uuid):
    """
    Deletes the blob upload with the given uuid under the matching repository. If none, does
    nothing.
    """
    raise NotImplementedError()

  @classmethod
  def create_blob_and_temp_tag(cls, namespace_name, repo_name, blob_digest, blob_upload,
                               expiration_sec):
    """
    Creates a blob and links a temporary tag with the specified expiration to it under the matching
    repository.
    """
    raise NotImplementedError()

  @classmethod
  def lookup_blobs_by_digest(cls, namespace_name, repo_name, digests):
    """
    Returns all the blobs with matching digests found under the matching repository. If the
    repository doesn't exist, returns {}.
    """
    raise NotImplementedError()

  @classmethod
  def get_blob_by_digest(cls, namespace_name, repo_name, digest):
    """
    Returns the blob with the given digest under the matching repository or None if none.
    """
    raise NotImplementedError()

  @classmethod
  def save_bittorrent_pieces(cls, blob, piece_size, piece_bytes):
    """
    Saves the BitTorrent piece hashes for the given blob.
    """
    raise NotImplementedError()

  @classmethod
  def get_blob_path(cls, blob):
    """
    Once everything is moved over, this could be in util.registry and not even touch the database.
    """
    raise NotImplementedError()


class PreOCIModel(DockerRegistryV2DataInterface):
  """
  PreOCIModel implements the data model for the v2 Docker Registry protocol using a database schema
  before it was changed to support the OCI specification.
  """
  @classmethod
  def create_repository(cls, namespace_name, repo_name, creating_user=None):
    return model.repository.create_repository(namespace_name, repo_name, creating_user)

  @classmethod
  def repository_is_public(cls, namespace_name, repo_name):
    return model.repository.repository_is_public(namespace_name, repo_name)

  @classmethod
  def get_repository(cls, namespace_name, repo_name):
    repo = model.repository.get_repository(namespace_name, repo_name)
    if repo is None:
      return None
    return _repository_for_repo(repo)

  @classmethod
  def has_active_tag(cls, namespace_name, repo_name, tag_name):
    try:
      model.tag.get_active_tag(namespace_name, repo_name, tag_name)
      return True
    except database.RepositoryTag.DoesNotExist:
      return False

  @classmethod
  def get_manifest_by_tag(cls, namespace_name, repo_name, tag_name):
    try:
      manifest = model.tag.load_tag_manifest(namespace_name, repo_name, tag_name)
      return ManifestJSON(digest=manifest.digest, json=manifest.json_data, media_type=_MEDIA_TYPE)
    except model.InvalidManifestException:
      return None

  @classmethod
  def get_manifest_by_digest(cls, namespace_name, repo_name, digest):
    try:
      manifest = model.tag.load_manifest_by_digest(namespace_name, repo_name, digest)
      return ManifestJSON(digest=digest, json=manifest.json_data, media_type=_MEDIA_TYPE)
    except model.InvalidManifestException:
      return None

  @classmethod
  def delete_manifest_by_digest(cls, namespace_name, repo_name, digest):
    def _tag_view(tag):
      return Tag(
        name=tag.name,
        repository=RepositoryReference(
          id=tag.repository_id,
          name=repo_name,
          namespace_name=namespace_name,
        )
      )

    tags = model.tag.delete_manifest_by_digest(namespace_name, repo_name, digest)
    return [_tag_view(tag) for tag in tags]

  @classmethod
  def get_docker_v1_metadata_by_tag(cls, namespace_name, repo_name, tag_name):
    try:
      repo_img = model.tag.get_tag_image(namespace_name, repo_name, tag_name, include_storage=True)
      return _docker_v1_metadata(namespace_name, repo_name, repo_img)
    except DataModelException:
      return None

  @classmethod
  def get_docker_v1_metadata_by_image_id(cls, namespace_name, repo_name, docker_image_ids):
    repo = model.repository.get_repository(namespace_name, repo_name)
    if repo is None:
      return {}

    images_query = model.image.lookup_repository_images(repo, docker_image_ids)
    return {image.docker_image_id: _docker_v1_metadata(namespace_name, repo_name, image)
            for image in images_query}

  @classmethod
  def get_parents_docker_v1_metadata(cls, namespace_name, repo_name, docker_image_id):
    repo_image = model.image.get_repo_image(namespace_name, repo_name, docker_image_id)
    if repo_image is None:
      return []

    parents = model.image.get_parent_images(namespace_name, repo_name, repo_image)
    return [_docker_v1_metadata(namespace_name, repo_name, image) for image in parents]

  @classmethod
  def create_manifest_and_update_tag(cls, namespace_name, repo_name, tag_name, manifest_digest,
                                     manifest_bytes):
    try:
      model.tag.associate_generated_tag_manifest(namespace_name, repo_name, tag_name,
                                                 manifest_digest, manifest_bytes)
    except IntegrityError:
      # It's already there!
      pass

  @classmethod
  def synthesize_v1_image(cls, repository, storage, image_id, created, comment, command,
                          compat_json, parent_image_id):
    repo = model.repository.get_repository(repository.namespace_name, repository.name)
    if repo is None:
      raise DataModelException('Unknown repository: %s/%s' % (repository.namespace_name,
                                                              repository.name))

    parent_image = None
    if parent_image_id is not None:
      parent_image = model.image.get_image(repo, parent_image_id)
      if parent_image is None:
        raise DataModelException('Unknown parent image: %s' % parent_image_id)

    storage_obj = model.storage.get_storage_by_uuid(storage.uuid)
    if storage_obj is None:
      raise DataModelException('Unknown storage: %s' % storage.uuid)

    repo_image = model.image.synthesize_v1_image(repo, storage_obj, image_id, created, comment,
                                                 command, compat_json, parent_image)
    return _docker_v1_metadata(repo.namespace_user.username, repo.name, repo_image)

  @classmethod
  def save_manifest(cls, namespace_name, repo_name, tag_name, leaf_layer_docker_id, manifest_digest,
                    manifest_bytes):
    model.tag.store_tag_manifest(namespace_name, repo_name, tag_name, leaf_layer_docker_id,
                                 manifest_digest, manifest_bytes)

  @classmethod
  def repository_tags(cls, namespace_name, repo_name, limit, offset):
    def _tag_view(tag):
      return Tag(
        name=tag.name,
        repository=RepositoryReference(
          id=tag.repository_id,
          name=repo_name,
          namespace_name=namespace_name,
        )
      )

    tags_query = model.tag.list_repository_tags(namespace_name, repo_name)
    tags_query = tags_query.limit(limit).offset(offset)
    return [_tag_view(tag) for tag in tags_query]

  @classmethod
  def get_visible_repositories(cls, username, limit, offset):
    query = model.repository.get_visible_repositories(username, include_public=(username is None))
    query = query.limit(limit).offset(offset)
    return [_repository_for_repo(repo) for repo in query]

  @classmethod
  def create_blob_upload(cls, namespace_name, repo_name, upload_uuid, location_name,
                         storage_metadata):
    try:
      model.blob.initiate_upload(namespace_name, repo_name, upload_uuid, location_name,
                                 storage_metadata)
      return True
    except database.Repository.DoesNotExist:
      return False

  @classmethod
  def blob_upload_by_uuid(cls, namespace_name, repo_name, upload_uuid):
    try:
      found = model.blob.get_blob_upload(namespace_name, repo_name, upload_uuid)
    except model.InvalidBlobUpload:
      return None

    return BlobUpload(
      repo_namespace_name=namespace_name,
      repo_name=repo_name,
      uuid=upload_uuid,
      byte_count=found.byte_count,
      uncompressed_byte_count=found.uncompressed_byte_count,
      chunk_count=found.chunk_count,
      sha_state=found.sha_state,
      piece_sha_state=found.piece_sha_state,
      piece_hashes=found.piece_hashes,
      location_name=found.location.name,
      storage_metadata=found.storage_metadata,
    )

  @classmethod
  def update_blob_upload(cls, blob_upload):
    # Lookup the blob upload object.
    try:
      blob_upload_record = model.blob.get_blob_upload(blob_upload.repo_namespace_name,
                                                      blob_upload.repo_name, blob_upload.uuid)
    except model.InvalidBlobUpload:
      return

    blob_upload_record.uncompressed_byte_count = blob_upload.uncompressed_byte_count
    blob_upload_record.piece_hashes = blob_upload.piece_hashes
    blob_upload_record.piece_sha_state = blob_upload.piece_sha_state
    blob_upload_record.storage_metadata = blob_upload.storage_metadata
    blob_upload_record.byte_count = blob_upload.byte_count
    blob_upload_record.chunk_count = blob_upload.chunk_count
    blob_upload_record.sha_state = blob_upload.sha_state
    blob_upload_record.save()

  @classmethod
  def delete_blob_upload(cls, namespace_name, repo_name, uuid):
    try:
      found = model.blob.get_blob_upload(namespace_name, repo_name, uuid)
      found.delete_instance()
    except model.InvalidBlobUpload:
      return

  @classmethod
  def create_blob_and_temp_tag(cls, namespace_name, repo_name, blob_digest, blob_upload,
                               expiration_sec):
    location_obj = model.storage.get_image_location_for_name(blob_upload.location_name)
    blob_record = model.blob.store_blob_record_and_temp_link(namespace_name, repo_name,
                                                             blob_digest,
                                                             location_obj.id,
                                                             blob_upload.byte_count,
                                                             expiration_sec,
                                                             blob_upload.uncompressed_byte_count)
    return Blob(
      uuid=blob_record.uuid,
      digest=blob_digest,
      size=blob_upload.byte_count,
      locations=[blob_upload.location_name],
    )

  @classmethod
  def lookup_blobs_by_digest(cls, namespace_name, repo_name, digests):
    def _blob_view(blob_record):
      return Blob(
        uuid=blob_record.uuid,
        digest=blob_record.content_checksum,
        size=blob_record.image_size,
        locations=None, # Note: Locations is None in this case.
      )

    repo = model.repository.get_repository(namespace_name, repo_name)
    if repo is None:
      return {}
    query = model.storage.lookup_repo_storages_by_content_checksum(repo, digests)
    return {storage.content_checksum: _blob_view(storage) for storage in query}

  @classmethod
  def get_blob_by_digest(cls, namespace_name, repo_name, digest):
    try:
      blob_record = model.blob.get_repo_blob_by_digest(namespace_name, repo_name, digest)
      return Blob(
        uuid=blob_record.uuid,
        digest=digest,
        size=blob_record.image_size,
        locations=blob_record.locations,
      )
    except model.BlobDoesNotExist:
      return None

  @classmethod
  def save_bittorrent_pieces(cls, blob, piece_size, piece_bytes):
    blob_record = model.storage.get_storage_by_uuid(blob.uuid)
    model.storage.save_torrent_info(blob_record, piece_size, piece_bytes)

  @classmethod
  def get_blob_path(cls, blob):
    blob_record = model.storage.get_storage_by_uuid(blob.uuid)
    return model.storage.get_layer_path(blob_record)