# -*- coding: utf-8 -*-

from django.contrib.auth.models import Group as DjangoGroup, User
from django.contrib.contenttypes.models import ContentType
from django.test import TestCase

from .fields import GroupsField, CorePermissionsField
from .forms import GroupForm, UserGroupForm
from .models import GenericTeamToken, Group, Permission


##
# Forms, and theirs fields.
##


class CorePermissionsFieldTests(TestCase):

    def setUp(self):
        kf_ct = ContentType.objects.get_for_model(GenericTeamToken)
        self.kf_perm1 = Permission.objects.create(
            content_type=kf_ct, codename='code1')
        self.kf_perm2 = Permission.objects.create(
            content_type=kf_ct, codename='code2')
        self.kf_perm3 = Permission.objects.create(
            content_type=kf_ct, codename='code3')

        ot_ct = ContentType.objects.get_for_model(Permission)
        self.ot_perm = Permission.objects.create(
            content_type=ot_ct, codename='code')

    def test_choices(self):
        """
        Only K-Fêt permissions are selectable.
        """
        field = CorePermissionsField()
        for p in [self.kf_perm1, self.kf_perm2, self.kf_perm3]:
            self.assertIn(p, field.queryset)
        self.assertNotIn(self.ot_perm, field.queryset)


class GroupsFieldTests(TestCase):

    def setUp(self):
        self.kf_group1 = Group.objects.create(name='KF Group1')
        self.kf_group2 = Group.objects.create(name='KF Group2')
        self.kf_group3 = Group.objects.create(name='KF Group3')
        self.ot_group = DjangoGroup.objects.create(name='OT Group')

    def test_choices(self):
        """
        Only K-Fêt groups are selectable.
        """
        field = GroupsField()
        self.assertQuerysetEqual(
            field.queryset,
            map(repr, [self.kf_group1, self.kf_group2, self.kf_group3]),
            ordered=False,
        )


class GroupFormTests(TestCase):

    def setUp(self):
        self.user = User.objects.create(username='user')
        self.kf_group = Group.objects.create(name='A Group')

        self.kf_perm1 = Permission.kfetcore.get(codename='is_team')
        self.kf_perm2 = Permission.kfetcore.get(codename='add_checkout')

        ot_ct = ContentType.objects.get_for_model(Permission)
        self.ot_perm = Permission.objects.create(
            content_type=ot_ct, codename='cool')

    def test_creation(self):
        data = {
            'name': 'Another Group',
            'permissions': [self.kf_perm1.pk],
        }
        form = GroupForm(data)
        instance = form.save()

        self.assertEqual(instance.name, 'Another Group')
        self.assertQuerysetEqual(
            instance.permissions.all(), map(repr, [self.kf_perm1]))

    def test_keep_others(self):
        """
        Non-kfet permissions of Group are kept when the form is submitted.
        Regression test for #168.
        """
        self.kf_group.permissions.add(self.ot_perm)

        selected = [self.kf_perm1, self.kf_perm2]

        data = {
            'name': 'A Group',
            'permissions': [str(p.pk) for p in selected],
        }

        form = GroupForm(data, instance=self.kf_group)
        form.save()

        self.assertQuerysetEqual(
            self.kf_group.permissions.all(),
            map(repr, [self.ot_perm] + selected),
            ordered=False,
        )


class UserGroupFormTests(TestCase):

    def setUp(self):
        # create user
        self.user = User.objects.create(username="foo", password="foo")

        # create some K-Fêt groups
        self.kf_group1 = Group.objects.create(name='KF Group1')
        self.kf_group2 = Group.objects.create(name='KF Group2')
        self.kf_group3 = Group.objects.create(name='KF Group3')

        # create a non-K-Fêt group
        self.ot_group = DjangoGroup.objects.create(name="OT Group")

    def test_keep_others(self):
        """
        User stays in its non-K-Fêt groups.
        Regression test for #161.
        """
        # add user to a non-K-Fêt group
        self.user.groups.add(self.ot_group)

        # add user to some K-Fêt groups through UserGroupForm
        selected = [self.kf_group1, self.kf_group2]
        data = {'groups': [str(g.pk) for g in selected]}
        form = UserGroupForm(data, instance=self.user)
        form.save()

        transform = lambda g: g.pk
        self.assertQuerysetEqual(
            self.user.groups.all(),
            map(transform, [self.ot_group] + selected),
            ordered=False, transform=transform,
        )


##
# Models
##

class PermissionTests(TestCase):

    def test_manager_kfet(self):
        """
        'kfet' manager only returns K-Fêt permissions.
        """
        kf_ct = ContentType.objects.get_for_model(GenericTeamToken)
        kf_perm1 = Permission.objects.create(
            content_type=kf_ct, codename='code1')
        kf_perm2 = Permission.objects.create(
            content_type=kf_ct, codename='code2')
        kf_perm3 = Permission.objects.create(
            content_type=kf_ct, codename='code3')

        self.assertEqual(Permission.kfetcore.get(codename='code1'), kf_perm1)
        self.assertEqual(Permission.kfetcore.get(codename='code2'), kf_perm2)
        self.assertEqual(Permission.kfetcore.get(codename='code3'), kf_perm3)

        ot_ct = ContentType.objects.get_for_model(Permission)
        Permission.objects.create(content_type=ot_ct, codename='code')

        with self.assertRaises(Permission.DoesNotExist):
            Permission.kfetcore.get(codename='code')