from django.contrib.auth import get_user_model
from rest_framework import serializers

from .models import Note
from .permissions import (
    can_complete_note,
    can_edit_note,
)


class NoteUserSerializer(serializers.ModelSerializer):
    """
    Annuaire minimal accessible à l'équipe
    sans exposer la gestion des comptes.
    """

    class Meta:
        model = get_user_model()

        fields = [
            'id',
            'username',
            'first_name',
            'last_name',
            'color',
        ]

        read_only_fields = fields


class NoteSerializer(serializers.ModelSerializer):
    author = NoteUserSerializer(
        read_only=True,
    )

    recipients = NoteUserSerializer(
        many=True,
        read_only=True,
    )

    recipient_ids = serializers.PrimaryKeyRelatedField(
        source='recipients',
        queryset=get_user_model().objects.filter(
            is_active=True,
        ),
        many=True,
        required=False,
        write_only=True,
    )

    is_done = serializers.ReadOnlyField()

    can_edit = serializers.SerializerMethodField()
    can_complete = serializers.SerializerMethodField()

    class Meta:
        model = Note

        fields = [
            'id',
            'title',
            'content',
            'kind',
            'author',
            'recipients',
            'recipient_ids',
            'is_public',
            'is_done',
            'completed_at',
            'created_at',
            'updated_at',
            'can_edit',
            'can_complete',
        ]

        read_only_fields = [
            'id',
            'completed_at',
            'created_at',
            'updated_at',
        ]

    def get_can_edit(self, obj):
        return can_edit_note(
            self.context['request'].user,
            obj,
        )

    def get_can_complete(self, obj):
        return can_complete_note(
            self.context['request'].user,
            obj,
        )

    def validate(self, attrs):
        is_public = attrs.get(
            'is_public',
            self.instance.is_public
            if self.instance
            else True,
        )

        if 'recipients' in attrs:
            recipients = attrs['recipients']
            has_recipients = bool(recipients)

        elif self.instance:
            has_recipients = (
                self.instance.recipients.exists()
            )

        else:
            has_recipients = False

        if not is_public and not has_recipients:
            raise serializers.ValidationError({
                'recipient_ids':
                    'Une publication privée doit avoir au moins un destinataire.',
            })

        return attrs

    def update(
        self,
        instance,
        validated_data,
    ):
        if (
            validated_data.get(
                'kind',
                instance.kind,
            )
            != Note.Kind.TASK
        ):
            validated_data[
                'completed_at'
            ] = None

        return super().update(
            instance,
            validated_data,
        )


class NoteCompletionSerializer(
    serializers.Serializer,
):
    is_done = serializers.BooleanField()