from django.contrib import admin
from django.utils.html import format_html
from django.utils import timezone
from django.urls import reverse
from django.http import HttpResponse
import csv
from .models import ChannelZone, ChannelCodec, Channel, EPGProgram, Jingle, ChannelSchedule


class EPGProgramInline(admin.TabularInline):
    """Inline for EPG Programs."""
    model = EPGProgram
    extra = 0
    fields = ('title', 'program_type', 'start_time', 'end_time', 'duration', 'has_ad_breaks')
    readonly_fields = ('created_at', 'updated_at')


class JingleInline(admin.TabularInline):
    """Inline for Channel Jingles."""
    model = Jingle
    extra = 0
    fields = ('name', 'jingle_type', 'duration', 'is_active', 'priority')
    readonly_fields = ('play_count', 'last_played')


class ChannelScheduleInline(admin.TabularInline):
    """Inline for Channel Schedules."""
    model = ChannelSchedule
    extra = 0
    fields = ('title', 'schedule_type', 'start_time', 'end_time', 'allow_ads', 'is_active')


@admin.register(ChannelZone)
class ChannelZoneAdmin(admin.ModelAdmin):
    """Admin for Channel Zones."""
    list_display = ('name', 'code', 'timezone', 'is_active', 'channels_count', 'created_at')
    list_filter = ('is_active', 'timezone', 'created_at')
    search_fields = ('name', 'code', 'description')
    readonly_fields = ('created_at', 'updated_at')
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('name', 'code', 'description')
        }),
        ('Location & Settings', {
            'fields': ('timezone', 'is_active')
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def channels_count(self, obj):
        """Display number of channels in this zone."""
        count = obj.channels.count()
        if count > 0:
            url = reverse('admin:channels_channel_changelist') + f'?zone__id__exact={obj.id}'
            return format_html('<a href="{}">{} channels</a>', url, count)
        return '0 channels'
    channels_count.short_description = 'Channels'


@admin.register(ChannelCodec)
class ChannelCodecAdmin(admin.ModelAdmin):
    """Admin for Channel Codecs."""
    list_display = ('name', 'video_codec', 'audio_codec', 'resolution', 'bitrate', 'channels_count', 'created_at')
    list_filter = ('video_codec', 'audio_codec', 'created_at')
    search_fields = ('name', 'video_codec', 'audio_codec')
    readonly_fields = ('created_at', 'updated_at')
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('name',)
        }),
        ('Codec Settings', {
            'fields': ('video_codec', 'audio_codec', 'resolution', 'bitrate', 'frame_rate')
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def channels_count(self, obj):
        """Display number of channels using this codec."""
        count = obj.channels.count()
        if count > 0:
            url = reverse('admin:channels_channel_changelist') + f'?codec__id__exact={obj.id}'
            return format_html('<a href="{}">{} channels</a>', url, count)
        return '0 channels'
    channels_count.short_description = 'Channels'


@admin.register(Channel)
class ChannelAdmin(admin.ModelAdmin):
    """Admin for Channels."""
    list_display = ('channel_number', 'name', 'display_name', 'zone', 'status_badge', 
                   'is_online_badge', 'codec', 'last_health_check')
    list_filter = ('status', 'is_online', 'zone', 'codec', 'created_at')
    search_fields = ('name', 'display_name', 'description', 'channel_number')
    readonly_fields = ('created_at', 'updated_at', 'last_health_check')
    inlines = [EPGProgramInline, JingleInline, ChannelScheduleInline]
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('name', 'display_name', 'description', 'channel_number')
        }),
        ('Configuration', {
            'fields': ('zone', 'codec', 'stream_url', 'backup_stream_url')
        }),
        ('Status & Health', {
            'fields': ('status', 'is_online', 'last_health_check')
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    actions = ['activate_channels', 'deactivate_channels', 'check_health', 'export_to_csv']
    
    def status_badge(self, obj):
        """Display status with color badge."""
        colors = {
            'active': 'green',
            'inactive': 'red',
            'maintenance': 'orange'
        }
        color = colors.get(obj.status, 'gray')
        return format_html(
            '<span style="color: {}; font-weight: bold;">{}</span>',
            color, obj.get_status_display()
        )
    status_badge.short_description = 'Status'
    
    def is_online_badge(self, obj):
        """Display online status with badge."""
        if obj.is_online:
            return format_html('<span style="color: green;">● Online</span>')
        return format_html('<span style="color: red;">● Offline</span>')
    is_online_badge.short_description = 'Online Status'
    
    def activate_channels(self, request, queryset):
        """Activate selected channels."""
        updated = queryset.update(status='active')
        self.message_user(request, f'{updated} channels activated.')
    activate_channels.short_description = 'Activate selected channels'
    
    def deactivate_channels(self, request, queryset):
        """Deactivate selected channels."""
        updated = queryset.update(status='inactive')
        self.message_user(request, f'{updated} channels deactivated.')
    deactivate_channels.short_description = 'Deactivate selected channels'
    
    def check_health(self, request, queryset):
        """Check health of selected channels."""
        for channel in queryset:
            channel.update_health_status()
        self.message_user(request, f'Health check completed for {queryset.count()} channels.')
    check_health.short_description = 'Check health status'
    
    def export_to_csv(self, request, queryset):
        """Export selected channels to CSV."""
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="channels.csv"'
        
        writer = csv.writer(response)
        writer.writerow(['Channel Number', 'Name', 'Display Name', 'Zone', 'Status', 'Online', 'Codec'])
        
        for channel in queryset:
            writer.writerow([
                channel.channel_number,
                channel.name,
                channel.display_name,
                channel.zone.name if channel.zone else '',
                channel.get_status_display(),
                'Yes' if channel.is_online else 'No',
                channel.codec.name if channel.codec else ''
            ])
        
        return response
    export_to_csv.short_description = 'Export to CSV'


@admin.register(EPGProgram)
class EPGProgramAdmin(admin.ModelAdmin):
    """Admin for EPG Programs."""
    list_display = ('title', 'channel', 'program_type', 'start_time', 'end_time', 
                   'duration_display', 'is_airing_badge', 'has_ad_breaks')
    list_filter = ('program_type', 'channel', 'has_ad_breaks', 'start_time', 'created_at')
    search_fields = ('title', 'description', 'channel__name')
    readonly_fields = ('created_at', 'updated_at')
    date_hierarchy = 'start_time'
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('channel', 'title', 'description', 'program_type')
        }),
        ('Scheduling', {
            'fields': ('start_time', 'end_time', 'duration')
        }),
        ('Content Details', {
            'fields': ('season_number', 'episode_number', 'original_air_date', 
                      'content_rating', 'language', 'subtitles_available')
        }),
        ('Ad Settings', {
            'fields': ('has_ad_breaks', 'ad_break_positions')
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    actions = ['enable_ad_breaks', 'disable_ad_breaks', 'export_schedule']
    
    def duration_display(self, obj):
        """Display duration in hours and minutes."""
        hours = obj.duration // 60
        minutes = obj.duration % 60
        if hours > 0:
            return f'{hours}h {minutes}m'
        return f'{minutes}m'
    duration_display.short_description = 'Duration'
    
    def is_airing_badge(self, obj):
        """Display if program is currently airing."""
        if obj.is_currently_airing:
            return format_html('<span style="color: green; font-weight: bold;">● LIVE</span>')
        return format_html('<span style="color: gray;">○ Scheduled</span>')
    is_airing_badge.short_description = 'Status'
    
    def enable_ad_breaks(self, request, queryset):
        """Enable ad breaks for selected programs."""
        updated = queryset.update(has_ad_breaks=True)
        self.message_user(request, f'Ad breaks enabled for {updated} programs.')
    enable_ad_breaks.short_description = 'Enable ad breaks'
    
    def disable_ad_breaks(self, request, queryset):
        """Disable ad breaks for selected programs."""
        updated = queryset.update(has_ad_breaks=False)
        self.message_user(request, f'Ad breaks disabled for {updated} programs.')
    disable_ad_breaks.short_description = 'Disable ad breaks'
    
    def export_schedule(self, request, queryset):
        """Export program schedule to CSV."""
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="program_schedule.csv"'
        
        writer = csv.writer(response)
        writer.writerow(['Channel', 'Title', 'Type', 'Start Time', 'End Time', 'Duration', 'Ad Breaks'])
        
        for program in queryset:
            writer.writerow([
                program.channel.name,
                program.title,
                program.get_program_type_display(),
                program.start_time,
                program.end_time,
                program.duration,
                'Yes' if program.has_ad_breaks else 'No'
            ])
        
        return response
    export_schedule.short_description = 'Export schedule to CSV'


@admin.register(Jingle)
class JingleAdmin(admin.ModelAdmin):
    """Admin for Jingles."""
    list_display = ('name', 'channel', 'jingle_type', 'duration_display', 
                   'is_active_badge', 'priority', 'play_count', 'last_played')
    list_filter = ('jingle_type', 'is_active', 'channel', 'created_at')
    search_fields = ('name', 'channel__name')
    readonly_fields = ('play_count', 'last_played', 'created_at', 'updated_at')
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('channel', 'name', 'jingle_type', 'file', 'duration')
        }),
        ('Usage Settings', {
            'fields': ('is_active', 'priority')
        }),
        ('Scheduling', {
            'fields': ('start_date', 'end_date', 'time_slots')
        }),
        ('Usage Statistics', {
            'fields': ('play_count', 'last_played'),
            'classes': ('collapse',)
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    actions = ['activate_jingles', 'deactivate_jingles', 'reset_play_count']
    
    def duration_display(self, obj):
        """Display duration in seconds."""
        return f'{obj.duration}s'
    duration_display.short_description = 'Duration'
    
    def is_active_badge(self, obj):
        """Display active status with badge."""
        if obj.is_active:
            return format_html('<span style="color: green;">● Active</span>')
        return format_html('<span style="color: red;">● Inactive</span>')
    is_active_badge.short_description = 'Status'
    
    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 reset_play_count(self, request, queryset):
        """Reset play count for selected jingles."""
        updated = queryset.update(play_count=0, last_played=None)
        self.message_user(request, f'Play count reset for {updated} jingles.')
    reset_play_count.short_description = 'Reset play count'


@admin.register(ChannelSchedule)
class ChannelScheduleAdmin(admin.ModelAdmin):
    """Admin for Channel Schedules."""
    list_display = ('title', 'channel', 'schedule_type', 'start_time', 'end_time', 
                   'is_active_badge', 'allow_ads', 'ad_break_duration')
    list_filter = ('schedule_type', 'is_active', 'allow_ads', 'channel', 'start_time')
    search_fields = ('title', 'description', 'channel__name')
    readonly_fields = ('created_at', 'updated_at')
    date_hierarchy = 'start_time'
    
    fieldsets = (
        ('Basic Information', {
            'fields': ('channel', 'title', 'description', 'schedule_type')
        }),
        ('Scheduling', {
            'fields': ('start_time', 'end_time', 'is_active')
        }),
        ('Content', {
            'fields': ('content_url', 'backup_content_url')
        }),
        ('Ad Settings', {
            'fields': ('allow_ads', 'ad_break_duration')
        }),
        ('Timestamps', {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    actions = ['activate_schedules', 'deactivate_schedules', 'enable_ads', 'disable_ads']
    
    def is_active_badge(self, obj):
        """Display active status with badge."""
        if obj.is_currently_active:
            return format_html('<span style="color: green; font-weight: bold;">● LIVE</span>')
        elif obj.is_active:
            return format_html('<span style="color: blue;">● Scheduled</span>')
        return format_html('<span style="color: red;">● Inactive</span>')
    is_active_badge.short_description = 'Status'
    
    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'
    
    def enable_ads(self, request, queryset):
        """Enable ads for selected schedules."""
        updated = queryset.update(allow_ads=True)
        self.message_user(request, f'Ads enabled for {updated} schedules.')
    enable_ads.short_description = 'Enable ads'
    
    def disable_ads(self, request, queryset):
        """Disable ads for selected schedules."""
        updated = queryset.update(allow_ads=False)
        self.message_user(request, f'Ads disabled for {updated} schedules.')
    disable_ads.short_description = 'Disable ads'