from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
from django.http import Http404, HttpResponse, HttpResponseRedirect, HttpResponseNotAllowed
from django.template import loader, RequestContext
from django.shortcuts import render_to_response
from django.core.xheaders import populate_xheaders
from django.core.serializers import serialize
from django.newforms.models import ModelFormMetaclass, ModelForm
from django.utils.feedgenerator import DefaultFeed, Atom1Feed, Rss201rev2Feed

try:
    from django.views.generic.base import BaseDetailView
except ImportError:
    from compatability import BaseDetailView

def django_authentication(request, **kwargs):
    return request.user.is_authenticated()


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'


class ModelView(BaseDetailView):
    """
    ModelView: a RESTful class-based view of your resources
    =======================================================
    
    Philosophy
    ----------
    
    The goal of this class is to provide a lightweight REST interface, I know
    that django-rest-interface exists but it's abandoned and it suffers from
    some defaults. Given my experience with it, I always need to rewrite large
    parts of the library in order to customize it to fits with my own needs.
    
    In order to avoid this with ModelView, the philosophy is to allow 
    dead-easy subclassing with granularity at each point.
    
    Note: I totally respect what had been done before and this class is 
    inspired from a lot of existing projects so many thanks to all authors.
    
    
    Goals
    -----
    
    Basically, it dispatches requests to the appropriated function given the
    HTTP verb and it allows you to specify a responder in order to avoid 
    duplication of code at the resource logic level.
    
    You can specify your own responders, and restrict to allowed HTTP methods.
    
    Secret goal: to be honest, I dream of resource oriented stuff in 
    Django's trunk for years now. A RESTful Django's (newforms-)admin could be
    awesome too in order to provide a built-in API!
        
    
    Example
    -------
    
    A quick example in order to demonstrate what is possible.
    
    models.py::
    
        class Post(models.Model):
            title = models.Charfield(max_length=200)
            slug = models.SlugField(max_length=200, prepopulate_from=('title',), unique=True)
            content = models.TextField()
        
    urls.py::
    
        blog = ModelView(Post.objects.filter(is_online=True), responders=(HtmlResponder, JsonResponder), methods=('GET',))
        blog_admin = ModelView(Post.objects.all(), methods=('GET', 'POST', 'PUT', 'DELETE'))
        urlpatterns = pattern('', 
            url(^blog/(?P<slug>[-\w]+)/(?P<format>(html|json))?/?$), blog, name='blog'),
            url(^blog/admin/(?P<object_pk>\d)/), blog_admin, name='blog_admin'),
        )
    
    Note: here we consider that you want a custom admin for your blog,
    otherwise Django's built-in admin is much more interesting, of course.
    
    
    TODO
    ----
    
        * Add tests and documentation
        * Create a collection of generic Responders
        * Handle receivers in order to use it as an API (for the moment,
          it assumes that you receive formencoded data), need more reflexion.
        * Handle privacy, need more reflexion
        * See what can be done with APP, it could be fun!
        * Ideas?
    
    """
    def __init__(self, queryset, slug_field='slug', post_save_redirect=None,
            paginate_by=None, allow_empty=True,
            responders=(HtmlResponder,), methods=('GET', 'POST', 'PUT', 'DELETE')):
        self.post_save_redirect = post_save_redirect
        self.paginate_by = paginate_by
        self.allow_empty = allow_empty
        self.responders = dict((responder.__name__, responder) for responder in responders)
        if isinstance(methods, tuple):
            self.methods = dict(zip(methods, len(methods)*(False,)))
        else:
            self.methods = methods
        super(ModelView, self).__init__(queryset, slug_field)


    def __call__(self, request, object_pk=None, slug=None, format='html', **kwargs):
        """
        Redirects to one of the CRUD methods depending on the HTTP method of 
        the request. Checks whether the requested method is allowed for this 
        resource.
        """
        # Restrict
        request_method = request.method.upper()
        if request_method not in self.methods.keys():
            return HttpResponseNotAllowed(request_method)
        if self.methods[request_method]:
            if not self.methods[request_method](request, **kwargs):
                return HttpResponseNotAllowed(request_method)

        # Unmatched regex groups in the url will not recieve
        # the default value specified for the method, but
        # instead recieve the value None. Thus we must
        # explicitly check for None and assign the desired
        # value if we want default values.
        if format is None:
            format = 'html'

        # If we didn't get object_pk or slug, assume this is an add view.
        if object_pk is None and slug is None:
            obj = None
        else:
            obj = self.get_object(request, object_pk, slug)
                
        # Dispatch
        if request_method == 'GET':
            return self.read(request, obj, self.get_responder(format))
        elif request_method == 'POST':
            return self.create(request, self.get_responder(format))
        elif request_method == 'PUT':
            return self.update(request, obj, self.get_responder(format))
        elif request_method == 'DELETE':
            return self.delete(request, obj, self.get_responder(format))
        else:
            raise Http404

    def get_responder(self, format):
        """
        Returns a ``Responder`` instance given the format.
        """
        try:
            # get_query_set requires a request parameter, but doesn't
            # do anything with the parameter (presumably a subclass
            # might. Passing self is an arbitrary decision.
            return self.responders['%sResponder' % format.title()](self.get_query_set(self))
        except KeyError:
            raise ImproperlyConfigured("%s responder doesn't exist." % '%sResponder' % format.title())

    def get_form(self, request):
        """
        Returns a ``ModelForm`` class to be used in this view.
        """
        # TODO: we should be able to construct a ModelForm without creating
        # and passing in a temporary inner class
        class Meta:
            model = self.model
        class_name = self.model.__name__ + 'Form'
        return ModelFormMetaclass(class_name, (ModelForm,), {'Meta': Meta})

    def save_form(self, request, form):
        """
        Saves and returns the object represented by the given form. This
        method will only be called if the form is valid.
        """
        return form.save()

    def read(self, request, obj, responder):
        """
        Returns a rendered list or element whether ``obj`` exists, idempotent.
        """
        if obj is None:
            return responder.list(request, self.paginate_by, self.allow_empty)
        else:
            return responder.element(request, obj)

    def create(self, request, responder):
        """
        Create a new resource.
        """
        Form = self.get_form(request)
        form = Form(request.POST, request.FILES)
        if form.is_valid():
            new_obj = self.save_form(request, form)
            return responder.create_success(request, new_obj, self.post_save_redirect)

    def update(self, request, obj, responder):
        """
        Update an existing resource (there is no PUT creation for now), idempotent.
        """
        Form = self.get_form(request)
        form = Form(request.POST, request.FILES, instance=obj)
        if form.is_valid():
            new_obj = self.save_form(request, form)
            return responder.update_success(request, obj, new_obj, self.post_save_redirect)

    def delete(self, request, obj, responder):
        """
        Delete an existing resource, idempotent.
        """
        if obj is not None:
            obj.delete()
        return responder.delete_success(self.post_save_redirect)