import json

from collections import defaultdict

from app import storage as store
from endpoints.api import (resource, nickname, require_repo_read, RepositoryParamResource,
                           format_date, NotFound, path_param)
from data import model
from util.cache import cache_control_flask_restful


def image_view(image, image_map):
  extended_props = image
  if image.storage and image.storage.id:
    extended_props = image.storage

  command = extended_props.command

  def docker_id(aid):
    if not aid:
      return ''

    return image_map[aid]

  # Calculate the ancestors string, with the DBID's replaced with the docker IDs.
  ancestors = [docker_id(a) for a in image.ancestors.split('/')]
  ancestors_string = '/'.join(ancestors)

  return {
    'id': image.docker_image_id,
    'created': format_date(extended_props.created),
    'comment': extended_props.comment,
    'command': json.loads(command) if command else None,
    'size': extended_props.image_size,
    'locations': list(image.storage.locations),
    'uploading': image.storage.uploading,
    'ancestors': ancestors_string,
    'sort_index': len(image.ancestors)
  }


@resource('/v1/repository/<repopath:repository>/image/')
@path_param('repository', 'The full path of the repository. e.g. namespace/name')
class RepositoryImageList(RepositoryParamResource):
  """ Resource for listing repository images. """
  @require_repo_read
  @nickname('listRepositoryImages')
  def get(self, namespace, repository):
    """ List the images for the specified repository. """
    all_images = model.get_repository_images(namespace, repository)
    all_tags = model.list_repository_tags(namespace, repository)

    tags_by_image_id = defaultdict(list)
    for tag in all_tags:
      tags_by_image_id[tag.image.docker_image_id].append(tag.name)

    image_map = {}
    for image in all_images:
      image_map[str(image.id)] = image.docker_image_id

    def add_tags(image_json):
      image_json['tags'] = tags_by_image_id[image_json['id']]
      return image_json

    return {
      'images': [add_tags(image_view(image, image_map)) for image in all_images]
    }


@resource('/v1/repository/<repopath:repository>/image/<image_id>')
@path_param('repository', 'The full path of the repository. e.g. namespace/name')
@path_param('image_id', 'The Docker image ID')
class RepositoryImage(RepositoryParamResource):
  """ Resource for handling repository images. """
  @require_repo_read
  @nickname('getImage')
  def get(self, namespace, repository, image_id):
    """ Get the information available for the specified image. """
    image = model.get_repo_image(namespace, repository, image_id)
    if not image:
      raise NotFound()

    # Lookup all the ancestor images for the image.
    image_map = {}
    for current_image in model.get_parent_images(namespace, repository, image):
      image_map[str(current_image.id)] = image.docker_image_id

    return image_view(image, image_map)


@resource('/v1/repository/<repopath:repository>/image/<image_id>/changes')
@path_param('repository', 'The full path of the repository. e.g. namespace/name')
@path_param('image_id', 'The Docker image ID')
class RepositoryImageChanges(RepositoryParamResource):
  """ Resource for handling repository image change lists. """

  @cache_control_flask_restful(max_age=60*60)  # Cache for one hour
  @require_repo_read
  @nickname('getImageChanges')
  def get(self, namespace, repository, image_id):
    """ Get the list of changes for the specified image. """
    image = model.get_repo_image(namespace, repository, image_id)

    if not image:
      raise NotFound()

    diffs_path = store.image_file_diffs_path(image.storage.uuid)

    try:
      response_json = json.loads(store.get_content(image.storage.locations, diffs_path))
      return response_json
    except IOError:
      raise NotFound()