import json
from asgiref.sync import async_to_sync
from channels.generic.websocket import WebsocketConsumer
from channels.generic.websocket import AsyncWebsocketConsumer
from time import sleep
import asyncio



class TestwebsocketConsumer(WebsocketConsumer):
    def connect(self):
        
        self.room_name='test_consumer'
        self.room_group_name='test_consumer_group'
        async_to_sync(self.channel_layer.group_add)(
            self.room_name,
            self.room_group_name
        )
        print("Websocket Connects")
        self.accept()
        self.send(text_data=json.dumps({'status': 'connected channels'}))
        
        
 

    def receive(self, text_data):
        print("Message Received From Client",text_data)
        self.send(text_data=json.dumps({'status': 'connected channels'}))
        
        
    def disconnect(self, close_code):
    
        print("Websocket Disconnect")    
        
             
    def send_notification(self,event):
        print("send notification")
        print(event)








class MywebsocketConsumer(WebsocketConsumer):
    def connect(self):
        
        self.room_name='test_consumer'
        self.room_group_name='test_consumer_group'
        async_to_sync(self.channel_layer.group_add)(
            self.room_group_name,
            self.channel_name
           
        )
        print("Websocket Connects")
        self.accept()
        self.send(text_data=json.dumps({'status': 'connected channels'}))
        
        
  

    def receive(self, text_data):
        print("Message Received From Client",text_data)
        self.send(text_data=json.dumps({'status': 'we got you save'}))
        
    # def disconnect(self, *args,**kwargs):
        
    #     print("Websocket Disconnect")
             
    def send_notification(self,event):
        print("send notification")
        print(event)
        print("send notification")


class MyAsyncwebsocketConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.channel_layer.group_add("quotations", self.channel_name)
        await self.accept()
        
        
        print("Websocket Connect")

    async def disconnect(self, close_code):
        await self.channel_layer.group_discard("quotations", self.channel_name)
        print("Websocket Disconnect")

    async def receive(self, text_data):
         print("Message Received From Client",text_data)
         for i in range(20):
             await self.send(text_data=str(i))
             await asyncio.sleep
             
             
    async def send_quote_data(self, event):
        await self.send(text_data=json.dumps(event['data']))         
             
from channels.generic.websocket import WebsocketConsumer

class RealTimeUpdatesConsumer(WebsocketConsumer):
    def connect(self):
        self.group_name = 'realtime_updates_group'

        # Join the group
        self.channel_layer.group_add(
            self.group_name,
            self.channel_name
        )

        self.accept()

    def disconnect(self, close_code):
        # Leave the group
        self.channel_layer.group_discard(
            self.group_name,
            self.channel_name
        )

    def send_updates(self, event):
        # Send message to WebSocket
        self.send(text_data=json.dumps(event['data']))
        
from product.models import Student        
from asgiref.sync import sync_to_async        
class StudentDetailConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.group_name='tableData'
        await self.channel_layer.group_add(
            self.group_name,
            self.channel_name
        )
        print("connect")
        await self.accept()

    async def disconnect(self, close_code):
        await self.channel_layer.group_discard(
            self.group_name,
            self.channel_name
        )
        print("disconnect")
        
        
        
    async def receive(self,text_data):
        print (text_data)
        await self.channel_layer.group_send(
            self.group_name,
            {
                'type':'randomFunction',
                'value':text_data,
            }
        )    
        
        

    # async def update_student_detail(self, event):
    #     field = event['field']
    #     value = event['value']
    #     await self.send(text_data=json.dumps({
    #         'field': field,
    #         'value': value
    #     }))

    # @sync_to_async
    # def get_student_detail(self):
    #     student = Student.objects.all()
    #     print("deepak")
    #     print(student)
    #     return student.phone_number, student.address
            
class TableData(AsyncWebsocketConsumer):

    async def connect(self):
        self.group_name='tableData'
        await self.channel_layer.group_add(
            self.group_name,
            self.channel_name
        )

        await self.accept()

    async def disconnect(self,close_code):
        pass

    async def receive(self,text_data):
        print (text_data)
        await self.channel_layer.group_send(
            self.group_name,
            {
                'type':'randomFunction',
                'value':text_data,
            }
        )

    async def randomFunction(self,event):
        print (event['value'])
        await self.send(event['value'])