from rest_framework import serializers
from .models import ChatRoom, Message, SupportTicket, RoomMember, MessageReadStatus, DirectMessage
from users.serializers import GetFullUserSerializer


class MessageReadStatusSerializer(serializers.ModelSerializer):
    class Meta:
        model = MessageReadStatus
        fields = ['id', 'read_at', 'user', 'message']
        read_only_fields = ['read_at']


class MessageSerializer(serializers.ModelSerializer):
    sender = GetFullUserSerializer(source='user', read_only=True)
    read_status = MessageReadStatusSerializer(many=True, read_only=True)
    
    class Meta:
        model = Message
        fields = [
            'id', 'message_type', 'content', 'file_url', 'file_name', 
            'file_size', 'is_edited', 'edited_at', 'is_deleted', 
            'deleted_at', 'created_at', 'updated_at', 'sender', 'room', 'read_status'
        ]
        read_only_fields = ['created_at', 'updated_at', 'sender']


class RoomMemberSerializer(serializers.ModelSerializer):
    user = GetFullUserSerializer(read_only=True)
    
    class Meta:
        model = RoomMember
        fields = ['id', 'joined_at', 'is_admin', 'is_active', 'user', 'room']
        read_only_fields = ['joined_at']


class ChatRoomSerializer(serializers.ModelSerializer):
    created_by = GetFullUserSerializer(read_only=True)
    members = RoomMemberSerializer(many=True, read_only=True)
    messages = MessageSerializer(many=True, read_only=True)
    member_count = serializers.SerializerMethodField()
    unread_count = serializers.SerializerMethodField()
    
    class Meta:
        model = ChatRoom
        fields = [
            'id', 'name', 'room_type', 'status', 'created_at', 'updated_at',
            'ticket_id', 'priority', 'subject', 'description', 'created_by',
            'organisation', 'branch', 'members', 'messages', 'member_count', 'unread_count'
        ]
        read_only_fields = ['created_at', 'updated_at', 'created_by']
    
    def get_member_count(self, obj):
        return obj.members.filter(is_active=True).count()
    
    def get_unread_count(self, obj):
        request = self.context.get('request')
        if request and request.user.is_authenticated:
            # Count unread messages for the current user
            return obj.messages.exclude(
                read_status__user=request.user
            ).count()
        return 0


class SupportTicketSerializer(serializers.ModelSerializer):
    customer = GetFullUserSerializer(read_only=True)
    assigned_staff = GetFullUserSerializer(read_only=True)
    chat_room = ChatRoomSerializer(read_only=True)
    
    class Meta:
        model = SupportTicket
        fields = [
            'id', 'ticket_id', 'subject', 'description', 'status', 'priority',
            'created_at', 'updated_at', 'resolved_at', 'assigned_staff',
            'chat_room', 'customer'
        ]
        read_only_fields = ['created_at', 'updated_at', 'ticket_id']


class CreateMessageSerializer(serializers.ModelSerializer):
    class Meta:
        model = Message
        fields = ['message_type', 'content', 'file_url', 'file_name', 'file_size', 'room']
    
    def create(self, validated_data):
        validated_data['user'] = self.context['request'].user
        return super().create(validated_data)


class CreateChatRoomSerializer(serializers.ModelSerializer):
    member_ids = serializers.ListField(
        child=serializers.IntegerField(),
        write_only=True,
        required=False,
        help_text="List of user IDs to add as members"
    )
    
    class Meta:
        model = ChatRoom
        fields = [
            'name', 'room_type', 'priority', 'subject', 'description',
            'organisation', 'branch', 'member_ids'
        ]
        read_only_fields = []
    
    def create(self, validated_data):
        member_ids = validated_data.pop('member_ids', [])
        user = self.context['request'].user
        validated_data['created_by'] = user
        
        room_type = validated_data.get('room_type')
        if room_type == 'organisation' and hasattr(user, 'user_organisation_branch'):
            validated_data['organisation'] = user.user_organisation_branch.branch_organisation
            validated_data['branch'] = user.user_organisation_branch
        
        room = super().create(validated_data)
        
        # Add creator as admin member
        RoomMember.objects.create(
            room=room,
            user=user,
            is_admin=True,
            is_active=True
        )
        
        if room_type == 'organisation' and validated_data.get('organisation'):
            from django.contrib.auth import get_user_model
            User = get_user_model()
            
            # Get all active staff from the same organization
            org_staff = User.objects.filter(
                user_organisation_branch__branch_organisation=validated_data['organisation'],
                is_active=True,
                is_staff=True
            ).exclude(id=user.id)  # Exclude creator as they're already added
            
            # Add all staff as members
            for staff_member in org_staff:
                RoomMember.objects.create(
                    room=room,
                    user=staff_member,
                    is_active=True
                )
        
        # Add specified members (for non-organisation rooms or additional members)
        elif member_ids:
            from django.contrib.auth import get_user_model
            User = get_user_model()
            for user_id in member_ids:
                try:
                    member_user = User.objects.get(id=user_id)
                    RoomMember.objects.create(
                        room=room,
                        user=member_user,
                        is_active=True
                    )
                except User.DoesNotExist:
                    pass
        
        return room


class CreateSupportTicketSerializer(serializers.ModelSerializer):
    class Meta:
        model = SupportTicket
        fields = ['subject', 'description', 'priority']
    
    def create(self, validated_data):
        # Get the current user as the customer
        customer = self.context['request'].user
        
        # Create a chat room for the support ticket
        chat_room = ChatRoom.objects.create(
            name=f"Support Ticket - {validated_data['subject']}",
            room_type='support',
            priority=validated_data['priority'],
            subject=validated_data['subject'],
            description=validated_data['description'],
            created_by=customer,
            organisation=customer.user_organisation_branch.branch_organisation
        )
        
        # Add customer as member
        RoomMember.objects.create(
            room=chat_room,
            user=customer,
            is_active=True
        )
        
        # Create the support ticket
        validated_data['chat_room'] = chat_room
        validated_data['customer'] = customer
        validated_data['ticket_id'] = f"TICKET-{chat_room.id:06d}"
        return super().create(validated_data)


class AddMemberSerializer(serializers.Serializer):
    user_id = serializers.IntegerField(required=True)
    is_admin = serializers.BooleanField(default=False)


class DirectMessageSerializer(serializers.ModelSerializer):
    sender = GetFullUserSerializer(read_only=True)
    recipient = GetFullUserSerializer(read_only=True)
    
    class Meta:
        model = DirectMessage
        fields = [
            'id', 'message_type', 'content', 'file_url', 'file_name', 
            'file_size', 'is_read', 'read_at', 'is_edited', 'edited_at', 
            'is_deleted', 'deleted_at', 'created_at', 'updated_at', 
            'sender', 'recipient'
        ]
        read_only_fields = ['created_at', 'updated_at', 'sender', 'recipient']


class CreateDirectMessageSerializer(serializers.ModelSerializer):
    class Meta:
        model = DirectMessage
        fields = ['message_type', 'content', 'file_url', 'file_name', 'file_size']
    
    def create(self, validated_data):
        validated_data['sender'] = self.context['request'].user
        validated_data['recipient'] = self.context['recipient']
        return super().create(validated_data)