from uuid import uuid4

from data.model import tag, _basequery, BlobDoesNotExist, db_transaction
from data.database import (Repository, Namespace, ImageStorage, Image, ImageStorageLocation,
                           ImageStoragePlacement)


def get_repo_blob_by_digest(namespace, repo_name, blob_digest):
  """ Find the content-addressable blob linked to the specified repository.
  """
  placements = list(ImageStoragePlacement
                    .select(ImageStoragePlacement, ImageStorage, ImageStorageLocation)
                    .join(ImageStorageLocation)
                    .switch(ImageStoragePlacement)
                    .join(ImageStorage)
                    .join(Image)
                    .join(Repository)
                    .join(Namespace)
                    .where(Repository.name == repo_name, Namespace.username == namespace,
                           ImageStorage.checksum == blob_digest))
  if not placements:
    raise BlobDoesNotExist('Blob does not exist with digest: {0}'.format(blob_digest))

  found = placements[0].storage
  found.locations = {placement.location.name for placement in placements}

  return found

def store_blob_record_and_temp_link(namespace, repo_name, blob_digest, location_name,
                                    link_expiration_s):
  """ Store a record of the blob and temporarily link it to the specified repository.
  """
  random_image_name = str(uuid4())
  with db_transaction:
    repo = _basequery.get_existing_repository(namespace, repo_name)

    try:
      storage = ImageStorage.get(checksum=blob_digest)
      location = ImageStorageLocation.get(name=location_name)
      ImageStoragePlacement.get(storage=storage, location=location)
    except ImageStorage.DoesNotExist:
      storage = ImageStorage.create(checksum=blob_digest)
    except ImageStoragePlacement.DoesNotExist:
      ImageStoragePlacement.create(storage=storage, location=location)

    # Create a temporary link into the repository, to be replaced by the v1 metadata later
    # and create a temporary tag to reference it
    image = Image.create(storage=storage, docker_image_id=random_image_name, repository=repo)
    tag.create_temporary_hidden_tag(repo, image, link_expiration_s)