import json
from channels.generic.websocket import AsyncWebsocketConsumer , WebsocketConsumer
from django.contrib.auth import get_user_model
from channels.db import database_sync_to_async
from .models import Chat
from auth_apis.models import User
from asgiref.sync import async_to_sync


# User = get_user_model()

class ChatConsumer(WebsocketConsumer):
    def connect(self):
        self.sender_id = self.scope['url_route']['kwargs']['sender_id']
        self.receiver_id = self.scope['url_route']['kwargs']['receiver_id']
        self.sender = self.get_user(self.sender_id)
        print('sender',self.sender)
        self.receiver = self.get_user(self.receiver_id)
        print('receiver',self.receiver)
        self.chat_room_name = f'chat_{self.sender_id}_{self.receiver_id}'
        async_to_sync (self.channel_layer.group_add)(
            self.chat_room_name,
            self.channel_name
        )
        self.accept()

        self.send(text_data=json.dumps ({
            'type': 'connection_established',
            'message': 'You are now connected!'
            }))

    def disconnect(self, close_code):
        async_to_sync(self.channel_layer.group_discard)(
            self.chat_room_name,
            self.channel_name
        )

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

        async_to_sync(self.create_message(message))

        # data = {
        #     'sender_id': self.sender_id,
        #     'receiver_id': self.receiver_id,
        #     'message': message
        # }

        async_to_sync(self.channel_layer.group_send)(
            self.chat_room_name,
            {
                'type': 'chat_message',
                'message': message,
                'sender': self.sender.id,
                'receiver': self.receiver.id,
                'created_at': str(Chat.objects.latest('created_at').created_at),
            }
        )

    def chat_message(self, event):
        message = event['message']
        sender = event['sender']
        created_at = event['created_at']
        # data = event['data']
        # await self.send(text_data=json.dumps(data))

        self.send(text_data=json.dumps({
            'message': message,
            'sender': sender,
            'created_at': created_at,
        }))

    # @staticmethod
    def get_user(self, user_id):
        try:
            user = User.objects.get(id=user_id)
            return user
        except User.DoesNotExist:
            return None

    def create_message(self, message):
        # Chat.objects.create(
        #     sender=self.sender,
        #     receiver=self.receiver,
        #     message=message
        # )
        chat = Chat.objects.create(sender=self.sender, receiver=self.receiver, message=message)

    def get_chat_room(self):
        return f'chat_{min(self.sender_id, self.receiver_id)}_{max(self.sender_id, self.receiver_id)}'



# class ChatConsumerAPI(AsyncWebsocketConsumer):
#     async def connect(self):
#         self.sender_id = self.scope['url_route']['kwargs']['sender_id']
#         self.receiver_id = self.scope['url_route']['kwargs']['receiver_id']
#         self.sender = await self.get_user(self.sender_id)
#         print('sender',self.sender)
#         self.receiver = await self.get_user(self.receiver_id)
#         self.chat_room_name = f'chat_{self.sender_id}_{self.receiver_id}'
#         await self.channel_layer.group_add(
#             self.chat_room_name,
#             self.channel_name
#         )
#         await self.accept()

#     async def disconnect(self, close_code):
#         await self.channel_layer.group_discard(
#             self.chat_room_name,
#             self.channel_name
#         )

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

#         await self.create_message(message)

#         # data = {
#         #     'sender_id': self.sender_id,
#         #     'receiver_id': self.receiver_id,
#         #     'message': message
#         # }

#         await self.channel_layer.group_send(
#             self.chat_room_name,
#             {
#                 'type': 'chat_message',
#                 'message': message,
#                 'sender': self.sender.username,
#                 'created_at': str(Chat.objects.latest('created_at').created_at),
#             }
#         )

#     async def chat_message(self, event):
#         message = event['message']
#         sender = event['sender']
#         created_at = event['created_at']
#         # data = event['data']
#         # await self.send(text_data=json.dumps(data))

#         await self.send(text_data=json.dumps({
#             'message': message,
#             'sender': sender,
#             'created_at': created_at,
#         }))

#     # @staticmethod
#     async def get_user(self, user_id):
#         try:
#             user = await User.objects.get(id=user_id)
#             return user
#         except User.DoesNotExist:
#             return None

#     async def create_message(self, message):
#         # Chat.objects.create(
#         #     sender=self.sender,
#         #     receiver=self.receiver,
#         #     message=message
#         # )
#         chat = Chat.objects.create(sender=self.sender, receiver=self.receiver, message=message)

#     def get_chat_room(self):
#         return f'chat_{min(self.sender_id, self.receiver_id)}_{max(self.sender_id, self.receiver_id)}'


    # async def get_user(self, user_id):
    #     user = await self.get_user_from_db(user_id)
    #     return ChatUser.objects.get(user=user)

    # @database_sync_to_async
    # def get_user_from_db(self, user_id):
    #     return User.objects.get(pk=user_id)



    #  @database_sync_to_async
    # def get_b_users(self, id):
    #     # id = int(id)
    #     c = Buyer.objects.filter(id=id)[0]
    #     l = c.id

    #     return l
    # @database_sync_to_async
    # def get_s_users(self, id):
    #     # id = int(id)
    #     c = Stores.objects.filter(id=id)[0]
    #     l = c.id

    #     return l