# Copyright 2008 Canonical Ltd.

# This file is part of lazr.restfulclient.
#
# lazr.restfulclient 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 3 of
# the License, or (at your option) any later version.
#
# lazr.restfulclient 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 lazr.restfulclient.  If not, see
# <http://www.gnu.org/licenses/>.

"""Common support for web service resources."""

__metaclass__ = type
__all__ = [
    "Collection",
    "CollectionWithKeyBasedLookup",
    "Entry",
    "NamedOperation",
    "Resource",
    "ServiceRoot",
]


from email.message import Message
from io import BytesIO
from json import dumps, loads

try:
    # Python 3.
    from urllib.parse import parse_qs, unquote, urlencode, urljoin, urlparse
except ImportError:
    from urlparse import urljoin, urlparse, parse_qs
    from urllib import unquote, urlencode

import sys

if sys.version_info[0] >= 3:
    text_type = str
    binary_type = bytes
else:
    text_type = unicode  # noqa: F821
    binary_type = str

from wadllib.application import Resource as WadlResource

from lazr.restfulclient import __version__
from lazr.restfulclient._browser import Browser, RestfulHttp
from lazr.restfulclient._json import DatetimeJSONEncoder
from lazr.restfulclient.errors import HTTPError
from lazr.uri import URI

missing = object()


class HeaderDictionary:
    """A dictionary that bridges httplib2's and wadllib's expectations.

    httplib2 expects all header dictionary access to give lowercase
    header names. wadllib expects to access the header exactly as it's
    specified in the WADL file, which means the official HTTP header name.

    This class transforms keys to lowercase before doing a lookup on
    the underlying dictionary. That way wadllib can pass in the
    official header name and httplib2 will get the lowercased name.
    """

    def __init__(self, wrapped_dictionary):
        self.wrapped_dictionary = wrapped_dictionary

    def get(self, key, default=None):
        """Retrieve a value, converting the key to lowercase."""
        return self.wrapped_dictionary.get(key.lower())

    def __getitem__(self, key):
        """Retrieve a value, converting the key to lowercase."""
        value = self.get(key, missing)
        if value is missing:
            raise KeyError(key)
        return value


class RestfulBase:
    """Base class for classes that know about lazr.restful services."""

    JSON_MEDIA_TYPE = "application/json"

    def _transform_resources_to_links(self, dictionary):
        new_dictionary = {}
        for key, value in dictionary.items():
            if isinstance(value, Resource):
                value = value.self_link
            new_dictionary[self._get_external_param_name(key)] = value
        return new_dictionary

    def _get_external_param_name(self, param_name):
        """Turn a lazr.restful name into something to be sent over HTTP.

        For resources this may involve sticking '_link' or
        '_collection_link' on the end of the parameter name. For
        arguments to named operations, the parameter name is returned
        as is.
        """
        return param_name


class Resource(RestfulBase):
    """Base class for lazr.restful HTTP resources."""

    def __init__(self, root, wadl_resource):
        """Initialize with respect to a wadllib Resource object."""
        if root is None:
            # This _is_ the root.
            root = self
        # These values need to be put directly into __dict__ to avoid
        # calling __setattr__, which would cause an infinite recursion.
        self.__dict__["_root"] = root
        self.__dict__["_wadl_resource"] = wadl_resource

    FIND_COLLECTIONS = object()
    FIND_ENTRIES = object()
    FIND_ATTRIBUTES = object()

    @property
    def lp_collections(self):
        """Name the collections this resource links to."""
        return self._get_parameter_names(self.FIND_COLLECTIONS)

    @property
    def lp_entries(self):
        """Name the entries this resource links to."""
        return self._get_parameter_names(self.FIND_ENTRIES)

    @property
    def lp_attributes(self):
        """Name this resource's scalar attributes."""
        return self._get_parameter_names(self.FIND_ATTRIBUTES)

    @property
    def lp_operations(self):
        """Name all of this resource's custom operations."""
        # This library distinguishes between named operations by the
        # value they give for ws.op, not by their WADL names or IDs.
        names = []
        for method in self._wadl_resource.method_iter:
            name = method.name.lower()
            if name == "get":
                params = method.request.params(["query", "plain"])
            elif name == "post":
                for media_type in [
                    "application/x-www-form-urlencoded",
                    "multipart/form-data",
                ]:
                    definition = method.request.get_representation_definition(
                        media_type
                    )
                    if definition is not None:
                        definition = definition.resolve_definition()
                        break
                params = definition.params(self._wadl_resource)
            for param in params:
                if param.name == "ws.op":
                    names.append(param.fixed_value)
                    break
        return names

    @property
    def __members__(self):
        """A hook into dir() that returns web service-derived members."""
        return self._get_parameter_names(
            self.FIND_COLLECTIONS, self.FIND_ENTRIES, self.FIND_ATTRIBUTES
        )

    __methods__ = lp_operations

    def _get_parameter_names(self, *kinds):
        """Retrieve some subset of the resource's parameters."""
        names = []
        for parameter in self._wadl_resource.parameters(self.JSON_MEDIA_TYPE):
            name = parameter.name
            link = parameter.link
            if name != "self_link" and link is not None and link.can_follow:
                # This is a link to a resource with a WADL
                # description.  Since this is a lazr.restful web
                # service, we know it's either an entry or a
                # collection, and that its name ends with '_link' or
                # '_collection_link', respectively.
                #
                # self_link is a special case. 'obj.self' will always
                # work, but it's not useful. 'obj.self_link' is
                # useful, so we advertise the scalar value instead.
                if name.endswith("_collection_link"):
                    # It's a link to a collection.
                    if self.FIND_COLLECTIONS in kinds:
                        names.append(name[:-16])
                else:
                    # It's a link to an entry.
                    if self.FIND_ENTRIES in kinds:
                        names.append(name[:-5])
            else:
                # There are three possibilities. This is not a link at
                # all, it's a link to a resource not described by
                # WADL, or it's the 'self_link'. Either way,
                # lazr.restfulclient should treat this parameter as a
                # scalar attribute.
                if self.FIND_ATTRIBUTES in kinds:
                    names.append(name)
        return names

    def lp_has_parameter(self, param_name):
        """Does this resource have a parameter with the given name?"""
        return self._get_external_param_name(param_name) is not None

    def lp_get_parameter(self, param_name):
        """Get the value of one of the resource's parameters.

        :return: A scalar value if the parameter is not a link. A new
                 Resource object, whose resource is bound to a
                 representation, if the parameter is a link.
        """
        self._ensure_representation()
        for suffix in ["_link", "_collection_link"]:
            param = self._wadl_resource.get_parameter(param_name + suffix)
            if param is not None:
                try:
                    param.get_value()
                except KeyError:
                    # The parameter could have been present, but isn't.
                    # Try the next parameter.
                    continue
                if param.get_value() is None:
                    # This parameter is a link to another object, but
                    # there's no other object. Return None rather than
                    # chasing down the nonexistent other object.
                    return None
                linked_resource = param.linked_resource
                return self._create_bound_resource(
                    self._root, linked_resource, param_name=param.name
                )
        param = self._wadl_resource.get_parameter(param_name)
        if param is None:
            raise KeyError("No such parameter: %s" % param_name)
        return param.get_value()

    def lp_get_named_operation(self, operation_name):
        """Get a custom operation with the given name.

        :return: A NamedOperation instance that can be called with
                 appropriate arguments to invoke the operation.
        """
        params = {"ws.op": operation_name}
        method = self._wadl_resource.get_method("get", query_params=params)
        if method is None:
            method = self._wadl_resource.get_method(
                "post", representation_params=params
            )
        if method is None:
            raise KeyError("No operation with name: %s" % operation_name)
        return NamedOperation(self._root, self, method)

    @classmethod
    def _create_bound_resource(
        cls,
        root,
        resource,
        representation=None,
        representation_media_type="application/json",
        representation_needs_processing=True,
        representation_definition=None,
        param_name=None,
    ):
        """Create a lazr.restful Resource subclass from a wadllib Resource.

        :param resource: The wadllib Resource to wrap.
        :param representation: A previously fetched representation of
            this resource, to be reused. If not provided, this method
            will act just like the Resource constructor.
        :param representation_media_type: The media type of any previously
            fetched representation.
        :param representation_needs_processing: Set to False if the
            'representation' parameter should be used as
            is.
        :param representation_definition: A wadllib
            RepresentationDefinition object describing the structure
            of this representation. Used in cases when the representation
            isn't the result of sending a standard GET to the resource.
        :param param_name: The name of the link that was followed to get
            to this resource.
        :return: An instance of the appropriate lazr.restful Resource
            subclass.
        """
        # We happen to know that all lazr.restful resource types are
        # defined in a single document. Turn the resource's type_url
        # into an anchor into that document: this is its resource
        # type. Then look up a client-side class that corresponds to
        # the resource type.
        type_url = resource.type_url
        resource_type = urlparse(type_url)[-1]
        default = Entry

        if type_url.endswith("-page") or (
            param_name is not None and param_name.endswith("_collection_link")
        ):
            default = Collection
        r_class = root.RESOURCE_TYPE_CLASSES.get(resource_type, default)
        if representation is not None:
            # We've been given a representation. Bind the resource
            # immediately.
            resource = resource.bind(
                representation,
                representation_media_type,
                representation_needs_processing,
                representation_definition=representation_definition,
            )
        else:
            # We'll fetch a representation and bind the resource when
            # necessary.
            pass
        return r_class(root, resource)

    def lp_refresh(self, new_url=None, etag=None):
        """Update this resource's representation."""
        if new_url is not None:
            self._wadl_resource._url = new_url
        headers = {}
        if etag is not None:
            headers["If-None-Match"] = etag
        representation = self._root._browser.get(
            self._wadl_resource, headers=headers
        )
        if representation == self._root._browser.NOT_MODIFIED:
            # The entry wasn't modified. No need to do anything.
            return
        # __setattr__ assumes we're setting an attribute of the resource,
        # so we manipulate __dict__ directly.
        self.__dict__["_wadl_resource"] = self._wadl_resource.bind(
            representation, self.JSON_MEDIA_TYPE
        )

    def __getattr__(self, attr):
        """Try to retrive a named operation or parameter of the given name."""
        try:
            return self.lp_get_named_operation(attr)
        except KeyError:
            pass
        try:
            return self.lp_get_parameter(attr)
        except KeyError:
            raise AttributeError(
                "%s object has no attribute '%s'" % (self, attr)
            )

    def lp_values_for(self, param_name):
        """Find the set of possible values for a parameter."""
        parameter = self._wadl_resource.get_parameter(
            param_name, self.JSON_MEDIA_TYPE
        )
        options = parameter.options
        if len(options) > 0:
            return [option.value for option in options]
        return None

    def _get_external_param_name(self, param_name):
        """What's this parameter's name in the underlying representation?"""
        for suffix in ["_link", "_collection_link", ""]:
            name = param_name + suffix
            if self._wadl_resource.get_parameter(name):
                return name
        return None

    def _ensure_representation(self):
        """Make sure this resource has a representation fetched."""
        if self._wadl_resource.representation is None:
            # Get a representation of the linked resource.
            representation = self._root._browser.get(self._wadl_resource)
            if isinstance(representation, binary_type):
                representation = representation.decode("utf-8")
            representation = loads(representation)

            # In rare cases, the resource type served by the
            # server conflicts with the type the client thought
            # this resource had. When this happens, the server
            # value takes precedence.
            #
            # XXX This should probably be moved into a hook method
            # defined by Entry, since it's not relevant to other
            # resource types.
            if isinstance(representation, dict):
                type_link = representation["resource_type_link"]
                if (
                    type_link is not None
                    and type_link != self._wadl_resource.type_url
                ):
                    resource_type = self._root._wadl.get_resource_type(
                        type_link
                    )
                    self._wadl_resource.tag = resource_type.tag
            self.__dict__["_wadl_resource"] = self._wadl_resource.bind(
                representation,
                self.JSON_MEDIA_TYPE,
                representation_needs_processing=False,
            )

    def __ne__(self, other):
        """Inequality operator."""
        return not self == other


class ScalarValue(Resource):
    """A resource representing a single scalar value."""

    @property
    def value(self):
        """Return the scalar value."""
        self._ensure_representation()
        return self._wadl_resource.representation


class HostedFile(Resource):
    """A resource representing a file managed by a lazr.restful service."""

    def open(self, mode="r", content_type=None, filename=None):
        """Open the file on the server for read or write access."""
        if mode in ("r", "w"):
            return HostedFileBuffer(self, mode, content_type, filename)
        else:
            raise ValueError("Invalid mode. Supported modes are: r, w")

    def delete(self):
        """Delete the file from the server."""
        self._root._browser.delete(self._wadl_resource.url)

    def _get_parameter_names(self, *kinds):
        """HostedFile objects define no web service parameters."""
        return []

    def __eq__(self, other):
        """Equality comparison.

        Two hosted files are the same if they have the same URL.

        There is no need to check the contents because the only way to
        retrieve or modify the hosted file contents is to open a
        filehandle, which goes direct to the server.
        """
        return (
            other is not None
            and self._wadl_resource.url == other._wadl_resource.url
        )


class ServiceRoot(Resource):
    """Entry point to the service. Subclass this for a service-specific client.

    :ivar credentials: The credentials instance used to access Launchpad.
    """

    # Custom subclasses of Resource to use when
    # instantiating resources of a certain WADL type.
    RESOURCE_TYPE_CLASSES = {
        "HostedFile": HostedFile,
        "ScalarValue": ScalarValue,
    }

    def __init__(
        self,
        authorizer,
        service_root,
        cache=None,
        timeout=None,
        proxy_info=None,
        version=None,
        base_client_name="",
        max_retries=Browser.MAX_RETRIES,
    ):
        """Root access to a lazr.restful API.

        :param credentials: The credentials used to access the service.
        :param service_root: The URL to the root of the web service.
        :type service_root: string
        """
        if version is not None:
            if service_root[-1] != "/":
                service_root += "/"
            service_root += str(version)
            if service_root[-1] != "/":
                service_root += "/"
        self._root_uri = URI(service_root)

        # Set up data necessary to calculate the User-Agent header.
        self._base_client_name = base_client_name

        # Get the WADL definition.
        self.credentials = authorizer
        self._browser = Browser(
            self,
            authorizer,
            cache,
            timeout,
            proxy_info,
            self._user_agent,
            max_retries,
        )
        self._wadl = self._browser.get_wadl_application(self._root_uri)

        # Get the root resource.
        root_resource = self._wadl.get_resource_by_path("")
        bound_root = root_resource.bind(
            self._browser.get(root_resource), "application/json"
        )
        super(ServiceRoot, self).__init__(None, bound_root)

    @property
    def _user_agent(self):
        """The value for the User-Agent header.

        This will be something like:
        launchpadlib 1.6.1, lazr.restfulclient 1.0.0; application=apport

        That is, a string describing lazr.restfulclient and an
        optional custom client built on top, and parameters containing
        any authorization-specific information that identifies the
        user agent (such as the application name).
        """
        base_portion = "lazr.restfulclient %s" % __version__
        if self._base_client_name != "":
            base_portion = self._base_client_name + " (" + base_portion + ")"

        message = Message()
        message["User-Agent"] = base_portion
        if self.credentials is not None:
            user_agent_params = self.credentials.user_agent_params
            for key in sorted(user_agent_params):
                value = user_agent_params[key]
                message.set_param(key, value, "User-Agent")
        return message["User-Agent"]

    def httpFactory(self, authorizer, cache, timeout, proxy_info):
        return RestfulHttp(authorizer, cache, timeout, proxy_info)

    def load(self, url):
        """Load a resource given its URL."""
        parsed = urlparse(url)
        if parsed.scheme == "":
            # This is a relative URL. Make it absolute by joining
            # it with the service root resource.
            if url[:1] == "/":
                url = url[1:]
            url = str(self._root_uri.append(url))
        document = self._browser.get(url)
        if isinstance(document, binary_type):
            document = document.decode("utf-8")
        try:
            representation = loads(document)
        except ValueError:
            raise ValueError("%s doesn't serve a JSON document." % url)
        type_link = representation.get("resource_type_link")
        if type_link is None:
            raise ValueError(
                "Couldn't determine the resource type of %s." % url
            )
        resource_type = self._root._wadl.get_resource_type(type_link)
        wadl_resource = WadlResource(self._root._wadl, url, resource_type.tag)
        return self._create_bound_resource(
            self._root,
            wadl_resource,
            representation,
            "application/json",
            representation_needs_processing=False,
        )


class NamedOperation(RestfulBase):
    """A class for a named operation to be invoked with GET or POST."""

    def __init__(self, root, resource, wadl_method):
        """Initialize with respect to a WADL Method object"""
        self.root = root
        self.resource = resource
        self.wadl_method = wadl_method

    def __call__(self, *args, **kwargs):
        """Invoke the method and process the result."""
        if len(args) > 0:
            raise TypeError("Method must be called with keyword args.")
        http_method = self.wadl_method.name
        args = self._transform_resources_to_links(kwargs)
        request = self.wadl_method.request

        if http_method in ("get", "head", "delete"):
            params = request.query_params
        else:
            definition = request.get_representation_definition(
                "multipart/form-data"
            )
            if definition is None:
                definition = request.get_representation_definition(
                    "application/x-www-form-urlencoded"
                )
            assert definition is not None, (
                "A POST named operation must define a multipart or "
                "form-urlencoded request representation."
            )
            params = definition.params(self.resource._wadl_resource)
        send_as_is_params = {
            param.name
            for param in params
            if param.type == "binary" or len(param.options) > 0
        }
        for key, value in args.items():
            # Certain parameter values should not be JSON-encoded:
            # binary parameters (because they can't be JSON-encoded)
            # and option values (because JSON-encoding them will screw
            # up wadllib's parameter validation). The option value thing
            # is a little hacky, but it's the best solution for now.
            if key not in send_as_is_params:
                args[key] = dumps(value, cls=DatetimeJSONEncoder)
        if http_method in ("get", "head", "delete"):
            url = self.wadl_method.build_request_url(**args)
            in_representation = ""
            extra_headers = {}
        else:
            url = self.wadl_method.build_request_url()
            (
                media_type,
                in_representation,
            ) = self.wadl_method.build_representation(**args)
            extra_headers = {"Content-type": media_type}
        # Pass uppercase method names to httplib2, as that is what it works
        # with. If you pass a lowercase method name to httplib then it doesn't
        # consider it to be a GET, PUT, etc., and so will do things like not
        # cache. Wadl Methods return their method lower cased, which is how it
        # is compared in this method, but httplib2 expects the opposite, hence
        # the .upper() call.
        response, content = self.root._browser._request(
            url,
            in_representation,
            http_method.upper(),
            extra_headers=extra_headers,
        )

        if response.status == 201:
            return self._handle_201_response(url, response, content)
        else:
            if http_method == "post":
                # The method call probably modified this resource in
                # an unknown way. If it moved to a new location, reload it or
                # else just refresh its representation.
                if response.status == 301:
                    url = response["location"]
                    response, content = self.root._browser._request(url)
                else:
                    self.resource.lp_refresh()
            return self._handle_200_response(url, response, content)

    def _handle_201_response(self, url, response, content):
        """Handle the creation of a new resource by fetching it."""
        wadl_response = self.wadl_method.response.bind(
            HeaderDictionary(response)
        )
        wadl_parameter = wadl_response.get_parameter("Location")
        wadl_resource = wadl_parameter.linked_resource
        # Fetch a representation of the new resource.
        response, content = self.root._browser._request(wadl_resource.url)
        # Return an instance of the appropriate lazr.restful
        # Resource subclass.
        return Resource._create_bound_resource(
            self.root, wadl_resource, content, response["content-type"]
        )

    def _handle_200_response(self, url, response, content):
        """Process the return value of an operation."""
        content_type = response["content-type"]
        # Process the returned content, assuming we know how.
        response_definition = self.wadl_method.response
        representation_definition = (
            response_definition.get_representation_definition(content_type)
        )

        if representation_definition is None:
            # The operation returned a document with nothing
            # special about it.
            if content_type == self.JSON_MEDIA_TYPE:
                if isinstance(content, binary_type):
                    content = content.decode("utf-8")
                return loads(content)
            # We don't know how to process the content.
            return content

        # The operation returned a representation of some
        # resource. Instantiate a Resource object for it.
        if isinstance(content, binary_type):
            content = content.decode("utf-8")

        document = loads(content)
        if document is None:
            # The operation returned a null value.
            return document
        if "self_link" in document and "resource_type_link" in document:
            # The operation returned an entry. Use the self_link and
            # resource_type_link of the entry representation to build
            # a Resource object of the appropriate type. That way this
            # object will support all of the right named operations.
            url = document["self_link"]
            resource_type = self.root._wadl.get_resource_type(
                document["resource_type_link"]
            )
            wadl_resource = WadlResource(
                self.root._wadl, url, resource_type.tag
            )
        else:
            # The operation returned a collection. It's probably an ad
            # hoc collection that doesn't correspond to any resource
            # type.  Instantiate it as a resource backed by the
            # representation type defined in the return value, instead
            # of a resource type tag.
            representation_definition = (
                representation_definition.resolve_definition()
            )
            wadl_resource = WadlResource(
                self.root._wadl, url, representation_definition.tag
            )

        return Resource._create_bound_resource(
            self.root,
            wadl_resource,
            document,
            content_type,
            representation_needs_processing=False,
            representation_definition=representation_definition,
        )

    def _get_external_param_name(self, param_name):
        """Named operation parameter names are sent as is."""
        return param_name


class Entry(Resource):
    """A class for an entry-type resource that can be updated with PATCH."""

    def __init__(self, root, wadl_resource):
        super(Entry, self).__init__(root, wadl_resource)
        # Initialize this here in a semi-magical way so as to stop a
        # particular infinite loop that would follow.  Setting
        # self._dirty_attributes would call __setattr__(), which would
        # turn around immediately and get self._dirty_attributes.  If
        # this latter was not in the instance dictionary, that would
        # end up calling __getattr__(), which would again reference
        # self._dirty_attributes.  This is where the infloop would
        # occur.  Poking this directly into self.__dict__ means that
        # the check for self._dirty_attributes won't call __getattr__(),
        # breaking the cycle.
        self.__dict__["_dirty_attributes"] = {}
        super(Entry, self).__init__(root, wadl_resource)

    def __repr__(self):
        """Return the WADL resource type and the URL to the resource."""
        return "<%s at %s>" % (
            URI(self.resource_type_link).fragment,
            self.self_link,
        )

    def lp_delete(self):
        """Delete the resource."""
        return self._root._browser.delete(URI(self.self_link))

    def __str__(self):
        """Return the URL to the resource."""
        return self.self_link

    def __getattr__(self, name):
        """Try to retrive a parameter of the given name."""
        if name != "_dirty_attributes":
            if name in self._dirty_attributes:
                return self._dirty_attributes[name]
        return super(Entry, self).__getattr__(name)

    def __setattr__(self, name, value):
        """Set the parameter of the given name."""
        if not self.lp_has_parameter(name):
            raise AttributeError(
                "'%s' object has no attribute '%s'"
                % (self.__class__.__name__, name)
            )
        self._dirty_attributes[name] = value

    def __eq__(self, other):
        """Equality operator.

        Two entries are the same if their self_link and http_etag
        attributes are the same, and if their dirty attribute dicts
        contain the same values.
        """
        return (
            other is not None
            and self.self_link == other.self_link
            and self.http_etag == other.http_etag
            and self._dirty_attributes == other._dirty_attributes
        )

    def lp_refresh(self, new_url=None):
        """Update this resource's representation."""
        etag = getattr(self, "http_etag", None)
        super(Entry, self).lp_refresh(new_url, etag)
        self._dirty_attributes.clear()

    def lp_save(self):
        """Save changes to the entry."""
        representation = self._transform_resources_to_links(
            self._dirty_attributes
        )

        # If the entry contains an ETag, set the If-Match header
        # to that value.
        headers = {}
        etag = getattr(self, "http_etag", None)
        if etag is not None:
            headers["If-Match"] = etag

        # PATCH the new representation to the 'self' link.  It's possible that
        # this will cause the object to be permanently moved.  Catch that
        # exception and refresh our representation.
        response, content = self._root._browser.patch(
            URI(self.self_link), representation, headers
        )
        if response.status == 301:
            self.lp_refresh(response["location"])
        self._dirty_attributes.clear()

        content_type = response["content-type"]
        if response.status == 209 and content_type == self.JSON_MEDIA_TYPE:
            # The server sent back a new representation of the object.
            # Use it in preference to the existing representation.
            if isinstance(content, binary_type):
                content = content.decode("utf-8")
            new_representation = loads(content)
            self._wadl_resource.representation = new_representation
            self._wadl_resource.media_type = content_type


class Collection(Resource):
    """A collection-type resource that supports pagination."""

    def __init__(self, root, wadl_resource):
        """Create a collection object."""
        super(Collection, self).__init__(root, wadl_resource)

    def __len__(self):
        """The number of items in the collection.

        :return: length of the collection
        :rtype: int
        """
        total_size = self.total_size
        if isinstance(total_size, int):
            # The size was a number present in the collection
            # representation.
            return total_size
        elif isinstance(total_size, ScalarValue):
            # The size was linked to from the collection representation,
            # not directly present.
            return total_size.value
        else:
            raise TypeError("collection size is not available")

    def __iter__(self):
        """Iterate over the items in the collection.

        :return: iterator
        :rtype: sequence of `Entry`
        """
        self._ensure_representation()
        current_page = self._wadl_resource.representation
        while True:
            for resource in self._convert_dicts_to_entries(
                current_page.get("entries", {})
            ):
                yield resource
            next_link = current_page.get("next_collection_link")
            if next_link is None:
                break
            next_get = self._root._browser.get(URI(next_link))
            if isinstance(next_get, binary_type):
                next_get = next_get.decode("utf-8")
            current_page = loads(next_get)

    def __getitem__(self, key):
        """Look up a slice, or a subordinate resource by index.

        To discourage situations where a lazr.restful client fetches
        all of an enormous list, all collection slices must have a
        definitive end point. For performance reasons, all collection
        slices must be indexed from the start of the list rather than
        the end.
        """
        if isinstance(key, slice):
            return self._get_slice(key)
        else:
            # Look up a single item by its position in the list.
            found_slice = self._get_slice(slice(key, key + 1))
            if len(found_slice) != 1:
                raise IndexError("list index out of range")
            return found_slice[0]

    def _get_slice(self, slice):
        """Retrieve a slice of a collection."""
        start = slice.start or 0
        stop = slice.stop

        if start < 0:
            raise ValueError(
                "Collection slices must have a nonnegative " "start point."
            )
        if stop < 0:
            raise ValueError(
                "Collection slices must have a definite, "
                "nonnegative end point."
            )

        existing_representation = self._wadl_resource.representation
        if existing_representation is not None and start < len(
            existing_representation["entries"]
        ):
            # An optimization: the first page of entries has already
            # been loaded. This can happen if this collection is the
            # return value of a named operation, or if the client did
            # something like check the length of the collection.
            #
            # Either way, we've already made an HTTP request and
            # gotten some entries back. The client has requested a
            # slice that includes some of the entries we already have.
            # In the best case, we can fulfil the slice immediately,
            # without making another HTTP request.
            #
            # Even if we can't fulfil the entire slice, we can get one
            # or more objects from the first page and then have fewer
            # objects to retrieve from the server later. This saves us
            # time and bandwidth, and it might let us save a whole
            # HTTP request.
            entry_page = existing_representation["entries"]

            first_page_size = len(entry_page)
            entry_dicts = entry_page[start:stop]
            page_url = existing_representation.get("next_collection_link")
        else:
            # No part of this collection has been loaded yet, or the
            # slice starts beyond the part that has been loaded. We'll
            # use our secret knowledge of lazr.restful to set a value for
            # the ws.start variable. That way we start reading entries
            # from the first one we want.
            first_page_size = None
            entry_dicts = []
            page_url = self._with_url_query_variable_set(
                self._wadl_resource.url, "ws.start", start
            )

        desired_size = stop - start
        more_needed = desired_size - len(entry_dicts)

        # Iterate over pages until we have the correct number of entries.
        while more_needed > 0 and page_url is not None:
            page_get = self._root._browser.get(page_url)
            if isinstance(page_get, binary_type):
                page_get = page_get.decode("utf-8")
            representation = loads(page_get)
            current_page_entries = representation["entries"]
            entry_dicts += current_page_entries[:more_needed]
            more_needed = desired_size - len(entry_dicts)

            page_url = representation.get("next_collection_link")
            if page_url is None:
                # We've gotten the entire collection; there are no
                # more entries.
                break
            if first_page_size is None:
                first_page_size = len(current_page_entries)
            if more_needed > 0 and more_needed < first_page_size:
                # An optimization: it's likely that we need less than
                # a full page of entries, because the number we need
                # is less than the size of the first page we got.
                # Instead of requesting a full-sized page, we'll
                # request only the number of entries we think we'll
                # need. If we're wrong, there's no problem; we'll just
                # keep looping.
                page_url = self._with_url_query_variable_set(
                    page_url, "ws.size", more_needed
                )

        if slice.step is not None:
            entry_dicts = entry_dicts[:: slice.step]

        # Convert entry_dicts into a list of Entry objects.
        return [
            resource
            for resource in self._convert_dicts_to_entries(entry_dicts)
        ]

    def _convert_dicts_to_entries(self, entries):
        """Convert dictionaries describing entries to Entry objects.

        The dictionaries come from the 'entries' field of the JSON
        dictionary you get when you GET a page of a collection. Each
        dictionary is the same as you'd get if you sent a GET request
        to the corresponding entry resource. So each of these
        dictionaries can be treated as a preprocessed representation
        of an entry resource, and turned into an Entry instance.

        :yield: A sequence of Entry instances.
        """
        for entry_dict in entries:
            resource_url = entry_dict["self_link"]
            resource_type_link = entry_dict["resource_type_link"]
            wadl_application = self._wadl_resource.application
            resource_type = wadl_application.get_resource_type(
                resource_type_link
            )
            resource = WadlResource(
                self._wadl_resource.application,
                resource_url,
                resource_type.tag,
            )
            yield Resource._create_bound_resource(
                self._root, resource, entry_dict, self.JSON_MEDIA_TYPE, False
            )

    def _with_url_query_variable_set(self, url, variable, new_value):
        """A helper method to set a query variable in a URL."""
        uri = URI(url)
        if uri.query is None:
            params = {}
        else:
            params = parse_qs(uri.query)
        params[variable] = str(new_value)
        uri.query = urlencode(params, True)
        return str(uri)


class CollectionWithKeyBasedLookup(Collection):
    """A collection-type resource that supports key-based lookup.

    This collection can be sliced, but any single index passed into
    __getitem__ will be treated as a custom lookup key.
    """

    def __getitem__(self, key):
        """Look up a slice, or a subordinate resource by unique ID."""
        if isinstance(key, slice):
            return super(CollectionWithKeyBasedLookup, self).__getitem__(key)

        try:
            url = self._get_url_from_id(key)
        except NotImplementedError:
            raise TypeError("unsubscriptable object")
        if url is None:
            raise KeyError(key)

        shim_resource = self(key)
        try:
            shim_resource._ensure_representation()
        except HTTPError as e:
            if e.response.status == 404:
                raise KeyError(key)
            else:
                raise
        return shim_resource

    def __call__(self, key):
        """Retrieve a member from this collection without looking it up."""

        try:
            url = self._get_url_from_id(key)
        except NotImplementedError:
            raise TypeError("unsubscriptable object")
        if url is None:
            raise ValueError(key)

        if self.collection_of is not None:
            # We know what kind of resource is at the other end of the
            # URL. There's no need to actually fetch that URL until
            # the user demands it. If the user is invoking a named
            # operation on this object rather than fetching its data,
            # this will save us one round trip.
            representation = None
            resource_type_link = urljoin(
                self._root._wadl.markup_url, "#" + self.collection_of
            )
        else:
            # We don't know what kind of resource this is. Either the
            # subclass wasn't programmed with this knowledge, or
            # there's simply no way to tell without going to the
            # server, because the collection contains more than one
            # kind of resource. The only way to know for sure is to
            # retrieve a representation of the resource and see how
            # the resource describes itself.
            try:
                url_get = self._root._browser.get(url)
                if isinstance(url_get, binary_type):
                    url_get = url_get.decode("utf-8")
                representation = loads(url_get)
            except HTTPError as error:
                # There's no resource corresponding to the given ID.
                if error.response.status == 404:
                    raise KeyError(key)
                raise
            # We know that every lazr.restful resource has a
            # 'resource_type_link' in its representation.
            resource_type_link = representation["resource_type_link"]

        resource = WadlResource(self._root._wadl, url, resource_type_link)
        return self._create_bound_resource(
            self._root,
            resource,
            representation=representation,
            representation_needs_processing=False,
        )

    # If provided, this should be a string designating the ID of a
    # resource_type from a specific service's WADL file.
    collection_of = None

    def _get_url_from_id(self, key):
        """Transform the unique ID of an object into its URL."""
        raise NotImplementedError()


class HostedFileBuffer(BytesIO):
    """The contents of a file hosted by a lazr.restful service."""

    def __init__(self, hosted_file, mode, content_type=None, filename=None):
        self.url = hosted_file._wadl_resource.url
        if mode == "r":
            if content_type is not None:
                raise ValueError(
                    "Files opened for read access can't "
                    "specify content_type."
                )
            if filename is not None:
                raise ValueError(
                    "Files opened for read access can't " "specify filename."
                )
            response, value = hosted_file._root._browser.get(
                self.url, return_response=True
            )
            content_type = response["content-type"]
            last_modified = response.get("last-modified")

            # The Content-Location header contains the URL of the file
            # hosted by the web service. We happen to know that the
            # final component of the URL is the name of the uploaded
            # file.
            content_location = response["content-location"]
            path = urlparse(content_location)[2]
            filename = unquote(path.split("/")[-1])
        elif mode == "w":
            value = b""
            if content_type is None:
                raise ValueError(
                    "Files opened for write access must "
                    "specify content_type."
                )
            if filename is None:
                raise ValueError(
                    "Files opened for write access must " "specify filename."
                )
            last_modified = None
        else:
            raise ValueError("Invalid mode. Supported modes are: r, w")

        self.hosted_file = hosted_file
        self.mode = mode
        self.content_type = content_type
        self.filename = filename
        self.last_modified = last_modified
        BytesIO.__init__(self, value)

    def close(self):
        if self.mode == "w":
            disposition = 'attachment; filename="%s"' % self.filename
            self.hosted_file._root._browser.put(
                self.url,
                self.getvalue(),
                self.content_type,
                {"Content-Disposition": disposition},
            )
        BytesIO.close(self)

    def write(self, b):
        BytesIO.write(self, b)
