# -*- coding: utf-8 -*-
"""
Accounts Admin Configuration

This module configures the Django admin interface for the accounts app,
providing a professional and user-friendly interface for managing users,
roles, and user profiles.

Author: Senior Django Developer
Date: 2024
"""

from django.urls import reverse
from django.contrib import admin
from django.utils.html import format_html
from django.contrib.auth.models import Group
from django.utils.safestring import mark_safe
from django.utils.translation import gettext_lazy as _
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin

from apps.accounts.models import User, Role, Profile


# Unregister the default Group model since we're using custom Roles
admin.site.unregister(Group)



@admin.register(Role)
class RoleAdmin(admin.ModelAdmin):
    """
    Admin configuration for Role model.
    
    Provides comprehensive management interface for roles including
    permissions management, priority settings, and user assignments.
    """
    
    # List display configuration
    list_display = [
        'name', 
        'priority', 
        'is_active', 
        'permissions_count',
        'users_count',
        'created_at',
        'updated_at'
    ]
    
    # List filters for easy filtering
    list_filter = [
        'is_active',
        'priority',
        'created_at',
        'updated_at'
    ]
    
    # Search functionality
    search_fields = [
        'name',
        'description'
    ]
    
    # Ordering
    ordering = ['-priority', 'name']
    
    # Fields to display in the form
    fieldsets = (
        (_('Basic Information'), {
            'fields': ('name', 'description', 'priority')
        }),
        (_('Status'), {
            'fields': ('is_active',)
        }),
        (_('Permissions'), {
            'fields': ('permissions',),
            'classes': ('wide',)
        }),
        (_('Metadata'), {
            'fields': ('created_at', 'updated_at', 'created_by', 'updated_by'),
            'classes': ('collapse',)
        })
    )
    
    # Read-only fields
    readonly_fields = [
        'created_at', 
        'updated_at', 
        'created_by', 
        'updated_by'
    ]
    
    # Filter for permissions field
    filter_horizontal = ['permissions']
    
    # Actions
    actions = ['activate_roles', 'deactivate_roles']
    
    def permissions_count(self, obj):
        """
        Display the number of permissions assigned to the role.
        
        Args:
            obj: Role instance
            
        Returns:
            str: Formatted count of permissions
        """
        count = obj.permissions.count()
        return format_html(
            '<span style="color: {}">{} permissions</span>',
            'green' if count > 0 else 'red',
            count
        )
    permissions_count.short_description = _('Permissions')
    
    def users_count(self, obj):
        """
        Display the number of users assigned to the role.
        
        Args:
            obj: Role instance
            
        Returns:
            str: Formatted count of users
        """
        count = obj.user_set.count()
        if count > 0:
            url = reverse('admin:accounts_user_changelist') + f'?roles__id__exact={obj.id}'
            return format_html(
                '<a href="{}" style="color: green">{} users</a>',
                url,
                count
            )
        return format_html('<span style="color: red">0 users</span>')
    users_count.short_description = _('Users')
    
    def activate_roles(self, request, queryset):
        """
        Admin action to activate selected roles.
        
        Args:
            request: HTTP request object
            queryset: Selected role objects
        """
        updated = queryset.update(is_active=True)
        self.message_user(
            request,
            _(f'{updated} roles were successfully activated.')
        )
    activate_roles.short_description = _('Activate selected roles')
    
    def deactivate_roles(self, request, queryset):
        """
        Admin action to deactivate selected roles.
        
        Args:
            request: HTTP request object
            queryset: Selected role objects
        """
        updated = queryset.update(is_active=False)
        self.message_user(
            request,
            _(f'{updated} roles were successfully deactivated.')
        )
    deactivate_roles.short_description = _('Deactivate selected roles')


class ProfileInline(admin.StackedInline):
    """
    Inline admin for Profile model.
    
    This allows editing user profile information directly
    from the user admin page.
    """
    model = Profile
    fk_name = 'user'  # Specify the foreign key field name
    can_delete = False
    verbose_name_plural = _('Profile Information')
    
    # Organize fields in fieldsets
    fieldsets = (
        (_('Personal Information'), {
            'fields': ('bio', 'avatar', 'birth_date')
        }),
        (_('Social Links'), {
            'fields': ('website', )
        }),
        (_('Privacy & Notifications'), {
            'fields': ('is_profile_public', 'email_notifications', 'sms_notifications')
        })
    )


@admin.register(User)
class UserAdmin(BaseUserAdmin):
    """
    Custom admin configuration for User model.
    
    Extends Django's default UserAdmin to include custom fields
    and provide better user management interface.
    """
    
    # Include the profile inline
    inlines = [ProfileInline]
    
    # List display configuration
    list_display = [
        'email',
        'get_full_name',
        'username',
        'is_verified',
        'is_active',
        'is_staff',
        'roles_display',
        'last_login',
        'date_joined'
    ]
    
    # List filters
    list_filter = [
        'is_active',
        'is_staff',
        'is_superuser',
        'is_verified',
        'roles',
        'date_joined',
        'last_login'
    ]
    
    # Search functionality
    search_fields = [
        'email',
        'username',
        'first_name',
        'last_name',
        'phone_number'
    ]
    
    # Ordering
    ordering = ['-date_joined']
    
    # Custom fieldsets for the user form
    fieldsets = (
        (_('Authentication'), {
            'fields': ('email', 'username', 'password')
        }),
        (_('Personal Information'), {
            'fields': ('first_name', 'last_name', 'phone_number')
        }),
        (_('Permissions'), {
            'fields': ('is_active', 'is_staff', 'is_superuser', 'roles', 'groups', 'user_permissions'),
            'classes': ('wide',)
        }),
        (_('Account Status'), {
            'fields': ('is_verified', 'email_verified_at', 'last_login_ip')
        }),
        (_('Important Dates'), {
            'fields': ('last_login', 'date_joined')
        })
    )
    
    # Fieldsets for adding new users
    add_fieldsets = (
        (_('Authentication'), {
            'classes': ('wide',),
            'fields': ('email', 'username', 'password1', 'password2')
        }),
        (_('Personal Information'), {
            'fields': ('first_name', 'last_name', 'phone_number')
        }),
        (_('Permissions'), {
            'fields': ('is_active', 'is_staff', 'roles')
        })
    )
    
    # Read-only fields
    readonly_fields = [
        'last_login',
        'date_joined',
        'email_verified_at',
        'last_login_ip'
    ]
    
    # Filter horizontal for many-to-many fields
    filter_horizontal = ['roles', 'groups', 'user_permissions']
    
    # Actions
    actions = [
        'verify_users',
        'unverify_users',
        'activate_users',
        'deactivate_users'
    ]
    
    def roles_display(self, obj):
        """
        Display user's roles in a formatted way.
        
        Args:
            obj: User instance
            
        Returns:
            str: Formatted list of user roles
        """
        roles = obj.get_user_roles()
        if roles:
            role_links = []
            for role_name in roles:
                try:
                    role = Role.objects.get(name=role_name)
                    url = reverse('admin:accounts_role_change', args=[role.id])
                    role_links.append(f'<a href="{url}">{role_name}</a>')
                except Role.DoesNotExist:
                    role_links.append(role_name)
            return mark_safe(', '.join(role_links))
        return format_html('<span style="color: red">No roles</span>')
    roles_display.short_description = _('Roles')
    
    def verify_users(self, request, queryset):
        """
        Admin action to verify selected users.
        
        Args:
            request: HTTP request object
            queryset: Selected user objects
        """
        updated = 0
        for user in queryset:
            if not user.is_verified:
                user.verify_email()
                updated += 1
        
        self.message_user(
            request,
            _(f'{updated} users were successfully verified.')
        )
    verify_users.short_description = _('Verify selected users')
    
    def unverify_users(self, request, queryset):
        """
        Admin action to unverify selected users.
        
        Args:
            request: HTTP request object
            queryset: Selected user objects
        """
        updated = queryset.update(
            is_verified=False,
            email_verified_at=None
        )
        self.message_user(
            request,
            _(f'{updated} users were successfully unverified.')
        )
    unverify_users.short_description = _('Unverify selected users')
    
    def activate_users(self, request, queryset):
        """
        Admin action to activate selected users.
        
        Args:
            request: HTTP request object
            queryset: Selected user objects
        """
        updated = queryset.update(is_active=True)
        self.message_user(
            request,
            _(f'{updated} users were successfully activated.')
        )
    activate_users.short_description = _('Activate selected users')
    
    def deactivate_users(self, request, queryset):
        """
        Admin action to deactivate selected users.
        
        Args:
            request: HTTP request object
            queryset: Selected user objects
        """
        updated = queryset.update(is_active=False)
        self.message_user(
            request,
            _(f'{updated} users were successfully deactivated.')
        )
    deactivate_users.short_description = _('Deactivate selected users')


@admin.register(Profile)
class ProfileAdmin(admin.ModelAdmin):
    """
    Admin configuration for Profile model.
    
    Provides interface for managing user profiles separately
    from the main user admin.
    """
    
    # List display configuration
    list_display = [
        'user', 
        'birth_date',
        'is_profile_public',
        'email_notifications',
        'sms_notifications',
        'created_at'
    ]
    
    # List filters
    list_filter = [
        'is_profile_public',
        'email_notifications',
        'sms_notifications',
        'created_at'
    ]
    
    # Search functionality
    search_fields = [
        'user__email',
        'user__first_name',
        'user__last_name', 
        'bio'
    ]
    
    # Ordering
    ordering = ['-created_at']
    
    # Fields organization
    fieldsets = (
        (_('User'), {
            'fields': ('user',)
        }),
        (_('Personal Information'), {
            'fields': ('bio', 'avatar', 'birth_date')
        }),
        (_('Social Links'), {
            'fields': ('website', )
        }),
        (_('Privacy & Notifications'), {
            'fields': ('is_profile_public', 'email_notifications', 'sms_notifications')
        }),
        (_('Metadata'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        })
    )
    
    # Read-only fields
    readonly_fields = ['created_at', 'updated_at']
    
    # Raw ID fields for better performance with large datasets
    raw_id_fields = ['user']

#     # User preferences
#     timezone_field = models.CharField(
#         _('Timezone'),
#         max_length=50,
#         default='UTC',
#         help_text=_('User preferred timezone')
#     )
    
#     language = models.CharField(
#         _('Language'),
#         max_length=10,
#         default='en',
#         choices=[
#             ('en', _('English')),
#             ('es', _('Spanish')),
#             ('fr', _('French')),
#             ('de', _('German')),
#         ],
#         help_text=_('User preferred language')
#     )