from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
from drf_queryfields import QueryFieldsMixin
from rest_framework import serializers
from rest_framework.reverse import reverse
from slugify import slugify
from crm.models.entries import Person
from authentication.models import User

import logging

logger = logging.getLogger()

class PermissionRepresentationField(serializers.RelatedField):

    def to_representation(self, value):
        return '{0.content_type.app_label}.{0.codename}'.format(value)


class GroupSerializer(QueryFieldsMixin, serializers.ModelSerializer):
    permissions_repr = PermissionRepresentationField(
        many=True, read_only=True, source='permissions')

    class Meta:
        model = Group
        fields = (
            'id',
            'name',
            'permissions',
            'permissions_repr',
        )


class PermissionSerializer(QueryFieldsMixin, serializers.ModelSerializer):
    content_type_repr = serializers.SerializerMethodField()

    class Meta:
        model = Permission
        fields = (
            'id',
            'name',
            'content_type',
            'content_type_repr',
            'codename'
        )

    def get_content_type_repr(self, obj):
        return str(obj.content_type.app_label)


class UserModelSerializer(QueryFieldsMixin, serializers.ModelSerializer):
    change_password = serializers.SerializerMethodField()
    user_permissions = serializers.PrimaryKeyRelatedField(
        many=True, read_only=True)
    user_permissions_repr = PermissionRepresentationField(
        many=True, read_only=True, source='user_permissions')
    groups = serializers.PrimaryKeyRelatedField(many=True, queryset=Group.objects.all())
    groups_repr = serializers.StringRelatedField(
        many=True, read_only=True, source='groups')
    all_permissions = serializers.SerializerMethodField()
    all_permissions_repr = serializers.SerializerMethodField()
    profile = serializers.PrimaryKeyRelatedField(many=False, queryset=Person.objects.all())
    profile_href = serializers.HyperlinkedRelatedField(
        many=False, read_only=True, view_name='crm:person-detail', source='profile')
    reset_password = serializers.HyperlinkedIdentityField('authentication:user-reset-password')
    username = serializers.CharField(required=False)
    is_employee = serializers.SerializerMethodField()
    def get_is_employee(self, obj):
        return Person.employees.filter(id=obj.profile.id).exists()

    main_manager_of = serializers.SerializerMethodField()
    def get_main_manager_of(self, obj):
        return obj.profile.main_manager_of.all().values_list('id', flat=True)

    def get_all_permissions(self, obj):
        permissions = list(
            obj.user_permissions.all().values_list('id', flat=True))
        for group in obj.groups.all():
            group_permissions = group.permissions.all().values_list('id', flat=True)
            permissions.extend(list(group_permissions))
        return list(set(permissions))

    def get_all_permissions_repr(self, obj):
        permissions = list()
        permissions_dict = list(obj.user_permissions.all().values_list(
            'content_type__app_label', 'codename'))
        permissions.extend(['{0[0]}.{0[1]}'.format(_permission)
                            for _permission in permissions_dict])
        for group in obj.groups.all():
            group_permissions = group.permissions.all().values_list(
                'content_type__app_label', 'codename')
            permissions.extend(['{0[0]}.{0[1]}'.format(_permission)
                                for _permission in group_permissions])
        return list(set(permissions))

    @classmethod
    def prefetch_related(cls, queryset, request):
        queryset = queryset.prefetch_related('groups')
        queryset = queryset.prefetch_related('user_permissions')
        return queryset


    def validate(self, data):
        if ('username' not in data or data['username'] == '') and self.context['request'].method == 'POST':
            profile = data['profile']
            data['username'] = slugify('{0.first_name} {0.last_name}'.format(profile))

        return super().validate(data)


    def validate_profile(self, value):
        if hasattr(value, 'user_account') and self.context['request'].method == 'POST':
            raise serializers.ValidationError('CRM Profile has already an user account.')
        return value

    class Meta:
        model = get_user_model()
        fields = (
            'id',
            'username',
            'email',
            'user_permissions',
            'user_permissions_repr',
            'groups',
            'groups_repr',
            'all_permissions',
            'all_permissions_repr',
            'profile',
            'profile_href',
            'is_staff',
            'is_active',
            'is_superuser',
            'is_employee',
            'change_password',
            'frontend_settings',
            'reset_password',
            'main_manager_of',
        )

    def get_change_password(self, obj):
        return '%s' % (reverse('authentication:user-change-password', args=[obj.id], request=self.context['request']))