from django.db import models
from django.core.validators import EmailValidator
from django.utils import timezone
from apps.common.models import UUIDModel, TimeStampedModel 

 
class ActivityLog(UUIDModel, TimeStampedModel):
    """Model to track user activities and system events."""
    ACTION_CHOICES = [
        ('CREATE', 'Create'),
        ('UPDATE', 'Update'),
        ('DELETE', 'Delete'),
        ('LOGIN', 'Login'),
        ('LOGOUT', 'Logout'),
        ('UPLOAD', 'Upload'),
        ('DOWNLOAD', 'Download'),
        ('EXPORT', 'Export'),
        ('IMPORT', 'Import'),
    ]
    
    user = models.ForeignKey("accounts.User", on_delete=models.SET_NULL, null=True, blank=True)
    action = models.CharField(max_length=20, choices=ACTION_CHOICES)
    content_type = models.CharField(max_length=100, blank=True)
    object_id = models.PositiveIntegerField(null=True, blank=True)
    description = models.TextField(blank=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.TextField(blank=True)
    
    class Meta:
        db_table = 'activity_logs'
        ordering = ['-created_at']
    
    def __str__(self):
        return f"{self.user} - {self.action} - {self.created_at}"


class SystemConfiguration(UUIDModel, TimeStampedModel):
    """Model to store system-wide configuration settings."""
    key = models.CharField(max_length=100, unique=True)
    value = models.TextField()
    description = models.TextField(blank=True)
    is_active = models.BooleanField(default=True)
    
    class Meta:
        db_table = 'system_configurations'
        ordering = ['key']
    
    def __str__(self):
        return f"{self.key}: {self.value[:50]}"
    
    @classmethod
    def get_value(cls, key, default=None):
        """Get configuration value by key."""
        try:
            config = cls.objects.get(key=key, is_active=True)
            return config.value
        except cls.DoesNotExist:
            return default
    
    @classmethod
    def set_value(cls, key, value, description=''):
        """Set configuration value by key."""
        config, created = cls.objects.get_or_create(
            key=key,
            defaults={'value': value, 'description': description}
        )
        if not created:
            config.value = value
            config.description = description
            config.save()
        return config


class Newsletter(UUIDModel, TimeStampedModel):
    """Model to store newsletter subscriptions."""
    email = models.EmailField(
        unique=True,
        validators=[EmailValidator()],
        help_text="Email address for newsletter subscription"
    )
    first_name = models.CharField(max_length=100, blank=True)
    last_name = models.CharField(max_length=100, blank=True)
    is_subscribed = models.BooleanField(default=True)
    subscribed_at = models.DateTimeField(default=timezone.now)
    unsubscribed_at = models.DateTimeField(null=True, blank=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.TextField(blank=True)
    source = models.CharField(
        max_length=50,
        default='website',
        help_text="Source of subscription (website, api, etc.)"
    )
    
    class Meta:
        db_table = 'newsletter_subscriptions'
        ordering = ['-subscribed_at']
        indexes = [
            models.Index(fields=['email']),
            models.Index(fields=['is_subscribed']),
            models.Index(fields=['subscribed_at']),
        ]
    
    def __str__(self):
        return f"{self.email} - {'Subscribed' if self.is_subscribed else 'Unsubscribed'}"
    
    def unsubscribe(self):
        """Unsubscribe from newsletter."""
        self.is_subscribed = False
        self.unsubscribed_at = timezone.now()
        self.save()
    
    def resubscribe(self):
        """Resubscribe to newsletter."""
        self.is_subscribed = True
        self.unsubscribed_at = None
        self.save()


class ContactMessage(UUIDModel, TimeStampedModel):
    """Model to store contact form messages."""
    STATUS_CHOICES = [
        ('NEW', 'New'),
        ('READ', 'Read'),
        ('REPLIED', 'Replied'),
        ('CLOSED', 'Closed'),
        ('SPAM', 'Spam'),
    ]
    
    PRIORITY_CHOICES = [
        ('LOW', 'Low'),
        ('MEDIUM', 'Medium'),
        ('HIGH', 'High'),
        ('URGENT', 'Urgent'),
    ]
    
    # Contact Information
    name = models.CharField(max_length=100, help_text="Full name of the person")
    email = models.EmailField(validators=[EmailValidator()])
    phone = models.CharField(max_length=20, blank=True)
    company = models.CharField(max_length=100, blank=True)
    
    # Message Details
    subject = models.CharField(max_length=200)
    message = models.TextField()
    
    # Message Management
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='NEW')
    priority = models.CharField(max_length=20, choices=PRIORITY_CHOICES, default='MEDIUM')
    
    # Response Information
    responded_at = models.DateTimeField(null=True, blank=True)
    responded_by = models.ForeignKey(
        "accounts.User",
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='responded_messages'
    )
    response_message = models.TextField(blank=True)
    
    # Technical Information
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.TextField(blank=True)
    source = models.CharField(
        max_length=50,
        default='website',
        help_text="Source of contact (website, api, etc.)"
    )
    
    # Additional metadata
    is_newsletter_signup = models.BooleanField(
        default=False,
        help_text="Whether the user also wants to subscribe to newsletter"
    )
    
    class Meta:
        db_table = 'contact_messages'
        ordering = ['-created_at']
        indexes = [
            models.Index(fields=['email']),
            models.Index(fields=['status']),
            models.Index(fields=['priority']),
            models.Index(fields=['created_at']),
        ]
    
    def __str__(self):
        return f"{self.name} - {self.subject} ({self.status})"
    
    def mark_as_read(self, user=None):
        """Mark message as read."""
        if self.status == 'NEW':
            self.status = 'READ'
            self.save()
    
    def mark_as_replied(self, user, response_message=''):
        """Mark message as replied."""
        self.status = 'REPLIED'
        self.responded_by = user
        self.responded_at = timezone.now()
        self.response_message = response_message
        self.save()
    
    def get_priority_color(self):
        """Get color class based on priority."""
        colors = {
            'LOW': 'success',
            'MEDIUM': 'warning',
            'HIGH': 'danger',
            'URGENT': 'dark'
        }
        return colors.get(self.priority, 'secondary')
    
    def get_status_color(self):
        """Get color class based on status."""
        colors = {
            'NEW': 'primary',
            'READ': 'info',
            'REPLIED': 'success',
            'CLOSED': 'secondary',
            'SPAM': 'danger'
        }
        return colors.get(self.status, 'secondary')