"""
Django Admin Configuration for Streams Application

This module configures the Django admin interface for stream management,
providing comprehensive administrative controls for channels, sessions,
configurations, and segments.
"""

from django.contrib import admin
from django.utils.html import format_html
from django.urls import reverse
from django.utils import timezone
from apps.streams.models import (
    Channel, VideoConfiguration, AudioConfiguration,
    StreamSession, HLSSegment
)


@admin.register(Channel)
class ChannelAdmin(admin.ModelAdmin):
    """
    Admin interface for Channel model.
    
    Provides comprehensive management of streaming channels including
    configuration, status monitoring, and session management.
    """
    
    # List display configuration
    list_display = [
        'name', 'slug', 'is_active', 'created_by', 
        'get_active_session_status', 'segments_count', 'created_at'
    ]
    
    # List filtering options
    list_filter = [
        'is_active', 'created_at', 'created_by'
    ]
    
    # Search functionality
    search_fields = [
        'name', 'slug', 'description', 'hls_url'
    ]
    
    # Field organization
    fieldsets = (
        ('Basic Information', {
            'fields': ('name', 'slug', 'description', 'is_active')
        }),
        ('Stream Configuration', {
            'fields': ('hls_url', 'output_directory')
        }),
        ('HLS Settings', {
            'fields': ('segment_duration', 'max_segments')
        }),
        ('Retry Configuration', {
            'fields': ('retry_attempts', 'retry_interval')
        }),
        ('Metadata', {
            'fields': ('created_by',),
            'classes': ('collapse',)
        })
    )
    
    # Prepopulated fields
    prepopulated_fields = {'slug': ('name',)}
    
    # Read-only fields
    readonly_fields = ['created_at', 'updated_at']
    
    # Ordering
    ordering = ['name']
    
    def get_active_session_status(self, obj):
        """Get the status of the active session for this channel."""
        active_session = obj.get_active_session()
        if active_session:
            color = {
                'active': 'green',
                'processing': 'orange',
                'failed': 'red',
            }.get(active_session.status, 'gray')
            
            return format_html(
                '<span style="color: {};">{}</span>',
                color,
                active_session.status.title()
            )
        return format_html('<span style="color: gray;">No Active Session</span>')
    
    get_active_session_status.short_description = 'Active Session'
    get_active_session_status.admin_order_field = 'sessions__status'
    
    def segments_count(self, obj):
        """Get the total number of segments for this channel."""
        total_segments = sum(
            session.segments.count() 
            for session in obj.sessions.all()
        )
        return total_segments
    
    segments_count.short_description = 'Total Segments'
    
    def get_queryset(self, request):
        """Optimize queryset with prefetch_related."""
        return super().get_queryset(request).select_related('created_by')


@admin.register(VideoConfiguration)
class VideoConfigurationAdmin(admin.ModelAdmin):
    """
    Admin interface for VideoConfiguration model.
    
    Provides management of video encoding presets and parameters.
    """
    
    # List display configuration
    list_display = [
        'name', 'resolution', 'frame_rate', 'codec', 
        'min_bitrate', 'max_bitrate', 'preset'
    ]
    
    # List filtering options
    list_filter = [
        'codec', 'preset', 'resolution', 'frame_rate'
    ]
    
    # Search functionality
    search_fields = ['name', 'resolution']
    
    # Field organization
    fieldsets = (
        ('Configuration Identity', {
            'fields': ('name',)
        }),
        ('Video Parameters', {
            'fields': ('resolution', 'aspect_ratio', 'frame_rate')
        }),
        ('Bitrate Settings', {
            'fields': ('min_bitrate', 'max_bitrate')
        }),
        ('Codec Configuration', {
            'fields': ('codec', 'preset', 'profile', 'level')
        })
    )
    
    # Ordering
    ordering = ['name']


@admin.register(AudioConfiguration)
class AudioConfigurationAdmin(admin.ModelAdmin):
    """
    Admin interface for AudioConfiguration model.
    
    Provides management of audio encoding presets and parameters.
    """
    
    # List display configuration
    list_display = [
        'name', 'codec', 'bitrate', 'sample_rate', 
        'channels', 'normalize'
    ]
    
    # List filtering options
    list_filter = [
        'codec', 'sample_rate', 'channels', 'normalize'
    ]
    
    # Search functionality
    search_fields = ['name']
    
    # Field organization
    fieldsets = (
        ('Configuration Identity', {
            'fields': ('name',)
        }),
        ('Audio Quality', {
            'fields': ('codec', 'bitrate', 'sample_rate', 'channels')
        }),
        ('Processing Options', {
            'fields': ('normalize',)
        })
    )
    
    # Ordering
    ordering = ['name']


class HLSSegmentInline(admin.TabularInline):
    """
    Inline admin for HLS segments within stream sessions.
    
    Provides a tabular view of segments belonging to a session.
    """
    
    model = HLSSegment
    extra = 0
    readonly_fields = [
        'filename', 'sequence_number', 'duration', 
        'file_size', 'processed_at', 'is_available'
    ]
    
    def has_add_permission(self, request, obj=None):
        """Disable adding segments through admin."""
        return False


@admin.register(StreamSession)
class StreamSessionAdmin(admin.ModelAdmin):
    """
    Admin interface for StreamSession model.
    
    Provides comprehensive monitoring and management of stream sessions
    including statistics, error tracking, and segment management.
    """
    
    # List display configuration
    list_display = [
        'get_session_info', 'channel', 'status', 'started_at', 
        'duration_display', 'segments_processed', 'errors_count'
    ]
    
    # List filtering options
    list_filter = [
        'status', 'started_at', 'channel', 'video_config', 'audio_config'
    ]
    
    # Search functionality
    search_fields = [
        'channel__name', 'channel__slug', 'process_id'
    ]
    
    # Field organization
    fieldsets = (
        ('Session Information', {
            'fields': ('channel', 'status', 'process_id')
        }),
        ('Configuration', {
            'fields': ('video_config', 'audio_config')
        }),
        ('Timing', {
            'fields': ('started_at', 'ended_at')
        }),
        ('Statistics', {
            'fields': ('segments_processed', 'errors_count', 'last_error')
        }),
        ('Additional Data', {
            'fields': ('statistics',),
            'classes': ('collapse',)
        })
    )
    
    # Read-only fields
    readonly_fields = [
        'created_at', 'updated_at', 'started_at', 'ended_at',
        'segments_processed', 'errors_count'
    ]
    
    # Inline models
    inlines = [HLSSegmentInline]
    
    # Ordering
    ordering = ['-started_at']
    
    def get_session_info(self, obj):
        """Get formatted session information."""
        status_color = {
            'active': 'green',
            'processing': 'orange',
            'completed': 'blue',
            'failed': 'red',
            'cancelled': 'gray',
        }.get(obj.status, 'black')
        
        return format_html(
            '<strong>{}</strong><br/>'
            '<span style="color: {};">{}</span>',
            str(obj.id)[:8],
            status_color,
            obj.status.title()
        )
    
    get_session_info.short_description = 'Session'
    get_session_info.admin_order_field = 'status'
    
    def duration_display(self, obj):
        """Display session duration in a readable format."""
        duration = obj.duration()
        if duration:
            total_seconds = int(duration.total_seconds())
            hours = total_seconds // 3600
            minutes = (total_seconds % 3600) // 60
            seconds = total_seconds % 60
            
            if hours > 0:
                return f"{hours}h {minutes}m {seconds}s"
            elif minutes > 0:
                return f"{minutes}m {seconds}s"
            else:
                return f"{seconds}s"
        return "-"
    
    duration_display.short_description = 'Duration'
    duration_display.admin_order_field = 'started_at'
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related(
            'channel', 'video_config', 'audio_config'
        )


@admin.register(HLSSegment)
class HLSSegmentAdmin(admin.ModelAdmin):
    """
    Admin interface for HLSSegment model.
    
    Provides detailed management of individual HLS segments
    including file information and availability status.
    """
    
    # List display configuration
    list_display = [
        'get_segment_info', 'session', 'sequence_number', 
        'duration', 'file_size_display', 'is_available', 'processed_at'
    ]
    
    # List filtering options
    list_filter = [
        'is_available', 'processed_at', 'session__channel'
    ]
    
    # Search functionality
    search_fields = [
        'filename', 'session__channel__name', 'sequence_number'
    ]
    
    # Field organization
    fieldsets = (
        ('Segment Information', {
            'fields': ('session', 'filename', 'sequence_number')
        }),
        ('File Details', {
            'fields': ('file_path', 'duration', 'file_size', 'is_available')
        }),
        ('Processing', {
            'fields': ('processed_at',)
        })
    )
    
    # Read-only fields
    readonly_fields = [
        'processed_at', 'created_at', 'updated_at'
    ]
    
    # Ordering
    ordering = ['-processed_at']
    
    def get_segment_info(self, obj):
        """Get formatted segment information."""
        availability_color = 'green' if obj.is_available else 'red'
        availability_text = 'Available' if obj.is_available else 'Missing'
        
        return format_html(
            '<strong>{}</strong><br/>'
            '<span style="color: {};">{}</span>',
            obj.filename,
            availability_color,
            availability_text
        )
    
    get_segment_info.short_description = 'Segment'
    get_segment_info.admin_order_field = 'filename'
    
    def file_size_display(self, obj):
        """Display file size in a human-readable format."""
        if obj.file_size:
            size = obj.file_size
            for unit in ['B', 'KB', 'MB', 'GB']:
                if size < 1024.0:
                    return f"{size:.1f} {unit}"
                size /= 1024.0
            return f"{size:.1f} TB"
        return "-"
    
    file_size_display.short_description = 'File Size'
    file_size_display.admin_order_field = 'file_size'
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related('session__channel')


# Custom admin site configurations
admin.site.site_header = "Stream Processor Administration"
admin.site.site_title = "Stream Processor"
admin.site.index_title = "Stream Management Dashboard"