from django.contrib.auth.models import AbstractUser
from django.db import models


class User(AbstractUser):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    username = models.CharField(max_length=30, unique=True)
    email = models.EmailField(unique=True)
    password = models.CharField(max_length=128)
    bio = models.TextField(blank=True, null=True)
    avatar = models.ImageField(upload_to='avatars/', blank=True, null=True)
    banner = models.ImageField(upload_to='banners/', blank=True, null=True)
    banner_position_y = models.IntegerField(default=50)  # 0-100% vertical position
    banner_zoom = models.FloatField(default=1.0)
    banner_brightness = models.IntegerField(default=100)
    banner_contrast = models.IntegerField(default=100)
    is_private = models.BooleanField(default=False)
    is_verified = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    USERNAME_FIELD = 'username'
    REQUIRED_FIELDS = ['first_name', 'last_name', 'email']

    def __str__(self):
        return self.username


class BlockedUser(models.Model):
    """
    Tracks user blocking relationships.
    - blocker: The user who initiated the block
    - blocked: The user who was blocked
    """
    blocker = models.ForeignKey(
        User,
        related_name='blocked_users',
        on_delete=models.CASCADE
    )
    blocked = models.ForeignKey(
        User,
        related_name='blocked_by',
        on_delete=models.CASCADE
    )
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('blocker', 'blocked')
        indexes = [
            models.Index(fields=['blocker']),
            models.Index(fields=['blocked']),
        ]

    def __str__(self):
        return f"{self.blocker.username} blocked {self.blocked.username}"


class VerificationCode(models.Model):
    VERIFICATION_TYPES = (
        ('register', 'Registration'),
        ('reset', 'Password Reset'),
        ('email_change', 'Email Change'),
    )
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='verification_codes')
    code = models.CharField(max_length=6)
    type = models.CharField(max_length=20, choices=VERIFICATION_TYPES)
    created_at = models.DateTimeField(auto_now_add=True)
    expires_at = models.DateTimeField()
    pending_email = models.EmailField(null=True, blank=True)

    def is_valid(self):
        from django.utils import timezone
        return timezone.now() < self.expires_at

    def __str__(self):
        return f"{self.user.username} - {self.type} - {self.code}"


class CloseFriend(models.Model):
    """
    Tracks close friend relationships.
    - user: The owner of the close friends list
    - friend: The user added to the close friends list
    """
    user = models.ForeignKey(
        User,
        related_name='close_friends',
        on_delete=models.CASCADE
    )
    friend = models.ForeignKey(
        User,
        related_name='close_friend_of',
        on_delete=models.CASCADE
    )
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('user', 'friend')
        indexes = [
            models.Index(fields=['user']),
            models.Index(fields=['friend']),
        ]

    def __str__(self):
        return f"{self.user.username} -> {self.friend.username} (close friend)"


class RestrictedUser(models.Model):
    """
    Tracks restricted user relationships.
    - user: The owner of the restricted list
    - restricted: The user who won't see posts
    """
    user = models.ForeignKey(
        User,
        related_name='restricted_users',
        on_delete=models.CASCADE
    )
    restricted = models.ForeignKey(
        User,
        related_name='restricted_by',
        on_delete=models.CASCADE
    )
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('user', 'restricted')
        indexes = [
            models.Index(fields=['user']),
            models.Index(fields=['restricted']),
        ]

    def __str__(self):
        return f"{self.user.username} -> {self.restricted.username} (restricted)"


class ProfileLink(models.Model):
    """
    Tracks social media and custom links for user profiles.
    - Predefined types: Facebook, WhatsApp, YouTube, Instagram, TikTok, Telegram, Snapchat
    - Custom type for personal websites/portfolios
    """
    LINK_TYPES = (
        ('facebook', 'Facebook'),
        ('whatsapp', 'WhatsApp'),
        ('youtube', 'YouTube'),
        ('instagram', 'Instagram'),
        ('tiktok', 'TikTok'),
        ('telegram', 'Telegram'),
        ('snapchat', 'Snapchat'),
        ('custom', 'Custom'),
    )

    user = models.ForeignKey(
        User,
        related_name='profile_links',
        on_delete=models.CASCADE
    )
    link_type = models.CharField(max_length=20, choices=LINK_TYPES)
    url = models.URLField(max_length=500)
    display_name = models.CharField(max_length=100, blank=True, null=True)  # For custom links
    is_enabled = models.BooleanField(default=True)
    order = models.IntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ['order', 'created_at']
        indexes = [
            models.Index(fields=['user', 'is_enabled']),
        ]

    def __str__(self):
        if self.link_type == 'custom':
            return f"{self.user.username} - {self.display_name or 'Custom Link'}"
        return f"{self.user.username} - {self.get_link_type_display()}"