import inspect
import logging
import hashlib

from data.database import DerivedStorageForImage, TagManifest, Manifest, Image
from data.registry_model.registry_oci_model import oci_model
from data.registry_model.registry_pre_oci_model import pre_oci_model
from data.registry_model.datatypes import LegacyImage, Manifest as ManifestDataType


logger = logging.getLogger(__name__)


class SplitModel(object):
  def __init__(self, oci_model_proportion, oci_namespace_whitelist, v22_namespace_whitelist):
    self.v22_namespace_whitelist = set(v22_namespace_whitelist)

    self.oci_namespace_whitelist = set(oci_namespace_whitelist)
    self.oci_namespace_whitelist.update(v22_namespace_whitelist)

    self.oci_model_proportion = oci_model_proportion

  def supports_schema2(self, namespace_name):
    """ Returns whether the implementation of the data interface supports schema 2 format
        manifests. """
    return namespace_name in self.v22_namespace_whitelist

  def _namespace_from_kwargs(self, args_dict):
    if 'namespace_name' in args_dict:
      return args_dict['namespace_name']

    if 'repository_ref' in args_dict:
      return args_dict['repository_ref'].namespace_name

    if 'tag' in args_dict:
      return args_dict['tag'].repository.namespace_name

    if 'manifest' in args_dict:
      manifest = args_dict['manifest']
      if manifest._is_tag_manifest:
        return TagManifest.get(id=manifest._db_id).tag.repository.namespace_user.username
      else:
        return Manifest.get(id=manifest._db_id).repository.namespace_user.username

    if 'manifest_or_legacy_image' in args_dict:
      manifest_or_legacy_image = args_dict['manifest_or_legacy_image']
      if isinstance(manifest_or_legacy_image, LegacyImage):
        return Image.get(id=manifest_or_legacy_image._db_id).repository.namespace_user.username
      else:
        manifest = manifest_or_legacy_image
        if manifest._is_tag_manifest:
          return TagManifest.get(id=manifest._db_id).tag.repository.namespace_user.username
        else:
          return Manifest.get(id=manifest._db_id).repository.namespace_user.username

    if 'derived_image' in args_dict:
      return (DerivedStorageForImage
              .get(id=args_dict['derived_image']._db_id)
              .source_image
              .repository
              .namespace_user
              .username)

    if 'blob' in args_dict:
      return '' # Blob functions are shared, so no need to do anything.

    if 'blob_upload' in args_dict:
      return '' # Blob functions are shared, so no need to do anything.

    raise Exception('Unknown namespace for dict `%s`' % args_dict)

  def __getattr__(self, attr):
    def method(*args, **kwargs):
      argnames = inspect.getargspec(getattr(oci_model, attr))[0]
      if not argnames and isinstance(args[0], ManifestDataType):
        args_dict = dict(manifest=args[0])
      else:
        args_dict = {argnames[index + 1]: value for index, value in enumerate(args)}

      namespace_name = self._namespace_from_kwargs(args_dict)
      use_oci = namespace_name in self.oci_namespace_whitelist
      if not use_oci and self.oci_model_proportion:
        # Hash the namespace name and see if it falls into the proportion bucket.
        bucket = (int(hashlib.md5(namespace_name).hexdigest(), 16) % 100)
        if bucket <= int(self.oci_model_proportion * 100):
          logger.debug('Enabling OCI for namespace `%s` in proportional bucket',
                       namespace_name)
          use_oci = True

      if use_oci:
        logger.debug('Calling method `%s` under OCI data model for namespace `%s`',
                     attr, namespace_name)
        return getattr(oci_model, attr)(*args, **kwargs)
      else:
        return getattr(pre_oci_model, attr)(*args, **kwargs)

    return method