from rest_framework import serializers

from apps.notifications.membership_events import notify_workspace_membership_added
from apps.users.models import User
from core.serializers.base import BaseModelSerializer
from apps.workspaces.models import Workspace, WorkspaceMembership
from core.serializers.mini import UserMiniSerializer


class WorkspaceMemberInputSerializer(serializers.Serializer):
    user_id = serializers.UUIDField()
    role = serializers.ChoiceField(choices=WorkspaceMembership.Role.choices, default=WorkspaceMembership.Role.MEMBER)


class WorkspaceSerializer(BaseModelSerializer):
    members = WorkspaceMemberInputSerializer(many=True, write_only=True, required=False)
    my_role = serializers.SerializerMethodField()

    class Meta:
        model = Workspace
        fields = BaseModelSerializer.Meta.fields + (
            "name",
            "description",
            "owner",
            "my_role",
            "members",
        )
        read_only_fields = BaseModelSerializer.Meta.fields + (
            "owner",
        )
    
    def get_my_role(self, obj):
        membership = WorkspaceMembership.objects.filter(
            workspace=obj,
            user=self.context["request"].user,
        ).first()
        return getattr(membership, "role", None)

    def create(self, validated_data):
        members_data = validated_data.pop('members', [])

        workspace = super().create(validated_data)

        memberships_to_create = []
        for member in members_data:
            memberships_to_create.append(
                WorkspaceMembership(
                    workspace=workspace,
                    user_id=member['user_id'],
                    role=member['role'],
                    is_active=True
                )
            )

        if memberships_to_create:
            WorkspaceMembership.objects.bulk_create(memberships_to_create)
            request = self.context.get("request")
            actor = getattr(request, "user", None)
            if actor and actor.is_authenticated:
                users_by_id = User.objects.in_bulk(
                    [member["user_id"] for member in members_data]
                )
                for member in members_data:
                    recipient = users_by_id.get(member["user_id"])
                    if recipient:
                        notify_workspace_membership_added(
                            actor=actor,
                            recipient=recipient,
                            workspace=workspace,
                            role=member["role"],
                        )

        return workspace


class WorkspaceMembershipSerializer(BaseModelSerializer):
    class Meta:
        model = WorkspaceMembership
        fields = BaseModelSerializer.Meta.fields + (
            "workspace",
            "user",
            "role",
            "is_active",
        )

    def to_representation(self, instance):
        data = super().to_representation(instance)
        data["user"] = UserMiniSerializer(
            instance.user,
            context=self.context
        ).data
        return data