import json
from channels.consumer import AsyncConsumer

from channels.generic.websocket import AsyncJsonWebsocketConsumer
from asgiref.sync import sync_to_async
import base64


# Channel consumer for both chat room group

class ChatConsumer(AsyncJsonWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = 'chat_%s' % self.room_name

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

        await self.accept()


    async def disconnect(self, close_code):

        # Leave room group
        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)

    # Receive message from WebSocket

    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        if message_type == 'edit_message':
            message_id = text_data_json['message_id']
            new_message = text_data_json['new_message']
            await self.edit_message(message_id, new_message)


        @sync_to_async
        def edit_message(self, message_id, new_message):
            # update retreived message from database
            message = Message.objects.get(id=message_id)
            message.content = new_message
            message.save()

        # broadcast (send) to group
        self.channel_layer.group_send(
            self.group_name,
            {
                'type': 'message_edited',
                'message_id': message_id,
                'new_message': new_message,
            }
        }

    async def message_edited(self, event):
        message_id = event['message_id']
        new_message = event['new_message']
        await self.send(text_data=json.dumps({
            'type': 'message_edited',
            'message_id': message_id,
            'new_message': new_message,
        }))
        print(f"Received message: {message}")
        # Send message to room group
        await self.channel_layer.group_send(
            self.room_group_name, {'type': 'chat.message', 'message': message}
        )

    # Receive message from room group

    async def chat_message(self, event):
        message = event['message']
        print(f"Broadcasting message: {message}")  # Debugging output
        # send message to websocket
        await self.send(text_data=json.dumps({'message': message}))


# Channel Consumer that consumed events for uploading/receiving image files in the message room

class UploadImageConsumer(AsyncJsonWebsocketConsumer):
    async def connect(self):
        await self.accept()


    async def disconnect(self, close_code):

        async def receive(self, bytes_data=None, text_data=None):
            if bytes_data:
            # Handles image file chunks (binary data)

                with open('image.jpg', 'rb') as f:
                    fcontent = f.read()
                await self.send(base64.b64encode(fcontent).decode('utf-8'))
            elif text_data:
                # Handles metadata (text data)

                await self.send(text_data=json.dumps({'message': text_data}))


    async def send_image(self, event):
        image_data = event['image_text']
        await self.send(bytes_data=image_data)