from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured

from django.http import Http404, HttpResponse, HttpResponseRedirect, HttpResponseNotAllowed

from django.utils.feedgenerator import DefaultFeed, Atom1Feed, Rss201rev2Feed

from django.core.xheaders import populate_xheaders

from django.core.serializers import serialize

from django.shortcuts import render_to_response

from django.template import loader, RequestContext

class BaseResponder(object):

    def __init__(self, queryset):

        self.queryset = queryset

    def get_context_vars(self, context_vars):

        """

        Returns a dictionary of context vars, override if you need more.

        """

        return context_vars

    def list(self, request, paginate_by, allow_empty):

        """

        Renders a list of model objects to HttpResponse.

        """

        if paginate_by:

            paginator = QuerySetPaginator(self.queryset, paginate_by,

                                          allow_empty_first_page=allow_empty)

            page = request.GET.get('page', 1)

            try:

                page_number = int(page)

            except ValueError:

                if page == 'last':

                    page_number = paginator.num_pages

                else:

                    # Page is not 'last', nor can it be converted to an int.

                    raise Http404

            try:

                page_obj = paginator.page(page_number)

            except InvalidPage:

                raise Http404

            object_list = page_obj.object_list

        else:

            object_list = self.queryset

            paginator = None

            page_obj = None

            if not allow_empty and len(self.queryset) == 0:

                raise Http404

        return self.render_list(request, object_list, paginator, page_obj)

    def render_list(self, request, object_list, paginator, page_obj):

        """

        Renders the specified queryset. By the time it reaches this

        method the queryset has already been reduced to its appropriate

        paginated size, and successfully passed all "should this happen"

        logic (in the list method), and should be rendered with minimal

        fuss.

        """

        raise NotImplementedError(u"render_list() must be implemented by subclass.")

    def element(self, request, obj):

        raise NotImplementedError(u"element() must be implemented by subclass.")

    def create_success(self, request, new_obj, post_save_redirect):

        """

        Returns an HttpResonse, generally an HttpResponse redirect. This will

        be the final return value of the view and will only be called if the

        object was saved successfuly.

        """

        # Redirect to the new object: first by trying post_save_redirect,

        # then by obj.get_absolute_url; fail if neither works.

        if post_save_redirect:

            return HttpResponseRedirect(post_save_redirect % new_obj.__dict__)

        elif hasattr(new_obj, 'get_absolute_url'):

            return HttpResponseRedirect(new_obj.get_absolute_url())

        else:

            raise ImproperlyConfigured("No URL to redirect to from generic create view.")

    def update_success(self, request, obj, new_obj, post_save_redirect):

        """

        Returns an HttpResonse, generally an HttpResponse redirect. This will

        be the final return value of the view and will only be called if the

        object was saved successfuly.

        """

        # Redirect to the new object: first by trying post_save_redirect,

        # then by obj.get_absolute_url; fail if neither works.

        if post_save_redirect:

            return HttpResponseRedirect(post_save_redirect % new_obj.__dict__)

        elif hasattr(new_obj, 'get_absolute_url'):

            return HttpResponseRedirect(new_obj.get_absolute_url())

        else:

            raise ImproperlyConfigured("No URL to redirect to from generic create view.")

    def delete_success(self, post_save_redirect):

        return HttpResponseRedirect(post_save_redirect)

class HtmlResponder(BaseResponder):

    """

    HtmlResponder renders an object or a list of objects with the Django

    templating system.

    """

    def render_response(self, request, template, context_vars, mimetype=None):

        """

        Returns an HttpResponse for the given request, template object,

        dictionary of context variables, and optional mimetype.

        """

        context = RequestContext(request, context_vars)

        template = template.render(context)

        return HttpResponse(template, mimetype=mimetype)

    def get_template(self, opts, target='list'):

        """

        Returns a loaded template, the template_name depends of the model name.

        Examples::

            blog/post_list.html

            auth/user_detail.html

        """

        template_name = "%s/%s_%s.html" % (opts.app_label, opts.object_name.lower(), target)

        return loader.get_template(template_name)

    def render_list(self, request, object_list, paginator, page_obj):

        context_vars = self.get_context_vars({

            'object_list': object_list,

            'paginator': paginator,

            'page_obj': page_obj

        })

        opts = self.queryset.model._meta

        template = self.get_template(opts)

        return self.render_response(request, template, context_vars)

    def element(self, request, obj):

        """

        Renders single model objects to HttpResponse.

        """

        context_vars = self.get_context_vars({'object': obj})

        opts = self.queryset.model._meta

        template = self.get_template(opts, target='detail')

        response = self.render_response(request, template, context_vars)

        populate_xheaders(request, response, self.queryset.model, getattr(obj, opts.pk.name))

        return response

class FeedResponder(BaseResponder):

    feedgenerator_class = DefaultFeed

    def add_obj(self, feed, obj):

        """

        Wrapper for feed.add_item which compute title, link and description.

        """

        title = unicode(obj)

        if hasattr(obj, 'get_absolute_url'):

            link = obj.get_absolute_url()

        else:

            raise ImproperlyConfigured(\

                    "get_absolute_url function  is required for model %s." % \

                    self.queryset.model._meta.object_name.lower())

        description = ''

        feed.add_item(title, link, description)

        return feed

    def render_list(self, request, object_list, paginator, page_obj):

        feed = self.feedgenerator_class(title='', link='', description='')

        for obj in object_list:

            feed = self.add_obj(feed, obj)

        response = HttpResponse(mimetype=feed.mime_type)

        feed.write(response, 'utf-8')

        return response

    def element(self, request, obj):

        feed = self.feedgenerator_class(title='', link='', description='')

        feed = self.add_obj(feed, obj)

        response = HttpResponse(mimetype=feed.mime_type)

        feed.write(response, 'utf-8')

        return response

class AtomResponder(FeedResponder):

    feedgenerator_class = Atom1Feed

class RssResponder(FeedResponder):

    feedgenerator_class = Rss201rev2Feed

class SerializingResponder(BaseResponder):

    serializer = "YourSerializerHere"

    mimetype = "Serializer's MimeType"

    ensure_ascii = False

    def render_list(self, request, object_list, paginator, page_obj):

        if self.ensure_ascii:

            data = serialize(self.serializer, object_list, ensure_ascii=False)

        else:

            data = serialize(self.serializer, object_list)

        response = HttpResponse(data, mimetype=self.mimetype)

        return response

    def element(self, request, obj):

        """

        Renders single model objects to HttpResponse.

        """

        if self.ensure_ascii:

            data = serialize(self.serializer, [obj], ensure_ascii=False)

        else:

            data = serialize(self.serializer, [obj])

        response = HttpResponse(data, mimetype=self.mimetype)

        return response

class JsonResponder(SerializingResponder):

    serializer = 'json'

    mimetype = 'application/json'

    ensure_ascii = True

class XmlResponder(SerializingResponder):

    serializer = 'xml'

    mimetype = 'application/xml'

class YamlResponder(SerializingResponder):

    """

    The YamlResponder requires the PyYaml library to

    be installed for it to work properly.

        import yaml

    If the above import fails, so will the YamlResponder.

    """

    serializer = 'yaml'

    mimetype = 'text/yaml'

from responders import *