"""Advertisers Views

This module contains views for managing advertisers, brands, and agencies.
Includes both API views and traditional Django views for CRUD operations.

Views:
    - AgencyViewSet: API views for agency management
    - BrandViewSet: API views for brand management
    - BrandCategoryViewSet: API views for brand category management
    - UserAdvertiserViewSet: API views for user-advertiser relationships
    - Agency/Brand list, create, update, delete views
"""

import logging
from django.shortcuts import render, get_object_or_404, redirect
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator
from django.db.models import Q, Count, Sum
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods

from rest_framework import viewsets, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from django_filters.rest_framework import DjangoFilterBackend

from .models import Agency, Brand, BrandCategory, UserAdvertiser
from .serializers import (
    AgencySerializer, BrandSerializer, BrandCategorySerializer,
    UserAdvertiserSerializer, AgencyDetailSerializer, BrandDetailSerializer
)
from .filters import AgencyFilter, BrandFilter
from apps.common.permissions import IsOwnerOrReadOnly



logger = logging.getLogger(__name__)


# ============================================================================
# API ViewSets (REST Framework)
# ============================================================================

class AgencyViewSet(viewsets.ModelViewSet):
    """API ViewSet for Agency management.
    
    Provides CRUD operations for agencies with filtering, searching,
    and pagination capabilities.
    
    Endpoints:
        GET /api/agencies/ - List all agencies
        POST /api/agencies/ - Create new agency
        GET /api/agencies/{id}/ - Retrieve specific agency
        PUT /api/agencies/{id}/ - Update agency
        DELETE /api/agencies/{id}/ - Delete agency
        GET /api/agencies/{id}/brands/ - Get agency's brands
        GET /api/agencies/{id}/stats/ - Get agency statistics
    """
    
    queryset = Agency.objects.all()
    permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = AgencyFilter
    search_fields = ['name', 'description', 'contact_person']
    ordering_fields = ['name', 'created_at', 'updated_at']
    ordering = ['name']
    
    def get_serializer_class(self):
        """Return appropriate serializer based on action."""
        if self.action == 'retrieve':
            return AgencyDetailSerializer
        return AgencySerializer
    
    def get_queryset(self):
        """Filter queryset based on user permissions."""
        queryset = super().get_queryset()
        
        # Filter based on user role and permissions
        if not self.request.user.is_superuser:
            # Users can only see agencies they own or have access to
            queryset = queryset.filter(
                Q(owner=self.request.user) |
                Q(brands__user_relationships__user=self.request.user)
            ).distinct()
        
        return queryset.select_related('owner').prefetch_related('brands')
    
    def perform_create(self, serializer):
        """Set the owner when creating an agency."""
        serializer.save(owner=self.request.user)
        logger.info(f"Agency '{serializer.instance.name}' created by {self.request.user.username}")
    
    @action(detail=True, methods=['get'])
    def brands(self, request, pk=None):
        """Get all brands associated with this agency."""
        agency = self.get_object()
        brands = agency.brands.filter(status='active')
        serializer = BrandSerializer(brands, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def stats(self, request, pk=None):
        """Get statistics for this agency."""
        agency = self.get_object()
        
        stats = {
            'total_brands': agency.total_brands,
            'total_campaigns': agency.total_campaigns,
            'active_campaigns': agency.brands.filter(
                campaigns__status='active'
            ).aggregate(count=Count('campaigns'))['count'] or 0,
            'total_budget': agency.brands.aggregate(
                total=Sum('annual_budget')
            )['total'] or 0
        }
        
        return Response(stats)


class BrandViewSet(viewsets.ModelViewSet):
    """API ViewSet for Brand management.
    
    Provides CRUD operations for brands with filtering, searching,
    and pagination capabilities.
    
    Endpoints:
        GET /api/brands/ - List all brands
        POST /api/brands/ - Create new brand
        GET /api/brands/{id}/ - Retrieve specific brand
        PUT /api/brands/{id}/ - Update brand
        DELETE /api/brands/{id}/ - Delete brand
        GET /api/brands/{id}/campaigns/ - Get brand's campaigns
        GET /api/brands/{id}/stats/ - Get brand statistics
    """
    
    queryset = Brand.objects.all()
    permission_classes = [IsAuthenticated]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = BrandFilter
    search_fields = ['name', 'description', 'industry']
    ordering_fields = ['name', 'created_at', 'updated_at']
    ordering = ['name']
    
    def get_serializer_class(self):
        """Return appropriate serializer based on action."""
        if self.action == 'retrieve':
            return BrandDetailSerializer
        return BrandSerializer
    
    def get_queryset(self):
        """Filter queryset based on user permissions."""
        queryset = super().get_queryset()
        
        # Filter based on user role and permissions
        if not self.request.user.is_superuser:
            # Users can only see brands they have access to
            queryset = queryset.filter(
                Q(agency__owner=self.request.user) |
                Q(user_relationships__user=self.request.user)
            ).distinct()
        
        return queryset.select_related('agency', 'category').prefetch_related('campaigns')
    
    @action(detail=True, methods=['get'])
    def campaigns(self, request, pk=None):
        """Get all campaigns for this brand."""
        brand = self.get_object()
        campaigns = brand.campaigns.filter(status='active')
        
        # Import here to avoid circular imports
        from apps.campaigns.serializers import CampaignSerializer
        serializer = CampaignSerializer(campaigns, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def stats(self, request, pk=None):
        """Get statistics for this brand."""
        brand = self.get_object()
        
        stats = {
            'total_campaigns': brand.total_campaigns,
            'active_campaigns': brand.active_campaigns.count(),
            'total_budget_spent': float(brand.total_budget_spent),
            'annual_budget': float(brand.annual_budget) if brand.annual_budget else 0
        }
        
        return Response(stats)


class BrandCategoryViewSet(viewsets.ModelViewSet):
    """API ViewSet for Brand Category management.
    
    Provides CRUD operations for brand categories with hierarchical support.
    """
    
    queryset = BrandCategory.objects.all()
    serializer_class = BrandCategorySerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [filters.SearchFilter, filters.OrderingFilter]
    search_fields = ['name', 'description']
    ordering_fields = ['name', 'created_at']
    ordering = ['name']
    
    @action(detail=False, methods=['get'])
    def tree(self, request):
        """Get hierarchical tree of categories."""
        root_categories = self.queryset.filter(parent=None)
        serializer = self.get_serializer(root_categories, many=True)
        return Response(serializer.data)


class UserAdvertiserViewSet(viewsets.ModelViewSet):
    """API ViewSet for User-Advertiser relationship management."""
    
    queryset = UserAdvertiser.objects.all()
    serializer_class = UserAdvertiserSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter]
    filterset_fields = ['user', 'brand', 'role', 'is_active']
    ordering_fields = ['created_at', 'updated_at']
    ordering = ['-created_at']
    
    def get_queryset(self):
        """Filter based on user permissions."""
        queryset = super().get_queryset()
        
        if not self.request.user.is_superuser:
            # Users can only see their own relationships or relationships for brands they manage
            queryset = queryset.filter(
                Q(user=self.request.user) |
                Q(brand__agency__owner=self.request.user)
            ).distinct()
        
        return queryset.select_related('user', 'brand', 'brand__agency')


# ============================================================================
# Traditional Django Views
# ============================================================================

@login_required
def agency_list(request):
    """Display list of agencies with search and pagination."""
    search_query = request.GET.get('search', '')
    agencies = Agency.objects.filter(status='active')
    
    # Apply search filter
    if search_query:
        agencies = agencies.filter(
            Q(name__icontains=search_query) |
            Q(description__icontains=search_query) |
            Q(contact_person__icontains=search_query)
        )
    
    # Filter based on user permissions
    if not request.user.is_superuser:
        agencies = agencies.filter(
            Q(owner=request.user) |
            Q(brands__user_relationships__user=request.user)
        ).distinct()
    
    # Pagination
    paginator = Paginator(agencies, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    context = {
        'page_obj': page_obj,
        'search_query': search_query,
        'total_agencies': agencies.count()
    }
    
    return render(request, 'advertisers/agency_list.html', context)


@login_required
def agency_detail(request, agency_id):
    """Display detailed view of an agency."""
    agency = get_object_or_404(Agency, id=agency_id, status='active')
    
    # Check permissions
    if not request.user.is_superuser and agency.owner != request.user:
        # Check if user has access through brand relationships
        if not agency.brands.filter(user_relationships__user=request.user).exists():
            messages.error(request, "You don't have permission to view this agency.")
            return redirect('advertisers:agency_list')
    
    brands = agency.brands.filter(status='active')
    
    context = {
        'agency': agency,
        'brands': brands,
        'total_brands': brands.count(),
        'total_campaigns': agency.total_campaigns
    }
    
    return render(request, 'advertisers/agency_detail.html', context)


@login_required
def brand_list(request):
    """Display list of brands with search and filtering."""
    search_query = request.GET.get('search', '')
    agency_filter = request.GET.get('agency', '')
    category_filter = request.GET.get('category', '')
    
    brands = Brand.objects.filter(status='active')
    
    # Apply filters
    if search_query:
        brands = brands.filter(
            Q(name__icontains=search_query) |
            Q(description__icontains=search_query) |
            Q(industry__icontains=search_query)
        )
    
    if agency_filter:
        brands = brands.filter(agency_id=agency_filter)
    
    if category_filter:
        brands = brands.filter(category_id=category_filter)
    
    # Filter based on user permissions
    if not request.user.is_superuser:
        brands = brands.filter(
            Q(agency__owner=request.user) |
            Q(user_relationships__user=request.user)
        ).distinct()
    
    # Get filter options
    agencies = Agency.objects.filter(status='active')
    categories = BrandCategory.objects.all()
    
    if not request.user.is_superuser:
        agencies = agencies.filter(
            Q(owner=request.user) |
            Q(brands__user_relationships__user=request.user)
        ).distinct()
    
    # Pagination
    paginator = Paginator(brands, 12)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    context = {
        'page_obj': page_obj,
        'search_query': search_query,
        'agencies': agencies,
        'categories': categories,
        'selected_agency': agency_filter,
        'selected_category': category_filter,
        'total_brands': brands.count()
    }
    
    return render(request, 'advertisers/brand_list.html', context)


@login_required
def brand_detail(request, brand_id):
    """Display detailed view of a brand."""
    brand = get_object_or_404(Brand, id=brand_id, status='active')
    
    # Check permissions
    if not request.user.is_superuser:
        if (brand.agency.owner != request.user and 
            not brand.user_relationships.filter(user=request.user).exists()):
            messages.error(request, "You don't have permission to view this brand.")
            return redirect('advertisers:brand_list')
    
    campaigns = brand.campaigns.filter(status='active')[:5]  # Latest 5 campaigns
    
    context = {
        'brand': brand,
        'campaigns': campaigns,
        'total_campaigns': brand.total_campaigns,
        'active_campaigns': brand.active_campaigns.count(),
        'total_budget_spent': brand.total_budget_spent
    }
    
    return render(request, 'advertisers/brand_detail.html', context)


# ============================================================================
# AJAX Views
# ============================================================================

@login_required
@require_http_methods(["GET"])
def get_agency_brands(request, agency_id):
    """AJAX endpoint to get brands for a specific agency."""
    try:
        agency = get_object_or_404(Agency, id=agency_id)
        brands = agency.brands.filter(status='active').values('id', 'name')
        return JsonResponse({'brands': list(brands)})
    except Exception as e:
        logger.error(f"Error fetching brands for agency {agency_id}: {str(e)}")
        return JsonResponse({'error': 'Failed to fetch brands'}, status=500)


@login_required
@require_http_methods(["POST"])
@csrf_exempt
def toggle_brand_status(request, brand_id):
    """AJAX endpoint to toggle brand active status."""
    try:
        brand = get_object_or_404(Brand, id=brand_id)
        
        # Check permissions
        if not request.user.is_superuser and brand.agency.owner != request.user:
            return JsonResponse({'error': 'Permission denied'}, status=403)
        
        brand.status = 'inactive' if brand.status == 'active' else 'active'
        brand.save()
        
        logger.info(f"Brand '{brand.name}' status changed to {brand.status} by {request.user.username}")
        
        return JsonResponse({
            'success': True,
            'new_status': brand.status,
            'message': f"Brand status updated to {brand.status}"
        })
    
    except Exception as e:
        logger.error(f"Error toggling brand status: {str(e)}")
        return JsonResponse({'error': 'Failed to update brand status'}, status=500)


# ============================================================================
# CRUD Views for Agencies
# ============================================================================

@login_required
def agency_create(request):
    """Create a new agency."""
    from .forms import AgencyForm
    
    if request.method == 'POST':
        form = AgencyForm(request.POST, request.FILES, user=request.user)
        if form.is_valid():
            agency = form.save()
            messages.success(request, f"Agency '{agency.name}' created successfully.")
            logger.info(f"Agency '{agency.name}' created by {request.user.username}")
            return redirect('advertisers:agency_detail', agency_id=agency.id)
    else:
        form = AgencyForm(user=request.user)
    
    context = {
        'form': form,
        'title': 'Create New Agency',
        'submit_text': 'Create Agency'
    }
    
    return render(request, 'advertisers/agency_form.html', context)


@login_required
def agency_edit(request, agency_id):
    """Edit an existing agency."""
    from .forms import AgencyForm
    
    agency = get_object_or_404(Agency, id=agency_id)
    
    # Check permissions
    if not request.user.is_superuser and agency.owner != request.user:
        messages.error(request, "You don't have permission to edit this agency.")
        return redirect('advertisers:agency_detail', agency_id=agency.id)
    
    if request.method == 'POST':
        form = AgencyForm(request.POST, request.FILES, instance=agency, user=request.user)
        if form.is_valid():
            agency = form.save()
            messages.success(request, f"Agency '{agency.name}' updated successfully.")
            logger.info(f"Agency '{agency.name}' updated by {request.user.username}")
            return redirect('advertisers:agency_detail', agency_id=agency.id)
    else:
        form = AgencyForm(instance=agency, user=request.user)
    
    context = {
        'form': form,
        'agency': agency,
        'title': f'Edit {agency.name}',
        'submit_text': 'Update Agency'
    }
    
    return render(request, 'advertisers/agency_form.html', context)


@login_required
def agency_delete(request, agency_id):
    """Delete an agency."""
    agency = get_object_or_404(Agency, id=agency_id)
    
    # Check permissions
    if not request.user.is_superuser and agency.owner != request.user:
        messages.error(request, "You don't have permission to delete this agency.")
        return redirect('advertisers:agency_detail', agency_id=agency.id)
    
    if request.method == 'POST':
        agency_name = agency.name
        agency.delete()
        messages.success(request, f"Agency '{agency_name}' deleted successfully.")
        logger.info(f"Agency '{agency_name}' deleted by {request.user.username}")
        return redirect('advertisers:agency_list')
    
    context = {
        'agency': agency,
        'title': f'Delete {agency.name}'
    }
    
    return render(request, 'advertisers/agency_confirm_delete.html', context)


# ============================================================================
# CRUD Views for Brands
# ============================================================================

@login_required
def brand_create(request):
    """Create a new brand."""
    from .forms import BrandForm
    
    # Get agency from query parameter if provided
    agency_id = request.GET.get('agency')
    initial_data = {}
    if agency_id:
        try:
            agency = Agency.objects.get(id=agency_id, status='active')
            # Check if user has permission to create brands for this agency
            if request.user.is_superuser or agency.owner == request.user:
                initial_data['agency'] = agency
        except Agency.DoesNotExist:
            pass
    
    if request.method == 'POST':
        form = BrandForm(request.POST, request.FILES, user=request.user)
        if form.is_valid():
            brand = form.save()
            messages.success(request, f"Brand '{brand.name}' created successfully.")
            logger.info(f"Brand '{brand.name}' created by {request.user.username}")
            return redirect('advertisers:brand_detail', brand_id=brand.id)
    else:
        form = BrandForm(initial=initial_data, user=request.user)
    
    context = {
        'form': form,
        'title': 'Create New Brand',
        'submit_text': 'Create Brand'
    }
    
    return render(request, 'advertisers/brand_form.html', context)


@login_required
def brand_edit(request, brand_id):
    """Edit an existing brand."""
    from .forms import BrandForm
    
    brand = get_object_or_404(Brand, id=brand_id)
    
    # Check permissions
    if not request.user.is_superuser:
        if (brand.agency.owner != request.user and 
            not brand.user_relationships.filter(user=request.user, role__in=['manager', 'admin']).exists()):
            messages.error(request, "You don't have permission to edit this brand.")
            return redirect('advertisers:brand_detail', brand_id=brand.id)
    
    if request.method == 'POST':
        form = BrandForm(request.POST, request.FILES, instance=brand, user=request.user)
        if form.is_valid():
            brand = form.save()
            messages.success(request, f"Brand '{brand.name}' updated successfully.")
            logger.info(f"Brand '{brand.name}' updated by {request.user.username}")
            return redirect('advertisers:brand_detail', brand_id=brand.id)
    else:
        form = BrandForm(instance=brand, user=request.user)
    
    context = {
        'form': form,
        'brand': brand,
        'title': f'Edit {brand.name}',
        'submit_text': 'Update Brand'
    }
    
    return render(request, 'advertisers/brand_form.html', context)


@login_required
def brand_delete(request, brand_id):
    """Delete a brand."""
    brand = get_object_or_404(Brand, id=brand_id)
    
    # Check permissions
    if not request.user.is_superuser:
        if (brand.agency.owner != request.user and 
            not brand.user_relationships.filter(user=request.user, role='admin').exists()):
            messages.error(request, "You don't have permission to delete this brand.")
            return redirect('advertisers:brand_detail', brand_id=brand.id)
    
    if request.method == 'POST':
        brand_name = brand.name
        agency = brand.agency
        brand.delete()
        messages.success(request, f"Brand '{brand_name}' deleted successfully.")
        logger.info(f"Brand '{brand_name}' deleted by {request.user.username}")
        return redirect('advertisers:agency_detail', agency_id=agency.id)
    
    context = {
        'brand': brand,
        'title': f'Delete {brand.name}'
    }
    
    return render(request, 'advertisers/brand_confirm_delete.html', context)


# ============================================================================
# Performance and Analytics Views
# ============================================================================

@login_required
@require_http_methods(["GET"])
def agency_performance_data(request, agency_id):
    """AJAX endpoint to get agency performance data for charts."""
    try:
        agency = get_object_or_404(Agency, id=agency_id)
        
        # Check permissions
        if not request.user.is_superuser and agency.owner != request.user:
            if not agency.brands.filter(user_relationships__user=request.user).exists():
                return JsonResponse({'error': 'Permission denied'}, status=403)
        
        period = request.GET.get('period', '30')  # days
        
        # Sample performance data (replace with actual analytics)
        performance_data = {
            'impressions': [1200, 1350, 1100, 1400, 1250, 1600, 1450],
            'clicks': [45, 52, 38, 61, 48, 73, 56],
            'conversions': [3, 4, 2, 5, 3, 6, 4],
            'dates': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05', '2024-01-06', '2024-01-07'],
            'ctr': 4.2,
            'conversion_rate': 8.1,
            'total_budget': float(agency.brands.aggregate(total=Sum('annual_budget'))['total'] or 0)
        }
        
        return JsonResponse(performance_data)
    
    except Exception as e:
        logger.error(f"Error fetching agency performance data: {str(e)}")
        return JsonResponse({'error': 'Failed to fetch performance data'}, status=500)


@login_required
@require_http_methods(["GET"])
def brand_performance_data(request, brand_id):
    """AJAX endpoint to get brand performance data for charts."""
    try:
        brand = get_object_or_404(Brand, id=brand_id)
        
        # Check permissions
        if not request.user.is_superuser:
            if (brand.agency.owner != request.user and 
                not brand.user_relationships.filter(user=request.user).exists()):
                return JsonResponse({'error': 'Permission denied'}, status=403)
        
        period = request.GET.get('period', '30')  # days
        
        # Sample performance data (replace with actual analytics)
        performance_data = {
            'impressions': [800, 950, 720, 1100, 890, 1200, 1050],
            'clicks': [32, 41, 28, 48, 35, 56, 42],
            'conversions': [2, 3, 1, 4, 2, 5, 3],
            'dates': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05', '2024-01-06', '2024-01-07'],
            'ctr': 3.8,
            'conversion_rate': 7.5,
            'budget_spent': float(brand.total_budget_spent),
            'annual_budget': float(brand.annual_budget) if brand.annual_budget else 0
        }
        
        return JsonResponse(performance_data)
    
    except Exception as e:
        logger.error(f"Error fetching brand performance data: {str(e)}")
        return JsonResponse({'error': 'Failed to fetch performance data'}, status=500)


# ============================================================================
# Utility Views
# ============================================================================

@login_required
def advertiser_list(request):
    """
    Display a combined list of agencies and brands with filtering and search.
    
    This view provides a unified interface for managing both agencies and brands,
    with advanced filtering, search, and pagination capabilities.
    """
    # Get search query
    search_query = request.GET.get('search', '').strip()
    
    # Get filter parameters
    agency_filter = request.GET.get('agency', '')
    category_filter = request.GET.get('category', '')
    status_filter = request.GET.get('status', '')
    
    # Base querysets with permission filtering
    if request.user.is_superuser:
        agencies = Agency.objects.filter(status='active')
        brands = Brand.objects.filter(status='active')
    else:
        # Get agencies where user is owner or has brand relationships
        user_agencies = Agency.objects.filter(
            Q(owner=request.user) |
            Q(brands__user_relationships__user=request.user)
        ).filter(status='active').distinct()
        
        agencies = user_agencies
        brands = Brand.objects.filter(
            agency__in=user_agencies,
            status='active'
        )
    
    # Apply search filters
    if search_query:
        agencies = agencies.filter(
            Q(name__icontains=search_query) |
            Q(description__icontains=search_query) |
            Q(contact_person__icontains=search_query)
        )
        brands = brands.filter(
            Q(name__icontains=search_query) |
            Q(description__icontains=search_query) |
            Q(industry__icontains=search_query)
        )
    
    # Apply agency filter to brands
    if agency_filter:
        brands = brands.filter(agency_id=agency_filter)
    
    # Apply category filter to brands
    if category_filter:
        brands = brands.filter(category_id=category_filter)
    
    # Apply status filter
    if status_filter:
        if status_filter == 'active':
            agencies = agencies.filter(status='active')
            brands = brands.filter(status='active')
        elif status_filter == 'inactive':
            agencies = agencies.filter(status='inactive')
            brands = brands.filter(status='inactive')
    
    # Get filter options
    all_agencies = Agency.objects.filter(status='active')
    if not request.user.is_superuser:
        all_agencies = all_agencies.filter(
            Q(owner=request.user) |
            Q(brands__user_relationships__user=request.user)
        ).distinct()
    
    categories = BrandCategory.objects.all()
    
    # Calculate statistics
    total_agencies = agencies.count()
    total_brands = brands.count()
    active_campaigns = 0  # Would be calculated from campaign data
    total_budget = brands.aggregate(
        total=Sum('annual_budget')
    )['total'] or 0
    
    # Pagination for brands (main content)
    paginator = Paginator(brands.select_related('agency', 'category'), 25)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    context = {
        'agencies': all_agencies,
        'brands': page_obj,
        'categories': categories,
        'search_query': search_query,
        'agency_filter': agency_filter,
        'category_filter': category_filter,
        'status_filter': status_filter,
        'total_agencies': total_agencies,
        'total_brands': total_brands,
        'active_campaigns': active_campaigns,
        'total_budget': total_budget,
        'page_obj': page_obj,
    }
    
    return render(request, 'advertisers/list.html', context)


@login_required
def dashboard_stats(request):
    """
    Get dashboard statistics for agencies and brands.
    
    Returns aggregated statistics including:
    - Total agencies and brands
    - Total campaigns and budget
    - Filtered by user permissions
    """
    # Filter based on user permissions
    if request.user.is_superuser:
        agencies = Agency.objects.filter(status='active')
        brands = Brand.objects.filter(status='active')
    else:
        # Get agencies where user is owner or has brand relationships
        user_agencies = Agency.objects.filter(
            Q(owner=request.user) |
            Q(brands__user_relationships__user=request.user)
        ).filter(status='active').distinct()
        
        agencies = user_agencies
        brands = Brand.objects.filter(
            agency__in=user_agencies,
            status='active'
        )
    
    # Calculate statistics
    total_agencies = agencies.count()
    total_brands = brands.count()
    
    # These would be calculated from actual campaign data
    total_campaigns = 0  # Sum of campaigns from all brands
    total_budget = 0     # Sum of budgets from all brands
    
    # Sample data for now
    stats = {
        'total_agencies': total_agencies,
        'total_brands': total_brands,
        'total_campaigns': total_campaigns,
        'total_budget': total_budget,
        'active_campaigns': 0,
        'budget_spent': 0,
    }
    
    if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
        return JsonResponse(stats)
    
    return JsonResponse(stats)