import re
from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.core.exceptions import ValidationError
from django.utils import timezone
from django.conf import settings

RESERVED_USERNAMES = {
    'admin', 'api', 'static', 'login', 'register', 'inbox', 'staff', 'u', 'me', 'settings', 'messages'
}

def validate_username_format(value):
    if not value:
        raise ValidationError('Username is required.')
    if len(value) < 3 or len(value) > 20:
        raise ValidationError('Username must be between 3 and 20 characters.')
    if not re.match(r'^[a-z0-9_]+$', value):
        raise ValidationError('Username can only contain lowercase letters, numbers, and underscores.')
    if value in RESERVED_USERNAMES:
        raise ValidationError(f'Username "{value}" is reserved.')

class CustomUserManager(BaseUserManager):
    def create_user(self, username, email, password=None, **extra_fields):
        if not username:
            raise ValueError('The Username must be set')
        if not email:
            raise ValueError('The Email must be set')
        
        username = username.strip().lower()
        email = self.normalize_email(email).strip().lower()
        
        user = self.model(username=username, email=email, **extra_fields)
        if password:
            user.set_password(password)
        else:
            user.set_unusable_password()
        user.save(using=self._db)
        return user

    def create_superuser(self, username, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('role', 'admin')
        extra_fields.setdefault('email_verified', True)

        return self.create_user(username, email, password, **extra_fields)

class User(AbstractBaseUser, PermissionsMixin):
    ROLE_CHOICES = [
        ('user', 'User'),
        ('moderator', 'Moderator'),
        ('admin', 'Admin'),
    ]

    username = models.CharField(
        max_length=20,
        unique=True,
        validators=[validate_username_format],
        db_index=True
    )
    email = models.EmailField(
        max_length=255,
        unique=True,
        db_index=True
    )
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)
    date_joined = models.DateTimeField(default=timezone.now)
    last_login = models.DateTimeField(null=True, blank=True)
    
    email_verified = models.BooleanField(default=False)
    role = models.CharField(max_length=20, choices=ROLE_CHOICES, default='user')
    is_suspended = models.BooleanField(default=False)
    suspended_until = models.DateTimeField(null=True, blank=True)
    suspension_reason = models.CharField(max_length=300, null=True, blank=True)
    username_changed_at = models.DateTimeField(null=True, blank=True)

    # 6-digit verification code support
    verification_code = models.CharField(max_length=6, blank=True, null=True)
    verification_code_expires_at = models.DateTimeField(null=True, blank=True)

    # Phase 2: lockout fields
    failed_login_count = models.IntegerField(default=0)
    locked_until = models.DateTimeField(null=True, blank=True)
    lock_count = models.IntegerField(default=0)

    objects = CustomUserManager()

    USERNAME_FIELD = 'username'
    REQUIRED_FIELDS = ['email']

    def clean(self):
        super().clean()
        if self.username:
            self.username = self.username.strip().lower()
            validate_username_format(self.username)
        if self.email:
            self.email = self.email.strip().lower()

    def save(self, *args, **kwargs):
        if self.username:
            self.username = self.username.strip().lower()
        if self.email:
            self.email = self.email.strip().lower()
        super().save(*args, **kwargs)

    def __str__(self):
        return self.username


class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    display_name = models.CharField(max_length=50, blank=True, default='')
    bio = models.CharField(max_length=160, blank=True, default='')
    avatar = models.ImageField(upload_to='avatars/', blank=True, null=True)
    cover = models.ImageField(upload_to='covers/', blank=True, null=True)
    updated_at = models.DateTimeField(auto_now=True)

    def _strip_exif_data(self, image_field):
        if not image_field:
            return
        try:
            import io
            from PIL import Image, ImageOps
            from django.core.files.base import ContentFile

            # Check if this is an uncommitted (newly uploaded) file
            if not getattr(image_field, '_committed', True) and getattr(image_field, 'file', None):
                image_field.file.seek(0)
                img = Image.open(image_field.file)
                fmt = img.format or 'JPEG'
                img = ImageOps.exif_transpose(img)
                out_buf = io.BytesIO()
                if fmt.upper() in ('JPEG', 'JPG') and img.mode in ('RGBA', 'P'):
                    img = img.convert('RGB')
                img.save(out_buf, format=fmt)
                out_buf.seek(0)
                image_field.save(image_field.name, ContentFile(out_buf.getvalue()), save=False)
        except Exception:
            pass

    def save(self, *args, **kwargs):
        # Strip EXIF metadata from newly uploaded images before saving
        if self.avatar and not getattr(self.avatar, '_committed', True):
            self._strip_exif_data(self.avatar)
        if self.cover and not getattr(self.cover, '_committed', True):
            self._strip_exif_data(self.cover)
        super().save(*args, **kwargs)

    def __str__(self):
        return f"Profile of {self.user.username}"



class EmailJob(models.Model):
    STATUS_CHOICES = [
        ('pending', 'Pending'),
        ('sent', 'Sent'),
        ('failed', 'Failed'),
    ]

    to_email = models.EmailField(max_length=255)
    subject = models.CharField(max_length=255)
    body_text = models.TextField()
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
    attempts = models.PositiveIntegerField(default=0)
    last_error = models.TextField(blank=True, default='')
    created_at = models.DateTimeField(default=timezone.now)
    sent_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        indexes = [
            models.Index(fields=['status', 'created_at']),
        ]

    def __str__(self):
        return f"EmailJob({self.to_email}, {self.status})"


class UserSession(models.Model):
    """Tracks active login sessions for the session management UI."""
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='user_sessions')
    session_key = models.CharField(max_length=40, unique=True, db_index=True)
    device_label = models.CharField(max_length=60, blank=True, default='')
    created_at = models.DateTimeField(default=timezone.now)
    last_seen_at = models.DateTimeField(default=timezone.now)

    def __str__(self):
        return f"UserSession({self.user.username}, {self.device_label})"


class BlockedEmailDomain(models.Model):
    """Email domains blocked from registration (disposable email providers)."""
    domain = models.CharField(max_length=255, unique=True, db_index=True)
    created_at = models.DateTimeField(default=timezone.now)
    created_by = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.SET_NULL,
        null=True, blank=True, related_name='blocked_domains'
    )

    def __str__(self):
        return f"BlockedEmailDomain({self.domain})"


def cleanup_profile_files(sender, instance, **kwargs):
    """Purge avatar and cover files from storage when a profile is deleted."""
    for field in [instance.avatar, instance.cover]:
        if field and getattr(field, 'name', None):
            try:
                field.delete(save=False)
            except Exception:
                pass

models.signals.post_delete.connect(cleanup_profile_files, sender=Profile)


