"""
CODH Subscriptions Models
Subscription lifecycle management
"""

import uuid
from django.db import models
from django.conf import settings
from django.utils import timezone


class SubscriptionPlan(models.Model):
    """
    Subscription plan definitions
    """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    name = models.CharField(max_length=255)
    description = models.TextField(blank=True)
    
    # Features
    max_projects = models.IntegerField(default=1)
    max_hosting_accounts = models.IntegerField(default=1)
    max_domains = models.IntegerField(default=1)
    max_storage_gb = models.IntegerField(default=1)
    max_bandwidth_gb = models.IntegerField(default=10)
    
    # Included services
    includes_support = models.BooleanField(default=True)
    support_level = models.CharField(max_length=20, default='basic')  # basic, priority, dedicated
    includes_backups = models.BooleanField(default=False)
    includes_ssl = models.BooleanField(default=True)
    includes_cdn = models.BooleanField(default=False)
    
    # Pricing
    monthly_price = models.DecimalField(max_digits=10, decimal_places=2)
    yearly_price = models.DecimalField(max_digits=10, decimal_places=2)
    setup_fee = models.DecimalField(max_digits=10, decimal_places=2, default=0)
    
    # Billing
    billing_cycle = models.CharField(max_length=20, default='monthly')  # monthly, yearly
    trial_days = models.IntegerField(default=0)
    
    # WordPress mapping
    wordpress_plan_id = models.CharField(max_length=100, blank=True)
    
    is_active = models.BooleanField(default=True)
    is_public = models.BooleanField(default=True)
    display_order = models.IntegerField(default=0)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = 'Subscription Plan'
        verbose_name_plural = 'Subscription Plans'
        ordering = ['display_order', 'monthly_price']
    
    def __str__(self):
        return self.name


class Subscription(models.Model):
    """
    User subscriptions
    """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='subscriptions')
    plan = models.ForeignKey(SubscriptionPlan, on_delete=models.PROTECT, related_name='subscriptions')
    
    # Related objects
    hosting_account = models.ForeignKey('hosting.HostingAccount', on_delete=models.SET_NULL, null=True, blank=True, related_name='subscriptions')
    
    # Status
    STATUS_CHOICES = [
        ('pending', 'Pending'),
        ('trial', 'Trial'),
        ('active', 'Active'),
        ('past_due', 'Past Due'),
        ('expired', 'Expired'),
        ('cancelled', 'Cancelled'),
        ('suspended', 'Suspended'),
    ]
    status = models.CharField(max_length=15, choices=STATUS_CHOICES, default='pending')
    
    # Billing
    billing_cycle = models.CharField(max_length=20, default='monthly')
    amount = models.DecimalField(max_digits=10, decimal_places=2)
    currency = models.CharField(max_length=3, default='USD')
    
    # Dates
    start_date = models.DateTimeField(null=True, blank=True)
    end_date = models.DateTimeField(null=True, blank=True)
    trial_end_date = models.DateTimeField(null=True, blank=True)
    next_billing_date = models.DateTimeField(null=True, blank=True)
    cancelled_at = models.DateTimeField(null=True, blank=True)
    
    # Payment
    payment_method = models.CharField(max_length=50, blank=True)
    
    # WordPress sync
    wordpress_subscription_id = models.CharField(max_length=100, blank=True)
    last_sync_at = models.DateTimeField(null=True, blank=True)
    
    # Auto-renew
    auto_renew = models.BooleanField(default=True)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = 'Subscription'
        verbose_name_plural = 'Subscriptions'
        ordering = ['-created_at']
    
    def __str__(self):
        return f"{self.user.email} - {self.plan.name}"
    
    @property
    def is_active_or_trial(self):
        return self.status in ['active', 'trial']
    
    @property
    def days_until_expiry(self):
        if self.end_date:
            delta = self.end_date - timezone.now()
            return max(0, delta.days)
        return None
    
    def can_access_feature(self, feature):
        """Check if subscription allows access to feature"""
        if not self.is_active_or_trial:
            return False
        
        feature_map = {
            'support': self.plan.includes_support,
            'backups': self.plan.includes_backups,
            'ssl': self.plan.includes_ssl,
            'cdn': self.plan.includes_cdn,
        }
        
        return feature_map.get(feature, False)


class SubscriptionUsage(models.Model):
    """
    Track subscription resource usage
    """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    subscription = models.OneToOneField(Subscription, on_delete=models.CASCADE, related_name='usage')
    
    # Current usage
    projects_count = models.IntegerField(default=0)
    hosting_accounts_count = models.IntegerField(default=0)
    domains_count = models.IntegerField(default=0)
    storage_used_gb = models.DecimalField(max_digits=10, decimal_places=2, default=0)
    bandwidth_used_gb = models.DecimalField(max_digits=10, decimal_places=2, default=0)
    
    # History
    last_calculated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = 'Subscription Usage'
        verbose_name_plural = 'Subscription Usage'
    
    def is_within_limits(self):
        """Check if usage is within plan limits"""
        plan = self.subscription.plan
        
        return (
            self.projects_count <= plan.max_projects and
            self.hosting_accounts_count <= plan.max_hosting_accounts and
            self.domains_count <= plan.max_domains and
            self.storage_used_gb <= plan.max_storage_gb
        )


class SubscriptionHistory(models.Model):
    """
    Subscription change history
    """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    subscription = models.ForeignKey(Subscription, on_delete=models.CASCADE, related_name='history')
    
    ACTION_CHOICES = [
        ('created', 'Created'),
        ('activated', 'Activated'),
        ('renewed', 'Renewed'),
        ('upgraded', 'Upgraded'),
        ('downgraded', 'Downgraded'),
        ('suspended', 'Suspended'),
        ('resumed', 'Resumed'),
        ('cancelled', 'Cancelled'),
        ('expired', 'Expired'),
    ]
    action = models.CharField(max_length=15, choices=ACTION_CHOICES)
    
    description = models.TextField(blank=True)
    
    old_plan = models.ForeignKey(SubscriptionPlan, on_delete=models.SET_NULL, null=True, blank=True, related_name='history_old')
    new_plan = models.ForeignKey(SubscriptionPlan, on_delete=models.SET_NULL, null=True, blank=True, related_name='history_new')
    
    created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        verbose_name = 'Subscription History'
        verbose_name_plural = 'Subscription History'
        ordering = ['-created_at']