from django.forms.models import inlineformset_factory

from cm.models import *

from cm.message import *

from django.contrib.auth import authenticate

from django.contrib.auth import login as django_login  

from django.forms import ModelForm

from django.contrib.auth.models import User

from django.forms.formsets import formset_factory

from django.shortcuts import render_to_response

from django.template import RequestContext

from django.utils.translation import ugettext as _, ugettext_lazy, ungettext

from django.http import HttpResponse, HttpResponseRedirect, Http404

from django.forms.util import ErrorList

from django.shortcuts import get_object_or_404

from cm.activity import register_activity

from cm.views import get_text_by_keys_or_404

from cm.message import display_message

from cm.utils import get_among, get_int

from cm.models import ApplicationConfiguration

from django.views.generic.list_detail import object_list

from django.contrib.auth.decorators import login_required

from cm.views import get_keys_from_dict

from cm.security import has_global_perm, has_global_perm_or_perm_on_text

from cm.exception import UnauthorizedException

from cm.cm_settings import SHOW_EMAILS_IN_ADMIN

from tagging.models import Tag

import sys

import re

USER_PAGINATION = 10

@has_global_perm('can_manage_workspace')

def user_list(request):    

    display_suspended_users = get_int(request.GET, 'display', 0)

    tag_selected = request.GET.get('tag_selected', 0)

    paginate_by = get_int(request.GET, 'paginate', USER_PAGINATION)

    order_by = get_among(request.GET, 'order', ('user__username',

                                              'user__email',

                                              '-user__username',

                                              '-user__email',

                                              'role__name',

                                              '-role__name',

                                              'user__date_joined',

                                              '-user__date_joined',

                                              ),

                          'user__username')

    UserRole.objects.create_userroles_text(None)

    if request.method == 'POST':

        # bulk apply

        if 'apply' in request.POST and not 'save' in request.POST:

            action = request.POST.get('action', None)

            user_profile_keys = get_keys_from_dict(request.POST, 'check-').keys()

            if action == 'disable':

                for user_profile_key in user_profile_keys:

                    profile = UserProfile.objects.get(key=user_profile_key)

                    if profile != request.user.get_profile():

                        profile.is_suspended = True

                        profile.save()             

                display_message(request, _(u"%(count)i User's access suspended") % {'count':len(user_profile_keys)})

            if action == 'enable':

                for user_profile_key in user_profile_keys:

                    profile = UserProfile.objects.get(key=user_profile_key)

                    profile.is_suspended = False

                    profile.save()             

                display_message(request, _(u"%(count)i User's access enabled") % {'count':len(user_profile_keys)})

            ROLE_RE = re.compile('role_(\d*)')

            match = ROLE_RE.match(action)

            if match:

                role_id = match.group(1)

                for user_profile_key in user_profile_keys:

                    user_role = UserRole.objects.get(user__userprofile__key=user_profile_key, text=None)

                    user_role.role_id = role_id

                    user_role.save()

                display_message(request, _(u"%(count)i user(s) role modified") % {'count':len(user_profile_keys)})

            return HttpResponseRedirect(reverse('user'))

        if 'save' in request.POST:

            user_profile_keys_roles = get_keys_from_dict(request.POST, 'user-role-')

            count = 0

            for user_profile_key in user_profile_keys_roles:

                role_id = user_profile_keys_roles[user_profile_key]

                if not user_profile_key:

                    user_role = UserRole.objects.get(user=None, text=None)

                else:                    

                    user_role = UserRole.objects.get(user__userprofile__key=user_profile_key, text=None)

                if (role_id != u'' or user_role.role_id != None) and role_id != unicode(user_role.role_id):

                    if role_id:

                        user_role.role_id = int(role_id)

                    else:

                        user_role.role_id = None

                    user_role.save()

                    count += 1

            display_message(request, _(u"%(count)i user(s) role modified") % {'count':count})                

            return HttpResponseRedirect(reverse('user'))

    try:

        anon_role = UserRole.objects.get(user=None, text=None).role

    except UserRole.DoesNotExist:

        anon_role = None

    context = {

               'anon_role' : anon_role,

               'all_roles' : Role.objects.all(),

               'anon_roles' : Role.objects.filter(anon=True),

               'display_suspended_users' : display_suspended_users,

               'tag_list' : Tag.objects.usage_for_model(UserProfile),

               'tag_selected': tag_selected,

               'SHOW_EMAILS_IN_ADMIN': SHOW_EMAILS_IN_ADMIN,

               }

    query = UserRole.objects.select_related().filter(text=None).filter(~Q(user=None)).order_by(order_by)

    if not display_suspended_users:

        query = query.exclude(Q(user__userprofile__is_suspended=True) & Q(user__is_active=True))

    else:

        # trick to include userprofile table anyway (to filter by tags)

        query = query.filter(Q(user__userprofile__is_suspended=True) | Q(user__userprofile__is_suspended=False))

    if tag_selected:     

        tag_ids = Tag.objects.filter(name=tag_selected)

        if tag_ids:   

            content_type_id = ContentType.objects.get_for_model(UserProfile).pk

            query = query.extra(where=['tagging_taggeditem.object_id = cm_userprofile.id', 

                                       'tagging_taggeditem.content_type_id = %i' %content_type_id,

                                       'tagging_taggeditem.tag_id = %i' %tag_ids[0].id],

                                tables=['tagging_taggeditem'],

                                )

    return object_list(request, query,

                       template_name='site/user_list.html',

                       paginate_by=paginate_by,

                       extra_context=context,

                       )

class UserForm(ModelForm):

    email = forms.EmailField(label=ugettext_lazy(u'E-mail address'), required=True)

    class Meta:

        model = User

        fields = ('email', 'first_name', 'last_name')

    def clean_email(self):

        """

        Validates that the supplied email is new to the site

        """

        if 'email' in self.cleaned_data:

            email = self.cleaned_data['email']

            try:

                if self.instance:

                    user = User.objects.exclude(email__iexact=self.instance.email).get(email__iexact=email)

                else:

                    user = User.objects.get(email__iexact=email)

            except User.DoesNotExist:

                return email

            raise forms.ValidationError(_(u'This user is already a member.'))

class MassUserForm(forms.Form):

    email = forms.CharField(label=ugettext_lazy(u'Emails'),

                           help_text=ugettext_lazy(u'Add multiples emails one per line (or separated by "," or ";")'),

                           widget=forms.Textarea,

                           required=True)

class UserRoleForm(ModelForm):

    class Meta:

        model = UserRole

        fields = ('role',)

    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

                 initial=None, error_class=ErrorList, label_suffix=':',

                 empty_permitted=False, instance=None):

        ModelForm.__init__(self, data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance)

        # override manually

        role_field = self.fields['role']

        #role_field.required = True

        role_field.label = _(u'Workspace level role')

        role_field.help_text = _(u'This role will apply to every text in the workspace. To share only a (few) texts with this user, you can leave this blank and delegate roles on texts once the user is created.')

        self.fields['role'] = role_field

class UserRoleTextForm(ModelForm):

    class Meta:

        model = UserRole

        fields = ('role',)

    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

                 initial=None, error_class=ErrorList, label_suffix=':',

                 empty_permitted=False, instance=None):

        ModelForm.__init__(self, data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance)

        # override manually

        role_field = self.fields['role']

        #role_field.required = True

        role_field.label = _(u'Text level role')

        role_field.help_text = _(u'This role will apply only to this text.')

        self.fields['role'] = role_field

class UserProfileForm(ModelForm):

    class Meta:

        model = UserProfile

        fields = ('is_suspended', 'tags')

class MyUserProfileForm(ModelForm):

    class Meta:

        model = UserProfile

        fields = ('tags',)

class UserProfileAddForm(ModelForm):

    class Meta:

        model = UserProfile

        fields = ('tags',)

class UserProfileRegisterForm(ModelForm):

    class Meta:

        model = UserProfile

class UserAddForm(forms.Form):

    note = forms.CharField(label=ugettext_lazy(u'Note'),

                           help_text=ugettext_lazy(u'Optional text to add to invitation email'),

                           widget=forms.Textarea,

                           required=False)

SEPARATORS_RE = re.compile('[;,\n]+')

@has_global_perm_or_perm_on_text('can_manage_workspace', 'can_manage_text')

def user_mass_add(request, key=None):

    return user_add(request, key=key, mass=True)

@has_global_perm_or_perm_on_text('can_manage_workspace', 'can_manage_text')

def user_add(request, key=None, mass=False):

    text = get_text_by_keys_or_404(key) if key else None

    if request.method == 'POST':

        userform = UserForm(request.POST) if not mass else MassUserForm(request.POST)

        userroleform = UserRoleForm(request.POST) if not(key) else None

        noteform = UserAddForm(request.POST)

        userprofileform = UserProfileAddForm(request.POST)

        localroleform = UserRoleTextForm(request.POST, prefix="local") if key else None

        if userform.is_valid() and (not userroleform or userroleform.is_valid()) and noteform.is_valid() and userprofileform.is_valid() and (not localroleform or localroleform.is_valid()):

            data = userform.cleaned_data

            data.update(userprofileform.cleaned_data)

            data.update(noteform.cleaned_data)

            emails = data['email']

            del data['email']

            email_created = set()

            for email in [s.strip() for s in SEPARATORS_RE.split(emails)]:

                if email and not User.objects.filter(email__iexact=email) and email not in email_created:

                    user = UserProfile.objects.create_inactive_user(email, True, **data)

                    if key:

                        localuserrole = UserRole.objects.create(user=user, role=localroleform.cleaned_data['role'], text=text)

                    else:

                        userrole = UserRole.objects.create(user=user, role=userroleform.cleaned_data['role'], text=None)

                    email_created.add(email)

                    register_activity(request, "user_created", user=user)

            display_message(request, ungettext(u'%(nb_users)d user added', u'%(nb_users)d users added', len(email_created)) % {'nb_users': len(email_created)})

            if key:

                return HttpResponseRedirect(reverse('text-share', args=[text.key]))

            else:

                return HttpResponseRedirect(reverse('user'))

    else:

        userform = UserForm() if not mass else MassUserForm()

        userroleform = UserRoleForm() if not(key) else None

        userprofileform = UserProfileAddForm()

        noteform = UserAddForm()

        localroleform = UserRoleTextForm(prefix="local") if key else None

    if key:

        template = 'site/user_mass_add_text.html' if mass else 'site/user_add_text.html'

    else:

        template = 'site/user_mass_add.html' if mass else 'site/user_add.html'

    return render_to_response(template, {'forms' : [userform, userprofileform , userroleform, noteform, localroleform],

                                                               'save_name' : ungettext(u'Add user', u'Add users', 2 if mass else 1),

                                                               'mass' : mass,

                                                               'text' : text,

                                                                }, context_instance=RequestContext(request))

class UserValidateForm(ModelForm):

    email = forms.EmailField(label=ugettext_lazy(u'Email'), required=True)

    class Meta:

        model = User

        fields = ('email', 'username', 'first_name', 'last_name')

    def clean_username(self):

        """

        Validates that the supplied username is unique for the site.

        """

        if 'username' in self.cleaned_data:

            username = self.cleaned_data['username']

            try:

                user = User.objects.get(username__exact=username)

            except User.DoesNotExist:

                return username

            raise forms.ValidationError(_(u'This username is already in use. Please supply a different username.'))

from django.contrib.auth.forms import SetPasswordForm

def user_activate(request, key):

    try:

        profile = UserProfile.objects.get(adminkey=key)

        user = profile.user

        if not user.is_active:

            if request.method == 'POST':

                userform = UserValidateForm(request.POST, instance=user)

                pwform = SetPasswordForm(profile.user, request.POST)

                if userform.is_valid() and pwform.is_valid():

                    userform.save()

                    pwform.save()

                    user.is_active = True

                    user.save()

                    # login

                    user.backend = 'django.contrib.auth.backends.ModelBackend'

                    django_login(request, user)

                    register_activity(request, "user_activated", user=user)

                    display_message(request, _(u"Your account has been activated. You're now logged-in."))

                    return HttpResponseRedirect(reverse('index'))

            else:

                user.username = ''

                userform = UserValidateForm(instance=user)

                pwform = SetPasswordForm(user)

            return render_to_response('site/activate.html', {

                                                                  'forms' : [userform, pwform],

                                                                  'title': _(u'Activate your account'),

                                                                  'save_name' : _(u'activate account'),

                                                                  }, context_instance=RequestContext(request))

        else:

            user.backend = 'django.contrib.auth.backends.ModelBackend'

            django_login(request, user)

            display_message(request, _(u"Your account has been activated. You're now logged-in."))

            return HttpResponseRedirect(reverse('index'))

    except UserProfile.DoesNotExist:

        raise UnauthorizedException('No profile')

#@has_global_perm('can_manage_workspace')

#def user_delete(request, key):

#    try:

#        if request.method == 'POST':

#            profile = UserProfile.objects.get(key=key)

#            profile.delete()

#            display_message(request, "User %s has been deleted." %(profile.simple_print()))

#            return HttpResponse('') # no redirect because this is called by js

#    except UserProfile.DoesNotExist:

#        raise UnauthorizedException('No profile')

@has_global_perm('can_manage_workspace')

def user_suspend(request, key):

    if request.method == 'POST':

        profile = get_object_or_404(UserProfile, key=key)

        profile.is_suspended = True

        profile.save()

        if profile.user.is_active:            

            display_message(request, _(u"User's access %(prof)s has been suspended.") % {'prof':profile.simple_print()})

            register_activity(request, "user_suspended", user=profile.user)

        else:

            # make use active but disabled

            profile.user.is_active = True 

            profile.user.save()

            display_message(request, _(u"User's access %(prof)s has been refused.") % {'prof':profile.simple_print()})

            register_activity(request, "user_refused", user=profile.user)                

        return HttpResponse('') # no redirect because this is called by js

    raise UnauthorizedException('')