#!/usr/bin/env python
#
# Copyright 2010 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""JSON support for message types.

Public classes:
  MessageJSONEncoder: JSON encoder for message objects.

Public functions:
  encode_message: Encodes a message in to a JSON string.
  decode_message: Merge from a JSON string in to a message.
"""
import six

__author__ = 'rafek@google.com (Rafe Kaplan)'

import base64
import binascii
import logging

from . import message_types
from . import messages
from . import util

__all__ = [
    'ALTERNATIVE_CONTENT_TYPES',
    'CONTENT_TYPE',
    'MessageJSONEncoder',
    'encode_message',
    'decode_message',
    'ProtoJson',
]


def _load_json_module():
  """Try to load a valid json module.

  There are more than one json modules that might be installed.  They are
  mostly compatible with one another but some versions may be different.
  This function attempts to load various json modules in a preferred order.
  It does a basic check to guess if a loaded version of json is compatible.

  Returns:
    Compatible json module.

  Raises:
    ImportError if there are no json modules or the loaded json module is
      not compatible with ProtoRPC.
  """
  first_import_error = None
  for module_name in ['json',
                      'simplejson']:
    try:
      module = __import__(module_name, {}, {}, 'json')
      if not hasattr(module, 'JSONEncoder'):
        message = ('json library "%s" is not compatible with ProtoRPC' %
                   module_name)
        logging.warning(message)
        raise ImportError(message)
      else:
        return module
    except ImportError as err:
      if not first_import_error:
        first_import_error = err

  logging.error('Must use valid json library (Python 2.6 json or simplejson)')
  raise first_import_error
json = _load_json_module()


# TODO: Rename this to MessageJsonEncoder.
class MessageJSONEncoder(json.JSONEncoder):
  """Message JSON encoder class.

  Extension of JSONEncoder that can build JSON from a message object.
  """

  def __init__(self, protojson_protocol=None, **kwargs):
    """Constructor.

    Args:
      protojson_protocol: ProtoJson instance.
    """
    super(MessageJSONEncoder, self).__init__(**kwargs)
    self.__protojson_protocol = protojson_protocol or ProtoJson.get_default()

  def default(self, value):
    """Return dictionary instance from a message object.

    Args:
    value: Value to get dictionary for.  If not encodable, will
      call superclasses default method.
    """
    if isinstance(value, messages.Enum):
      return str(value)

    if six.PY3 and isinstance(value, bytes):
      return value.decode('utf8')

    if isinstance(value, messages.Message):
      result = {}
      for field in value.all_fields():
        item = value.get_assigned_value(field.name)
        if item not in (None, [], ()):
          result[field.name] = self.__protojson_protocol.encode_field(
             field, item)
      # Handle unrecognized fields, so they're included when a message is
      # decoded then encoded.
      for unknown_key in value.all_unrecognized_fields():
        unrecognized_field, _ = value.get_unrecognized_field_info(unknown_key)
        result[unknown_key] = unrecognized_field
      return result
    else:
      return super(MessageJSONEncoder, self).default(value)


class ProtoJson(object):
  """ProtoRPC JSON implementation class.

  Implementation of JSON based protocol used for serializing and deserializing
  message objects.  Instances of remote.ProtocolConfig constructor or used with
  remote.Protocols.add_protocol.  See the remote.py module for more details.
  """

  CONTENT_TYPE = 'application/json'
  ALTERNATIVE_CONTENT_TYPES = [
      'application/x-javascript',
      'text/javascript',
      'text/x-javascript',
      'text/x-json',
      'text/json',
  ]

  def encode_field(self, field, value):
    """Encode a python field value to a JSON value.

    Args:
      field: A ProtoRPC field instance.
      value: A python value supported by field.

    Returns:
      A JSON serializable value appropriate for field.
    """
    if isinstance(field, messages.BytesField):
      if field.repeated:
        value = [base64.b64encode(byte) for byte in value]
      else:
        value = base64.b64encode(value)
    elif isinstance(field, message_types.DateTimeField):
      # DateTimeField stores its data as a RFC 3339 compliant string.
      if field.repeated:
        value = [i.isoformat() for i in value]
      else:
        value = value.isoformat()
    return value

  def encode_message(self, message):
    """Encode Message instance to JSON string.

    Args:
      Message instance to encode in to JSON string.

    Returns:
      String encoding of Message instance in protocol JSON format.

    Raises:
      messages.ValidationError if message is not initialized.
    """
    message.check_initialized()

    return json.dumps(message, cls=MessageJSONEncoder, protojson_protocol=self)

  def decode_message(self, message_type, encoded_message):
    """Merge JSON structure to Message instance.

    Args:
      message_type: Message to decode data to.
      encoded_message: JSON encoded version of message.

    Returns:
      Decoded instance of message_type.

    Raises:
      ValueError: If encoded_message is not valid JSON.
      messages.ValidationError if merged message is not initialized.
    """
    dictionary = json.loads(encoded_message) if encoded_message.strip() else {}
    message = self.__decode_dictionary(message_type, dictionary)
    message.check_initialized()
    return message

  def __find_variant(self, value):
    """Find the messages.Variant type that describes this value.

    Args:
      value: The value whose variant type is being determined.

    Returns:
      The messages.Variant value that best describes value's type, or None if
      it's a type we don't know how to handle.
    """
    if isinstance(value, bool):
      return messages.Variant.BOOL
    elif isinstance(value, six.integer_types):
      return messages.Variant.INT64
    elif isinstance(value, float):
      return messages.Variant.DOUBLE
    elif isinstance(value, six.string_types):
      return messages.Variant.STRING
    elif isinstance(value, (list, tuple)):
      # Find the most specific variant that covers all elements.
      variant_priority = [None, messages.Variant.INT64, messages.Variant.DOUBLE,
                          messages.Variant.STRING]
      chosen_priority = 0
      for v in value:
        variant = self.__find_variant(v)
        try:
          priority = variant_priority.index(variant)
        except IndexError:
          priority = -1
        if priority > chosen_priority:
          chosen_priority = priority
      return variant_priority[chosen_priority]
    # Unrecognized type.
    return None

  def __decode_dictionary(self, message_type, dictionary):
    """Merge dictionary in to message.

    Args:
      message: Message to merge dictionary in to.
      dictionary: Dictionary to extract information from.  Dictionary
        is as parsed from JSON.  Nested objects will also be dictionaries.
    """
    message = message_type()
    for key, value in six.iteritems(dictionary):
      if value is None:
        try:
          message.reset(key)
        except AttributeError:
          pass  # This is an unrecognized field, skip it.
        continue

      try:
        field = message.field_by_name(key)
      except KeyError:
        # Save unknown values.
        variant = self.__find_variant(value)
        if variant:
          if key.isdigit():
            key = int(key)
          message.set_unrecognized_field(key, value, variant)
        else:
          logging.warning('No variant found for unrecognized field: %s', key)
        continue

      # Normalize values in to a list.
      if isinstance(value, list):
        if not value:
          continue
      else:
        value = [value]

      valid_value = []
      for item in value:
        valid_value.append(self.decode_field(field, item))

      if field.repeated:
        existing_value = getattr(message, field.name)
        setattr(message, field.name, valid_value)
      else:
        setattr(message, field.name, valid_value[-1])
    return message

  def decode_field(self, field, value):
    """Decode a JSON value to a python value.

    Args:
      field: A ProtoRPC field instance.
      value: A serialized JSON value.

    Return:
      A Python value compatible with field.
    """
    if isinstance(field, messages.EnumField):
      try:
        return field.type(value)
      except TypeError:
        raise messages.DecodeError('Invalid enum value "%s"' % (value or ''))

    elif isinstance(field, messages.BytesField):
      try:
        return base64.b64decode(value)
      except (binascii.Error, TypeError) as err:
        raise messages.DecodeError('Base64 decoding error: %s' % err)

    elif isinstance(field, message_types.DateTimeField):
      try:
        return util.decode_datetime(value)
      except ValueError as err:
        raise messages.DecodeError(err)

    elif (isinstance(field, messages.MessageField) and
          issubclass(field.type, messages.Message)):
      return self.__decode_dictionary(field.type, value)

    elif (isinstance(field, messages.FloatField) and
          isinstance(value, (six.integer_types, six.string_types))):
      try:
        return float(value)
      except:
        pass

    elif (isinstance(field, messages.IntegerField) and
          isinstance(value, six.string_types)):
      try:
        return int(value)
      except:
        pass

    return value

  @staticmethod
  def get_default():
    """Get default instanceof ProtoJson."""
    try:
      return ProtoJson.__default
    except AttributeError:
      ProtoJson.__default = ProtoJson()
      return ProtoJson.__default

  @staticmethod
  def set_default(protocol):
    """Set the default instance of ProtoJson.

    Args:
      protocol: A ProtoJson instance.
    """
    if not isinstance(protocol, ProtoJson):
      raise TypeError('Expected protocol of type ProtoJson')
    ProtoJson.__default = protocol

CONTENT_TYPE = ProtoJson.CONTENT_TYPE

ALTERNATIVE_CONTENT_TYPES = ProtoJson.ALTERNATIVE_CONTENT_TYPES

encode_message = ProtoJson.get_default().encode_message

decode_message = ProtoJson.get_default().decode_message
