from mongoengine import Document, EmbeddedDocument, fields, CASCADE, NULLIFY
from datetime import datetime
import uuid
from accounts.models import Customer
from vehicles.models import Vehicle
from explorePlaces.models import Place
from accessories.models import Accessories


# ---------------------------------------------------------
# ✅ COUPON MODEL
# ---------------------------------------------------------
class Coupon(Document):
    """
    Coupon Model — Represents discount codes that can depend on price, distance, or duration.
    """

    id = fields.UUIDField(primary_key=True, default=uuid.uuid4)
    code = fields.StringField(required=True, unique=True)
    description = fields.StringField()

    depends_on = fields.StringField(choices=["PRICE", "KMS", "TIME"], required=True)
    discount_type = fields.StringField(choices=["PERCENTAGE", "FIXED"], required=True)
    discount_value = fields.DecimalField(precision=2, required=True)

    min_price = fields.DecimalField(precision=2, default=0)
    min_kms = fields.DecimalField(precision=2, default=0)
    min_time_in_hours = fields.IntField(default=0)

    valid_from = fields.DateTimeField(default=datetime.utcnow)
    valid_till = fields.DateTimeField(required=True)

    is_recurring = fields.BooleanField(default=False)
    used_count = fields.IntField(default=0)
    is_active = fields.BooleanField(default=True)

    created_at = fields.DateTimeField(default=datetime.utcnow)
    updated_at = fields.DateTimeField(default=datetime.utcnow)

    meta = {"collection": "coupons"}

    def is_valid(self):
        now = datetime.utcnow()
        return self.is_active and self.valid_from <= now <= self.valid_till

    def __str__(self):
        recurring_text = "Recurring" if self.is_recurring else "One-time"
        return f"{self.code} ({recurring_text} | {self.depends_on})"


# ---------------------------------------------------------
# ✅ EMBEDDED ACCESSORY DOCUMENT (for quantity support)
# ---------------------------------------------------------
class OrderedAccessory(EmbeddedDocument):
    """
    Represents an accessory and its quantity within an order.
    """

    accessory = fields.ReferenceField(Accessories, required=True)
    quantity = fields.IntField(required=True, min_value=1, default=1)

    def __str__(self):
        return f"{self.accessory.name if self.accessory else 'N/A'} x{self.quantity}"

class Order(Document):
    """
    Order Model — Represents a user's vehicle booking with accessories & coupon usage.
    """

    # ---------------- Primary Fields ----------------
    id = fields.UUIDField(primary_key=True, default=uuid.uuid4)
    booking_id = fields.StringField(required=False, unique=True)   # Not required initially

    # ---------------- References ----------------
    customer = fields.ReferenceField(Customer, required=True, reverse_delete_rule=CASCADE)
    pickup_point = fields.ReferenceField(Place, required=True, reverse_delete_rule=NULLIFY)
    vehicle = fields.ReferenceField(Vehicle, required=True, reverse_delete_rule=NULLIFY)
    accessories = fields.EmbeddedDocumentListField(OrderedAccessory)
    coupon = fields.ReferenceField(Coupon, reverse_delete_rule=NULLIFY, default=None)

    # ---------------- Booking Timeline ----------------
    from_date = fields.DateTimeField(required=True)
    to_date = fields.DateTimeField(required=True)

    # ---------------- Pricing ----------------
    overall_price = fields.DecimalField(precision=2, required=True)
    price_after_discount = fields.DecimalField(precision=2, required=True)

    # ---------------- Order Workflow Status ----------------
    STATUS_CHOICES = ("Declined", "Processing", "Approved", "Cancelled")
    status = fields.StringField(
        choices=STATUS_CHOICES,
        default="Processing",
        required=True,
    )

    BOOKING_STATUS_CHOICES = ("Upcoming", "Ongoing", "Fulfilled", "Cancelled")
    booking_status = fields.StringField(
        choices=BOOKING_STATUS_CHOICES,
        default="Upcoming",
        required=True
    )

    # ---------------- Metadata ----------------
    created_at = fields.DateTimeField(default=datetime.utcnow)
    updated_at = fields.DateTimeField(default=datetime.utcnow)

    meta = {
        "collection": "orders",
        "indexes": [
            "customer",
            "pickup_point",
            "vehicle",
            "coupon",
            "status",
            {"fields": ["from_date", "to_date"]},
        ],
    }

    # -----------------------------------------------------------------
    # ✅ OVERRIDDEN SAVE METHOD (SAFE & BUG-FREE)
    # -----------------------------------------------------------------
    def save(self, *args, **kwargs):
        """
        Save override:
        - Only NEW orders update vehicle status.
        - Booking ID can be generated later (admin list).
        - Prevents errors when updating existing orders.
        """

        is_new = self._created  # MongoEngine flag

        self.updated_at = datetime.utcnow()

        # ---------------------------------------------------------
        # 🔹 VEHICLE BOOKING LOGIC — ONLY FOR NEW ORDERS
        # ---------------------------------------------------------
        if is_new and self.status != "Cancelled":
            if self.vehicle:
                vehicle = Vehicle.objects(id=self.vehicle.id, status="Active").first()

                if not vehicle:
                    raise ValueError("❌ Vehicle is already booked or inactive.")

                # Mark vehicle as booked
                vehicle.verification_status = "Booked"
                vehicle.status = "Inactive"
                vehicle.save()

        # ---------------------------------------------------------
        # 🔹 Apply coupon if present
        # ---------------------------------------------------------
        self.apply_coupon()

        # Default workflow status
        if not self.status:
            self.status = "Processing"

        # ---------------------------------------------------------
        # 🔹 Final Save
        # ---------------------------------------------------------
        return super().save(*args, **kwargs)

    # -----------------------------------------------------------------
    # 🔹 Coupon Logic
    # -----------------------------------------------------------------
    def apply_coupon(self):
        """Apply coupon discount if valid."""
        if not self.coupon or not self.coupon.is_valid():
            return

        if self.coupon.discount_type == "PERCENTAGE":
            discount_amount = (self.overall_price * self.coupon.discount_value) / 100
        else:
            discount_amount = self.coupon.discount_value

        discounted_price = self.overall_price - discount_amount
        self.price_after_discount = max(discounted_price, 0)

    # -----------------------------------------------------------------
    # 🔹 Accessory Total Calculation
    # -----------------------------------------------------------------
    def calculate_accessories_total(self):
        """Calculates total price of all accessories based on quantity."""
        total = 0
        for item in self.accessories:
            try:
                total += float(item.accessory.price) * item.quantity
            except Exception:
                pass
        return total

    # -----------------------------------------------------------------
    # 🔹 String Representation
    # -----------------------------------------------------------------
    def __str__(self):
        accessories_info = ", ".join(str(a) for a in self.accessories) if self.accessories else "None"
        return (
            f"Order({str(self.id)[:8]}) | Customer: {self.customer.first_name} | "
            f"Status: {self.status} | Vehicle: {self.vehicle.id if self.vehicle else 'N/A'} | "
            f"Pickup: {self.pickup_point.name if self.pickup_point else 'N/A'} | "
            f"Accessories: {accessories_info} | Total: ₹{self.price_after_discount}"
        )
