from django.db import models
from django.utils import timezone
from django.contrib.contenttypes.models import ContentType


class ActivityCategoryManager(models.Manager):
    """Custom manager for ActivityCategory model that returns only active categories."""
    
    def get_queryset(self):
        """Override to return only active categories."""
        return super().get_queryset().filter(is_active=True)


class ActivityManager(models.Manager):
    """
    Custom manager for Activity model with additional query methods.
    
    This manager provides convenient methods for querying activities
    with common filters and aggregations.
    """
    
    def for_user(self, user):
        """
        Get activities for a specific user.
        
        Args:
            user: User instance to filter activities for
        
        Returns:
            QuerySet: Activities performed by the specified user
        """
        return self.filter(user=user)
    
    def by_user(self, user):
        """Alias for for_user method."""
        return self.for_user(user)
    
    def for_object(self, obj):
        """
        Get activities for a specific object.
        
        Args:
            obj: Model instance to get activities for
        
        Returns:
            QuerySet: Activities related to the specified object
        """
        content_type = ContentType.objects.get_for_model(obj)
        return self.filter(content_type=content_type, object_id=obj.pk)
    
    def by_category(self, category_code):
        """
        Get activities by category code.
        
        Args:
            category_code (str): Category code to filter by
        
        Returns:
            QuerySet: Activities in the specified category
        """
        return self.filter(category__code=category_code)
    
    def recent(self, days=7):
        """
        Get recent activities within the specified number of days.
        
        Args:
            days (int): Number of days to look back (default: 7)
        
        Returns:
            QuerySet: Activities from the last N days
        """
        cutoff_date = timezone.now() - timezone.timedelta(days=days)
        return self.filter(created_at__gte=cutoff_date)
    
    def by_action(self, action):
        """
        Get activities by action type.
        
        Args:
            action (str): Action type to filter by
        
        Returns:
            QuerySet: Activities with the specified action
        """
        return self.filter(action=action)
    
    def successful(self):
        """
        Get only successful activities.
        
        Returns:
            QuerySet: Activities that completed successfully
        """
        return self.filter(is_successful=True)
    
    def failed(self):
        """
        Get only failed activities.
        
        Returns:
            QuerySet: Activities that failed
        """
        return self.filter(is_successful=False)
    
    def in_date_range(self, start_date, end_date):
        """
        Get activities within a specific date range.
        
        Args:
            start_date: Start date for the range
            end_date: End date for the range
        
        Returns:
            QuerySet: Activities within the specified date range
        """
        return self.filter(created_at__gte=start_date, created_at__lte=end_date)