"""Accounts Signals

This module contains Django signals for the accounts app.
Signals handle automatic actions when certain events occur.
"""

import logging
# from django.conf import settings
# from django.utils import timezone
# from django.dispatch import receiver
# from django.core.mail import send_mail
# from django.template.loader import render_to_string
# from django.utils.translation import gettext_lazy as _
# from django.db.models.signals import post_save, pre_delete, post_delete, post_migrate
# from django.contrib.auth.signals import user_logged_in, user_logged_out

# from apps.accounts.models import User, UserProfile, UserSession

# Signal to create user profile automatically
from django.db.models.signals import post_save
from django.dispatch import receiver

from apps.accounts.models import Profile, User

logger = logging.getLogger('adtlas.accounts')


@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    """
    Signal to automatically create a Profile when a User is created.
    
    This ensures every user has an associated profile without manual intervention.
    """
    if created:
        Profile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    """
    Signal to save the Profile when the User is saved.
    
    This ensures the profile is always kept in sync with the user.
    """
    if hasattr(instance, "profile"):
        instance.profile.save()







# @receiver(post_save, sender=User)
# def create_user_profile(sender, instance, created, **kwargs):
#     """Create UserProfile when a new User is created."""
#     if created:
#         try:
#             UserProfile.objects.create(user=instance)
#             logger.info(f'Profile created for user: {instance.email}')
#         except Exception as e:
#             logger.error(f'Failed to create profile for user {instance.email}: {e}')


# @receiver(post_save, sender=User)
# def save_user_profile(sender, instance, **kwargs):
#     """Save UserProfile when User is saved."""
#     try:
#         if hasattr(instance, 'profile'):
#             instance.profile.save()
#         else:
#             # Create profile if it doesn't exist
#             UserProfile.objects.create(user=instance)
#             logger.info(f'Profile created for existing user: {instance.email}')
#     except Exception as e:
#         logger.error(f'Failed to save profile for user {instance.email}: {e}')


# @receiver(user_logged_in)
# def log_user_login(sender, request, user, **kwargs):
#     """Log user login and update last login IP."""
#     try:
#         # Update last login IP
#         ip_address = get_client_ip(request)
#         user.last_login_ip = ip_address
#         user.save(update_fields=['last_login_ip'])
        
#         # Create or update session record
#         session_key = request.session.session_key
#         if session_key:
#             UserSession.objects.update_or_create(
#                 user=user,
#                 session_key=session_key,
#                 defaults={
#                     'ip_address': ip_address,
#                     'user_agent': request.META.get('HTTP_USER_AGENT', '')[:500],
#                     'is_active': True,
#                     'expires_at': request.session.get_expiry_date(),
#                 }
#             )
        
#         logger.info(f'User logged in: {user.email} from {ip_address}')
        
#         # Send login notification email if enabled
#         if getattr(settings, 'SEND_LOGIN_NOTIFICATIONS', False):
#             send_login_notification(user, request)
            
#     except Exception as e:
#         logger.error(f'Failed to log user login for {user.email}: {e}')


# @receiver(user_logged_out)
# def log_user_logout(sender, request, user, **kwargs):
#     """Log user logout and deactivate session."""
#     try:
#         if user and hasattr(request, 'session'):
#             session_key = request.session.session_key
#             if session_key:
#                 # Deactivate session
#                 UserSession.objects.filter(
#                     user=user,
#                     session_key=session_key,
#                     is_active=True
#                 ).update(is_active=False)
                
#                 logger.info(f'User logged out: {user.email}')
#     except Exception as e:
#         logger.error(f'Failed to log user logout: {e}')


# @receiver(pre_delete, sender=User)
# def log_user_deletion(sender, instance, **kwargs):
#     """Log user deletion."""
#     logger.info(f'User being deleted: {instance.email} (ID: {instance.id})')


# @receiver(post_delete, sender=User)
# def cleanup_user_data(sender, instance, **kwargs):
#     """Clean up user-related data after user deletion."""
#     try:
#         # Deactivate all user sessions
#         UserSession.objects.filter(user=instance).update(is_active=False)
        
#         logger.info(f'Cleaned up data for deleted user: {instance.email}')
#     except Exception as e:
#         logger.error(f'Failed to cleanup data for deleted user: {e}')


# @receiver(post_save, sender=UserSession)
# def log_session_creation(sender, instance, created, **kwargs):
#     """Log session creation."""
#     if created:
#         logger.info(
#             f'New session created for user {instance.user.email} '
#             f'from {instance.ip_address}'
#         )


# def get_client_ip(request):
#     """Get the client IP address from request."""
#     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
#     if x_forwarded_for:
#         ip = x_forwarded_for.split(',')[0]
#     else:
#         ip = request.META.get('REMOTE_ADDR')
#     return ip


# def send_login_notification(user, request):
#     """Send login notification email to user."""
#     try:
#         ip_address = get_client_ip(request)
#         user_agent = request.META.get('HTTP_USER_AGENT', '')
        
#         context = {
#             'user': user,
#             'ip_address': ip_address,
#             'user_agent': user_agent,
#             'login_time': timezone.now(),
#             'site_name': getattr(settings, 'SITE_NAME', 'Adtlas'),
#         }
        
#         subject = _('New login to your account')
#         message = render_to_string('accounts/emails/login_notification.txt', context)
#         html_message = render_to_string('accounts/emails/login_notification.html', context)
        
#         send_mail(
#             subject=subject,
#             message=message,
#             from_email=settings.DEFAULT_FROM_EMAIL,
#             recipient_list=[user.email],
#             html_message=html_message,
#             fail_silently=True,
#         )
        
#         logger.info(f'Login notification sent to {user.email}')
        
#     except Exception as e:
#         logger.error(f'Failed to send login notification to {user.email}: {e}')


# def send_welcome_email(user):
#     """Send welcome email to new user."""
#     try:
#         context = {
#             'user': user,
#             'site_name': getattr(settings, 'SITE_NAME', 'Adtlas'),
#             'site_url': getattr(settings, 'SITE_URL', 'http://localhost:8000'),
#         }
        
#         subject = _(f'Welcome to {context["site_name"]}!')
#         message = render_to_string('accounts/emails/welcome.txt', context)
#         html_message = render_to_string('accounts/emails/welcome.html', context)
        
#         send_mail(
#             subject=subject,
#             message=message,
#             from_email=settings.DEFAULT_FROM_EMAIL,
#             recipient_list=[user.email],
#             html_message=html_message,
#             fail_silently=True,
#         )
        
#         logger.info(f'Welcome email sent to {user.email}')
        
#     except Exception as e:
#         logger.error(f'Failed to send welcome email to {user.email}: {e}')


# # Custom signal for user registration
# from django.dispatch import Signal
# from django.core.management import call_command

# user_registered = Signal()


# @receiver(user_registered)
# def handle_user_registration(sender, user, request, **kwargs):
#     """Handle user registration."""
#     try:
#         # Send welcome email
#         if getattr(settings, 'SEND_WELCOME_EMAILS', True):
#             send_welcome_email(user)
        
#         # Log registration
#         ip_address = get_client_ip(request)
#         logger.info(f'New user registered: {user.email} from {ip_address}')
        
#         # Additional registration logic can be added here
#         # e.g., create default settings, send to analytics, etc.
        
#     except Exception as e:
#         logger.error(f'Failed to handle user registration for {user.email}: {e}')


# @receiver(post_migrate)
# def create_default_admin_user(sender, **kwargs):
#     """Create default admin user after migrations.
    
#     This signal handler runs after migrations and ensures that the
#     admin@adtlas.com superuser always exists in the system.
#     """
#     # Only run for the accounts app to avoid running multiple times
#     if sender.name == 'apps.accounts':
#         try:
#             logger.info('Running post-migration admin user creation...')
#             call_command('ensure_admin_user', '--quiet')
#             logger.info('Post-migration admin user creation completed')
#         except Exception as e:
#             logger.error(f'Failed to create admin user after migration: {e}')