"""Creative Management Admin Configuration

Django admin interface for creative asset management.
Provides comprehensive admin functionality for all creative-related models.

Features:
- Custom admin interfaces for all models
- Inline editing for related models
- Custom filters and search
- Bulk actions and operations
- Custom display methods
- File upload handling
- Performance metrics display
- Approval workflow management

Admin Classes:
- CreativeAdmin: Main creative management
- CreativeTemplateAdmin: Template administration
- CreativeApprovalAdmin: Approval workflow
- CreativePerformanceAdmin: Performance data
- CreativeVersionAdmin: Version management
- CreativeAssetAdmin: Asset management
- CreativeComplianceAdmin: Compliance tracking
- CreativeTagAdmin: Tag management

Customizations:
- Rich text editing
- Image previews
- Performance charts
- Bulk approval actions
- Export functionality
- Advanced filtering
"""

from django.contrib import admin
from django.utils.html import format_html, mark_safe
from django.utils import timezone
from django.urls import reverse
from django.db.models import Count, Sum, Avg
from django.contrib.admin import SimpleListFilter
from django.http import HttpResponse
from django.shortcuts import render
from django.contrib import messages
from django.core.exceptions import ValidationError

import csv
import json
from datetime import datetime, timedelta

from .models import (
    Creative, CreativeVersion, CreativeFormat, CreativeTemplate,
    CreativeAsset, CreativeApproval, CreativePerformance,
    CreativeTag, CreativeCompliance, CreativeVariant
)
from .tasks import process_creative_file, check_compliance


# Custom Filters
class CreativeTypeFilter(SimpleListFilter):
    """Filter creatives by type."""
    title = 'Creative Type'
    parameter_name = 'creative_type'
    
    def lookups(self, request, model_admin):
        return Creative.CREATIVE_TYPES
    
    def queryset(self, request, queryset):
        if self.value():
            return queryset.filter(creative_type=self.value())
        return queryset


class CreativeStatusFilter(SimpleListFilter):
    """Filter creatives by status."""
    title = 'Creative Status'
    parameter_name = 'creative_status'
    
    def lookups(self, request, model_admin):
        return Creative.CREATIVE_STATUS
    
    def queryset(self, request, queryset):
        if self.value():
            return queryset.filter(creative_status=self.value())
        return queryset


class CampaignFilter(SimpleListFilter):
    """Filter creatives by campaign."""
    title = 'Campaign'
    parameter_name = 'campaign'
    
    def lookups(self, request, model_admin):
        from apps.campaigns.models import Campaign
        campaigns = Campaign.objects.all()[:20]  # Limit for performance
        return [(c.id, c.name) for c in campaigns]
    
    def queryset(self, request, queryset):
        if self.value():
            return queryset.filter(campaign_id=self.value())
        return queryset


class HasFileFilter(SimpleListFilter):
    """Filter creatives by file presence."""
    title = 'Has File'
    parameter_name = 'has_file'
    
    def lookups(self, request, model_admin):
        return (
            ('yes', 'Yes'),
            ('no', 'No'),
        )
    
    def queryset(self, request, queryset):
        if self.value() == 'yes':
            return queryset.exclude(primary_file='')
        elif self.value() == 'no':
            return queryset.filter(primary_file='')
        return queryset


class ComplianceFilter(SimpleListFilter):
    """Filter creatives by compliance status."""
    title = 'Compliance'
    parameter_name = 'compliance'
    
    def lookups(self, request, model_admin):
        return (
            ('compliant', 'Compliant'),
            ('non_compliant', 'Non-Compliant'),
            ('not_checked', 'Not Checked'),
        )
    
    def queryset(self, request, queryset):
        if self.value() == 'compliant':
            return queryset.filter(is_compliant=True)
        elif self.value() == 'non_compliant':
            return queryset.filter(is_compliant=False)
        elif self.value() == 'not_checked':
            return queryset.filter(compliance_score__isnull=True)
        return queryset


class PerformanceFilter(SimpleListFilter):
    """Filter creatives by performance."""
    title = 'Performance'
    parameter_name = 'performance'
    
    def lookups(self, request, model_admin):
        return (
            ('high', 'High Performance'),
            ('medium', 'Medium Performance'),
            ('low', 'Low Performance'),
            ('no_data', 'No Performance Data'),
        )
    
    def queryset(self, request, queryset):
        if self.value() == 'high':
            return queryset.filter(clicks__gte=1000)
        elif self.value() == 'medium':
            return queryset.filter(clicks__gte=100, clicks__lt=1000)
        elif self.value() == 'low':
            return queryset.filter(clicks__lt=100)
        elif self.value() == 'no_data':
            return queryset.filter(impressions=0)
        return queryset


# Inline Admin Classes
class CreativeVersionInline(admin.TabularInline):
    """Inline admin for creative versions."""
    model = CreativeVersion
    extra = 0
    readonly_fields = ['version_number', 'file_size', 'created_at']
    fields = ['version_number', 'file', 'file_size', 'changes', 'created_by', 'created_at']
    
    def get_readonly_fields(self, request, obj=None):
        if obj:  # Editing existing object
            return self.readonly_fields + ['created_by']
        return self.readonly_fields


class CreativeAssetInline(admin.TabularInline):
    """Inline admin for creative assets."""
    model = CreativeAsset
    extra = 0
    readonly_fields = ['file_size', 'created_at']
    fields = ['asset_type', 'name', 'file', 'file_size', 'order', 'created_at']


class CreativeApprovalInline(admin.TabularInline):
    """Inline admin for creative approvals."""
    model = CreativeApproval
    extra = 0
    readonly_fields = ['created_at', 'reviewed_at']
    fields = ['reviewer', 'approval_status', 'comments', 'reviewed_at', 'created_at']
    
    def get_readonly_fields(self, request, obj=None):
        if obj:  # Editing existing object
            return self.readonly_fields + ['reviewer']
        return self.readonly_fields


class CreativePerformanceInline(admin.TabularInline):
    """Inline admin for creative performance."""
    model = CreativePerformance
    extra = 0
    readonly_fields = ['created_at']
    fields = ['date', 'impressions', 'clicks', 'conversions', 'spend', 'revenue', 'created_at']


class CreativeVariantInline(admin.TabularInline):
    """Inline admin for creative variants."""
    model = CreativeVariant
    extra = 0
    readonly_fields = ['created_at']
    fields = ['variant_name', 'variant_data', 'is_control', 'traffic_allocation', 'created_at']


# Main Admin Classes
@admin.register(Creative)
class CreativeAdmin(admin.ModelAdmin):
    """Creative admin interface."""
    
    list_display = [
        'name', 'creative_type_display', 'creative_status_display',
        'campaign_link', 'file_preview', 'compliance_display',
        'performance_summary', 'priority_display', 'created_by',
        'created_at'
    ]
    
    list_filter = [
        CreativeTypeFilter, CreativeStatusFilter, CampaignFilter,
        HasFileFilter, ComplianceFilter, PerformanceFilter,
        'priority', 'created_at', 'deadline'
    ]
    
    search_fields = [
        'name', 'description', 'campaign__name',
        'created_by__first_name', 'created_by__last_name'
    ]
    
    readonly_fields = [
        'file_size', 'duration', 'dimensions', 'is_compliant',
        'compliance_score', 'impressions', 'clicks', 'conversions',
        'created_at', 'updated_at', 'file_preview_large',
        'performance_chart'
    ]
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('name', 'description', 'creative_type', 'campaign', 'priority')
        }),
        ('File Information', {
            'fields': ('primary_file', 'file_preview_large', 'thumbnail', 'file_size', 'duration', 'dimensions')
        }),
        ('Compliance', {
            'fields': ('is_compliant', 'compliance_score'),
            'classes': ('collapse',)
        }),
        ('Performance', {
            'fields': ('impressions', 'clicks', 'conversions', 'performance_chart'),
            'classes': ('collapse',)
        }),
        ('Scheduling', {
            'fields': ('deadline',),
            'classes': ('collapse',)
        }),
        ('Tags', {
            'fields': ('tags',),
            'classes': ('collapse',)
        }),
        ('Metadata', {
            'fields': ('created_by', 'updated_by', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )
    
    filter_horizontal = ['tags']
    
    inlines = [
        CreativeVersionInline,
        CreativeAssetInline,
        CreativeApprovalInline,
        CreativePerformanceInline,
        CreativeVariantInline
    ]
    
    actions = [
        'approve_creatives', 'reject_creatives', 'process_files',
        'check_compliance_bulk', 'export_creatives', 'duplicate_creatives'
    ]
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'campaign', 'created_by', 'updated_by'
        ).prefetch_related('tags', 'versions', 'approvals')
    
    def creative_type_display(self, obj):
        """Display creative type with icon."""
        icons = {
            'image': '🖼️',
            'video': '🎥',
            'audio': '🎵',
            'html': '📄',
            'banner': '📰'
        }
        icon = icons.get(obj.creative_type, '📄')
        return format_html(
            '<span title="{}">{} {}</span>',
            obj.get_creative_type_display(),
            icon,
            obj.get_creative_type_display()
        )
    creative_type_display.short_description = 'Type'
    creative_type_display.admin_order_field = 'creative_type'
    
    def creative_status_display(self, obj):
        """Display creative status with color coding."""
        colors = {
            'draft': '#6c757d',
            'processing': '#ffc107',
            'pending_review': '#17a2b8',
            'approved': '#28a745',
            'rejected': '#dc3545',
            'archived': '#6c757d'
        }
        color = colors.get(obj.creative_status, '#6c757d')
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color,
            obj.get_creative_status_display()
        )
    creative_status_display.short_description = 'Status'
    creative_status_display.admin_order_field = 'creative_status'
    
    def campaign_link(self, obj):
        """Display campaign as clickable link."""
        if obj.campaign:
            url = reverse('admin:campaigns_campaign_change', args=[obj.campaign.pk])
            return format_html('<a href="{}">{}</a>', url, obj.campaign.name)
        return '-'
    campaign_link.short_description = 'Campaign'
    campaign_link.admin_order_field = 'campaign__name'
    
    def file_preview(self, obj):
        """Display file preview thumbnail."""
        if obj.thumbnail:
            return format_html(
                '<img src="{}" style="width: 50px; height: 50px; object-fit: cover; border-radius: 4px;">',
                obj.thumbnail.url
            )
        elif obj.primary_file:
            return format_html(
                '<span style="padding: 10px; background: #f8f9fa; border-radius: 4px; font-size: 12px;">📄</span>'
            )
        return '-'
    file_preview.short_description = 'Preview'
    
    def file_preview_large(self, obj):
        """Display large file preview."""
        if obj.thumbnail:
            return format_html(
                '<img src="{}" style="max-width: 300px; max-height: 300px; border-radius: 8px;">',
                obj.thumbnail.url
            )
        elif obj.primary_file:
            return format_html(
                '<div style="padding: 20px; background: #f8f9fa; border-radius: 8px; text-align: center;">'
                '<span style="font-size: 48px;">📄</span><br>'
                '<small>{}</small></div>',
                obj.primary_file.name.split('/')[-1] if obj.primary_file.name else 'File'
            )
        return 'No file uploaded'
    file_preview_large.short_description = 'File Preview'
    
    def compliance_display(self, obj):
        """Display compliance status."""
        if obj.is_compliant is None:
            return format_html('<span style="color: #6c757d;">Not Checked</span>')
        elif obj.is_compliant:
            return format_html(
                '<span style="color: #28a745;">✓ Compliant ({})</span>',
                obj.compliance_score or 'N/A'
            )
        else:
            return format_html(
                '<span style="color: #dc3545;">✗ Non-Compliant ({})</span>',
                obj.compliance_score or 'N/A'
            )
    compliance_display.short_description = 'Compliance'
    
    def performance_summary(self, obj):
        """Display performance summary."""
        if obj.impressions > 0:
            ctr = (obj.clicks / obj.impressions * 100) if obj.impressions else 0
            return format_html(
                '<small>👁 {} | 👆 {} | CTR: {:.1f}%</small>',
                obj.impressions,
                obj.clicks,
                ctr
            )
        return format_html('<small style="color: #6c757d;">No data</small>')
    performance_summary.short_description = 'Performance'
    
    def priority_display(self, obj):
        """Display priority with visual indicator."""
        colors = {
            1: '#dc3545',  # High - Red
            2: '#fd7e14',  # Medium-High - Orange
            3: '#ffc107',  # Medium - Yellow
            4: '#20c997',  # Medium-Low - Teal
            5: '#28a745'   # Low - Green
        }
        color = colors.get(obj.priority, '#6c757d')
        return format_html(
            '<span style="color: {}; font-weight: bold;">● {}</span>',
            color,
            obj.get_priority_display()
        )
    priority_display.short_description = 'Priority'
    priority_display.admin_order_field = 'priority'
    
    def performance_chart(self, obj):
        """Display performance chart."""
        if obj.pk:
            # Get recent performance data
            performance_data = obj.performance_data.all()[:30]
            if performance_data:
                chart_data = {
                    'labels': [p.date.strftime('%m/%d') for p in performance_data],
                    'impressions': [p.impressions for p in performance_data],
                    'clicks': [p.clicks for p in performance_data],
                    'conversions': [p.conversions for p in performance_data]
                }
                return format_html(
                    '<div id="performance-chart-{}" style="width: 100%; height: 200px;"></div>'
                    '<script>'
                    'if (typeof Chart !== "undefined") {{'
                    '  var ctx = document.getElementById("performance-chart-{}").getContext("2d");'
                    '  new Chart(ctx, {{'
                    '    type: "line",'
                    '    data: {},'
                    '    options: {{ responsive: true, maintainAspectRatio: false }}'
                    '  }});'
                    '}}'
                    '</script>',
                    obj.pk, obj.pk, json.dumps(chart_data)
                )
        return 'No performance data available'
    performance_chart.short_description = 'Performance Chart'
    
    # Bulk Actions
    def approve_creatives(self, request, queryset):
        """Bulk approve creatives."""
        count = 0
        for creative in queryset:
            if creative.creative_status == 'pending_review':
                CreativeApproval.objects.create(
                    creative=creative,
                    reviewer=request.user,
                    approval_status='approved',
                    comments='Bulk approved by admin',
                    reviewed_at=timezone.now()
                )
                creative.creative_status = 'approved'
                creative.save()
                count += 1
        
        self.message_user(
            request,
            f'{count} creatives were successfully approved.',
            messages.SUCCESS
        )
    approve_creatives.short_description = 'Approve selected creatives'
    
    def reject_creatives(self, request, queryset):
        """Bulk reject creatives."""
        count = 0
        for creative in queryset:
            if creative.creative_status == 'pending_review':
                CreativeApproval.objects.create(
                    creative=creative,
                    reviewer=request.user,
                    approval_status='rejected',
                    comments='Bulk rejected by admin',
                    reviewed_at=timezone.now()
                )
                creative.creative_status = 'rejected'
                creative.save()
                count += 1
        
        self.message_user(
            request,
            f'{count} creatives were rejected.',
            messages.WARNING
        )
    reject_creatives.short_description = 'Reject selected creatives'
    
    def process_files(self, request, queryset):
        """Bulk process creative files."""
        count = 0
        for creative in queryset:
            if creative.primary_file:
                process_creative_file.delay(creative.id)
                count += 1
        
        self.message_user(
            request,
            f'Processing started for {count} creatives.',
            messages.INFO
        )
    process_files.short_description = 'Process selected creative files'
    
    def check_compliance_bulk(self, request, queryset):
        """Bulk check compliance."""
        count = 0
        for creative in queryset:
            check_compliance.delay(creative.id)
            count += 1
        
        self.message_user(
            request,
            f'Compliance check started for {count} creatives.',
            messages.INFO
        )
    check_compliance_bulk.short_description = 'Check compliance for selected creatives'
    
    def export_creatives(self, request, queryset):
        """Export creatives to CSV."""
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="creatives.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Name', 'Type', 'Status', 'Campaign', 'Priority',
            'Impressions', 'Clicks', 'Conversions', 'Created At'
        ])
        
        for creative in queryset:
            writer.writerow([
                creative.name,
                creative.get_creative_type_display(),
                creative.get_creative_status_display(),
                creative.campaign.name if creative.campaign else '',
                creative.get_priority_display(),
                creative.impressions,
                creative.clicks,
                creative.conversions,
                creative.created_at.strftime('%Y-%m-%d %H:%M:%S')
            ])
        
        return response
    export_creatives.short_description = 'Export selected creatives to CSV'
    
    def duplicate_creatives(self, request, queryset):
        """Duplicate selected creatives."""
        count = 0
        for original in queryset:
            # Create duplicate
            duplicate = Creative.objects.create(
                name=f"{original.name} (Copy)",
                description=original.description,
                creative_type=original.creative_type,
                campaign=original.campaign,
                priority=original.priority,
                created_by=request.user,
                updated_by=request.user
            )
            
            # Copy tags
            duplicate.tags.set(original.tags.all())
            count += 1
        
        self.message_user(
            request,
            f'{count} creatives were duplicated.',
            messages.SUCCESS
        )
    duplicate_creatives.short_description = 'Duplicate selected creatives'


@admin.register(CreativeTemplate)
class CreativeTemplateAdmin(admin.ModelAdmin):
    """Creative template admin interface."""
    
    list_display = [
        'name', 'template_type_display', 'usage_count',
        'is_active', 'created_by', 'created_at'
    ]
    
    list_filter = ['template_type', 'is_active', 'created_at']
    
    search_fields = ['name', 'description']
    
    readonly_fields = ['usage_count', 'created_at', 'updated_at', 'preview_display']
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('name', 'description', 'template_type', 'is_active')
        }),
        ('Template Data', {
            'fields': ('template_data', 'variables')
        }),
        ('Preview', {
            'fields': ('preview_image', 'preview_display')
        }),
        ('Usage Statistics', {
            'fields': ('usage_count',),
            'classes': ('collapse',)
        }),
        ('Metadata', {
            'fields': ('created_by', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )
    
    def template_type_display(self, obj):
        """Display template type with icon."""
        icons = {
            'image': '🖼️',
            'video': '🎥',
            'audio': '🎵',
            'html': '📄',
            'banner': '📰'
        }
        icon = icons.get(obj.template_type, '📄')
        return format_html('{} {}', icon, obj.get_template_type_display())
    template_type_display.short_description = 'Type'
    template_type_display.admin_order_field = 'template_type'
    
    def preview_display(self, obj):
        """Display template preview."""
        if obj.preview_image:
            return format_html(
                '<img src="{}" style="max-width: 300px; max-height: 300px; border-radius: 8px;">',
                obj.preview_image.url
            )
        return 'No preview available'
    preview_display.short_description = 'Preview'


@admin.register(CreativeApproval)
class CreativeApprovalAdmin(admin.ModelAdmin):
    """Creative approval admin interface."""
    
    list_display = [
        'creative_link', 'approval_status_display', 'reviewer',
        'reviewed_at', 'created_at'
    ]
    
    list_filter = ['approval_status', 'reviewed_at', 'created_at']
    
    search_fields = [
        'creative__name', 'reviewer__first_name',
        'reviewer__last_name', 'comments'
    ]
    
    readonly_fields = ['created_at']
    
    def creative_link(self, obj):
        """Display creative as clickable link."""
        url = reverse('admin:creatives_creative_change', args=[obj.creative.pk])
        return format_html('<a href="{}">{}</a>', url, obj.creative.name)
    creative_link.short_description = 'Creative'
    creative_link.admin_order_field = 'creative__name'
    
    def approval_status_display(self, obj):
        """Display approval status with color coding."""
        colors = {
            'pending': '#ffc107',
            'approved': '#28a745',
            'rejected': '#dc3545'
        }
        color = colors.get(obj.approval_status, '#6c757d')
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color,
            obj.get_approval_status_display()
        )
    approval_status_display.short_description = 'Status'
    approval_status_display.admin_order_field = 'approval_status'


@admin.register(CreativePerformance)
class CreativePerformanceAdmin(admin.ModelAdmin):
    """Creative performance admin interface."""
    
    list_display = [
        'creative_link', 'date', 'impressions', 'clicks',
        'conversions', 'ctr_display', 'spend', 'revenue'
    ]
    
    list_filter = ['date', 'created_at']
    
    search_fields = ['creative__name']
    
    readonly_fields = ['created_at', 'ctr_display', 'conversion_rate_display', 'roas_display']
    
    def creative_link(self, obj):
        """Display creative as clickable link."""
        url = reverse('admin:creatives_creative_change', args=[obj.creative.pk])
        return format_html('<a href="{}">{}</a>', url, obj.creative.name)
    creative_link.short_description = 'Creative'
    creative_link.admin_order_field = 'creative__name'
    
    def ctr_display(self, obj):
        """Display click-through rate."""
        if obj.impressions > 0:
            ctr = (obj.clicks / obj.impressions) * 100
            return f'{ctr:.2f}%'
        return '0.00%'
    ctr_display.short_description = 'CTR'
    
    def conversion_rate_display(self, obj):
        """Display conversion rate."""
        if obj.clicks > 0:
            rate = (obj.conversions / obj.clicks) * 100
            return f'{rate:.2f}%'
        return '0.00%'
    conversion_rate_display.short_description = 'Conv. Rate'
    
    def roas_display(self, obj):
        """Display return on ad spend."""
        if obj.spend > 0:
            roas = float(obj.revenue / obj.spend)
            return f'{roas:.2f}x'
        return '0.00x'
    roas_display.short_description = 'ROAS'


@admin.register(CreativeTag)
class CreativeTagAdmin(admin.ModelAdmin):
    """Creative tag admin interface."""
    
    list_display = ['name', 'color_display', 'usage_count_display', 'description']
    
    search_fields = ['name', 'description']
    
    def color_display(self, obj):
        """Display color with visual indicator."""
        return format_html(
            '<span style="display: inline-block; width: 20px; height: 20px; '
            'background-color: {}; border-radius: 50%; margin-right: 8px;"></span>{}',
            obj.color, obj.color
        )
    color_display.short_description = 'Color'
    
    def usage_count_display(self, obj):
        """Display tag usage count."""
        count = obj.creative_set.count()
        return format_html(
            '<span style="background: #e9ecef; padding: 2px 8px; border-radius: 12px; font-size: 12px;">{}</span>',
            count
        )
    usage_count_display.short_description = 'Usage Count'


@admin.register(CreativeVersion)
class CreativeVersionAdmin(admin.ModelAdmin):
    """Creative version admin interface."""
    
    list_display = [
        'creative_link', 'version_number', 'file_size_display',
        'created_by', 'created_at'
    ]
    
    list_filter = ['created_at']
    
    search_fields = ['creative__name', 'changes']
    
    readonly_fields = ['version_number', 'file_size', 'created_at']
    
    def creative_link(self, obj):
        """Display creative as clickable link."""
        url = reverse('admin:creatives_creative_change', args=[obj.creative.pk])
        return format_html('<a href="{}">{}</a>', url, obj.creative.name)
    creative_link.short_description = 'Creative'
    creative_link.admin_order_field = 'creative__name'
    
    def file_size_display(self, obj):
        """Display human-readable file size."""
        if obj.file_size:
            return obj.get_file_size_display()
        return '-'
    file_size_display.short_description = 'File Size'


@admin.register(CreativeAsset)
class CreativeAssetAdmin(admin.ModelAdmin):
    """Creative asset admin interface."""
    
    list_display = [
        'name', 'creative_link', 'asset_type', 'file_size_display',
        'order', 'created_at'
    ]
    
    list_filter = ['asset_type', 'created_at']
    
    search_fields = ['name', 'creative__name']
    
    readonly_fields = ['file_size', 'created_at']
    
    def creative_link(self, obj):
        """Display creative as clickable link."""
        url = reverse('admin:creatives_creative_change', args=[obj.creative.pk])
        return format_html('<a href="{}">{}</a>', url, obj.creative.name)
    creative_link.short_description = 'Creative'
    creative_link.admin_order_field = 'creative__name'
    
    def file_size_display(self, obj):
        """Display human-readable file size."""
        if obj.file_size:
            return obj.get_file_size_display()
        return '-'
    file_size_display.short_description = 'File Size'


@admin.register(CreativeCompliance)
class CreativeComplianceAdmin(admin.ModelAdmin):
    """Creative compliance admin interface."""
    
    list_display = [
        'creative_link', 'compliance_status_display',
        'compliance_score', 'checked_at', 'created_at'
    ]
    
    list_filter = ['compliance_status', 'checked_at', 'created_at']
    
    search_fields = ['creative__name']
    
    readonly_fields = ['checked_at', 'created_at']
    
    def creative_link(self, obj):
        """Display creative as clickable link."""
        url = reverse('admin:creatives_creative_change', args=[obj.creative.pk])
        return format_html('<a href="{}">{}</a>', url, obj.creative.name)
    creative_link.short_description = 'Creative'
    creative_link.admin_order_field = 'creative__name'
    
    def compliance_status_display(self, obj):
        """Display compliance status with color coding."""
        colors = {
            'compliant': '#28a745',
            'non_compliant': '#dc3545',
            'pending': '#ffc107'
        }
        color = colors.get(obj.compliance_status, '#6c757d')
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color,
            obj.get_compliance_status_display()
        )
    compliance_status_display.short_description = 'Status'
    compliance_status_display.admin_order_field = 'compliance_status'


@admin.register(CreativeFormat)
class CreativeFormatAdmin(admin.ModelAdmin):
    """Creative format admin interface."""
    
    list_display = [
        'name', 'dimensions_display', 'max_file_size_display',
        'supported_types_display', 'is_active', 'created_at'
    ]
    
    list_filter = ['is_active', 'created_at']
    
    search_fields = ['name', 'description']
    
    readonly_fields = ['created_at']
    
    def dimensions_display(self, obj):
        """Display format dimensions."""
        return f'{obj.width} × {obj.height}'
    dimensions_display.short_description = 'Dimensions'
    
    def max_file_size_display(self, obj):
        """Display max file size in human-readable format."""
        if obj.max_file_size:
            size_mb = obj.max_file_size / (1024 * 1024)
            return f'{size_mb:.1f} MB'
        return '-'
    max_file_size_display.short_description = 'Max Size'
    
    def supported_types_display(self, obj):
        """Display supported file types."""
        if obj.supported_types:
            return ', '.join(obj.supported_types[:3]) + ('...' if len(obj.supported_types) > 3 else '')
        return '-'
    supported_types_display.short_description = 'Supported Types'


# Customize admin site
admin.site.site_header = 'Adtlas Creative Management'
admin.site.site_title = 'Adtlas Creative Admin'
admin.site.index_title = 'Creative Management Dashboard'