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
)


@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')