# -*- coding: utf-8 -*-
"""
Django Admin Configuration for Activities App

This module provides comprehensive Django admin interface configuration for
the Activities app models, including Activity, ActivityCategory, and ActivitySummary.

Features:
    - Activity management with advanced filtering and search
    - Category administration with hierarchical display
    - Activity summary and analytics
    - Bulk actions for activity management
    - Custom admin actions for monitoring
    - Export functionality for reporting
    - Real-time activity monitoring

Author: Adtlas Development Team
Version: 2.0.0
Last Updated: 2025-07-15
"""

from django.contrib import admin
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _
from django.urls import reverse
from django.utils.safestring import mark_safe
from django.db.models import Count, Q
from django.utils import timezone
from datetime import timedelta

from .models import ActivityCategory, Activity, ActivitySummary


@admin.register(ActivityCategory)
class ActivityCategoryAdmin(admin.ModelAdmin):
    """ActivityCategory admin configuration."""
    
    list_display = (
        'name', 'code', 'get_color_display', 'get_icon_display', 
        'is_active', 'is_system', 'get_activities_count', 'created_at'
    )
    
    list_filter = ('is_active', 'is_system', 'created_at')
    
    search_fields = ('name', 'code', 'description')
    
    readonly_fields = ('created_at', 'updated_at')
    
    fieldsets = (
        (None, {'fields': ('name', 'code', 'description')}),
        (_('Appearance'), {
            'fields': ('color', 'icon')
        }),
        (_('Configuration'), {
            'fields': ('is_active', 'is_system', 'retention_days')
        }),
        (_('Hierarchy'), {
            'fields': ('parent',),
            'classes': ('collapse',)
        }),
        (_('Timestamps'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )
    
    def get_color_display(self, obj):
        """Display color with preview."""
        return format_html(
            '<span style="background-color: {}; padding: 2px 10px; border-radius: 3px; color: white;">{}</span>',
            obj.color, obj.color
        )
    get_color_display.short_description = "Color"
    
    def get_icon_display(self, obj):
        """Display icon with preview."""
        return format_html(
            '<i class="{}"></i> {}',
            obj.icon, obj.icon
        )
    get_icon_display.short_description = "Icon"
    
    def get_activities_count(self, obj):
        """Get count of activities in this category."""
        return obj.activities.count()
    get_activities_count.short_description = "Activities Count"
    
    actions = ['activate_categories', 'deactivate_categories']
    
    def activate_categories(self, request, queryset):
        """Bulk action to activate categories."""
        updated = queryset.update(is_active=True)
        self.message_user(request, f'{updated} categories activated successfully.')
    activate_categories.short_description = "Activate selected categories"
    
    def deactivate_categories(self, request, queryset):
        """Bulk action to deactivate categories."""
        updated = queryset.update(is_active=False)
        self.message_user(request, f'{updated} categories deactivated successfully.')
    deactivate_categories.short_description = "Deactivate selected categories"


@admin.register(Activity)
class ActivityAdmin(admin.ModelAdmin):
    """Activity admin configuration."""
    
    list_display = (
        'user', 'action', 'category', 'get_description_short', 
        'is_successful', 'created_at', 'duration_ms'
    )
    
    list_filter = (
        'action', 'category', 'is_successful', 'created_at',
        'request_method', 'user__is_staff'
    )
    
    search_fields = (
        'user__email', 'user__username', 'description', 
        'ip_address', 'request_path'
    )
    
    readonly_fields = (
        'id', 'created_at', 'updated_at', 'content_type', 'object_id'
    )
    
    date_hierarchy = 'created_at'
    
    fieldsets = (
        (None, {
            'fields': ('user', 'action', 'category', 'description')
        }),
        (_('Request Info'), {
            'fields': (
                'ip_address', 'user_agent', 'session_key',
                'request_path', 'request_method'
            ),
            'classes': ('collapse',)
        }),
        (_('Content Object'), {
            'fields': ('content_type', 'object_id'),
            'classes': ('collapse',)
        }),
        (_('Status'), {
            'fields': ('is_successful', 'error_message', 'duration_ms')
        }),
        (_('Metadata'), {
            'fields': ('metadata',),
            'classes': ('collapse',)
        }),
        (_('Timestamps'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )
    
    def get_description_short(self, obj):
        """Display shortened description."""
        if obj.description:
            return obj.description[:50] + "..." if len(obj.description) > 50 else obj.description
        return "No description"
    get_description_short.short_description = "Description"
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related('user', 'category', 'content_type')
    
    actions = ['mark_as_successful', 'mark_as_failed', 'export_activities']
    
    def mark_as_successful(self, request, queryset):
        """Bulk action to mark activities as successful."""
        updated = queryset.update(is_successful=True)
        self.message_user(request, f'{updated} activities marked as successful.')
    mark_as_successful.short_description = "Mark selected activities as successful"
    
    def mark_as_failed(self, request, queryset):
        """Bulk action to mark activities as failed."""
        updated = queryset.update(is_successful=False)
        self.message_user(request, f'{updated} activities marked as failed.')
    mark_as_failed.short_description = "Mark selected activities as failed"
    
    def export_activities(self, request, queryset):
        """Export activities to CSV."""
        import csv
        from django.http import HttpResponse
        
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="activities.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'User', 'Action', 'Category', 'Description', 'IP Address',
            'Is Successful', 'Created At', 'Duration (ms)'
        ])
        
        for activity in queryset:
            writer.writerow([
                activity.user.email if activity.user else 'System',
                activity.action,
                activity.category.name if activity.category else 'None',
                activity.description,
                activity.ip_address,
                activity.is_successful,
                activity.created_at,
                activity.duration_ms
            ])
        
        return response
    export_activities.short_description = "Export selected activities to CSV"


@admin.register(ActivitySummary)
class ActivitySummaryAdmin(admin.ModelAdmin):
    """ActivitySummary admin configuration."""
    
    list_display = (
        'date', 'category', 'get_total_activities', 'get_successful_activities',
        'get_failed_activities', 'get_success_rate', 'created_at'
    )
    
    list_filter = ('date', 'category', 'created_at')
    
    search_fields = ('category__name', 'date')
    
    readonly_fields = ('created_at', 'updated_at')
    
    date_hierarchy = 'date'
    
    fieldsets = (
        (None, {'fields': ('date', 'category')}),
        (_('Statistics'), {
            'fields': (
                'total_activities', 'successful_activities', 'failed_activities',
                'unique_users', 'unique_ips'
            )
        }),
        (_('Performance'), {
            'fields': ('avg_duration_ms', 'max_duration_ms', 'min_duration_ms'),
            'classes': ('collapse',)
        }),
        (_('Details'), {
            'fields': ('top_actions', 'top_users', 'summary_data'),
            'classes': ('collapse',)
        }),
        (_('Timestamps'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )
    
    def get_total_activities(self, obj):
        """Display total activities with formatting."""
        return format_html(
            '<strong>{}</strong>',
            obj.total_activities
        )
    get_total_activities.short_description = "Total"
    
    def get_successful_activities(self, obj):
        """Display successful activities with green color."""
        return format_html(
            '<span style="color: green;">{}</span>',
            obj.successful_activities
        )
    get_successful_activities.short_description = "Successful"
    
    def get_failed_activities(self, obj):
        """Display failed activities with red color."""
        return format_html(
            '<span style="color: red;">{}</span>',
            obj.failed_activities
        )
    get_failed_activities.short_description = "Failed"
    
    def get_success_rate(self, obj):
        """Calculate and display success rate."""
        if obj.total_activities > 0:
            rate = (obj.successful_activities / obj.total_activities) * 100
            color = "green" if rate >= 90 else "orange" if rate >= 70 else "red"
            return format_html(
                '<span style="color: {};">{:.1f}%</span>',
                color, rate
            )
        return "N/A"
    get_success_rate.short_description = "Success Rate"
    
    def get_queryset(self, request):
        """Optimize queryset with select_related."""
        return super().get_queryset(request).select_related('category')
    
    actions = ['regenerate_summaries']
    
    def regenerate_summaries(self, request, queryset):
        """Regenerate activity summaries."""
        # This would trigger a background task to regenerate summaries
        count = queryset.count()
        self.message_user(request, f'Regeneration queued for {count} summaries.')
    regenerate_summaries.short_description = "Regenerate selected summaries"


# Custom admin views for activities dashboard
class ActivityDashboardView(admin.ModelAdmin):
    """Custom dashboard view for activities."""
    
    def changelist_view(self, request, extra_context=None):
        """Add dashboard statistics to changelist view."""
        extra_context = extra_context or {}
        
        # Add recent activity statistics
        now = timezone.now()
        today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
        week_start = today_start - timedelta(days=7)
        
        extra_context.update({
            'activities_today': Activity.objects.filter(created_at__gte=today_start).count(),
            'activities_week': Activity.objects.filter(created_at__gte=week_start).count(),
            'failed_activities_today': Activity.objects.filter(
                created_at__gte=today_start, is_successful=False
            ).count(),
            'top_users_today': Activity.objects.filter(
                created_at__gte=today_start
            ).values('user__email').annotate(
                count=Count('id')
            ).order_by('-count')[:5],
        })
        
        return super().changelist_view(request, extra_context=extra_context)