from django.apps import apps
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.test import TestCase

from ..roles import get_system_user, get_ghost_user, get_group_members
from ..roles import get_group_names_by_role, get_users_by_role, has_role

from .generic import RoleMixin


class RolesTestCase(RoleMixin, TestCase):
    def test_get_system_user(self):
        u = get_system_user()
        self.assertIsInstance(u, get_user_model())
        self.assertEqual(u.username, '-system-')
        self.assertIsNotNone(u.pk)

    def test_get_ghost_user(self):
        u = get_ghost_user()
        self.assertIsInstance(u, get_user_model())
        self.assertEqual(u.username, '-deleted-')
        self.assertIsNotNone(u.pk)

    def test_group_members(self):
        # Create some groups
        g1 = Group(name='gruppe1')
        g1.save()
        g2 = Group(name='gruppe2')
        g2.save()

        # Create some users and add them to groups
        user_model = get_user_model()
        u1 = user_model(username='user1')
        u1.save()
        g1.user_set.add(u1)
        u2 = user_model(username='user2')
        u2.save()
        g1.user_set.add(u2)
        u3 = user_model(username='user3')
        u3.save()
        g2.user_set.add(u3)

        # Create a user, that will belong to no group
        u4 = user_model(username='user4')
        u4.save()

        # Check results of get_group_members
        self.assertSequenceEqual(get_group_members('gruppe1'), [u1, u2])
        self.assertSequenceEqual(get_group_members('gruppe2'), [u3])
        with self.assertRaises(Group.DoesNotExist):
            get_group_members('gruppe3')
        self.assertSequenceEqual(get_group_members('gruppe3', ignore_missing=True), [])

    def test_get_group_names_by_role_default_config(self):
        test_data = [
            ('publisher_print', ['Redaktion_KA-Alpin']),
            ('publisher_web', ['Redaktion_Joomla']),
            ('publisher_facebook', ['Redaktion_Facebook']),
            ('manager_w', ['Bereichsleiter_Wandern', 'Tourenreferenten']),
            ('manager_s', ['Bereichsleiter_Ski', 'Tourenreferenten']),
            ('manager_m', ['Bereichsleiter_MTB', 'Tourenreferenten']),
            ('manager_k', ['Bereichsleiter_Klettern', 'Tourenreferenten']),
            ('manager_b', ['Bereichsleiter_Bergsteigen', 'Tourenreferenten']),
            ('manager_super', ['Tourenreferenten']),
            ('publisher', ['Redaktion_KA-Alpin', 'Redaktion_Joomla', 'Redaktion_Facebook']),
            ('manager', ['Bereichsleiter_Wandern', 'Bereichsleiter_Ski', 'Bereichsleiter_MTB',
                         'Bereichsleiter_Klettern', 'Bereichsleiter_Bergsteigen', 'Tourenreferenten']),
            ('office', ['Geschaeftsstelle']),
        ]
        for role, expected_group_names in test_data:
            group_names = get_group_names_by_role(role)
            self.assertEqual(len(group_names), len(expected_group_names))
            for name in group_names:
                self.assertIn(name, expected_group_names)

    def get_group_names_by_role_adhoc_config(self):
        role_name = 'manager_w'
        super_role_name = 'manager_super'
        role_groups = ['group1', 'group2']
        super_role_groups = ['group3', 'group4']

        role_setting = 'groups_{}'.format(role_name)
        super_role_setting = 'groups_{}'.format(super_role_name)

        app_config = apps.get_app_config('dav_events')

        buf_role_setting = getattr(app_config.settings, role_setting)
        buf_super_role_setting = getattr(app_config.settings, super_role_setting)

        setattr(app_config.settings, role_setting, role_groups)
        setattr(app_config.settings, super_role_setting, super_role_groups)

        expected_groups = role_groups + super_role_groups
        self.assertSequenceEqual(get_group_names_by_role(role_name), expected_groups)

        setattr(app_config.settings, role_setting, buf_role_setting)
        setattr(app_config.settings, super_role_setting, buf_super_role_setting)

    def test_get_group_names_by_role_notexist(self):
        self.assertSequenceEqual(get_group_names_by_role('not_existing_test_role'), [])

    def test_get_users_by_role(self):
        u1 = self.create_user_for_role('manager_super', 'Touren', 'Referent')
        u2 = self.create_user_for_role('manager_super', 'Praktikant', 'Referent')
        u3 = self.create_user_for_role('manager_w', 'Bereichsleiter', 'Wandern')
        u4 = self.create_user_for_role('manager_w', 'Praktikant', 'Wandern')
        u5 = self.create_user_for_role('manager_s', 'Bereichsleiter', 'Ski')
        users = get_users_by_role('manager_w')
        self.assertSequenceEqual(users, [u1, u2, u3, u4])

    def test_has_role(self):
        u1 = self.create_user_for_role('test_role1', 'User1', 'Test')
        u2 = self.create_user_for_role('test_role1', 'User2', 'Test')
        u3 = self.create_user_for_role('test_role2', 'User3', 'Test')
        u4 = self.create_user_for_role('test_role2', 'User4', 'Test')

        g1 = u1.groups.first()
        g1.user_set.add(u4)

        self.assertTrue(has_role(u1, 'test_role1'))
        self.assertFalse(has_role(u1, 'test_role2'))
        self.assertTrue(has_role(u2, 'test_role1'))
        self.assertFalse(has_role(u2, 'test_role2'))
        self.assertFalse(has_role(u3, 'test_role1'))
        self.assertTrue(has_role(u3, 'test_role2'))
        self.assertTrue(has_role(u4, 'test_role1'))
        self.assertTrue(has_role(u4, 'test_role2'))