import json
from channels.generic.websocket import AsyncWebsocketConsumer
from .models import ChatRoomModel as ChatRoom, MsgModel as MessageChat

from django.contrib.auth import get_user_model
from asgiref.sync import sync_to_async


User = get_user_model()

class ChatConsumer(AsyncWebsocketConsumer):
    @sync_to_async
    def is_user_in_chat_room(self, user, chat_room):
        if chat_room.users.filter(id=user.id).exists():
            return True
        return user == chat_room.user_1 or user == chat_room.user_2

    async def connect(self):
        user = self.scope["user"]
        if user.is_authenticated:
            self.user = user
            self.chat_room_id = self.scope['url_route']['kwargs']['chat_room_id']
            self.chat_room = await sync_to_async(ChatRoom.objects.get)(id=self.chat_room_id)

            if not await self.is_user_in_chat_room(user, self.chat_room):
                await self.close()
                return

            self.room_group_name = f"chat_{self.chat_room.id}"

            # Join room group
            await self.channel_layer.group_add(
                self.room_group_name,
                self.channel_name
            )

            await self.accept()
        else:
            await self.close()

    async def disconnect(self, close_code):
        # Leave room group
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )

    async def receive(self, text_data):
        user = self.scope["user"]
        if not user.is_authenticated:
            await self.close()
            return
            
        data = json.loads(text_data)
        message_type = data.get('type') # اضافه کردن فیلد type برای تفکیک پیام‌ها

        # --- بخش جدید: مدیریت سیگنالینگ تماس ---
        # این بخش دیتابیس را درگیر نمی‌کند و فقط پیام را Broadcast می‌کند
        if message_type in ['call-offer', 'call-answer', 'ice-candidate', 'hangup']:
            await self.channel_layer.group_send(
                self.room_group_name,
                {
                    'type': 'webrtc_signal',
                    'data': data,
                    'sender_id': user.id
                }
            )
            return

        # --- بخش قدیمی: پیام‌های متنی (بدون تغییر در منطق دیتابیس) ---
        message = data.get('message')
        if message:
            sender_id = self.scope['user'].id
            sender = await sync_to_async(User.objects.get)(id=sender_id)

            chat_message = await sync_to_async(MessageChat.objects.create)(
                chat_room=self.chat_room,
                sender=sender,
                text=message
            )

            await self.channel_layer.group_send(
                self.room_group_name,
                {
                    'type': 'chat_message',
                    'id': chat_message.id,
                    'message': chat_message.text,
                    'created_at': chat_message.created_at.isoformat(),
                    'sender': {
                        'id': sender.id,
                        'username': sender.username, 
                    },
                    'chat_room': {'id': chat_message.chat_room.id}
                }
            )

    # اضافه کردن هندلر جدید برای سیگنال‌ها
    async def webrtc_signal(self, event):
        # پیام را به همه به جز فرستنده بفرست
        if self.scope['user'].id != event['sender_id']:
            await self.send(text_data=json.dumps(event['data']))

    async def chat_message(self, event):
        # Send message to WebSocket
        await self.send(text_data=json.dumps(event))