from peewee import IntegrityError

from data import model, database
from data.model import DataModelException
from image import Blob, BlobUpload, ManifestJSON, RepositoryReference, Tag
from image.docker.v1 import DockerV1Metadata
from data.interfaces.common import repository_for_repo

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

def create_repository(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.
  """
  return model.repository.create_repository(namespace_name, repo_name, creating_user)


def repository_is_public(namespace_name, repo_name):
  """ Returns true if the repository with the given name under the given namespace has public
      visibility.
  """
  return model.repository.repository_is_public(namespace_name, repo_name)



def get_repository(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.
  """
  repo = model.repository.get_repository(namespace_name, repo_name)
  if repo is None:
    return None

  return repository_for_repo(repo)


def has_active_tag(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.
  """
  try:
    model.tag.get_active_tag(namespace_name, repo_name, tag_name)
    return True
  except database.RepositoryTag.DoesNotExist:
    return False


def get_manifest_by_tag(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.
  """
  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


def get_manifest_by_digest(namespace_name, repo_name, digest):
  """ Returns the manifest matching the given digest under the matching repository, if any,
      or None if none.
  """
  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


def delete_manifest_by_digest(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.
  """
  tags = model.tag.delete_manifest_by_digest(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,
      )
    )

  return [_tag_view(tag) for tag in tags]


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,
    parent_image_id=None, # TODO: make sure this isn't needed anywhere, as it is expensive to lookup
  )


def get_docker_v1_metadata_by_tag(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.
  """
  try:
    repo_image = model.tag.get_tag_image(namespace_name, repo_name, tag_name, include_storage=True)
    return _docker_v1_metadata(namespace_name, repo_name, repo_image)
  except DataModelException:
    return None



def get_docker_v1_metadata_by_image_id(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.
  """
  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}


def get_parents_docker_v1_metadata(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.
  """
  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]


def create_manifest_and_update_tag(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.
  """
  try:
    model.tag.associate_generated_tag_manifest(namespace_name, repo_name, tag_name,
                                               manifest_digest, manifest_bytes)
  except IntegrityError:
    # It's already there!
    pass


def synthesize_v1_image(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.
  """
  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)


def save_manifest(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.
  """
  model.tag.store_tag_manifest(namespace_name, repo_name, tag_name, leaf_layer_docker_id,
                               manifest_digest, manifest_bytes)


def repository_tags(namespace_name, repo_name, limit, offset):
  """ Returns the active tags under the repository with the given name and namespace. """
  tags_query = model.tag.list_repository_tags(namespace_name, repo_name)
  tags_query = tags_query.limit(limit).offset(offset)

  def _tag_view(tag):
    return Tag(
      name=tag.name,
      repository=RepositoryReference(
        id=tag.repository_id,
        name=repo_name,
        namespace_name=namespace_name,
      )
    )

  return [_tag_view(tag) for tag in tags_query]


def get_visible_repositories(username, limit, offset):
  """ Returns the repositories visible to the user with the given username, if any. """
  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]


def create_blob_upload(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.
  """
  try:
    model.blob.initiate_upload(namespace_name, repo_name, upload_uuid, location_name,
                               storage_metadata)
    return True
  except database.Repository.DoesNotExist:
    return False


def blob_upload_by_uuid(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.
  """
  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,
  )


def update_blob_upload(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
  """
  # 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()


def delete_blob_upload(namespace_name, repo_name, uuid):
  """ Deletes the blob upload with the given uuid under the matching repository. If none, does
      nothing.
  """
  try:
    found = model.blob.get_blob_upload(namespace_name, repo_name, uuid)
  except model.InvalidBlobUpload:
    return

  found.delete_instance()


def create_blob_and_temp_tag(namespace_name, repo_name, blob_digest, blob_upload, expiration_sec):
  """ Crates a blob and links a temporary tag with the specified expiration to it under the
      matching repository.
  """
  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],
  )


def lookup_blobs_by_digest(namespace_name, repo_name, digests):
  """ Returns all the blobs with matching digests found under the matching repository. If the
      repository doesn't exist, returns {}.
  """
  repo = model.repository.get_repository(namespace_name, repo_name)
  if repo is None:
    return {}

  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.
    )

  query = model.storage.lookup_repo_storages_by_content_checksum(repo, digests)
  return {storage.content_checksum: _blob_view(storage) for storage in query}


def get_blob_by_digest(namespace_name, repo_name, digest):
  """ Returns the blob with the given digest under the matching repository or None if none. """
  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


def save_bittorrent_pieces(blob, piece_size, piece_bytes):
  """ Saves the BitTorrent piece hashes for the given blob. """
  blob_record = model.storage.get_storage_by_uuid(blob.uuid)
  model.storage.save_torrent_info(blob_record, piece_size, piece_bytes)


def get_blob_path(blob):
  # Once everything is moved over, this could be in util.registry and not even
  # touch the database.
  blob_record = model.storage.get_storage_by_uuid(blob.uuid)
  return model.storage.get_layer_path(blob_record)