from .visitor.visitor import Visitor
from .visitor import utils
from django.utils import timezone
from django.contrib.auth import get_user_model
from django.core.cache import cache
import logging
import json

logger = logging.getLogger(__name__)

User = get_user_model()

class VisitorTrackingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        visitor = Visitor(
            ip_address=request.META['REMOTE_ADDR'],
            user_agent=request.META.get('HTTP_USER_AGENT', ''),
            visited_url=request.path,
            uuid=utils.getUUID(request),
        )
        visitor.save()


        response = self.get_response(request)
        response.set_cookie('X_UUID', utils.getUUID(request), max_age=365*24*60*60)
        return response


class UserActivityMiddleware:
    """
    Middleware to track user activity as a fallback when signals don't work.
    
    This should only be used as a fallback since the primary activity tracking
    happens via authentication signals (user_logged_in, jwt_authenticated).
    
    Updated to track ALL requests without cache timeout as requested.
    """

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        
        # Only track for authenticated users
        if hasattr(request, 'user') and request.user.is_authenticated:
            if self.should_track_request(request):
                self.update_user_activity(request.user)
        
        return response

    def should_track_request(self, request):
        """
        Determine if we should track this request.
        """
        path = request.path
        
        # Skip static files and common excluded paths
        excluded_paths = [
            '/static/',
            '/media/',
            '/favicon.ico',
            '/robots.txt',
            '/__debug__/',
        ]
        
        for excluded in excluded_paths:
            if path.startswith(excluded):
                return False
        
        return True

    def update_user_activity(self, user):
        """
        Update user's last activity without any cache timeout.
        All requests will update activity as requested.
        """
        try:
            # Update user activity immediately - no cache, no throttling
            User.objects.filter(pk=user.pk).update(
                last_active_date=timezone.now()
            )
            
            logger.debug(f"Updated activity for user {user.pk} via middleware fallback")
            
        except Exception as e:
            logger.error(f"Error updating user activity for user {user.pk}: {e}")