from django.contrib import admin

# -*- coding: utf-8 -*-
"""
Core app Django admin configuration.

This module defines admin interfaces for core application models.
Currently, the core app focuses on views and doesn't have specific models,
but this file is prepared for future model additions.

Features:
    - Ready for future model admin configurations
    - Follows Django admin best practices
    - Includes common admin customizations

Author: Senior Django Developer
Date: 2024
"""

from django.contrib import admin
from django.contrib.admin import AdminSite
from django.utils.translation import gettext_lazy as _

# Custom admin site configuration (optional)
class CoreAdminSite(AdminSite):
    """
    Custom admin site for core app.
    
    Provides customized admin interface with
    branding and additional functionality.
    """
    
    site_header = _('Core Administration')
    site_title = _('Core Admin')
    index_title = _('Core Administration Dashboard')
    
    def get_app_list(self, request):
        """
        Get the application list for admin index.
        
        Args:
            request: HTTP request object
            
        Returns:
            list: List of applications for admin index
        """
        app_list = super().get_app_list(request)
        
        # Customize app ordering if needed
        app_order = ['accounts', 'authentication', 'core', 'common']
        
        def get_app_priority(app):
            """
            Get priority for app ordering.
            
            Args:
                app: Application dictionary
                
            Returns:
                int: Priority number for ordering
            """
            app_label = app.get('app_label', '')
            try:
                return app_order.index(app_label)
            except ValueError:
                return len(app_order)
        
        # Sort applications by priority
        app_list.sort(key=get_app_priority)
        
        return app_list


# Create custom admin site instance
core_admin_site = CoreAdminSite(name='core_admin')


# Base admin classes for future use
class BaseModelAdmin(admin.ModelAdmin):
    """
    Base admin class with common configurations.
    
    Provides standard admin interface features
    that can be inherited by other admin classes.
    """
    
    # Common list display settings
    list_per_page = 25
    show_full_result_count = False
    
    # Common date hierarchy
    date_hierarchy = 'created_at'
    
    # Common list filters
    list_filter = (
        'created_at',
        'updated_at',
    )
    
    # Common search fields
    search_fields = (
        'id',
    )
    
    # Common readonly fields
    readonly_fields = (
        'id',
        'created_at',
        'updated_at',
    )
    
    # Common fieldsets
    fieldsets = (
        (_('Basic Information'), {
            'fields': (
                'id',
            )
        }),
        (_('Timestamps'), {
            'fields': (
                'created_at',
                'updated_at',
            ),
            'classes': ('collapse',)
        }),
    )
    
    def get_queryset(self, request):
        """
        Get optimized queryset for admin list view.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset
        """
        queryset = super().get_queryset(request)
        
        # Add select_related and prefetch_related optimizations
        # This will be customized by subclasses
        
        return queryset
    
    def get_readonly_fields(self, request, obj=None):
        """
        Get readonly fields based on user permissions.
        
        Args:
            request: HTTP request object
            obj: Model instance being edited
            
        Returns:
            tuple: Readonly fields
        """
        readonly_fields = list(self.readonly_fields)
        
        # Add conditional readonly fields based on permissions
        if not request.user.is_superuser:
            # Add fields that only superusers can edit
            pass
        
        return readonly_fields
    
    def has_delete_permission(self, request, obj=None):
        """
        Check if user has delete permission.
        
        Args:
            request: HTTP request object
            obj: Model instance being deleted
            
        Returns:
            bool: True if user can delete, False otherwise
        """
        # Customize delete permissions if needed
        return super().has_delete_permission(request, obj)
    
    def save_model(self, request, obj, form, change):
        """
        Save model with additional processing.
        
        Args:
            request: HTTP request object
            obj: Model instance being saved
            form: Admin form instance
            change: True if editing existing object
        """
        # Add user tracking if model supports it
        if hasattr(obj, 'created_by') and not change:
            obj.created_by = request.user
        
        if hasattr(obj, 'updated_by'):
            obj.updated_by = request.user
        
        super().save_model(request, obj, form, change)


class ReadOnlyModelAdmin(BaseModelAdmin):
    """
    Read-only admin class for models that shouldn't be edited.
    
    Useful for log models or system-generated data.
    """
    
    def has_add_permission(self, request):
        """
        Disable add permission.
        
        Args:
            request: HTTP request object
            
        Returns:
            bool: Always False
        """
        return False
    
    def has_change_permission(self, request, obj=None):
        """
        Disable change permission.
        
        Args:
            request: HTTP request object
            obj: Model instance
            
        Returns:
            bool: Always False
        """
        return False
    
    def has_delete_permission(self, request, obj=None):
        """
        Disable delete permission.
        
        Args:
            request: HTTP request object
            obj: Model instance
            
        Returns:
            bool: Always False
        """
        return False


# Admin actions
def export_selected_objects(modeladmin, request, queryset):
    """
    Admin action to export selected objects.
    
    Args:
        modeladmin: Admin class instance
        request: HTTP request object
        queryset: Selected objects queryset
        
    Returns:
        HttpResponse: CSV export response
    """
    import csv
    from django.http import HttpResponse
    
    # Create CSV response
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = f'attachment; filename="{modeladmin.model._meta.verbose_name_plural}.csv"'
    
    # Create CSV writer
    writer = csv.writer(response)
    
    # Write header
    field_names = [field.name for field in modeladmin.model._meta.fields]
    writer.writerow(field_names)
    
    # Write data
    for obj in queryset:
        row = []
        for field_name in field_names:
            value = getattr(obj, field_name)
            if value is None:
                value = ''
            row.append(str(value))
        writer.writerow(row)
    
    return response

# Set action description
export_selected_objects.short_description = _('Export selected objects to CSV')


# Register admin actions globally
admin.site.add_action(export_selected_objects)


# Import core models
from .models import (
    SystemConfiguration,
    ApplicationMetrics,
    AuditLog,
    NotificationTemplate,
    SystemHealth
)

# Import logging models
from .logging import (
    LogEntry,
    AuditLogEntry,
    SecurityLogEntry
)


@admin.register(SystemConfiguration)
class SystemConfigurationAdmin(BaseModelAdmin):
    """
    Admin interface for SystemConfiguration model.
    
    Provides interface for managing system-wide configuration settings.
    """
    
    list_display = (
        'key',
        'value_preview',
        'is_active',
        'created_at',
        'updated_at'
    )
    
    list_filter = (
        'is_active',
        'created_at',
        'updated_at'
    )
    
    search_fields = (
        'key',
        'description',
        'value'
    )
    
    readonly_fields = (
        'id',
        'created_at',
        'updated_at',
        'created_by',
        'updated_by'
    )
    
    fieldsets = (
        (_('Configuration Details'), {
            'fields': (
                'key',
                'value',
                'description',
                'is_active'
            )
        }),
        (_('Audit Information'), {
            'fields': (
                'id',
                'created_at',
                'updated_at',
                'created_by',
                'updated_by'
            ),
            'classes': ('collapse',)
        })
    )
    
    def value_preview(self, obj):
        """
        Show a preview of the configuration value.
        
        Args:
            obj: SystemConfiguration instance
            
        Returns:
            str: Truncated value preview
        """
        return obj.value[:50] + '...' if len(obj.value) > 50 else obj.value
    
    value_preview.short_description = _('Value Preview')


@admin.register(ApplicationMetrics)
class ApplicationMetricsAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for ApplicationMetrics model.
    
    Read-only interface for viewing application metrics.
    """
    
    list_display = (
        'metric_name',
        'metric_value',
        'metric_type',
        'timestamp'
    )
    
    list_filter = (
        'metric_type',
        'timestamp',
        'metric_name'
    )
    
    search_fields = (
        'metric_name',
    )
    
    date_hierarchy = 'timestamp'
    
    readonly_fields = (
        'metric_name',
        'metric_value',
        'metric_type',
        'tags',
        'timestamp'
    )
    
    def get_queryset(self, request):
        """
        Optimize queryset for metrics display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset
        """
        return super().get_queryset(request).order_by('-timestamp')


@admin.register(AuditLog)
class AuditLogAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for AuditLog model.
    
    Read-only interface for viewing audit logs.
    """
    
    list_display = (
        'user_display',
        'action',
        'resource_type',
        'resource_id',
        'success',
        'created_at'
    )
    
    list_filter = (
        'action',
        'resource_type',
        'success',
        'created_at',
        'user'
    )
    
    search_fields = (
        'user__email',
        'user__first_name',
        'user__last_name',
        'action',
        'resource_type',
        'resource_id',
        'ip_address'
    )
    
    date_hierarchy = 'created_at'
    
    readonly_fields = (
        'user',
        'action',
        'resource_type',
        'resource_id',
        'ip_address',
        'user_agent',
        'details',
        'success',
        'created_at'
    )
    
    def user_display(self, obj):
        """
        Display user information for audit log.
        
        Args:
            obj: AuditLog instance
            
        Returns:
            str: User display name or 'System'
        """
        return obj.user.email if obj.user else 'System'
    
    user_display.short_description = _('User')
    user_display.admin_order_field = 'user__email'
    
    def get_queryset(self, request):
        """
        Optimize queryset for audit log display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset with user data
        """
        return super().get_queryset(request).select_related('user')


@admin.register(NotificationTemplate)
class NotificationTemplateAdmin(BaseModelAdmin):
    """
    Admin interface for NotificationTemplate model.
    
    Provides interface for managing notification templates.
    """
    
    list_display = (
        'name',
        'notification_type',
        'subject_preview',
        'is_active',
        'created_at'
    )
    
    list_filter = (
        'notification_type',
        'is_active',
        'created_at'
    )
    
    search_fields = (
        'name',
        'subject',
        'body_text'
    )
    
    readonly_fields = (
        'id',
        'created_at',
        'updated_at',
        'created_by',
        'updated_by'
    )
    
    fieldsets = (
        (_('Template Information'), {
            'fields': (
                'name',
                'notification_type',
                'is_active'
            )
        }),
        (_('Content'), {
            'fields': (
                'subject',
                'body_text',
                'body_html'
            )
        }),
        (_('Configuration'), {
            'fields': (
                'variables',
            )
        }),
        (_('Audit Information'), {
            'fields': (
                'id',
                'created_at',
                'updated_at',
                'created_by',
                'updated_by'
            ),
            'classes': ('collapse',)
        })
    )
    
    def subject_preview(self, obj):
        """
        Show a preview of the notification subject.
        
        Args:
            obj: NotificationTemplate instance
            
        Returns:
            str: Truncated subject preview
        """
        return obj.subject[:50] + '...' if len(obj.subject) > 50 else obj.subject
    
    subject_preview.short_description = _('Subject Preview')


@admin.register(SystemHealth)
class SystemHealthAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for SystemHealth model.
    
    Read-only interface for viewing system health metrics.
    """
    
    list_display = (
        'service_name',
        'status',
        'response_time',
        'cpu_usage',
        'memory_usage',
        'disk_usage',
        'created_at'
    )
    
    list_filter = (
        'status',
        'service_name',
        'created_at'
    )
    
    search_fields = (
        'service_name',
    )
    
    date_hierarchy = 'created_at'
    
    readonly_fields = (
        'service_name',
        'status',
        'response_time',
        'cpu_usage',
        'memory_usage',
        'disk_usage',
        'additional_metrics',
        'created_at'
    )
    
    def get_queryset(self, request):
        """
        Optimize queryset for system health display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset
        """
        return super().get_queryset(request).order_by('-created_at')


# =============================================================================
# Logging Models Admin Configuration
# =============================================================================

@admin.register(LogEntry)
class LogEntryAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for LogEntry model.
    
    Read-only interface for viewing application logs.
    """
    
    list_display = (
        'timestamp',
        'level_badge',
        'logger_name',
        'message_preview',
        'user_display',
        'ip_address',
        'request_path'
    )
    
    list_filter = (
        'level',
        'logger_name',
        'timestamp',
        'user',
        'request_method'
    )
    
    search_fields = (
        'message',
        'logger_name',
        'module',
        'function',
        'user__email',
        'ip_address',
        'request_path'
    )
    
    date_hierarchy = 'timestamp'
    
    readonly_fields = (
        'timestamp',
        'level',
        'logger_name',
        'message',
        'module',
        'function',
        'line_number',
        'user',
        'ip_address',
        'user_agent',
        'request_path',
        'request_method',
        'session_key',
        'extra_data',
        'stack_trace'
    )
    
    fieldsets = (
        (_('Log Information'), {
            'fields': (
                'timestamp',
                'level',
                'logger_name',
                'message'
            )
        }),
        (_('Code Location'), {
            'fields': (
                'module',
                'function',
                'line_number'
            )
        }),
        (_('Request Context'), {
            'fields': (
                'user',
                'ip_address',
                'user_agent',
                'request_path',
                'request_method',
                'session_key'
            ),
            'classes': ('collapse',)
        }),
        (_('Additional Data'), {
            'fields': (
                'extra_data',
                'stack_trace'
            ),
            'classes': ('collapse',)
        })
    )
    
    actions = ['export_logs', 'analyze_errors']
    
    def level_badge(self, obj):
        """
        Display log level with color badge.
        
        Args:
            obj: LogEntry instance
            
        Returns:
            str: HTML formatted level badge
        """
        colors = {
            'DEBUG': 'gray',
            'INFO': 'blue',
            'WARNING': 'orange',
            'ERROR': 'red',
            'CRITICAL': 'darkred'
        }
        color = colors.get(obj.level, 'gray')
        return f'<span style="color: {color}; font-weight: bold;">● {obj.level}</span>'
    
    level_badge.short_description = _('Level')
    level_badge.allow_tags = True
    
    def message_preview(self, obj):
        """
        Show a preview of the log message.
        
        Args:
            obj: LogEntry instance
            
        Returns:
            str: Truncated message preview
        """
        return obj.message[:100] + '...' if len(obj.message) > 100 else obj.message
    
    message_preview.short_description = _('Message')
    
    def user_display(self, obj):
        """
        Display user information for log entry.
        
        Args:
            obj: LogEntry instance
            
        Returns:
            str: User display name or 'Anonymous'
        """
        return obj.user.email if obj.user else 'Anonymous'
    
    user_display.short_description = _('User')
    user_display.admin_order_field = 'user__email'
    
    def export_logs(self, request, queryset):
        """
        Export selected logs to CSV.
        
        Args:
            request: HTTP request object
            queryset: Selected logs queryset
            
        Returns:
            HttpResponse: CSV export response
        """
        import csv
        from django.http import HttpResponse
        
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="log_entries.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Timestamp', 'Level', 'Logger', 'Message', 'User', 
            'IP Address', 'Request Path', 'Module', 'Function'
        ])
        
        for log in queryset:
            writer.writerow([
                log.timestamp,
                log.level,
                log.logger_name,
                log.message,
                log.user.email if log.user else '',
                log.ip_address,
                log.request_path,
                log.module,
                log.function
            ])
        
        return response
    
    export_logs.short_description = _('Export selected logs to CSV')
    
    def analyze_errors(self, request, queryset):
        """
        Analyze error patterns in selected logs.
        
        Args:
            request: HTTP request object
            queryset: Selected logs queryset
        """
        error_logs = queryset.filter(level__in=['ERROR', 'CRITICAL'])
        total_errors = error_logs.count()
        
        if total_errors > 0:
            # Group by logger name
            from django.db.models import Count
            error_by_logger = error_logs.values('logger_name').annotate(
                count=Count('id')
            ).order_by('-count')[:5]
            
            analysis = f'Found {total_errors} errors. Top loggers: '
            analysis += ', '.join([
                f"{item['logger_name']} ({item['count']})"
                for item in error_by_logger
            ])
        else:
            analysis = 'No errors found in selected logs.'
        
        self.message_user(request, analysis)
    
    analyze_errors.short_description = _('Analyze error patterns')
    
    def get_queryset(self, request):
        """
        Optimize queryset for log display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset with user data
        """
        return super().get_queryset(request).select_related('user')


@admin.register(AuditLogEntry)
class AuditLogEntryAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for AuditLogEntry model.
    
    Read-only interface for viewing audit logs.
    """
    
    list_display = (
        'timestamp',
        'user_display',
        'action',
        'object_type',
        'object_id',
        'success_badge',
        'ip_address'
    )
    
    list_filter = (
        'action',
        'object_type',
        'success',
        'timestamp',
        'user'
    )
    
    search_fields = (
        'user__email',
        'action',
        'object_type',
        'object_id',
        'object_repr',
        'ip_address'
    )
    
    date_hierarchy = 'timestamp'
    
    readonly_fields = (
        'timestamp',
        'user',
        'action',
        'object_type',
        'object_id',
        'object_repr',
        'changes',
        'ip_address',
        'user_agent',
        'session_key',
        'success',
        'error_message'
    )
    
    fieldsets = (
        (_('Audit Information'), {
            'fields': (
                'timestamp',
                'user',
                'action',
                'success'
            )
        }),
        (_('Object Details'), {
            'fields': (
                'object_type',
                'object_id',
                'object_repr',
                'changes'
            )
        }),
        (_('Request Context'), {
            'fields': (
                'ip_address',
                'user_agent',
                'session_key'
            ),
            'classes': ('collapse',)
        }),
        (_('Error Information'), {
            'fields': (
                'error_message',
            ),
            'classes': ('collapse',)
        })
    )
    
    actions = ['export_audit_logs', 'analyze_user_activity']
    
    def user_display(self, obj):
        """
        Display user information for audit log.
        
        Args:
            obj: AuditLogEntry instance
            
        Returns:
            str: User display name or 'System'
        """
        return obj.user.email if obj.user else 'System'
    
    user_display.short_description = _('User')
    user_display.admin_order_field = 'user__email'
    
    def success_badge(self, obj):
        """
        Display success status with color badge.
        
        Args:
            obj: AuditLogEntry instance
            
        Returns:
            str: HTML formatted success badge
        """
        if obj.success:
            return '<span style="color: green; font-weight: bold;">● Success</span>'
        else:
            return '<span style="color: red; font-weight: bold;">● Failed</span>'
    
    success_badge.short_description = _('Status')
    success_badge.allow_tags = True
    
    def export_audit_logs(self, request, queryset):
        """
        Export selected audit logs to CSV.
        
        Args:
            request: HTTP request object
            queryset: Selected audit logs queryset
            
        Returns:
            HttpResponse: CSV export response
        """
        import csv
        from django.http import HttpResponse
        
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="audit_logs.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Timestamp', 'User', 'Action', 'Object Type', 'Object ID',
            'Success', 'IP Address', 'Error Message'
        ])
        
        for log in queryset:
            writer.writerow([
                log.timestamp,
                log.user.email if log.user else 'System',
                log.action,
                log.object_type,
                log.object_id,
                'Yes' if log.success else 'No',
                log.ip_address,
                log.error_message
            ])
        
        return response
    
    export_audit_logs.short_description = _('Export selected audit logs to CSV')
    
    def analyze_user_activity(self, request, queryset):
        """
        Analyze user activity patterns in selected audit logs.
        
        Args:
            request: HTTP request object
            queryset: Selected audit logs queryset
        """
        from django.db.models import Count
        
        # Analyze by user
        user_activity = queryset.exclude(user__isnull=True).values(
            'user__email'
        ).annotate(count=Count('id')).order_by('-count')[:5]
        
        # Analyze by action
        action_activity = queryset.values('action').annotate(
            count=Count('id')
        ).order_by('-count')[:5]
        
        analysis = f'Total activities: {queryset.count()}. '
        
        if user_activity:
            analysis += 'Top users: ' + ', '.join([
                f"{item['user__email']} ({item['count']})"
                for item in user_activity
            ]) + '. '
        
        if action_activity:
            analysis += 'Top actions: ' + ', '.join([
                f"{item['action']} ({item['count']})"
                for item in action_activity
            ])
        
        self.message_user(request, analysis)
    
    analyze_user_activity.short_description = _('Analyze user activity patterns')
    
    def get_queryset(self, request):
        """
        Optimize queryset for audit log display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset with user data
        """
        return super().get_queryset(request).select_related('user')


@admin.register(SecurityLogEntry)
class SecurityLogEntryAdmin(ReadOnlyModelAdmin):
    """
    Admin interface for SecurityLogEntry model.
    
    Read-only interface for viewing security logs.
    """
    
    list_display = (
        'timestamp',
        'event_type',
        'severity_badge',
        'description_preview',
        'user_display',
        'ip_address',
        'resolved_badge'
    )
    
    list_filter = (
        'event_type',
        'severity',
        'resolved',
        'timestamp',
        'user',
        'resolved_by'
    )
    
    search_fields = (
        'event_type',
        'description',
        'user__email',
        'ip_address',
        'request_path'
    )
    
    date_hierarchy = 'timestamp'
    
    readonly_fields = (
        'timestamp',
        'event_type',
        'severity',
        'description',
        'user',
        'ip_address',
        'user_agent',
        'request_path',
        'additional_data',
        'resolved',
        'resolved_by',
        'resolved_at'
    )
    
    fieldsets = (
        (_('Security Event'), {
            'fields': (
                'timestamp',
                'event_type',
                'severity',
                'description'
            )
        }),
        (_('User Context'), {
            'fields': (
                'user',
                'ip_address',
                'user_agent',
                'request_path'
            )
        }),
        (_('Resolution'), {
            'fields': (
                'resolved',
                'resolved_by',
                'resolved_at'
            )
        }),
        (_('Additional Data'), {
            'fields': (
                'additional_data',
            ),
            'classes': ('collapse',)
        })
    )
    
    actions = ['export_security_logs', 'analyze_threats', 'mark_resolved']
    
    def severity_badge(self, obj):
        """
        Display severity level with color badge.
        
        Args:
            obj: SecurityLogEntry instance
            
        Returns:
            str: HTML formatted severity badge
        """
        colors = {
            'LOW': 'green',
            'MEDIUM': 'orange',
            'HIGH': 'red',
            'CRITICAL': 'darkred'
        }
        color = colors.get(obj.severity, 'gray')
        return f'<span style="color: {color}; font-weight: bold;">● {obj.severity}</span>'
    
    severity_badge.short_description = _('Severity')
    severity_badge.allow_tags = True
    
    def description_preview(self, obj):
        """
        Show a preview of the security event description.
        
        Args:
            obj: SecurityLogEntry instance
            
        Returns:
            str: Truncated description preview
        """
        return obj.description[:80] + '...' if len(obj.description) > 80 else obj.description
    
    description_preview.short_description = _('Description')
    
    def user_display(self, obj):
        """
        Display user information for security log.
        
        Args:
            obj: SecurityLogEntry instance
            
        Returns:
            str: User display name or 'Anonymous'
        """
        return obj.user.email if obj.user else 'Anonymous'
    
    user_display.short_description = _('User')
    user_display.admin_order_field = 'user__email'
    
    def resolved_badge(self, obj):
        """
        Display resolution status with color badge.
        
        Args:
            obj: SecurityLogEntry instance
            
        Returns:
            str: HTML formatted resolution badge
        """
        if obj.resolved:
            return '<span style="color: green; font-weight: bold;">● Resolved</span>'
        else:
            return '<span style="color: orange; font-weight: bold;">● Open</span>'
    
    resolved_badge.short_description = _('Status')
    resolved_badge.allow_tags = True
    
    def export_security_logs(self, request, queryset):
        """
        Export selected security logs to CSV.
        
        Args:
            request: HTTP request object
            queryset: Selected security logs queryset
            
        Returns:
            HttpResponse: CSV export response
        """
        import csv
        from django.http import HttpResponse
        
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="security_logs.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Timestamp', 'Event Type', 'Severity', 'Description', 'User',
            'IP Address', 'Resolved', 'Resolved By', 'Resolved At'
        ])
        
        for log in queryset:
            writer.writerow([
                log.timestamp,
                log.event_type,
                log.severity,
                log.description,
                log.user.email if log.user else 'Anonymous',
                log.ip_address,
                'Yes' if log.resolved else 'No',
                log.resolved_by.email if log.resolved_by else '',
                log.resolved_at
            ])
        
        return response
    
    export_security_logs.short_description = _('Export selected security logs to CSV')
    
    def analyze_threats(self, request, queryset):
        """
        Analyze threat patterns in selected security logs.
        
        Args:
            request: HTTP request object
            queryset: Selected security logs queryset
        """
        from django.db.models import Count
        
        # Analyze by severity
        severity_analysis = queryset.values('severity').annotate(
            count=Count('id')
        ).order_by('-count')
        
        # Analyze by event type
        event_analysis = queryset.values('event_type').annotate(
            count=Count('id')
        ).order_by('-count')[:5]
        
        # Count unresolved high/critical threats
        unresolved_critical = queryset.filter(
            severity__in=['HIGH', 'CRITICAL'],
            resolved=False
        ).count()
        
        analysis = f'Total security events: {queryset.count()}. '
        analysis += f'Unresolved critical/high: {unresolved_critical}. '
        
        if severity_analysis:
            analysis += 'By severity: ' + ', '.join([
                f"{item['severity']} ({item['count']})"
                for item in severity_analysis
            ]) + '. '
        
        if event_analysis:
            analysis += 'Top events: ' + ', '.join([
                f"{item['event_type']} ({item['count']})"
                for item in event_analysis
            ])
        
        self.message_user(request, analysis)
    
    analyze_threats.short_description = _('Analyze threat patterns')
    
    def mark_resolved(self, request, queryset):
        """
        Mark selected security logs as resolved.
        
        Args:
            request: HTTP request object
            queryset: Selected security logs queryset
        """
        from django.utils import timezone
        
        updated = queryset.filter(resolved=False).update(
            resolved=True,
            resolved_by=request.user,
            resolved_at=timezone.now()
        )
        
        self.message_user(
            request,
            f'{updated} security events marked as resolved.'
        )
    
    mark_resolved.short_description = _('Mark selected events as resolved')
    
    def get_queryset(self, request):
        """
        Optimize queryset for security log display.
        
        Args:
            request: HTTP request object
            
        Returns:
            QuerySet: Optimized queryset with user data
        """
        return super().get_queryset(request).select_related(
            'user', 'resolved_by'
        )