import logging

from django.contrib.auth import get_user_model

from django.contrib.auth.models import Group

from django.db import transaction

from notes import constants

from notes.api.fields.category import ProtocolField

from protocols.models import Protocol

from rest_auth.serializers import \

    UserDetailsSerializer as RestAuthUserDetailsSerializer

from rest_framework import serializers

logger = logging.getLogger(__name__)

User = get_user_model()

class GroupSerializer(serializers.ModelSerializer):

    owner = serializers.CharField(source='profile.owner.username', read_only=True)

    is_personal = serializers.BooleanField(source='profile.is_personal', read_only=True)

    description = serializers.CharField(source='profile.description')

    protocol = ProtocolField(read_only=True, source='profile.protocol')

    class Meta:

        model = Group

        fields = ['name', 'owner', 'is_personal', 'description', 'protocol']

class DetailGroupSerializer(GroupSerializer):

    users = serializers.SlugRelatedField(

        many=True,

        read_only=True,

        slug_field='username',

        source='user_set'

    )

    class Meta:

        model = Group

        fields = ['name', 'owner', 'description', 'users', 'is_personal', 'protocol']

class WriteGroupSerializer(serializers.ModelSerializer):

    '''

    Serializers for writing groups.

    '''

    description = serializers.CharField(source='profile.description', required=False)

    users = serializers.SlugRelatedField(

        many=True,

        slug_field='username',

        source='user_set',

        queryset=User.objects.all(),

        default=[]

    )

    protocol = ProtocolField(required=False, source='profile.protocol')

    class Meta:

        model = Group

        fields = ['name', 'description', 'users', 'protocol']

    def create(self, validated_data):

        profile_data = validated_data.pop('profile', None)

        group = super().create(validated_data)

        if profile_data is not None and profile_data.get('description', None) is not None:

            group.profile.description = profile_data.get('description')

        user = None

        request = self.context.get("request")

        if request and hasattr(request, "user"):

            user = request.user

            group.user_set.add(user)

            group.save()

        group.profile.owner = user

        new_protocol = Protocol.objects.create_from_default(

            "Protocol group %s"%validated_data.get('name', ''),

            "Protocol group %s"%validated_data.get('name', ''),

            validated_data.get('name', ''),

            None

        )

        group.profile.protocol = "%s%s.%s" % (constants.PROTOCOL_URN_PREFIX, new_protocol.ext_id, new_protocol.revisions.last().version)

        group.profile.save()

        return group

    def update(self, instance, validated_data):

        profile_data = validated_data.pop('profile', None)

        group = super().update(instance, validated_data)

        logger.debug("WriteGroupSerializer.update %r", profile_data)

        if profile_data is not None and profile_data.get('description', None) is not None:

            group.profile.description = profile_data.get('description')

            group.profile.save()

        # check that owner is still in user list

        if group.profile.owner and group.profile.owner not in group.user_set.all():

            group.user_set.add(group.profile.owner)

        return group

    @transaction.atomic()

    def save(self, **kwargs):

        return super().save(**kwargs)

class UserDetailsSerializer(RestAuthUserDetailsSerializer):

    default_group = serializers.SlugRelatedField(read_only=True, slug_field='name', source='profile.default_group')

    class Meta(RestAuthUserDetailsSerializer.Meta):

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

        read_only_fields = ('email', 'default_group')