from django.db import models
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin
from django.utils import timezone
import os


def profile_photo_path(instance, filename):
    """Generate upload path for profile photos"""
    return f'profiles/{instance.id}/{filename}'


class PersonManager(BaseUserManager):
    """Custom manager for Person model"""
    
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('Email is required')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user
    
    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)
        extra_fields.setdefault('role', 'admin')
        return self.create_user(email, password, **extra_fields)


class Person(AbstractBaseUser, PermissionsMixin):
    """Main person model - can be admin, worker, client, or guest"""
    
    ROLE_CHOICES = [
        ('admin', 'Admin'),
        ('worker', 'Worker'),
        ('client', 'Client'),
        ('guest', 'Guest'),
    ]
    
    # Core fields
    email = models.EmailField(unique=True)
    role = models.CharField(max_length=20, choices=ROLE_CHOICES, default='guest')
    
    # Personal info (not for guests)
    first_name = models.CharField(max_length=100, blank=True)
    last_name = models.CharField(max_length=100, blank=True)
    phone_number = models.CharField(max_length=20, blank=True)
    date_of_birth = models.DateField(null=True, blank=True)
    
    # Worker-specific fields
    profile_name = models.CharField(max_length=100, blank=True, help_text="Alias/Stage name for workers")
    bio = models.TextField(blank=True, help_text="About me description")
    interests = models.TextField(blank=True, help_text="Interests and hobbies")
    location = models.CharField(max_length=200, blank=True)
    city = models.CharField(max_length=100, blank=True)
    latitude = models.DecimalField(max_digits=10, decimal_places=7, null=True, blank=True)
    longitude = models.DecimalField(max_digits=10, decimal_places=7, null=True, blank=True)
    hourly_rate = models.DecimalField(max_digits=10, decimal_places=2, null=True, blank=True)
    is_touring = models.BooleanField(default=False)
    is_featured = models.BooleanField(default=False)
    is_available = models.BooleanField(default=True)
    
    # Profile photos
    photo_1 = models.ImageField(upload_to='profiles/', blank=True, null=True)
    photo_2 = models.ImageField(upload_to='profiles/', blank=True, null=True)
    photo_3 = models.ImageField(upload_to='profiles/', blank=True, null=True)
    photo_4 = models.ImageField(upload_to='profiles/', blank=True, null=True)
    photo_5 = models.ImageField(upload_to='profiles/', blank=True, null=True)
    
    # Timestamps
    date_created = models.DateTimeField(default=timezone.now)
    last_updated = models.DateTimeField(auto_now=True)
    
    # Django required fields
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)
    
    objects = PersonManager()
    
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']
    
    class Meta:
        verbose_name = 'Person'
        verbose_name_plural = 'People'
        ordering = ['-date_created']
    
    def __str__(self):
        if self.role == 'worker' and self.profile_name:
            return self.profile_name
        return self.get_full_name() or self.email
    
    def get_full_name(self):
        return f"{self.first_name} {self.last_name}".strip()
    
    def get_short_name(self):
        return self.first_name or self.email.split('@')[0]
    
    @property
    def age(self):
        if self.date_of_birth:
            today = timezone.now().date()
            return today.year - self.date_of_birth.year - (
                (today.month, today.day) < (self.date_of_birth.month, self.date_of_birth.day)
            )
        return None
    
    @property
    def display_name(self):
        if self.role == 'worker' and self.profile_name:
            return self.profile_name
        return self.get_full_name() or self.email
    
    def get_photos(self):
        """Return list of all uploaded photos"""
        photos = []
        for i in range(1, 6):
            photo = getattr(self, f'photo_{i}')
            if photo:
                photos.append(photo)
        return photos
    
    def has_minimum_photos(self):
        """Check if worker has minimum 3 photos"""
        return len(self.get_photos()) >= 3


class ActivityLog(models.Model):
    """Track user activities for admin viewing"""
    
    ACTION_TYPES = [
        ('login', 'Login'),
        ('logout', 'Logout'),
        ('profile_create', 'Profile Created'),
        ('profile_update', 'Profile Updated'),
        ('photo_upload', 'Photo Uploaded'),
        ('event_create', 'Event Created'),
        ('event_update', 'Event Updated'),
        ('referral_create', 'Referral Created'),
        ('password_change', 'Password Changed'),
    ]
    
    person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name='activity_logs')
    action_type = models.CharField(max_length=50, choices=ACTION_TYPES)
    description = models.TextField(blank=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    timestamp = models.DateTimeField(default=timezone.now)
    
    class Meta:
        ordering = ['-timestamp']
    
    def __str__(self):
        return f"{self.person} - {self.action_type} - {self.timestamp}"


class Referral(models.Model):
    """Referral tracking"""
    
    person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name='referrals_received')
    referrer = models.ForeignKey(Person, on_delete=models.SET_NULL, null=True, related_name='referrals_made')
    referral_date = models.DateField(default=timezone.now)
    referral_reason = models.TextField()
    action_due_date = models.DateField()
    status = models.CharField(max_length=50, default='pending', choices=[
        ('pending', 'Pending'),
        ('completed', 'Completed'),
        ('cancelled', 'Cancelled'),
    ])
    notes = models.TextField(blank=True)
    created_at = models.DateTimeField(default=timezone.now)
    
    class Meta:
        ordering = ['-referral_date']
    
    def __str__(self):
        return f"Referral for {self.person} by {self.referrer}"


class ContactMessage(models.Model):
    """Contact form messages"""
    
    email = models.EmailField()
    phone = models.CharField(max_length=20, blank=True)
    message = models.TextField()
    created_at = models.DateTimeField(default=timezone.now)
    is_read = models.BooleanField(default=False)
    
    class Meta:
        ordering = ['-created_at']
    
    def __str__(self):
        return f"Message from {self.email} - {self.created_at}"
