from django.db import models, transaction
from django.utils import timezone
from datetime import timedelta
import uuid
from project.utils.woocommerce_service import update_variant_stock


# ---------------------- STEMS ----------------------
class Stem(models.Model):
    """A single flower stem in stock."""
    name = models.CharField(max_length=120, unique=True)
    sku = models.CharField(max_length=80, unique=True)
    stock_quantity = models.PositiveIntegerField(default=0)
    reserved_quantity = models.PositiveIntegerField(default=0)
    low_stock_threshold = models.PositiveIntegerField(default=5)

    def available_quantity(self):
        return max(0, self.stock_quantity - self.reserved_quantity)

    def __str__(self):
        return f"{self.name} (avail: {self.available_quantity()})"


# ---------------------- BOUQUETS ----------------------
class Bouquet(models.Model):
    """A bouquet product (parent Woo product)."""
    name = models.CharField(max_length=200)
    sku = models.CharField(max_length=80, unique=True)
    active = models.BooleanField(default=True)
    woo_product_id = models.PositiveIntegerField(null=True, blank=True)

    def __str__(self):
        return f"{self.name} ({self.sku})"


class BouquetStem(models.Model):
    bouquet = models.ForeignKey("Bouquet", on_delete=models.CASCADE, related_name="default_stems")
    stem = models.ForeignKey("Stem", on_delete=models.CASCADE)
    alternative_stem = models.ForeignKey("Stem", on_delete=models.SET_NULL, null=True, blank=True, related_name="alt_for_bouquets")

    # Per-size units
    units_s = models.PositiveIntegerField(default=0)
    units_m = models.PositiveIntegerField(default=0)
    units_l = models.PositiveIntegerField(default=0)
    units_xl = models.PositiveIntegerField(default=0)

    def __str__(self):
        return f"{self.bouquet.name} – {self.stem.name}"

class BouquetVariant(models.Model):
    """Bouquet variation (size option)."""
    SIZE_CHOICES = [
        ("S", "Small"),
        ("M", "Medium"),
        ("L", "Large"),
        ("XL", "Extra Large"),
    ]

    bouquet = models.ForeignKey(Bouquet, on_delete=models.CASCADE, related_name="variants")
    size = models.CharField(max_length=10, choices=SIZE_CHOICES)
    woo_variation_id = models.PositiveIntegerField(unique=True, null=True, blank=True)
    price = models.DecimalField(max_digits=10, decimal_places=2, null=True, blank=True)

    class Meta:
        unique_together = ("bouquet", "size")

    def __str__(self):
        return f"{self.bouquet.name} - {self.size}"

    def sync_default_stems(self):
        """Auto-create default variant stems from bouquet defaults."""
        for default in self.bouquet.default_stems.all():
            BouquetVariantStem.objects.get_or_create(
                variant=self,
                stem=default.stem,
                defaults={"units_needed": 1},
            )


class BouquetVariantStem(models.Model):
    """How many stems each variant requires (overrides bouquet defaults)."""
    variant = models.ForeignKey(BouquetVariant, on_delete=models.CASCADE, related_name="stems")
    stem = models.ForeignKey(Stem, on_delete=models.CASCADE)
    units_needed = models.PositiveIntegerField(default=1)

    class Meta:
        unique_together = ("variant", "stem")

    def __str__(self):
        return f"{self.variant} needs {self.units_needed} x {self.stem.name}"

class ReservationManager(models.Manager):
    @transaction.atomic
    def create_reservation(self, variant_id, quantity=1, delivery_date=None):
        from project.models import BouquetVariant, BouquetStem, Stem

        variant = BouquetVariant.objects.select_related("bouquet").get(pk=variant_id)
        bouquet = variant.bouquet
        size = variant.size  # "S", "M", "L", or "XL"

        # Collect stem usage from default stems
        stems = bouquet.default_stems.select_related("stem")

        for bs in stems:
            units_needed = getattr(bs, f"units_{size.lower()}", 0) * quantity
            available = bs.stem.stock_quantity - bs.stem.reserved_quantity
            if available < units_needed:
                return False, f"Not enough stock for {bs.stem.name}"

        # Reserve stems
        for bs in stems:
            units_needed = getattr(bs, f"units_{size.lower()}", 0) * quantity
            if units_needed <= 0:
                continue
            stem = bs.stem
            stem.reserved_quantity = min(stem.stock_quantity, stem.reserved_quantity + units_needed)
            stem.save(update_fields=["reserved_quantity"])

        expires_at = timezone.now() + timedelta(minutes=10)
        reservation = self.create(
            variant=variant,
            bouquet=bouquet,
            quantity=quantity,
            delivery_date=delivery_date,
            expires_at=expires_at,
        )
        return True, {
            "reservation_id": str(reservation.id),
            "expires_at": expires_at.isoformat(),
            "seconds_remaining": 600
        }

# ---------------------- RESERVATIONS ----------------------
    
class OrderRecord(models.Model):
    """Record of Woo orders synced into Django."""
    
    woo_order_id = models.CharField(max_length=120, unique=True) 
    customer_name = models.CharField(max_length=200, blank=True)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2, null=True, blank=True, default=0)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Order {self.woo_order_id}"

# --- AUTO-CREATE VARIANTS ON NEW BOUQUET ---
from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Bouquet)
def create_default_variants(sender, instance, created, **kwargs):
    """
    Automatically create S, M, L, XL variants when a new bouquet is created.
    """
    if created:
        default_sizes = [
            ("S", "Small"),
            ("M", "Medium"),
            ("L", "Large"),
            ("XL", "Extra Large"),
        ]
        for code, label in default_sizes:
            BouquetVariant.objects.get_or_create(
                bouquet=instance,
                size=code,
                defaults={"price": 0.0},
            )
            
class ProcessedWooOrder(models.Model):
    woo_order_id = models.BigIntegerField(unique=True)
    processed_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Woo Order {self.woo_order_id}"
