from channels.generic.websocket import WebsocketConsumer 
from .models import * 
import json
from django.template.loader import render_to_string
from asgiref.sync import async_to_sync
import threading

def get_last_seen(user):
        connection = Connection.objects.filter(user=user).last()
        if not connection.exists():
            return "Not seen yet"

        if connection.online:
            return "Online"
        last_seen_time = connection.last_seen
        now = timezone.now()
        time_diff = now - last_seen_time
        if time_diff < timedelta(days=1):
            if last_seen_time.date() == now.date():
                return f"last seen today at {last_seen_time.strftime('%I:%M %p')}"
            else:
                return f"last seen yesterday at {last_seen_time.strftime('%I:%M %p')}"
        else:
            return f"last seen on {last_seen_time.strftime('%b %d at %I:%M %p')}"



class OnlineUserConsumer(WebsocketConsumer):
    def connect(self):
        self.user = self.scope['user']
        existing_connection = Connection.objects.filter(user=self.user).last()
        if existing_connection:
            self.connection = existing_connection
            self.connection.online = True
            self.connection.disconnected = False
            self.connection.save()
        else:
            self.connection = Connection.objects.create(user=self.user, online=True)

        async_to_sync(self.channel_layer.group_add)(
            'online_users', self.channel_name
        )
        self.accept()
        self.modify_online_user()

    def disconnect(self, close_code):
        self.last_seen = datetime.now()
        self.connection.disconnected = True
        self.connection.save()
        timer_thread = threading.Timer(10, self.check_disconnect_status)
        timer_thread.start()

    def check_disconnect_status(self):
        connection = Connection.objects.filter(user=self.user).last()
        if connection.disconnected:
            self.connection.last_seen = self.last_seen
            self.connection.online = False
            self.connection.save()
        self.modify_online_user()

    def modify_online_user(self):
        connections = Connection.objects.filter(online=True)
        online_users_ids = [connection.user.id for connection in connections]
        customer_connections = []
        staff_connections = []
        for connection in connections:
            if hasattr(connection.user, 'customerprofile'):
                customer_connections.append(connection)
            elif hasattr(connection.user, 'staffprofile'):
                staff_connections.append(connection)

        print(staff_connections)
        event = {
            'type': 'online_user_connection_handler',
            'staff_connections': staff_connections,
            'customer_connections': customer_connections,
            'online_users_ids': online_users_ids
        }
        async_to_sync(self.channel_layer.group_send)(
            'online_users', event
        )

    def online_user_connection_handler(self, event):
        context = {
            'staff_connections': event['staff_connections'],
            'customer_connections': event['customer_connections'],
        }
        html = render_to_string("details_templates/partials/recently-online.html", context=context)
        self.send(text_data=json.dumps({
            'event_type': 'online_user_status',
            'html': html,
            'online_users_ids': event.get('online_users_ids', []) 
        }))