"""
Views for creating, editing and viewing site-specific user profiles.

"""

from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse
from django.http import Http404, HttpResponseRedirect
from django.shortcuts import get_object_or_404, render_to_response
from django.template import RequestContext
from django.views.generic.list_detail import object_list

from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User

from profiles import utils


def create_profile(request, form_class=None, success_url=None,
                   template_name='profiles/create_profile.html'):
    """
    Create a profile for the current user, if one doesn't already
    exist.

    If the user already has a profile, as determined by
    ``request.user.get_profile()``, a redirect will be issued to the
    :view:`profiles.views.edit_profile` view. If no profile model has
    been specified in the ``AUTH_PROFILE_MODULE`` setting,
    ``django.contrib.auth.models.SiteProfileNotAvailable`` will be
    raised.

    To specify the form class used for profile creation, pass it as
    the keyword argument ``form_class``; if this is not supplied, it
    will fall back to a ``ModelForm`` for the model specified in the
    ``AUTH_PROFILE_MODULE`` setting.

    If you are supplying your own form class, it must define a method
    named ``save()`` which corresponds to the signature of ``save()``
    on ``ModelForm``, because this view will call it with
    ``commit=False`` and then fill in the relationship to the user
    (which must be via a field on the profile model named ``user``, a
    requirement already imposed by ``User.get_profile()``) before
    finally saving the profile object. If many-to-many relations are
    involved, the convention established by ``ModelForm`` of
    looking for a ``save_m2m()`` method on the form is used, and so
    your form class should define this method.

    To specify a URL to redirect to after successful profile creation,
    pass it as the keyword argument ``success_url``; this will default
    to the URL of the :view:`profiles.views.profile_detail` view for
    the new profile if unspecified.

    To specify the template to use, pass it as the keyword argument
    ``template_name``; this will default to
    :template:`profiles/create_profile.html` if unspecified.

    Context:

        form
            The profile-creation form.

    Template:

        ``template_name`` keyword argument, or
        :template:`profiles/create_profile.html`.

    """
    try:
        profile_obj = request.user.get_profile()
        return HttpResponseRedirect(reverse('profiles_edit_profile'))
    except ObjectDoesNotExist:
        pass
    if success_url is None:
        success_url = reverse('profiles_profile_detail',
                              kwargs={ 'username': request.user.username })
    if form_class is None:
        form_class = utils.get_profile_form()
    if request.method == 'POST':
        form = form_class(data=request.POST, files=request.FILES)
        if form.is_valid():
            profile_obj = form.save(commit=False)
            profile_obj.user = request.user
            profile_obj.city = request.method['POST'].get("city")
            profile_obj.country = request.method['POST'].get("country")
            profile_obj.save()
            if hasattr(form, 'save_m2m'):
                form.save_m2m()
            return HttpResponseRedirect(success_url)
    else:
        form = form_class()
    return render_to_response(template_name,
                              { 'form': form },
                              context_instance=RequestContext(request))
create_profile = login_required(create_profile)

def edit_profile(request, form_class=None, success_url=None,
                 template_name='profiles/edit_profile.html'):
    """
    Edit the current user's profile.

    If the user does not already have a profile (as determined by
    ``User.get_profile()``), a redirect will be issued to the
    :view:`profiles.views.create_profile` view; if no profile model
    has been specified in the ``AUTH_PROFILE_MODULE`` setting,
    ``django.contrib.auth.models.SiteProfileNotAvailable`` will be
    raised.

    To specify the form class used for profile editing, pass it as the
    keyword argument ``form_class``; this form class must have a
    ``save()`` method which will save updates to the profile
    object. If not supplied, this will default to
    a ``ModelForm`` for the profile model.

    If you supply a form class, its ``__init__()`` method must accept
    an instance of the profile model as the keyword argument
    ``instance``.

    To specify the URL to redirect to following a successful edit,
    pass it as the keyword argument ``success_url``; this will default
    to the URL of the :view:`profiles.views.profile_detail` view if
    not supplied.

    To specify the template to use, pass it as the keyword argument
    ``template_name``; this will default to
    :template:`profiles/edit_profile.html` if not supplied.

    Context:

        form
            The form for editing the profile.

        profile
            The user's current profile.

    Template:

        ``template_name`` keyword argument or
        :template:`profiles/edit_profile.html`.

    """
    try:
        profile_obj = request.user.get_profile()
    except ObjectDoesNotExist:
        return HttpResponseRedirect(reverse('profiles_create_profile'))
    if success_url is None:
        success_url = reverse('profiles_profile_detail',
                              kwargs={ 'username': request.user.username })
    if form_class is None:
        form_class = utils.get_profile_form()
    if request.method == 'POST':
        form = form_class(data=request.POST, files=request.FILES, instance=profile_obj)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(success_url)
    else:
        form = form_class(instance=profile_obj)
    return render_to_response(template_name,
                              { 'form': form,
                                'profile': profile_obj, },
                              context_instance=RequestContext(request))
edit_profile = login_required(edit_profile)

def profile_detail(request, username, public_profile_field=None,
                   template_name='profiles/profile_detail.html'):
    """
    Detail view of a user's profile.

    If no profile model has been specified in the
    ``AUTH_PROFILE_MODULE`` setting,
    ``django.contrib.auth.models.SiteProfileNotAvailable`` will be
    raised.

    If the user has not yet created a profile, ``Http404`` will be
    raised.

    If a field on the profile model determines whether the profile can
    be publicly viewed, pass the name of that field (as a string) as
    the keyword argument ``public_profile_field``; that attribute will
    be checked before displaying the profile, and if it does not
    return a ``True`` value, the ``profile`` variable in the template
    will be ``None``. As a result, this field must be a
    ``BooleanField``.

    To specify the template to use, pass it as the keyword argument
    ``template_name``; this will default to
    :template:`profiles/profile_detail.html` if not supplied.

    Context:

        profile
            The user's profile, or ``None`` if the user's profile is
            not publicly viewable (see the note about
            ``public_profile_field`` above).

    Template:

        ``template_name`` keyword argument or
        :template:`profiles/profile_detail.html`.

    """
    user = get_object_or_404(User, username=username)
    try:
        profile_obj = user.get_profile()
    except ObjectDoesNotExist:
        raise Http404
    if public_profile_field is not None and \
       not getattr(profile_obj, public_profile_field):
        profile_obj = None
    return render_to_response(template_name,
                              { 'profile': profile_obj },
                              context_instance=RequestContext(request))

def profile_list(request, public_profile_field=None,
                 template_name='profiles/profile_list.html', **kwargs):
    """
    List of user profiles.

    If no profile model has been specified in the
    ``AUTH_PROFILE_MODULE`` setting,
    ``django.contrib.auth.models.SiteProfileNotAvailable`` will be
    raised.

    If a field on the profile model determines whether the profile can
    be publicly viewed, pass the name of that field as the keyword
    argument ``public_profile_field``; the ``QuerySet`` of profiles
    will be filtered to include only those on which that field is
    ``True`` (as a result, this field must be a ``BooleanField``).

    This view is a wrapper around the
    :view:`django.views.generic.list_detail.object_list` generic view,
    so any arguments which are legal for that view will be accepted,
    with the exception of ``queryset``, which will always be set to
    the default ``QuerySet`` of the profile model, optionally filtered
    as described above.

    Template:

        ``template_name`` keyword argument or
        :template:`profiles/profile_list.html`.

    Context:

        Same as the :view:`django.views.generic.list_detail.object_list`
        generic view.

    """
    profile_model = utils.get_profile_model()
    if 'queryset' in kwargs:
        del kwargs['queryset']
    queryset = profile_model._default_manager.all()
    if public_profile_field is not None:
        queryset = queryset.filter(**{ public_profile_field: True })
    return object_list(request,
                       queryset=queryset,
                       template_name=template_name,
                       **kwargs)