
#
# spyne - Copyright (C) Spyne contributors.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
#

"""The ``spyne.protocol.json`` package contains the Json-related protocols.
Currently, only :class:`spyne.protocol.json.JsonDocument` is supported.

Initially released in 2.8.0-rc.

Missing Types
=============

The JSON standard does not define every type that Spyne supports. These include
Date/Time types as well as arbitrary-length integers and arbitrary-precision
decimals. Integers are parsed to ``int``\s or ``long``\s seamlessly but
``Decimal``\s are only parsed correctly when they come off as strings.

While it's possible to e.g. (de)serialize floats to ``Decimal``\s by adding
hooks to ``parse_float`` [#]_ (and convert later as necessary), such
customizations apply to the whole incoming document which pretty much messes up
``AnyDict`` serialization and deserialization.

It also wasn't possible to work with ``object_pairs_hook`` as Spyne's parsing
is always "from outside to inside" whereas ``object_pairs_hook`` is passed
``dict``\s basically in any order "from inside to outside".

.. [#] http://docs.python.org/2/library/json.html#json.loads
"""



import logging
logger = logging.getLogger(__name__)

from itertools import chain
from spyne.util import six


try:
    import simplejson as json
    from simplejson.decoder import JSONDecodeError
except ImportError:
    import json
    JSONDecodeError = ValueError

from spyne.error import ValidationError
from spyne.error import ResourceNotFoundError

from spyne.model.binary import BINARY_ENCODING_BASE64
from spyne.model.primitive import Date
from spyne.model.primitive import Time
from spyne.model.primitive import DateTime
from spyne.model.primitive import Double
from spyne.model.primitive import Integer
from spyne.model.primitive import Boolean
from spyne.model.fault import Fault
from spyne.protocol.dictdoc import HierDictDocument


# TODO: use this as default
class JsonEncoder(json.JSONEncoder):
    def default(self, o):
        try:
            return super(JsonEncoder, self).default(o)

        except TypeError as e:
            # if json can't serialize it, it's possibly a generator. If not,
            # additional hacks are welcome :)
            if logger.level == logging.DEBUG:
                logger.exception(e)
            return list(o)


NON_NUMBER_TYPES = tuple({list, dict, six.text_type, six.binary_type})


class JsonDocument(HierDictDocument):
    """An implementation of the json protocol that uses simplejson package when
    available, json package otherwise.

    :param ignore_wrappers: Does not serialize wrapper objects.
    :param complex_as: One of (list, dict). When list, the complex objects are
        serialized to a list of values instead of a dict of key/value pairs.
    """

    mime_type = 'application/json'
    text_based = True

    type = set(HierDictDocument.type)
    type.add('json')

    default_binary_encoding = BINARY_ENCODING_BASE64

    # flags used just for tests
    _decimal_as_string = True

    def __init__(self, app=None, validator=None, mime_type=None,
                        ignore_uncap=False,
                        # DictDocument specific
                        ignore_wrappers=True, complex_as=dict, ordered=False,
                        default_string_encoding=None, polymorphic=False,
                        **kwargs):

        super(JsonDocument, self).__init__(app, validator, mime_type, ignore_uncap,
                               ignore_wrappers, complex_as, ordered, polymorphic)

        # this is needed when we're overriding a regular instance attribute
        # with a property.
        self.__message = HierDictDocument.__getattribute__(self, 'message')

        self._from_unicode_handlers[Double] = self._ret_number
        self._from_unicode_handlers[Boolean] = self._ret_bool
        self._from_unicode_handlers[Integer] = self._ret_number

        self._to_unicode_handlers[Double] = self._ret
        self._to_unicode_handlers[Boolean] = self._ret
        self._to_unicode_handlers[Integer] = self._ret

        self.default_string_encoding = default_string_encoding
        self.kwargs = kwargs

    def _ret(self, cls, value):
        return value

    def _ret_number(self, cls, value):
        if isinstance(value, NON_NUMBER_TYPES):
            raise ValidationError(value)
        if value in (True, False):
            return int(value)
        return value

    def _ret_bool(self, cls, value):
        if value is None or value in (True, False):
            return value
        raise ValidationError(value)

    def validate(self, key, cls, val):
        super(JsonDocument, self).validate(key, cls, val)

        if issubclass(cls, (DateTime, Date, Time)) and not (
                                    isinstance(val, six.string_types) and
                                                 cls.validate_string(cls, val)):
            raise ValidationError(key, val)

    @property
    def message(self):
        return self.__message

    @message.setter
    def message(self, val):
        if val is self.RESPONSE and not ('cls' in self.kwargs):
            self.kwargs['cls'] = JsonEncoder
        self.__message = val

    def create_in_document(self, ctx, in_string_encoding=None):
        """Sets ``ctx.in_document``  using ``ctx.in_string``."""

        try:
            in_string = b''.join(ctx.in_string)
            if not isinstance(in_string, six.text_type):
                if in_string_encoding is None:
                    in_string_encoding = self.default_string_encoding
                if in_string_encoding is not None:
                    in_string = in_string.decode(in_string_encoding)
            ctx.in_document = json.loads(in_string, **self.kwargs)

        except JSONDecodeError as e:
            raise Fault('Client.JsonDecodeError', repr(e))

    def create_out_string(self, ctx, out_string_encoding='utf8'):
        """Sets ``ctx.out_string`` using ``ctx.out_document``."""
        if out_string_encoding is None:
            ctx.out_string = (json.dumps(o, **self.kwargs)
                                                      for o in ctx.out_document)
        else:
            ctx.out_string = (
                json.dumps(o, **self.kwargs).encode(out_string_encoding)
                                                      for o in ctx.out_document)


# Continuation of http://stackoverflow.com/a/24184379/1520211
class HybridHttpJsonDocument(JsonDocument):
    """This protocol lets you have the method name as the last fragment in the
    request url. Eg. instead of sending a HTTP POST request to

        http://api.endpoint/json/

    containing: ::

        {
            "method_name": {
                "arg1" : 42,
                "arg2" : "foo"
            }
        }

    you will have to send the request to

        http://api.endpoint/json/method_name

    containing: ::

        {
            "arg1" : 42,
            "arg2" : "foo"
        }

    Part of request data comes from HTTP and part of it comes from Json, hence
    the name.
    """

    def create_in_document(self, ctx, in_string_encoding=None):
        super(HybridHttpJsonDocument, self).create_in_document(ctx)

        url_fragment = ctx.transport.get_path().split('/')[-1]

        ctx.in_document = {url_fragment: ctx.in_document}



class JsonP(JsonDocument):
    """The JsonP protocol puts the reponse document inside a designated
    javascript function call. The input protocol is identical to the
    JsonDocument protocol.

    :param callback_name: The name of the function call that will wrapp all
        response documents.

    For other arguents, see :class:`spyne.protocol.json.JsonDocument`.
    """

    type = set(HierDictDocument.type)
    type.add('jsonp')

    def __init__(self, callback_name, *args, **kwargs):
        super(JsonP, self).__init__(*args, **kwargs)
        self.callback_name = callback_name

    def create_out_string(self, ctx, out_string_encoding='utf8'):
        super(JsonP, self).create_out_string(ctx,
                                        out_string_encoding=out_string_encoding)

        if out_string_encoding is None:
            ctx.out_string = chain(
                    (self.callback_name, '('),
                        ctx.out_string,
                    (');',),
                )
        else:
            ctx.out_string = chain(
                    [self.callback_name.encode(out_string_encoding), b'('],
                        ctx.out_string,
                    [b');'],
                )


class _SpyneJsonRpc1(JsonDocument):
    version = 1
    VERSION = 'ver'
    BODY = 'body'
    HEAD = 'head'
    FAULT = 'fault'

    def decompose_incoming_envelope(self, ctx, message=JsonDocument.REQUEST):
        indoc = ctx.in_document
        if not isinstance(indoc, dict):
            raise ValidationError(indoc, "Invalid Request")

        ver = indoc.get(self.VERSION)
        if ver is None:
            raise ValidationError(ver, "Unknown Version")

        body = indoc.get(self.BODY)
        err = indoc.get(self.FAULT)
        if body is None and err is None:
            raise ValidationError((body, err), "Request data not found")

        ctx.protocol.error = False
        if err is not None:
            ctx.in_body_doc = err
            ctx.protocol.error = True
        else:
            if not isinstance(body, dict):
                raise ValidationError(body, "Request body not found")
            if not len(body) == 1:
                raise ValidationError(body, "Need len(body) == 1")

            ctx.in_header_doc = indoc.get(self.HEAD)
            if not isinstance(ctx.in_header_doc, list):
                ctx.in_header_doc = [ctx.in_header_doc]

            (ctx.method_request_string,ctx.in_body_doc), = body.items()

    def deserialize(self, ctx, message):
        assert message in (self.REQUEST, self.RESPONSE)

        self.event_manager.fire_event('before_deserialize', ctx)

        if ctx.descriptor is None:
            raise ResourceNotFoundError(ctx.method_request_string)

        if ctx.protocol.error:
            ctx.in_object = None
            ctx.in_error = self._doc_to_object(ctx, Fault, ctx.in_body_doc)

        else:
            if message is self.REQUEST:
                header_class = ctx.descriptor.in_header
                body_class = ctx.descriptor.in_message

            elif message is self.RESPONSE:
                header_class = ctx.descriptor.out_header
                body_class = ctx.descriptor.out_message

            # decode header objects
            if (ctx.in_header_doc is not None and header_class is not None):
                headers = [None] * len(header_class)
                for i, (header_doc, head_class) in enumerate(
                                          zip(ctx.in_header_doc, header_class)):
                    if header_doc is not None and i < len(header_doc):
                        headers[i] = self._doc_to_object(ctx, head_class,
                                                                     header_doc)

                if len(headers) == 1:
                    ctx.in_header = headers[0]
                else:
                    ctx.in_header = headers
            # decode method arguments
            if ctx.in_body_doc is None:
                ctx.in_object = [None] * len(body_class._type_info)
            else:
                ctx.in_object = self._doc_to_object(ctx, body_class,
                                                                ctx.in_body_doc)

        self.event_manager.fire_event('after_deserialize', ctx)

    def serialize(self, ctx, message):
        assert message in (self.REQUEST, self.RESPONSE)

        self.event_manager.fire_event('before_serialize', ctx)

        ctx.out_document = {
            "ver": self.version,
        }
        if ctx.out_error is not None:
            ctx.out_document[self.FAULT] = Fault.to_dict(Fault,
                                                            ctx.out_error, self)

        else:
            if message is self.REQUEST:
                header_message_class = ctx.descriptor.in_header
                body_message_class = ctx.descriptor.in_message

            elif message is self.RESPONSE:
                header_message_class = ctx.descriptor.out_header
                body_message_class = ctx.descriptor.out_message

            # assign raw result to its wrapper, result_message
            out_type_info = body_message_class._type_info
            out_object = body_message_class()
            bm_attrs = self.get_cls_attrs(body_message_class)

            keys = iter(out_type_info)
            values = iter(ctx.out_object)
            while True:
                try:
                    k = next(keys)
                except StopIteration:
                    break
                try:
                    v = next(values)
                except StopIteration:
                    v = None

                out_object._safe_set(k, v, body_message_class, bm_attrs)

            ctx.out_document[self.BODY] = ctx.out_body_doc = \
                             self._object_to_doc(body_message_class, out_object)

            # header
            if ctx.out_header is not None and header_message_class is not None:
                if isinstance(ctx.out_header, (list, tuple)):
                    out_headers = ctx.out_header
                else:
                    out_headers = (ctx.out_header,)

                ctx.out_header_doc = out_header_doc = []

                for header_class, out_header in zip(header_message_class,
                                                                   out_headers):
                    out_header_doc.append(self._object_to_doc(header_class,
                                                                    out_header))

                if len(out_header_doc) > 1:
                    ctx.out_document[self.HEAD] = out_header_doc
                else:
                    ctx.out_document[self.HEAD] = out_header_doc[0]

        self.event_manager.fire_event('after_serialize', ctx)


_json_rpc_flavors = {
    'spyne': _SpyneJsonRpc1
}

def JsonRpc(flavour, *args, **kwargs):
    assert flavour in _json_rpc_flavors, "Unknown JsonRpc flavor. " \
                              "Accepted ones are: %r" % tuple(_json_rpc_flavors)

    return _json_rpc_flavors[flavour](*args, **kwargs)
