"""Admin configuration for Jingles app."""

from django.contrib import admin
from django.utils.html import format_html
from django.urls import reverse
from django.utils import timezone
from django.db.models import Count, Sum
from django.contrib.admin import SimpleListFilter
from django.utils.safestring import mark_safe

from .models import (
    JingleCategory,
    JingleType,
    Jingle,
    JinglePlaylist,
    JinglePlaylistItem,
    JingleSchedule,
)


class StatusFilter(SimpleListFilter):
    """Custom filter for jingle status."""
    title = 'status'
    parameter_name = 'status'

    def lookups(self, request, model_admin):
        return [
            ('active', 'Active & Approved'),
            ('pending', 'Pending Review'),
            ('expired', 'Expired'),
            ('inactive', 'Inactive'),
        ]

    def queryset(self, request, queryset):
        if self.value() == 'active':
            return queryset.filter(
                is_active=True,
                status='approved',
                is_deleted=False
            )
        elif self.value() == 'pending':
            return queryset.filter(status='pending')
        elif self.value() == 'expired':
            today = timezone.now().date()
            return queryset.filter(
                end_date__lt=today,
                is_active=True
            )
        elif self.value() == 'inactive':
            return queryset.filter(is_active=False)
        return queryset


class FileTypeFilter(SimpleListFilter):
    """Filter jingles by file type."""
    title = 'file type'
    parameter_name = 'file_type'

    def lookups(self, request, model_admin):
        return [
            ('audio', 'Audio Files'),
            ('video', 'Video Files'),
        ]

    def queryset(self, request, queryset):
        if self.value() == 'audio':
            return queryset.filter(
                file_format__in=['mp3', 'wav', 'aac', 'ogg', 'flac']
            )
        elif self.value() == 'video':
            return queryset.filter(
                file_format__in=['mp4', 'mov', 'avi', 'mkv', 'webm']
            )
        return queryset


@admin.register(JingleCategory)
class JingleCategoryAdmin(admin.ModelAdmin):
    """Admin for JingleCategory model."""
    
    list_display = [
        'name',
        'description_short',
        'color_display',
        'sort_order',
        'jingle_count',
        'is_active',
        'created_at',
    ]
    list_filter = ['is_active', 'created_at']
    search_fields = ['name', 'description']
    ordering = ['sort_order', 'name']
    list_editable = ['sort_order', 'is_active']
    
    fieldsets = [
        ('Basic Information', {
            'fields': ['name', 'description', 'color_code']
        }),
        ('Display Settings', {
            'fields': ['sort_order', 'is_active']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = ['created_at', 'updated_at']
    
    def description_short(self, obj):
        """Show truncated description."""
        if obj.description:
            return obj.description[:50] + '...' if len(obj.description) > 50 else obj.description
        return '-'
    description_short.short_description = 'Description'
    
    def color_display(self, obj):
        """Display color as a colored box."""
        return format_html(
            '<div style="width: 20px; height: 20px; background-color: {}; border: 1px solid #ccc;"></div>',
            obj.color_code
        )
    color_display.short_description = 'Color'
    
    def jingle_count(self, obj):
        """Show number of jingles in this category."""
        return obj.jingles.count()
    jingle_count.short_description = 'Jingles'
    
    actions = ['activate_categories', 'deactivate_categories']
    
    def activate_categories(self, request, queryset):
        """Activate selected categories."""
        updated = queryset.update(is_active=True)
        self.message_user(request, f'{updated} categories activated.')
    activate_categories.short_description = 'Activate selected categories'
    
    def deactivate_categories(self, request, queryset):
        """Deactivate selected categories."""
        updated = queryset.update(is_active=False)
        self.message_user(request, f'{updated} categories deactivated.')
    deactivate_categories.short_description = 'Deactivate selected categories'


@admin.register(JingleType)
class JingleTypeAdmin(admin.ModelAdmin):
    """Admin for JingleType model."""
    
    list_display = [
        'name',
        'usage',
        'description_short',
        'default_duration_display',
        'jingle_count',
        'is_active',
        'created_at',
    ]
    list_filter = ['usage', 'is_active', 'created_at']
    search_fields = ['name', 'description']
    ordering = ['name']
    list_editable = ['is_active']
    
    fieldsets = [
        ('Basic Information', {
            'fields': ['name', 'usage', 'description']
        }),
        ('Settings', {
            'fields': ['default_duration', 'is_active']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = ['created_at', 'updated_at']
    
    def description_short(self, obj):
        """Show truncated description."""
        if obj.description:
            return obj.description[:50] + '...' if len(obj.description) > 50 else obj.description
        return '-'
    description_short.short_description = 'Description'
    
    def default_duration_display(self, obj):
        """Display default duration in readable format."""
        if obj.default_duration:
            minutes, seconds = divmod(obj.default_duration, 60)
            return f"{minutes:02d}:{seconds:02d}"
        return '-'
    default_duration_display.short_description = 'Default Duration'
    
    def jingle_count(self, obj):
        """Show number of jingles of this type."""
        return obj.jingles.count()
    jingle_count.short_description = 'Jingles'


class JinglePlaylistItemInline(admin.TabularInline):
    """Inline for playlist items."""
    model = JinglePlaylistItem
    extra = 0
    fields = ['jingle', 'order', 'is_active', 'play_count', 'last_played']
    readonly_fields = ['play_count', 'last_played']
    ordering = ['order']


@admin.register(Jingle)
class JingleAdmin(admin.ModelAdmin):
    """Admin for Jingle model."""
    
    list_display = [
        'name',
        'channel',
        'category',
        'jingle_type',
        'file_info',
        'duration_display',
        'status_display',
        'quality',
        'play_count',
        'is_active',
        'created_at',
    ]
    list_filter = [
        StatusFilter,
        FileTypeFilter,
        'channel',
        'category',
        'jingle_type',
        'status',
        'quality',
        'is_active',
        'created_at',
    ]
    search_fields = [
        'name',
        'description',
        'tags',
        'channel__name',
        'category__name',
        'jingle_type__name',
    ]
    ordering = ['-created_at']
    list_editable = ['status', 'quality', 'is_active']
    date_hierarchy = 'created_at'
    
    fieldsets = [
        ('Basic Information', {
            'fields': [
                'name',
                'description',
                'channel',
                'category',
                'jingle_type',
                'tags',
            ]
        }),
        ('File Information', {
            'fields': [
                'file',
                'file_size',
                'file_format',
                'md5_hash',
            ]
        }),
        ('Media Properties', {
            'fields': [
                'duration_seconds',
                'bitrate',
                'sample_rate',
                'channels',
                'codec',
            ],
            'classes': ['collapse']
        }),
        ('Video Properties', {
            'fields': [
                'width',
                'height',
                'frame_rate',
            ],
            'classes': ['collapse']
        }),
        ('Status & Workflow', {
            'fields': [
                'status',
                'quality',
                'is_active',
                'is_deleted',
                'priority',
            ]
        }),
        ('Scheduling', {
            'fields': [
                'start_date',
                'end_date',
            ]
        }),
        ('Usage Statistics', {
            'fields': [
                'play_count',
                'last_played',
            ],
            'classes': ['collapse']
        }),
        ('User Tracking', {
            'fields': [
                'uploaded_by',
                'approved_by',
                'approved_at',
            ],
            'classes': ['collapse']
        }),
        ('Additional Information', {
            'fields': [
                'notes',
                'metadata',
            ],
            'classes': ['collapse']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = [
        'file_size',
        'file_format',
        'md5_hash',
        'play_count',
        'last_played',
        'created_at',
        'updated_at',
    ]
    
    def file_info(self, obj):
        """Display file information."""
        if obj.file:
            size = obj.get_file_size_display()
            format_info = obj.file_format.upper() if obj.file_format else 'Unknown'
            return f"{format_info} ({size})"
        return 'No file'
    file_info.short_description = 'File Info'
    
    def duration_display(self, obj):
        """Display duration in readable format."""
        return obj.get_duration_display()
    duration_display.short_description = 'Duration'
    
    def status_display(self, obj):
        """Display status with color coding."""
        colors = {
            'pending': '#ffc107',
            'processing': '#17a2b8',
            'approved': '#28a745',
            'rejected': '#dc3545',
            'archived': '#6c757d',
        }
        color = colors.get(obj.status, '#6c757d')
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color,
            obj.get_status_display()
        )
    status_display.short_description = 'Status'
    
    actions = [
        'approve_jingles',
        'reject_jingles',
        'archive_jingles',
        'activate_jingles',
        'deactivate_jingles',
    ]
    
    def approve_jingles(self, request, queryset):
        """Approve selected jingles."""
        updated = queryset.update(
            status='approved',
            approved_by=request.user,
            approved_at=timezone.now()
        )
        self.message_user(request, f'{updated} jingles approved.')
    approve_jingles.short_description = 'Approve selected jingles'
    
    def reject_jingles(self, request, queryset):
        """Reject selected jingles."""
        updated = queryset.update(status='rejected')
        self.message_user(request, f'{updated} jingles rejected.')
    reject_jingles.short_description = 'Reject selected jingles'
    
    def archive_jingles(self, request, queryset):
        """Archive selected jingles."""
        updated = queryset.update(status='archived', is_active=False)
        self.message_user(request, f'{updated} jingles archived.')
    archive_jingles.short_description = 'Archive selected jingles'
    
    def activate_jingles(self, request, queryset):
        """Activate selected jingles."""
        updated = queryset.update(is_active=True)
        self.message_user(request, f'{updated} jingles activated.')
    activate_jingles.short_description = 'Activate selected jingles'
    
    def deactivate_jingles(self, request, queryset):
        """Deactivate selected jingles."""
        updated = queryset.update(is_active=False)
        self.message_user(request, f'{updated} jingles deactivated.')
    deactivate_jingles.short_description = 'Deactivate selected jingles'
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'channel',
            'category',
            'jingle_type',
            'uploaded_by',
            'approved_by'
        )


@admin.register(JinglePlaylist)
class JinglePlaylistAdmin(admin.ModelAdmin):
    """Admin for JinglePlaylist model."""
    
    list_display = [
        'name',
        'channel',
        'playlist_type',
        'jingle_count_display',
        'total_duration_display',
        'is_active',
        'created_by',
        'created_at',
    ]
    list_filter = [
        'channel',
        'playlist_type',
        'is_active',
        'created_at',
    ]
    search_fields = [
        'name',
        'description',
        'channel__name',
        'created_by__username',
    ]
    ordering = ['channel', 'name']
    list_editable = ['is_active']
    
    fieldsets = [
        ('Basic Information', {
            'fields': [
                'name',
                'description',
                'channel',
                'playlist_type',
                'is_active',
            ]
        }),
        ('Scheduling', {
            'fields': [
                'start_time',
                'end_time',
                'days_of_week',
            ],
            'classes': ['collapse']
        }),
        ('Auto-generation Rules', {
            'fields': ['auto_rules'],
            'classes': ['collapse']
        }),
        ('User Information', {
            'fields': ['created_by'],
            'classes': ['collapse']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = ['created_at', 'updated_at']
    inlines = [JinglePlaylistItemInline]
    
    def jingle_count_display(self, obj):
        """Display number of jingles in playlist."""
        return obj.get_jingle_count()
    jingle_count_display.short_description = 'Jingles'
    
    def total_duration_display(self, obj):
        """Display total duration of playlist."""
        total_seconds = obj.get_total_duration()
        if total_seconds:
            minutes, seconds = divmod(total_seconds, 60)
            hours, minutes = divmod(minutes, 60)
            if hours:
                return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
            else:
                return f"{minutes:02d}:{seconds:02d}"
        return '00:00'
    total_duration_display.short_description = 'Total Duration'
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'channel',
            'created_by'
        ).prefetch_related('playlist_items__jingle')


@admin.register(JinglePlaylistItem)
class JinglePlaylistItemAdmin(admin.ModelAdmin):
    """Admin for JinglePlaylistItem model."""
    
    list_display = [
        'playlist',
        'jingle',
        'order',
        'is_active',
        'play_count',
        'last_played',
        'created_at',
    ]
    list_filter = [
        'playlist__channel',
        'playlist',
        'is_active',
        'created_at',
    ]
    search_fields = [
        'playlist__name',
        'jingle__name',
        'playlist__channel__name',
    ]
    ordering = ['playlist', 'order']
    list_editable = ['order', 'is_active']
    
    fieldsets = [
        ('Basic Information', {
            'fields': [
                'playlist',
                'jingle',
                'order',
                'is_active',
            ]
        }),
        ('Scheduling Overrides', {
            'fields': [
                'start_date',
                'end_date',
            ],
            'classes': ['collapse']
        }),
        ('Statistics', {
            'fields': [
                'play_count',
                'last_played',
            ],
            'classes': ['collapse']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = ['play_count', 'last_played', 'created_at', 'updated_at']
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'playlist',
            'playlist__channel',
            'jingle'
        )


@admin.register(JingleSchedule)
class JingleScheduleAdmin(admin.ModelAdmin):
    """Admin for JingleSchedule model."""
    
    list_display = [
        'name',
        'channel',
        'schedule_type',
        'playlist',
        'time_range_display',
        'priority',
        'is_active_now_display',
        'is_active',
        'created_at',
    ]
    list_filter = [
        'channel',
        'schedule_type',
        'is_active',
        'priority',
        'created_at',
    ]
    search_fields = [
        'name',
        'channel__name',
        'playlist__name',
    ]
    ordering = ['channel', 'priority', 'name']
    list_editable = ['priority', 'is_active']
    
    fieldsets = [
        ('Basic Information', {
            'fields': [
                'name',
                'channel',
                'schedule_type',
                'playlist',
                'priority',
                'is_active',
            ]
        }),
        ('Time Scheduling', {
            'fields': [
                'start_time',
                'end_time',
                'interval_minutes',
            ]
        }),
        ('Date Scheduling', {
            'fields': [
                'start_date',
                'end_date',
                'days_of_week',
            ]
        }),
        ('Conditions', {
            'fields': ['conditions'],
            'classes': ['collapse']
        }),
        ('User Information', {
            'fields': ['created_by'],
            'classes': ['collapse']
        }),
        ('Timestamps', {
            'fields': ['created_at', 'updated_at'],
            'classes': ['collapse']
        }),
    ]
    readonly_fields = ['created_at', 'updated_at']
    
    def time_range_display(self, obj):
        """Display time range for the schedule."""
        if obj.start_time and obj.end_time:
            return f"{obj.start_time.strftime('%H:%M')} - {obj.end_time.strftime('%H:%M')}"
        elif obj.interval_minutes:
            return f"Every {obj.interval_minutes} minutes"
        return '-'
    time_range_display.short_description = 'Time Range'
    
    def is_active_now_display(self, obj):
        """Display if schedule is currently active."""
        is_active = obj.is_active_now()
        color = '#28a745' if is_active else '#6c757d'
        text = 'Yes' if is_active else 'No'
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color,
            text
        )
    is_active_now_display.short_description = 'Active Now'
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'channel',
            'playlist',
            'created_by'
        )
    
    actions = ['activate_schedules', 'deactivate_schedules']
    
    def activate_schedules(self, request, queryset):
        """Activate selected schedules."""
        updated = queryset.update(is_active=True)
        self.message_user(request, f'{updated} schedules activated.')
    activate_schedules.short_description = 'Activate selected schedules'
    
    def deactivate_schedules(self, request, queryset):
        """Deactivate selected schedules."""
        updated = queryset.update(is_active=False)
        self.message_user(request, f'{updated} schedules deactivated.')
    deactivate_schedules.short_description = 'Deactivate selected schedules'