# -*- coding: utf-8 -*-
"""
Notifications Admin Configuration

This module configures the Django admin interface for the notifications app,
including custom admin classes, filters, actions, and display options.

Admin Classes:
    - NotificationTypeAdmin: Manage notification types
    - NotificationAdmin: Manage notifications
    - NotificationPreferenceAdmin: Manage user preferences
    - NotificationTemplateAdmin: Manage templates
    - NotificationQueueAdmin: Manage notification queue
    - NotificationHistoryAdmin: View delivery history

Author: AdTlas Development Team
Version: 1.0.0
Last Updated: 2024
"""

import csv
from datetime import datetime, timedelta
from django.contrib import admin
from django.contrib.admin import SimpleListFilter
from django.db.models import Count, Q
from django.http import HttpResponse
from django.urls import reverse
from django.utils.html import format_html
from django.utils.safestring import mark_safe
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from django.contrib import messages
from django.shortcuts import redirect
from django.template.response import TemplateResponse
from django.core.exceptions import ValidationError

from .models import (
    NotificationType,
    Notification,
    NotificationPreference,
    NotificationTemplate,
    NotificationQueue,
    NotificationHistory,
)


# Custom Filters
class NotificationTypeFilter(SimpleListFilter):
    """
    Filter notifications by type.
    """
    title = _('Notification Type')
    parameter_name = 'notification_type'
    
    def lookups(self, request, model_admin):
        """
        Return a list of tuples for filter options.
        
        Args:
            request: HTTP request
            model_admin: Model admin instance
        
        Returns:
            list: List of (value, label) tuples
        """
        types = NotificationType.objects.active().values_list('id', 'name')
        return [(str(type_id), name) for type_id, name in types]
    
    def queryset(self, request, queryset):
        """
        Filter the queryset based on the selected value.
        
        Args:
            request: HTTP request
            queryset: Original queryset
        
        Returns:
            QuerySet: Filtered queryset
        """
        if self.value():
            return queryset.filter(notification_type__id=self.value())
        return queryset


class ReadStatusFilter(SimpleListFilter):
    """
    Filter notifications by read status.
    """
    title = _('Read Status')
    parameter_name = 'read_status'
    
    def lookups(self, request, model_admin):
        """
        Return filter options.
        
        Args:
            request: HTTP request
            model_admin: Model admin instance
        
        Returns:
            list: List of (value, label) tuples
        """
        return [
            ('unread', _('Unread')),
            ('read', _('Read')),
        ]
    
    def queryset(self, request, queryset):
        """
        Filter the queryset based on read status.
        
        Args:
            request: HTTP request
            queryset: Original queryset
        
        Returns:
            QuerySet: Filtered queryset
        """
        if self.value() == 'unread':
            return queryset.filter(is_read=False)
        elif self.value() == 'read':
            return queryset.filter(is_read=True)
        return queryset


class DateRangeFilter(SimpleListFilter):
    """
    Filter by date range.
    """
    title = _('Date Range')
    parameter_name = 'date_range'
    
    def lookups(self, request, model_admin):
        """
        Return date range options.
        
        Args:
            request: HTTP request
            model_admin: Model admin instance
        
        Returns:
            list: List of (value, label) tuples
        """
        return [
            ('today', _('Today')),
            ('yesterday', _('Yesterday')),
            ('week', _('This Week')),
            ('month', _('This Month')),
            ('quarter', _('This Quarter')),
        ]
    
    def queryset(self, request, queryset):
        """
        Filter the queryset based on date range.
        
        Args:
            request: HTTP request
            queryset: Original queryset
        
        Returns:
            QuerySet: Filtered queryset
        """
        now = timezone.now()
        
        if self.value() == 'today':
            start = now.replace(hour=0, minute=0, second=0, microsecond=0)
            return queryset.filter(created_at__gte=start)
        
        elif self.value() == 'yesterday':
            yesterday = now - timedelta(days=1)
            start = yesterday.replace(hour=0, minute=0, second=0, microsecond=0)
            end = start + timedelta(days=1)
            return queryset.filter(created_at__gte=start, created_at__lt=end)
        
        elif self.value() == 'week':
            start = now - timedelta(days=now.weekday())
            start = start.replace(hour=0, minute=0, second=0, microsecond=0)
            return queryset.filter(created_at__gte=start)
        
        elif self.value() == 'month':
            start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            return queryset.filter(created_at__gte=start)
        
        elif self.value() == 'quarter':
            quarter_start_month = ((now.month - 1) // 3) * 3 + 1
            start = now.replace(month=quarter_start_month, day=1, hour=0, minute=0, second=0, microsecond=0)
            return queryset.filter(created_at__gte=start)
        
        return queryset


class PriorityFilter(SimpleListFilter):
    """
    Filter by notification priority.
    """
    title = _('Priority')
    parameter_name = 'priority'
    
    def lookups(self, request, model_admin):
        """
        Return priority options.
        
        Args:
            request: HTTP request
            model_admin: Model admin instance
        
        Returns:
            list: List of (value, label) tuples
        """
        return [
            ('high', _('High Priority (4-5)')),
            ('normal', _('Normal Priority (3)')),
            ('low', _('Low Priority (1-2)')),
        ]
    
    def queryset(self, request, queryset):
        """
        Filter the queryset based on priority.
        
        Args:
            request: HTTP request
            queryset: Original queryset
        
        Returns:
            QuerySet: Filtered queryset
        """
        if self.value() == 'high':
            return queryset.filter(notification_type__priority__gte=4)
        elif self.value() == 'normal':
            return queryset.filter(notification_type__priority=3)
        elif self.value() == 'low':
            return queryset.filter(notification_type__priority__lte=2)
        return queryset


# Admin Classes
@admin.register(NotificationType)
class NotificationTypeAdmin(admin.ModelAdmin):
    """
    Admin interface for NotificationType model.
    
    Provides comprehensive management of notification types
    including filtering, searching, and bulk actions.
    """
    
    list_display = [
        'name',
        'code',
        'priority_badge',
        'color_badge',
        'supports_email',
        'supports_in_app',
        'is_active',
        'notification_count',
        'recent_count',
        'created_at',
    ]
    
    list_filter = [
        'is_active',
        'priority',
        'color',
        'supports_email',
        'supports_in_app',
        'can_be_disabled',
        'created_at',
    ]
    
    search_fields = [
        'name',
        'code',
        'description',
    ]
    
    readonly_fields = [
        'id',
        'created_at',
        'updated_at',
        'notification_count',
        'recent_count',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'name',
                'code',
                'description',
            ]
        }),
        (_('Appearance'), {
            'fields': [
                'icon',
                'color',
            ]
        }),
        (_('Behavior'), {
            'fields': [
                'is_active',
                'default_enabled',
                'can_be_disabled',
                'priority',
                'retention_days',
            ]
        }),
        (_('Delivery Options'), {
            'fields': [
                'supports_email',
                'supports_in_app',
            ]
        }),
        (_('Statistics'), {
            'fields': [
                'notification_count',
                'recent_count',
            ],
            'classes': ['collapse'],
        }),
        (_('Metadata'), {
            'fields': [
                'id',
                'created_at',
                'updated_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    actions = [
        'activate_types',
        'deactivate_types',
        'export_types_csv',
    ]
    
    def priority_badge(self, obj):
        """
        Display priority as a colored badge.
        
        Args:
            obj: NotificationType instance
        
        Returns:
            str: HTML badge
        """
        colors = {
            1: 'secondary',
            2: 'info',
            3: 'primary',
            4: 'warning',
            5: 'danger',
        }
        color = colors.get(obj.priority, 'secondary')
        return format_html(
            '<span class="badge badge-{}">{}</span>',
            color,
            obj.get_priority_display()
        )
    priority_badge.short_description = _('Priority')
    
    def color_badge(self, obj):
        """
        Display color as a colored badge.
        
        Args:
            obj: NotificationType instance
        
        Returns:
            str: HTML badge
        """
        return format_html(
            '<span class="badge badge-{}">{}</span>',
            obj.color,
            obj.get_color_display()
        )
    color_badge.short_description = _('Color')
    
    def notification_count(self, obj):
        """
        Display total notification count.
        
        Args:
            obj: NotificationType instance
        
        Returns:
            int: Notification count
        """
        return obj.get_notification_count()
    notification_count.short_description = _('Total Notifications')
    
    def recent_count(self, obj):
        """
        Display recent notification count.
        
        Args:
            obj: NotificationType instance
        
        Returns:
            int: Recent notification count
        """
        return obj.get_recent_notification_count()
    recent_count.short_description = _('Recent (7 days)')
    
    def activate_types(self, request, queryset):
        """
        Bulk action to activate notification types.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = queryset.update(is_active=True)
        self.message_user(
            request,
            _(f'{updated} notification types were activated.'),
            messages.SUCCESS
        )
    activate_types.short_description = _('Activate selected notification types')
    
    def deactivate_types(self, request, queryset):
        """
        Bulk action to deactivate notification types.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = queryset.update(is_active=False)
        self.message_user(
            request,
            _(f'{updated} notification types were deactivated.'),
            messages.SUCCESS
        )
    deactivate_types.short_description = _('Deactivate selected notification types')
    
    def export_types_csv(self, request, queryset):
        """
        Export notification types to CSV.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        
        Returns:
            HttpResponse: CSV file response
        """
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="notification_types.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Name', 'Code', 'Priority', 'Color', 'Active',
            'Supports Email', 'Supports In-App', 'Total Notifications'
        ])
        
        for obj in queryset:
            writer.writerow([
                obj.name,
                obj.code,
                obj.get_priority_display(),
                obj.get_color_display(),
                obj.is_active,
                obj.supports_email,
                obj.supports_in_app,
                obj.get_notification_count(),
            ])
        
        return response
    export_types_csv.short_description = _('Export selected types to CSV')


@admin.register(Notification)
class NotificationAdmin(admin.ModelAdmin):
    """
    Admin interface for Notification model.
    
    Provides comprehensive management of notifications
    including filtering, searching, and bulk actions.
    """
    
    list_display = [
        'title',
        'recipient_link',
        'type_badge',
        'read_status',
        'archived_status',
        'priority_badge',
        'created_at',
        'expires_at',
        'action_buttons',
    ]
    
    list_filter = [
        NotificationTypeFilter,
        ReadStatusFilter,
        DateRangeFilter,
        PriorityFilter,
        'is_archived',
        'notification_type__supports_email',
        'notification_type__supports_in_app',
    ]
    
    search_fields = [
        'title',
        'message',
        'recipient__email',
        'recipient__first_name',
        'recipient__last_name',
        'notification_type__name',
    ]
    
    readonly_fields = [
        'id',
        'created_at',
        'updated_at',
        'read_at',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'recipient',
                'notification_type',
                'title',
                'message',
            ]
        }),
        (_('Status'), {
            'fields': [
                'is_read',
                'is_archived',
                'read_at',
            ]
        }),
        (_('Timing'), {
            'fields': [
                'expires_at',
            ]
        }),
        (_('Action'), {
            'fields': [
                'action_url',
            ]
        }),
        (_('Additional Data'), {
            'fields': [
                'data',
            ],
            'classes': ['collapse'],
        }),
        (_('Related Object'), {
            'fields': [
                'content_type',
                'object_id',
            ],
            'classes': ['collapse'],
        }),
        (_('Metadata'), {
            'fields': [
                'id',
                'created_at',
                'updated_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    actions = [
        'mark_as_read',
        'mark_as_unread',
        'archive_notifications',
        'unarchive_notifications',
        'export_notifications_csv',
    ]
    
    def recipient_link(self, obj):
        """
        Display recipient as a link to user admin.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML link
        """
        url = reverse('admin:accounts_user_change', args=[obj.recipient.pk])
        return format_html('<a href="{}">{}</a>', url, obj.recipient.email)
    recipient_link.short_description = _('Recipient')
    
    def type_badge(self, obj):
        """
        Display notification type as a colored badge.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML badge
        """
        return format_html(
            '<span class="badge badge-{}" title="{}"><i class="{}"></i> {}</span>',
            obj.notification_type.color,
            obj.notification_type.description,
            obj.notification_type.icon,
            obj.notification_type.name
        )
    type_badge.short_description = _('Type')
    
    def read_status(self, obj):
        """
        Display read status with icon.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML status
        """
        if obj.is_read:
            return format_html(
                '<span class="text-success"><i class="fas fa-check-circle"></i> Read</span>'
            )
        else:
            return format_html(
                '<span class="text-warning"><i class="fas fa-circle"></i> Unread</span>'
            )
    read_status.short_description = _('Status')
    
    def archived_status(self, obj):
        """
        Display archived status with icon.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML status
        """
        if obj.is_archived:
            return format_html(
                '<span class="text-muted"><i class="fas fa-archive"></i> Archived</span>'
            )
        else:
            return format_html(
                '<span class="text-primary"><i class="fas fa-bell"></i> Active</span>'
            )
    archived_status.short_description = _('Archive Status')
    
    def priority_badge(self, obj):
        """
        Display priority as a colored badge.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML badge
        """
        colors = {
            1: 'secondary',
            2: 'info',
            3: 'primary',
            4: 'warning',
            5: 'danger',
        }
        color = colors.get(obj.notification_type.priority, 'secondary')
        return format_html(
            '<span class="badge badge-{}">{}</span>',
            color,
            obj.notification_type.get_priority_display()
        )
    priority_badge.short_description = _('Priority')
    
    def action_buttons(self, obj):
        """
        Display action buttons for the notification.
        
        Args:
            obj: Notification instance
        
        Returns:
            str: HTML buttons
        """
        buttons = []
        
        if not obj.is_read:
            buttons.append(
                f'<a href="#" onclick="markAsRead({obj.pk})" class="btn btn-sm btn-success" title="Mark as Read">' +
                '<i class="fas fa-check"></i></a>'
            )
        else:
            buttons.append(
                f'<a href="#" onclick="markAsUnread({obj.pk})" class="btn btn-sm btn-warning" title="Mark as Unread">' +
                '<i class="fas fa-undo"></i></a>'
            )
        
        if not obj.is_archived:
            buttons.append(
                f'<a href="#" onclick="archiveNotification({obj.pk})" class="btn btn-sm btn-secondary" title="Archive">' +
                '<i class="fas fa-archive"></i></a>'
            )
        
        if obj.action_url:
            buttons.append(
                f'<a href="{obj.action_url}" class="btn btn-sm btn-primary" title="View Action" target="_blank">' +
                '<i class="fas fa-external-link-alt"></i></a>'
            )
        
        return format_html(' '.join(buttons))
    action_buttons.short_description = _('Actions')
    
    def mark_as_read(self, request, queryset):
        """
        Bulk action to mark notifications as read.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = 0
        for notification in queryset:
            if notification.mark_as_read():
                updated += 1
        
        self.message_user(
            request,
            _(f'{updated} notifications were marked as read.'),
            messages.SUCCESS
        )
    mark_as_read.short_description = _('Mark selected notifications as read')
    
    def mark_as_unread(self, request, queryset):
        """
        Bulk action to mark notifications as unread.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = 0
        for notification in queryset:
            if notification.mark_as_unread():
                updated += 1
        
        self.message_user(
            request,
            _(f'{updated} notifications were marked as unread.'),
            messages.SUCCESS
        )
    mark_as_unread.short_description = _('Mark selected notifications as unread')
    
    def archive_notifications(self, request, queryset):
        """
        Bulk action to archive notifications.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = 0
        for notification in queryset:
            if notification.archive():
                updated += 1
        
        self.message_user(
            request,
            _(f'{updated} notifications were archived.'),
            messages.SUCCESS
        )
    archive_notifications.short_description = _('Archive selected notifications')
    
    def unarchive_notifications(self, request, queryset):
        """
        Bulk action to unarchive notifications.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = 0
        for notification in queryset:
            if notification.unarchive():
                updated += 1
        
        self.message_user(
            request,
            _(f'{updated} notifications were unarchived.'),
            messages.SUCCESS
        )
    unarchive_notifications.short_description = _('Unarchive selected notifications')
    
    def export_notifications_csv(self, request, queryset):
        """
        Export notifications to CSV.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        
        Returns:
            HttpResponse: CSV file response
        """
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="notifications.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Title', 'Recipient', 'Type', 'Read', 'Archived',
            'Created', 'Read At', 'Expires At'
        ])
        
        for obj in queryset:
            writer.writerow([
                obj.title,
                obj.recipient.email,
                obj.notification_type.name,
                obj.is_read,
                obj.is_archived,
                obj.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                obj.read_at.strftime('%Y-%m-%d %H:%M:%S') if obj.read_at else '',
                obj.expires_at.strftime('%Y-%m-%d %H:%M:%S') if obj.expires_at else '',
            ])
        
        return response
    export_notifications_csv.short_description = _('Export selected notifications to CSV')
    
    class Media:
        js = ('admin/js/notification_actions.js',)


@admin.register(NotificationPreference)
class NotificationPreferenceAdmin(admin.ModelAdmin):
    """
    Admin interface for NotificationPreference model.
    
    Provides management of user notification preferences.
    """
    
    list_display = [
        'user_link',
        'notification_type',
        'enabled_status',
        'email_status',
        'in_app_status',
        'quiet_hours_display',
        'updated_at',
    ]
    
    list_filter = [
        'is_enabled',
        'email_enabled',
        'in_app_enabled',
        'notification_type',
        'timezone',
    ]
    
    search_fields = [
        'user__email',
        'user__first_name',
        'user__last_name',
        'notification_type__name',
    ]
    
    readonly_fields = [
        'id',
        'created_at',
        'updated_at',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'user',
                'notification_type',
            ]
        }),
        (_('Preferences'), {
            'fields': [
                'is_enabled',
                'email_enabled',
                'in_app_enabled',
            ]
        }),
        (_('Quiet Hours'), {
            'fields': [
                'quiet_hours_start',
                'quiet_hours_end',
                'timezone',
            ]
        }),
        (_('Metadata'), {
            'fields': [
                'id',
                'created_at',
                'updated_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    def user_link(self, obj):
        """
        Display user as a link to user admin.
        
        Args:
            obj: NotificationPreference instance
        
        Returns:
            str: HTML link
        """
        url = reverse('admin:accounts_user_change', args=[obj.user.pk])
        return format_html('<a href="{}">{}</a>', url, obj.user.email)
    user_link.short_description = _('User')
    
    def enabled_status(self, obj):
        """
        Display enabled status with icon.
        
        Args:
            obj: NotificationPreference instance
        
        Returns:
            str: HTML status
        """
        if obj.is_enabled:
            return format_html(
                '<span class="text-success"><i class="fas fa-check-circle"></i> Enabled</span>'
            )
        else:
            return format_html(
                '<span class="text-danger"><i class="fas fa-times-circle"></i> Disabled</span>'
            )
    enabled_status.short_description = _('Enabled')
    
    def email_status(self, obj):
        """
        Display email status with icon.
        
        Args:
            obj: NotificationPreference instance
        
        Returns:
            str: HTML status
        """
        if obj.email_enabled:
            return format_html('<i class="fas fa-envelope text-success"></i>')
        else:
            return format_html('<i class="fas fa-envelope text-muted"></i>')
    email_status.short_description = _('Email')
    
    def in_app_status(self, obj):
        """
        Display in-app status with icon.
        
        Args:
            obj: NotificationPreference instance
        
        Returns:
            str: HTML status
        """
        if obj.in_app_enabled:
            return format_html('<i class="fas fa-bell text-success"></i>')
        else:
            return format_html('<i class="fas fa-bell text-muted"></i>')
    in_app_status.short_description = _('In-App')
    
    def quiet_hours_display(self, obj):
        """
        Display quiet hours information.
        
        Args:
            obj: NotificationPreference instance
        
        Returns:
            str: Quiet hours display
        """
        if obj.quiet_hours_start and obj.quiet_hours_end:
            return f'{obj.quiet_hours_start} - {obj.quiet_hours_end} ({obj.timezone})'
        return '-'
    quiet_hours_display.short_description = _('Quiet Hours')


@admin.register(NotificationTemplate)
class NotificationTemplateAdmin(admin.ModelAdmin):
    """
    Admin interface for NotificationTemplate model.
    
    Provides management of notification templates.
    """
    
    list_display = [
        'name',
        'template_type',
        'is_active',
        'created_by',
        'created_at',
        'action_buttons',
    ]
    
    list_filter = [
        'template_type',
        'is_active',
        'created_at',
    ]
    
    search_fields = [
        'name',
        'subject',
        'description',
    ]
    
    readonly_fields = [
        'id',
        'created_at',
        'updated_at',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'name',
                'template_type',
                'description',
                'is_active',
            ]
        }),
        (_('Content'), {
            'fields': [
                'subject',
                'html_content',
                'text_content',
            ]
        }),
        (_('Variables'), {
            'fields': [
                'variables',
            ],
            'classes': ['collapse'],
        }),
        (_('Metadata'), {
            'fields': [
                'created_by',
                'id',
                'created_at',
                'updated_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    actions = [
        'activate_templates',
        'deactivate_templates',
        'clone_templates',
    ]
    
    def action_buttons(self, obj):
        """
        Display action buttons for the template.
        
        Args:
            obj: NotificationTemplate instance
        
        Returns:
            str: HTML buttons
        """
        buttons = [
            f'<a href="#" onclick="previewTemplate({obj.pk})" class="btn btn-sm btn-info" title="Preview">' +
            '<i class="fas fa-eye"></i></a>',
            f'<a href="#" onclick="cloneTemplate({obj.pk})" class="btn btn-sm btn-secondary" title="Clone">' +
            '<i class="fas fa-copy"></i></a>',
        ]
        
        return format_html(' '.join(buttons))
    action_buttons.short_description = _('Actions')
    
    def activate_templates(self, request, queryset):
        """
        Bulk action to activate templates.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = queryset.update(is_active=True)
        self.message_user(
            request,
            _(f'{updated} templates were activated.'),
            messages.SUCCESS
        )
    activate_templates.short_description = _('Activate selected templates')
    
    def deactivate_templates(self, request, queryset):
        """
        Bulk action to deactivate templates.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        updated = queryset.update(is_active=False)
        self.message_user(
            request,
            _(f'{updated} templates were deactivated.'),
            messages.SUCCESS
        )
    deactivate_templates.short_description = _('Deactivate selected templates')
    
    def clone_templates(self, request, queryset):
        """
        Bulk action to clone templates.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        cloned = 0
        for template in queryset:
            try:
                template.clone()
                cloned += 1
            except Exception as e:
                self.message_user(
                    request,
                    _(f'Error cloning template {template.name}: {e}'),
                    messages.ERROR
                )
        
        if cloned > 0:
            self.message_user(
                request,
                _(f'{cloned} templates were cloned.'),
                messages.SUCCESS
            )
    clone_templates.short_description = _('Clone selected templates')


@admin.register(NotificationQueue)
class NotificationQueueAdmin(admin.ModelAdmin):
    """
    Admin interface for NotificationQueue model.
    
    Provides management of the notification queue.
    """
    
    list_display = [
        'notification_title',
        'delivery_method',
        'status_badge',
        'scheduled_at',
        'sent_at',
        'retry_info',
        'action_buttons',
    ]
    
    list_filter = [
        'status',
        'delivery_method',
        'scheduled_at',
        'sent_at',
    ]
    
    search_fields = [
        'notification__title',
        'notification__recipient__email',
        'error_message',
    ]
    
    readonly_fields = [
        'id',
        'created_at',
        'updated_at',
        'sent_at',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'notification',
                'delivery_method',
                'status',
            ]
        }),
        (_('Scheduling'), {
            'fields': [
                'scheduled_at',
                'sent_at',
            ]
        }),
        (_('Retry Logic'), {
            'fields': [
                'retry_count',
                'max_retries',
                'next_retry_at',
            ]
        }),
        (_('Error Information'), {
            'fields': [
                'error_message',
            ]
        }),
        (_('Metadata'), {
            'fields': [
                'metadata',
                'id',
                'created_at',
                'updated_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    actions = [
        'retry_failed',
        'cancel_pending',
        'export_queue_csv',
    ]
    
    def notification_title(self, obj):
        """
        Display notification title with link.
        
        Args:
            obj: NotificationQueue instance
        
        Returns:
            str: HTML link
        """
        url = reverse('admin:notifications_notification_change', args=[obj.notification.pk])
        return format_html('<a href="{}">{}</a>', url, obj.notification.title)
    notification_title.short_description = _('Notification')
    
    def status_badge(self, obj):
        """
        Display status as a colored badge.
        
        Args:
            obj: NotificationQueue instance
        
        Returns:
            str: HTML badge
        """
        colors = {
            'pending': 'warning',
            'processing': 'info',
            'completed': 'success',
            'failed': 'danger',
            'cancelled': 'secondary',
        }
        color = colors.get(obj.status, 'secondary')
        return format_html(
            '<span class="badge badge-{}">{}</span>',
            color,
            obj.get_status_display()
        )
    status_badge.short_description = _('Status')
    
    def retry_info(self, obj):
        """
        Display retry information.
        
        Args:
            obj: NotificationQueue instance
        
        Returns:
            str: Retry information
        """
        if obj.status == 'failed':
            return f'{obj.retry_count}/{obj.max_retries}'
        return '-'
    retry_info.short_description = _('Retries')
    
    def action_buttons(self, obj):
        """
        Display action buttons for the queue item.
        
        Args:
            obj: NotificationQueue instance
        
        Returns:
            str: HTML buttons
        """
        buttons = []
        
        if obj.status == 'failed' and obj.can_retry():
            buttons.append(
                f'<a href="#" onclick="retryQueueItem({obj.pk})" class="btn btn-sm btn-warning" title="Retry">' +
                '<i class="fas fa-redo"></i></a>'
            )
        
        if obj.status in ['pending', 'processing']:
            buttons.append(
                f'<a href="#" onclick="cancelQueueItem({obj.pk})" class="btn btn-sm btn-danger" title="Cancel">' +
                '<i class="fas fa-times"></i></a>'
            )
        
        return format_html(' '.join(buttons))
    action_buttons.short_description = _('Actions')
    
    def retry_failed(self, request, queryset):
        """
        Bulk action to retry failed queue items.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        retried = 0
        for item in queryset.filter(status='failed'):
            if item.can_retry():
                item.status = 'pending'
                item.next_retry_at = timezone.now()
                item.save(update_fields=['status', 'next_retry_at'])
                retried += 1
        
        self.message_user(
            request,
            _(f'{retried} queue items were scheduled for retry.'),
            messages.SUCCESS
        )
    retry_failed.short_description = _('Retry selected failed items')
    
    def cancel_pending(self, request, queryset):
        """
        Bulk action to cancel pending queue items.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        """
        cancelled = queryset.filter(status__in=['pending', 'processing']).update(status='cancelled')
        self.message_user(
            request,
            _(f'{cancelled} queue items were cancelled.'),
            messages.SUCCESS
        )
    cancel_pending.short_description = _('Cancel selected pending items')
    
    def export_queue_csv(self, request, queryset):
        """
        Export queue items to CSV.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        
        Returns:
            HttpResponse: CSV file response
        """
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="notification_queue.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Notification', 'Delivery Method', 'Status', 'Scheduled',
            'Sent', 'Retries', 'Error Message'
        ])
        
        for obj in queryset:
            writer.writerow([
                obj.notification.title,
                obj.get_delivery_method_display(),
                obj.get_status_display(),
                obj.scheduled_at.strftime('%Y-%m-%d %H:%M:%S'),
                obj.sent_at.strftime('%Y-%m-%d %H:%M:%S') if obj.sent_at else '',
                f'{obj.retry_count}/{obj.max_retries}',
                obj.error_message,
            ])
        
        return response
    export_queue_csv.short_description = _('Export selected queue items to CSV')


@admin.register(NotificationHistory)
class NotificationHistoryAdmin(admin.ModelAdmin):
    """
    Admin interface for NotificationHistory model.
    
    Provides read-only view of notification delivery history.
    """
    
    list_display = [
        'notification_title',
        'recipient_email',
        'delivery_method',
        'status_badge',
        'sent_at',
        'delivered_at',
        'delivery_time',
    ]
    
    list_filter = [
        'status',
        'delivery_method',
        'sent_at',
        'delivered_at',
    ]
    
    search_fields = [
        'notification__title',
        'recipient_email',
        'error_message',
    ]
    
    readonly_fields = [
        'id',
        'notification',
        'recipient_email',
        'delivery_method',
        'status',
        'sent_at',
        'delivered_at',
        'error_message',
        'metadata',
        'created_at',
        'delivery_time_display',
    ]
    
    fieldsets = [
        (_('Basic Information'), {
            'fields': [
                'notification',
                'recipient_email',
                'delivery_method',
                'status',
            ]
        }),
        (_('Timing'), {
            'fields': [
                'sent_at',
                'delivered_at',
                'delivery_time_display',
            ]
        }),
        (_('Error Information'), {
            'fields': [
                'error_message',
            ]
        }),
        (_('Metadata'), {
            'fields': [
                'metadata',
                'id',
                'created_at',
            ],
            'classes': ['collapse'],
        }),
    ]
    
    actions = [
        'export_history_csv',
    ]
    
    def has_add_permission(self, request):
        """
        Disable add permission for history records.
        
        Args:
            request: HTTP request
        
        Returns:
            bool: False (no add permission)
        """
        return False
    
    def has_change_permission(self, request, obj=None):
        """
        Disable change permission for history records.
        
        Args:
            request: HTTP request
            obj: Object instance
        
        Returns:
            bool: False (no change permission)
        """
        return False
    
    def has_delete_permission(self, request, obj=None):
        """
        Disable delete permission for history records.
        
        Args:
            request: HTTP request
            obj: Object instance
        
        Returns:
            bool: False (no delete permission)
        """
        return False
    
    def notification_title(self, obj):
        """
        Display notification title with link.
        
        Args:
            obj: NotificationHistory instance
        
        Returns:
            str: HTML link
        """
        url = reverse('admin:notifications_notification_change', args=[obj.notification.pk])
        return format_html('<a href="{}">{}</a>', url, obj.notification.title)
    notification_title.short_description = _('Notification')
    
    def status_badge(self, obj):
        """
        Display status as a colored badge.
        
        Args:
            obj: NotificationHistory instance
        
        Returns:
            str: HTML badge
        """
        colors = {
            'sent': 'info',
            'delivered': 'success',
            'failed': 'danger',
            'bounced': 'warning',
            'complained': 'dark',
        }
        color = colors.get(obj.status, 'secondary')
        return format_html(
            '<span class="badge badge-{}">{}</span>',
            color,
            obj.get_status_display()
        )
    status_badge.short_description = _('Status')
    
    def delivery_time(self, obj):
        """
        Display delivery time.
        
        Args:
            obj: NotificationHistory instance
        
        Returns:
            str: Delivery time
        """
        time = obj.get_delivery_time()
        if time:
            return f'{time.total_seconds():.2f}s'
        return '-'
    delivery_time.short_description = _('Delivery Time')
    
    def delivery_time_display(self, obj):
        """
        Display delivery time for readonly field.
        
        Args:
            obj: NotificationHistory instance
        
        Returns:
            str: Delivery time
        """
        return self.delivery_time(obj)
    delivery_time_display.short_description = _('Delivery Time')
    
    def export_history_csv(self, request, queryset):
        """
        Export history to CSV.
        
        Args:
            request: HTTP request
            queryset: Selected objects
        
        Returns:
            HttpResponse: CSV file response
        """
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="notification_history.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Notification', 'Recipient', 'Delivery Method', 'Status',
            'Sent At', 'Delivered At', 'Delivery Time', 'Error Message'
        ])
        
        for obj in queryset:
            writer.writerow([
                obj.notification.title,
                obj.recipient_email,
                obj.get_delivery_method_display(),
                obj.get_status_display(),
                obj.sent_at.strftime('%Y-%m-%d %H:%M:%S'),
                obj.delivered_at.strftime('%Y-%m-%d %H:%M:%S') if obj.delivered_at else '',
                self.delivery_time(obj),
                obj.error_message,
            ])
        
        return response
    export_history_csv.short_description = _('Export selected history to CSV')


# Admin site customization
admin.site.site_header = 'AdTlas Notifications Admin'
admin.site.site_title = 'Notifications Admin'
admin.site.index_title = 'Notifications Administration'