from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
from datetime import datetime, timedelta
import uuid

class Tenant(models.Model):
    PLAN_CHOICES = [
        ('basic', 'Basic - KES 2,000/month'),
        ('standard', 'Standard - KES 5,000/month'),
        ('premium', 'Premium - KES 10,000/month'),
    ]

    STATUS_CHOICES = [
        ('active', 'Active'),
        ('suspended', 'Suspended'),
        ('trial', 'Trial'),
        ('expired', 'Expired'),
    ]

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=255)
    tenant_code = models.CharField(
        max_length=20, 
        unique=True, 
        help_text="Unique code for tenant login (letters, numbers only, no spaces)"
    )
    owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name='owned_tenants')
    plan = models.CharField(max_length=20, choices=PLAN_CHOICES, default='basic')
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='trial')
    created_at = models.DateTimeField(auto_now_add=True)
    trial_ends_at = models.DateTimeField(null=True, blank=True)
    subscription_ends_at = models.DateTimeField(null=True, blank=True)
    max_shops = models.IntegerField(default=1)
    max_users = models.IntegerField(default=3)

    # Contact info
    contact_email = models.EmailField()
    contact_phone = models.CharField(max_length=15)
    address = models.TextField(blank=True)

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.trial_ends_at:
            self.trial_ends_at = timezone.now() + timedelta(days=14)  # 14-day trial
        if not self.tenant_code:
            self.tenant_code = self.generate_tenant_code()
        super().save(*args, **kwargs)

    def generate_tenant_code(self):
        """Generate unique tenant code from business name"""
        import re
        import random
        import string
        
        # Create a slug-like code from the business name
        base_code = re.sub(r'[^a-zA-Z0-9]', '', self.name.lower())[:10]
        
        # If empty or too short, use random code
        if len(base_code) < 3:
            base_code = ''.join(random.choices(string.ascii_lowercase, k=6))
        
        # Ensure uniqueness
        code = base_code
        counter = 1
        while Tenant.objects.filter(tenant_code=code).exists():
            code = f"{base_code}{counter}"
            counter += 1
            
        return code

    @property
    def is_active(self):
        """Check if tenant is currently active (trial not expired)"""
        from django.utils import timezone
        if self.trial_ends_at is None:
            return True  # If no trial end date set, consider active
        now = timezone.now()
        return now <= self.trial_ends_at

    @property
    def days_remaining(self):
        now = timezone.now()
        if self.status == 'trial' and self.trial_ends_at:
            delta = self.trial_ends_at - now
            return max(0, delta.days)
        elif self.status == 'active' and self.subscription_ends_at:
            delta = self.subscription_ends_at - now
            return max(0, delta.days)
        return 0

    def get_plan_price(self):
        prices = {
            'basic': 2000,
            'standard': 5000,
            'premium': 10000,
        }
        return prices.get(self.plan, 2000)

    class Meta:
        db_table = 'tenants_tenant'


class TenantUser(models.Model):
    ROLE_CHOICES = [
        ('owner', 'Owner'),
        ('admin', 'Admin'),
        ('manager', 'Manager'),
        ('staff', 'Staff'),
    ]

    tenant = models.ForeignKey(Tenant, on_delete=models.CASCADE, related_name='tenant_users')
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='tenant_memberships')
    role = models.CharField(max_length=20, choices=ROLE_CHOICES, default='staff')
    is_active = models.BooleanField(default=True)
    joined_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('tenant', 'user')
        db_table = 'tenants_tenant_user'

    def __str__(self):
        return f"{self.user.username} - {self.tenant.name}"