# -*- coding: utf-8 -*-
"""
Django Admin Configuration for Common App

This module provides base admin configurations and mixins for common models.
These are abstract models that other apps inherit from, so they don't need
direct admin registration, but we provide mixins for consistent admin interfaces.

Features:
    - Base admin mixins for common functionality
    - Consistent admin interface patterns
    - Audit trail display
    - Soft delete management
    - Metadata display

Author: Adtlas Development Team
Version: 2.0.0
Last Updated: 2025-07-15
"""

from django.contrib import admin
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _


class TimeStampedModelAdminMixin:
    """Mixin for models that inherit from TimeStampedModel."""
    
    def get_readonly_fields(self, request, obj=None):
        """Add timestamp fields to readonly fields."""
        readonly_fields = list(super().get_readonly_fields(request, obj))
        readonly_fields.extend(['created_at', 'updated_at'])
        return readonly_fields
    
    def get_list_display(self, request):
        """Add timestamp fields to list display if not already present."""
        list_display = list(super().get_list_display(request))
        if 'created_at' not in list_display:
            list_display.append('created_at')
        if 'updated_at' not in list_display:
            list_display.append('updated_at')
        return list_display
    
    def get_list_filter(self, request):
        """Add timestamp filters if not already present."""
        list_filter = list(super().get_list_filter(request))
        if 'created_at' not in list_filter:
            list_filter.append('created_at')
        if 'updated_at' not in list_filter:
            list_filter.append('updated_at')
        return list_filter


class UUIDModelAdminMixin:
    """Mixin for models that inherit from UUIDModel."""
    
    def get_readonly_fields(self, request, obj=None):
        """Add UUID field to readonly fields."""
        readonly_fields = list(super().get_readonly_fields(request, obj))
        if 'id' not in readonly_fields:
            readonly_fields.append('id')
        return readonly_fields


class SoftDeleteModelAdminMixin:
    """Mixin for models that inherit from SoftDeleteModel."""
    
    def get_list_display(self, request):
        """Add soft delete status to list display."""
        list_display = list(super().get_list_display(request))
        if 'is_deleted' not in list_display:
            list_display.append('is_deleted')
        return list_display
    
    def get_list_filter(self, request):
        """Add soft delete filter."""
        list_filter = list(super().get_list_filter(request))
        if 'is_deleted' not in list_filter:
            list_filter.append('is_deleted')
        return list_filter
    
    def get_readonly_fields(self, request, obj=None):
        """Add soft delete timestamp to readonly fields."""
        readonly_fields = list(super().get_readonly_fields(request, obj))
        readonly_fields.extend(['deleted_at', 'deleted_by'])
        return readonly_fields
    
    actions = ['soft_delete_items', 'restore_items']
    
    def soft_delete_items(self, request, queryset):
        """Soft delete selected items."""
        updated = queryset.update(is_deleted=True, deleted_by=request.user)
        self.message_user(request, f'{updated} items soft deleted.')
    soft_delete_items.short_description = "Soft delete selected items"
    
    def restore_items(self, request, queryset):
        """Restore soft deleted items."""
        updated = queryset.update(is_deleted=False, deleted_by=None, deleted_at=None)
        self.message_user(request, f'{updated} items restored.')
    restore_items.short_description = "Restore selected items"


class AuditModelAdminMixin:
    """Mixin for models that inherit from AuditModel."""
    
    def get_readonly_fields(self, request, obj=None):
        """Add audit fields to readonly fields."""
        readonly_fields = list(super().get_readonly_fields(request, obj))
        readonly_fields.extend(['created_by', 'updated_by'])
        return readonly_fields
    
    def get_list_display(self, request):
        """Add audit fields to list display."""
        list_display = list(super().get_list_display(request))
        if 'created_by' not in list_display:
            list_display.append('created_by')
        return list_display
    
    def save_model(self, request, obj, form, change):
        """Set audit fields on save."""
        if not change:  # Creating new object
            obj.created_by = request.user
        obj.updated_by = request.user
        super().save_model(request, obj, form, change)


class StatusModelAdminMixin:
    """Mixin for models that inherit from StatusModel."""
    
    def get_list_display(self, request):
        """Add status to list display."""
        list_display = list(super().get_list_display(request))
        if 'status' not in list_display:
            list_display.append('status')
        return list_display
    
    def get_list_filter(self, request):
        """Add status filter."""
        list_filter = list(super().get_list_filter(request))
        if 'status' not in list_filter:
            list_filter.append('status')
        return list_filter


class MetaDataModelAdminMixin:
    """Mixin for models that inherit from MetaDataModel."""
    
    def get_fieldsets(self, request, obj=None):
        """Add metadata fieldset."""
        fieldsets = list(super().get_fieldsets(request, obj))
        fieldsets.append(
            (_('Metadata'), {
                'fields': ('metadata',),
                'classes': ('collapse',)
            })
        )
        return fieldsets


class BaseModelAdmin(
    TimeStampedModelAdminMixin,
    UUIDModelAdminMixin,
    SoftDeleteModelAdminMixin,
    AuditModelAdminMixin,
    admin.ModelAdmin
):
    """Base admin class for models that inherit from BaseModel."""
    
    def get_fieldsets(self, request, obj=None):
        """Add timestamp fieldset."""
        fieldsets = list(super().get_fieldsets(request, obj))
        fieldsets.append(
            (_('Timestamps'), {
                'fields': ('created_at', 'updated_at', 'deleted_at'),
                'classes': ('collapse',)
            })
        )
        fieldsets.append(
            (_('Audit'), {
                'fields': ('created_by', 'updated_by', 'deleted_by'),
                'classes': ('collapse',)
            })
        )
        return fieldsets


class FullBaseModelAdmin(
    BaseModelAdmin,
    StatusModelAdminMixin,
    MetaDataModelAdminMixin
):
    """Full base admin class for models that inherit from FullBaseModel."""
    
    def get_list_display(self, request):
        """Add slug to list display."""
        list_display = list(super().get_list_display(request))
        if 'slug' not in list_display:
            list_display.append('slug')
        return list_display
    
    def get_fieldsets(self, request, obj=None):
        """Add additional fieldsets."""
        fieldsets = list(super().get_fieldsets(request, obj))
        fieldsets.append(
            (_('Slug & Sort'), {
                'fields': ('slug', 'sort_order'),
                'classes': ('collapse',)
            })
        )
        return fieldsets


# Note: These are abstract models, so no direct admin registration
# Other apps should inherit from these mixins for consistent admin interfaces