# -*- coding: utf-8 -*-
"""
Analytics Admin Configuration
=============================

Django admin interface configuration for the Adtlas Analytics module.
Provides comprehensive admin interface for managing analytics data,
reports, and performance metrics.

Admin Classes:
- SfrAnalyticsAdmin: SFR analytics data management
- BouyguesAnalyticsAdmin: Bouygues analytics data management
- ImpressionAdmin: Impression tracking management
- VastResponseAdmin: VAST response data management
- PerformanceMetricAdmin: Performance metrics management
- AnalyticsReportAdmin: Report management

Key Features:
- Advanced filtering and search
- Bulk operations
- Data visualization
- Export capabilities
- Custom actions
- Performance optimization
- Data validation
- Security measures

Customizations:
- Custom list displays
- Advanced filters
- Inline editing
- Bulk actions
- Custom forms
- Data aggregation
- Export functions

Author: Adtlas Development Team
Version: 1.0.0
Last Updated: 2024
"""

from django.contrib import admin
from django.utils.translation import gettext_lazy as _
from django.utils.html import format_html
from django.urls import reverse
from django.db.models import Sum, Avg, Count
from django.http import HttpResponse
from django.utils import timezone
import csv
import json
from datetime import datetime, timedelta

from .models import (
    SfrAnalytics,
    BouyguesAnalytics,
    Impression,
    VastResponse,
    PerformanceMetric,
    AnalyticsReport
)


class BaseAnalyticsAdmin(admin.ModelAdmin):
    """
    Base admin class for analytics models.
    
    Provides common functionality for all analytics admin classes:
    - Standard list display
    - Filtering options
    - Search capabilities
    - Export actions
    - Performance optimization
    
    Attributes:
        list_per_page: Number of items per page
        show_full_result_count: Whether to show full count
        actions: Available bulk actions
    """
    
    list_per_page = 50
    show_full_result_count = False
    
    # Common fields for all analytics models
    readonly_fields = ['id', 'created_at', 'updated_at']
    
    # Common actions
    actions = ['export_as_csv', 'mark_as_inactive', 'mark_as_active']
    
    def get_queryset(self, request):
        """
        Optimize queryset for admin interface.
        
        Args:
            request: HTTP request
            
        Returns:
            QuerySet: Optimized queryset
        """
        queryset = super().get_queryset(request)
        
        # Select related fields to reduce database queries
        if hasattr(self.model, 'channel'):
            queryset = queryset.select_related('channel')
        if hasattr(self.model, 'campaign'):
            queryset = queryset.select_related('campaign')
        
        return queryset
    
    def export_as_csv(self, request, queryset):
        """
        Export selected records as CSV.
        
        Args:
            request: HTTP request
            queryset: Selected records
            
        Returns:
            HttpResponse: CSV file response
        """
        meta = self.model._meta
        field_names = [field.name for field in meta.fields]
        
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = f'attachment; filename={meta}.csv'
        
        writer = csv.writer(response)
        writer.writerow(field_names)
        
        for obj in queryset:
            row = []
            for field in field_names:
                value = getattr(obj, field)
                if callable(value):
                    value = value()
                row.append(str(value))
            writer.writerow(row)
        
        return response
    
    export_as_csv.short_description = _("Export selected as CSV")
    
    def mark_as_inactive(self, request, queryset):
        """
        Mark selected records as inactive.
        
        Args:
            request: HTTP request
            queryset: Selected records
        """
        updated = queryset.update(is_active=False)
        self.message_user(
            request,
            _(f'{updated} records marked as inactive.')
        )
    
    mark_as_inactive.short_description = _("Mark selected as inactive")
    
    def mark_as_active(self, request, queryset):
        """
        Mark selected records as active.
        
        Args:
            request: HTTP request
            queryset: Selected records
        """
        updated = queryset.update(is_active=True)
        self.message_user(
            request,
            _(f'{updated} records marked as active.')
        )
    
    mark_as_active.short_description = _("Mark selected as active")


@admin.register(SfrAnalytics)
class SfrAnalyticsAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for SFR Analytics data.
    
    Provides comprehensive management interface for SFR analytics
    including filtering, search, and data visualization.
    
    Features:
        - Channel and campaign filtering
        - Date range filtering
        - Performance metrics display
        - Bulk operations
        - Data export
        - Custom actions
    """
    
    list_display = [
        'id', 'channel_link', 'campaign_link', 'date', 'hour',
        'audience_count', 'market_share_display', 'rating_display',
        'performance_score_display', 'is_active', 'created_at'
    ]
    
    list_filter = [
        'is_active', 'date', 'hour', 'channel', 'campaign',
        'market_share',
        'rating',
        'audience_count'
    ]
    
    search_fields = [
        'channel__name', 'campaign__name', 'id'
    ]
    
    date_hierarchy = 'date'
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('channel', 'campaign', 'date', 'hour', 'is_active')
        }),
        (_('Audience Metrics'), {
            'fields': ('audience_count', 'market_share', 'rating', 'reach', 'frequency', 'duration')
        }),
        (_('Additional Data'), {
            'fields': ('demographics', 'geographic_data'),
            'classes': ('collapse',)
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def channel_link(self, obj):
        """
        Create link to channel admin page.
        
        Args:
            obj: SfrAnalytics instance
            
        Returns:
            str: HTML link to channel
        """
        if obj.channel:
            url = reverse('admin:channels_channel_change', args=[obj.channel.pk])
            return format_html('<a href="{}">{}</a>', url, obj.channel.name)
        return '-'
    
    channel_link.short_description = _('Channel')
    channel_link.admin_order_field = 'channel__name'
    
    def campaign_link(self, obj):
        """
        Create link to campaign admin page.
        
        Args:
            obj: SfrAnalytics instance
            
        Returns:
            str: HTML link to campaign or dash if none
        """
        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 market_share_display(self, obj):
        """
        Display market share with formatting.
        
        Args:
            obj: SfrAnalytics instance
            
        Returns:
            str: Formatted market share
        """
        return f"{obj.market_share:.2f}%"
    
    market_share_display.short_description = _('Market Share')
    market_share_display.admin_order_field = 'market_share'
    
    def rating_display(self, obj):
        """
        Display rating with color coding.
        
        Args:
            obj: SfrAnalytics instance
            
        Returns:
            str: HTML formatted rating
        """
        rating = float(obj.rating)
        if rating >= 5.0:
            color = 'green'
        elif rating >= 3.0:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{:.2f}</span>',
            color, rating
        )
    
    rating_display.short_description = _('Rating')
    rating_display.admin_order_field = 'rating'
    
    def performance_score_display(self, obj):
        """
        Display calculated performance score.
        
        Args:
            obj: SfrAnalytics instance
            
        Returns:
            str: Formatted performance score
        """
        score = obj.get_performance_score()
        return f"{score:.2f}"
    
    performance_score_display.short_description = _('Performance Score')


@admin.register(BouyguesAnalytics)
class BouyguesAnalyticsAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for Bouygues Analytics data.
    
    Similar to SFR analytics but with Bouygues-specific
    field names and display options.
    
    Features:
        - Provider-specific metrics display
        - Device data visualization
        - Age group analysis
        - Custom filtering
    """
    
    list_display = [
        'id', 'channel_link', 'campaign_link', 'date', 'hour',
        'viewers', 'share_display', 'rating_value_display',
        'watch_time_display', 'is_active', 'created_at'
    ]
    
    list_filter = [
        'is_active', 'date', 'hour', 'channel', 'campaign',
        'share',
        'rating_value',
        'viewers'
    ]
    
    search_fields = [
        'channel__name', 'campaign__name', 'id'
    ]
    
    date_hierarchy = 'date'
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('channel', 'campaign', 'date', 'hour', 'is_active')
        }),
        (_('Audience Metrics'), {
            'fields': ('viewers', 'share', 'rating_value', 'reach_percentage', 'avg_frequency', 'watch_time')
        }),
        (_('Additional Data'), {
            'fields': ('device_data', 'age_groups'),
            'classes': ('collapse',)
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def channel_link(self, obj):
        """Create link to channel admin page."""
        if obj.channel:
            url = reverse('admin:channels_channel_change', args=[obj.channel.pk])
            return format_html('<a href="{}">{}</a>', url, obj.channel.name)
        return '-'
    
    channel_link.short_description = _('Channel')
    channel_link.admin_order_field = 'channel__name'
    
    def campaign_link(self, obj):
        """Create link to campaign admin page."""
        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 share_display(self, obj):
        """Display share with formatting."""
        return f"{obj.share:.2f}%"
    
    share_display.short_description = _('Share')
    share_display.admin_order_field = 'share'
    
    def rating_value_display(self, obj):
        """Display rating value with color coding."""
        rating = float(obj.rating_value)
        if rating >= 5.0:
            color = 'green'
        elif rating >= 3.0:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{:.2f}</span>',
            color, rating
        )
    
    rating_value_display.short_description = _('Rating Value')
    rating_value_display.admin_order_field = 'rating_value'
    
    def watch_time_display(self, obj):
        """Display watch time in minutes."""
        return f"{obj.watch_time} min"
    
    watch_time_display.short_description = _('Watch Time')
    watch_time_display.admin_order_field = 'watch_time'


@admin.register(Impression)
class ImpressionAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for Impression tracking data.
    
    Provides detailed impression management with privacy
    protection for sensitive user data.
    
    Features:
        - Impression tracking overview
        - Completion rate analysis
        - Geographic distribution
        - Privacy-protected data display
        - Performance metrics
    """
    
    list_display = [
        'id', 'campaign_link', 'adspot_link', 'channel_link',
        'timestamp', 'duration_display', 'completion_rate_display',
        'click_through_display', 'viewable_status', 'created_at'
    ]
    
    list_filter = [
        'is_active', 'click_through', 'timestamp', 'campaign',
        'channel', 'adspot',
        'completion_rate',
        'duration'
    ]
    
    search_fields = [
        'campaign__name', 'adspot__name', 'channel__name', 'id'
    ]
    
    date_hierarchy = 'timestamp'
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('campaign', 'adspot', 'channel', 'timestamp', 'is_active')
        }),
        (_('Performance Metrics'), {
            'fields': ('duration', 'completion_rate', 'click_through', 'vast_response')
        }),
        (_('Additional Data'), {
            'fields': ('geographic_info', 'device_info'),
            'classes': ('collapse',)
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def campaign_link(self, obj):
        """Create link to campaign admin page."""
        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 adspot_link(self, obj):
        """Create link to adspot admin page."""
        if obj.adspot:
            url = reverse('admin:adspots_adspot_change', args=[obj.adspot.pk])
            return format_html('<a href="{}">{}</a>', url, obj.adspot.name)
        return '-'
    
    adspot_link.short_description = _('Ad Spot')
    adspot_link.admin_order_field = 'adspot__name'
    
    def channel_link(self, obj):
        """Create link to channel admin page."""
        if obj.channel:
            url = reverse('admin:channels_channel_change', args=[obj.channel.pk])
            return format_html('<a href="{}">{}</a>', url, obj.channel.name)
        return '-'
    
    channel_link.short_description = _('Channel')
    channel_link.admin_order_field = 'channel__name'
    
    def duration_display(self, obj):
        """Display duration in seconds."""
        return f"{obj.duration}s"
    
    duration_display.short_description = _('Duration')
    duration_display.admin_order_field = 'duration'
    
    def completion_rate_display(self, obj):
        """Display completion rate with color coding."""
        rate = float(obj.completion_rate)
        if rate >= 75:
            color = 'green'
        elif rate >= 50:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{:.1f}%</span>',
            color, rate
        )
    
    completion_rate_display.short_description = _('Completion Rate')
    completion_rate_display.admin_order_field = 'completion_rate'
    
    def click_through_display(self, obj):
        """Display click-through status with icons."""
        if obj.click_through:
            return format_html('<span style="color: green;">✓</span>')
        return format_html('<span style="color: red;">✗</span>')
    
    click_through_display.short_description = _('Click Through')
    click_through_display.admin_order_field = 'click_through'
    
    def viewable_status(self, obj):
        """Display viewability status."""
        if obj.is_viewable:
            return format_html('<span style="color: green;">Viewable</span>')
        return format_html('<span style="color: red;">Not Viewable</span>')
    
    viewable_status.short_description = _('Viewable')


@admin.register(VastResponse)
class VastResponseAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for VAST Response tracking data.
    
    Provides VAST response management with performance
    analysis and error tracking capabilities.
    
    Features:
        - Response time analysis
        - Status code tracking
        - Error message display
        - Performance optimization
        - Bulk operations
    """
    
    list_display = [
        'id', 'campaign_link', 'adspot_link', 'served_at',
        'response_time_display', 'status_code_display',
        'success_status', 'speed_status', 'created_at'
    ]
    
    list_filter = [
        'is_active', 'status_code', 'served_at', 'campaign',
        'response_time'
    ]
    
    search_fields = [
        'campaign__name', 'adspot__name', 'vast_url', 'id'
    ]
    
    date_hierarchy = 'served_at'
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('campaign', 'adspot', 'vast_url', 'served_at', 'is_active')
        }),
        (_('Response Metrics'), {
            'fields': ('response_time', 'status_code', 'error_message')
        }),
        (_('VAST Data'), {
            'fields': ('xml_content', 'tracking_urls', 'creative_info'),
            'classes': ('collapse',)
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def campaign_link(self, obj):
        """Create link to campaign admin page."""
        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 adspot_link(self, obj):
        """Create link to adspot admin page."""
        if obj.adspot:
            url = reverse('admin:adspots_adspot_change', args=[obj.adspot.pk])
            return format_html('<a href="{}">{}</a>', url, obj.adspot.name)
        return '-'
    
    adspot_link.short_description = _('Ad Spot')
    adspot_link.admin_order_field = 'adspot__name'
    
    def response_time_display(self, obj):
        """Display response time with color coding."""
        time_ms = obj.response_time
        if time_ms < 100:
            color = 'green'
        elif time_ms < 500:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{} ms</span>',
            color, time_ms
        )
    
    response_time_display.short_description = _('Response Time')
    response_time_display.admin_order_field = 'response_time'
    
    def status_code_display(self, obj):
        """Display status code with color coding."""
        code = obj.status_code
        if 200 <= code < 300:
            color = 'green'
        elif 300 <= code < 400:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{}</span>',
            color, code
        )
    
    status_code_display.short_description = _('Status Code')
    status_code_display.admin_order_field = 'status_code'
    
    def success_status(self, obj):
        """Display success status."""
        if obj.is_successful:
            return format_html('<span style="color: green;">✓</span>')
        return format_html('<span style="color: red;">✗</span>')
    
    success_status.short_description = _('Success')
    
    def speed_status(self, obj):
        """Display speed status."""
        if obj.is_fast_response:
            return format_html('<span style="color: green;">Fast</span>')
        return format_html('<span style="color: red;">Slow</span>')
    
    speed_status.short_description = _('Speed')


@admin.register(PerformanceMetric)
class PerformanceMetricAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for Performance Metrics data.
    
    Provides performance metrics management with
    aggregation and trend analysis capabilities.
    
    Features:
        - Performance metrics overview
        - ROI and CTR analysis
        - Revenue tracking
        - Trend visualization
        - Custom calculations
    """
    
    list_display = [
        'id', 'campaign_link', 'channel_link', 'date', 'metric_type',
        'impressions_count', 'ctr_display', 'revenue_display',
        'roi_display', 'created_at'
    ]
    
    list_filter = [
        'is_active', 'metric_type', 'date', 'campaign', 'channel',
        'ctr',
        'roi',
        'revenue'
    ]
    
    search_fields = [
        'campaign__name', 'channel__name', 'id'
    ]
    
    date_hierarchy = 'date'
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('campaign', 'channel', 'date', 'metric_type', 'is_active')
        }),
        (_('Performance Metrics'), {
            'fields': ('impressions_count', 'clicks_count', 'completion_rate', 'ctr')
        }),
        (_('Financial Metrics'), {
            'fields': ('cpm', 'revenue', 'cost', 'roi')
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def campaign_link(self, obj):
        """Create link to campaign admin page."""
        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 channel_link(self, obj):
        """Create link to channel admin page."""
        if obj.channel:
            url = reverse('admin:channels_channel_change', args=[obj.channel.pk])
            return format_html('<a href="{}">{}</a>', url, obj.channel.name)
        return _('All Channels')
    
    channel_link.short_description = _('Channel')
    channel_link.admin_order_field = 'channel__name'
    
    def ctr_display(self, obj):
        """Display CTR with color coding."""
        ctr = float(obj.ctr)
        if ctr >= 2.0:
            color = 'green'
        elif ctr >= 1.0:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{:.2f}%</span>',
            color, ctr
        )
    
    ctr_display.short_description = _('CTR')
    ctr_display.admin_order_field = 'ctr'
    
    def revenue_display(self, obj):
        """Display revenue with currency formatting."""
        return f"€{obj.revenue:,.2f}"
    
    revenue_display.short_description = _('Revenue')
    revenue_display.admin_order_field = 'revenue'
    
    def roi_display(self, obj):
        """Display ROI with color coding."""
        roi = float(obj.roi)
        if roi >= 20:
            color = 'green'
        elif roi >= 0:
            color = 'orange'
        else:
            color = 'red'
        
        return format_html(
            '<span style="color: {};">{:.1f}%</span>',
            color, roi
        )
    
    roi_display.short_description = _('ROI')
    roi_display.admin_order_field = 'roi'


@admin.register(AnalyticsReport)
class AnalyticsReportAdmin(BaseAnalyticsAdmin):
    """
    Admin interface for Analytics Report management.
    
    Provides report management with generation status,
    download tracking, and expiration handling.
    
    Features:
        - Report metadata management
        - Generation status tracking
        - Download statistics
        - Expiration management
        - File size tracking
    """
    
    list_display = [
        'id', 'name', 'report_type', 'generated_by_link',
        'generated_at', 'file_size_display', 'download_count',
        'expiration_status', 'is_public'
    ]
    
    list_filter = [
        'is_active', 'report_type', 'is_public', 'generated_at',
        'generated_by', 'expires_at'
    ]
    
    search_fields = [
        'name', 'report_type', 'generated_by__username', 'id'
    ]
    
    date_hierarchy = 'generated_at'
    
    readonly_fields = [
        'id', 'file_size', 'generated_by', 'generated_at',
        'download_count', 'created_at', 'updated_at'
    ]
    
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('name', 'report_type', 'is_public', 'is_active')
        }),
        (_('Report Configuration'), {
            'fields': ('parameters', 'expires_at')
        }),
        (_('File Information'), {
            'fields': ('file_path', 'file_size')
        }),
        (_('Generation Information'), {
            'fields': ('generated_by', 'generated_at', 'download_count')
        }),
        (_('System Information'), {
            'fields': ('id', 'created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    def generated_by_link(self, obj):
        """Create link to user admin page."""
        if obj.generated_by:
            url = reverse('admin:auth_user_change', args=[obj.generated_by.pk])
            return format_html('<a href="{}">{}</a>', url, obj.generated_by.username)
        return '-'
    
    generated_by_link.short_description = _('Generated By')
    generated_by_link.admin_order_field = 'generated_by__username'
    
    def file_size_display(self, obj):
        """Display file size in human-readable format."""
        size = obj.file_size
        if size < 1024:
            return f"{size} B"
        elif size < 1024 * 1024:
            return f"{size / 1024:.1f} KB"
        elif size < 1024 * 1024 * 1024:
            return f"{size / (1024 * 1024):.1f} MB"
        else:
            return f"{size / (1024 * 1024 * 1024):.1f} GB"
    
    file_size_display.short_description = _('File Size')
    file_size_display.admin_order_field = 'file_size'
    
    def expiration_status(self, obj):
        """Display expiration status."""
        if obj.is_expired:
            return format_html('<span style="color: red;">Expired</span>')
        elif obj.expires_at:
            return format_html('<span style="color: orange;">Expires {}</span>', obj.expires_at)
        return format_html('<span style="color: green;">No Expiration</span>')
    
    expiration_status.short_description = _('Expiration')


# Register admin site customizations
admin.site.site_header = _("Adtlas Analytics Administration")
admin.site.site_title = _("Adtlas Analytics Admin")
admin.site.index_title = _("Analytics Management")