from rest_framework import serializers
from pricing.models import VehiclePricing
from vehicles.models import Vehicle
from vehiclemakemodels.models import VehicleSubModel, VehicleAttributes
from explorePlaces.models import Place
from rest_framework import serializers
from .models import Coupon,OrderedAccessory,Order
from accessories.models import Accessories
from accounts.models import Customer

# -----------------------------------------------------------------------------
# 🔹 Vehicle Attributes Serializer
# -----------------------------------------------------------------------------
class VehicleAttributesSerializer(serializers.Serializer):
    fueltype = serializers.CharField()
    vehicletype = serializers.CharField()
    displacement = serializers.CharField()
    weight = serializers.CharField()
    mileage = serializers.CharField()
    power = serializers.CharField()
    torque = serializers.CharField()
    category = serializers.CharField()
    transmission = serializers.CharField()

# ---------------------------------------------------------------------
# 🔹 Admin Booking List Serializer
# ---------------------------------------------------------------------
class AdminBookingListSerializer(serializers.Serializer):
    booking_id = serializers.CharField()
    customer_name = serializers.SerializerMethodField()
    customer_phone = serializers.SerializerMethodField()
    location = serializers.SerializerMethodField()
    vehicle_name = serializers.SerializerMethodField()
    pickup_time = serializers.DateTimeField(source="from_date")
    drop_time = serializers.DateTimeField(source="to_date")
    booking_status = serializers.CharField()

    # ------------------------------------------
    # 🔸 Customer Name
    # ------------------------------------------
    def get_customer_name(self, obj):
        if obj.customer:
            return f"{obj.customer.first_name} {obj.customer.last_name}".strip()
        return None

    # ------------------------------------------
    # 🔸 Customer Phone
    # ------------------------------------------
    def get_customer_phone(self, obj):
        return getattr(obj.customer, "phone_number", None)

    # ------------------------------------------
    # 🔸 Pickup Point
    # ------------------------------------------
    def get_location(self, obj):
        if obj.pickup_point:
            return obj.pickup_point.name
        return None

    # ------------------------------------------
    # 🔸 Vehicle Name
    # ------------------------------------------
    def get_vehicle_name(self, obj):
        if obj.vehicle:
            return getattr(obj.vehicle, "model_name", None) or getattr(obj.vehicle.model, "name", None)
        return None

# -----------------------------------------------------------------------------
# 🔹 Vehicle SubModel Serializer (auto-loads attributes)
# -----------------------------------------------------------------------------
class VehicleSubModelSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField()
    image = serializers.CharField(allow_null=True, required=False)
    attributes = serializers.SerializerMethodField()

    def get_attributes(self, obj):
        """Attach vehicle attributes if they exist."""
        attributes = VehicleAttributes.objects(vehicle=obj).first()
        if attributes:
            return VehicleAttributesSerializer(attributes).data
        return None

class SimpleAccessorySerializer(serializers.Serializer):
    name = serializers.CharField(source="submodel_name")
    price = serializers.FloatField()
    image = serializers.SerializerMethodField()

    def get_image(self, obj):
        if obj.image_urls and len(obj.image_urls) > 0:
            return obj.image_urls[0]  # return first image
        return None
class VehiclePricingSerializer(serializers.Serializer):
    # Hourly prices
    hourly_price_s = serializers.FloatField()
    hourly_price_m = serializers.FloatField()
    hourly_price_l = serializers.FloatField()

    # Hourly base KM
    hourly_base_km_s = serializers.FloatField()
    hourly_base_km_m = serializers.FloatField()
    hourly_base_km_l = serializers.FloatField()

    # Monthly prices
    monthly_price_s = serializers.FloatField()
    monthly_price_m = serializers.FloatField()
    monthly_price_l = serializers.FloatField()

    # Monthly base KM
    monthly_base_km_s = serializers.FloatField()
    monthly_base_km_m = serializers.FloatField()
    monthly_base_km_l = serializers.FloatField()

    # Optional: extras (if you need them in future)
    hourly_extra_price_per_km_s = serializers.FloatField()
    hourly_extra_price_per_km_m = serializers.FloatField()
    hourly_extra_price_per_km_l = serializers.FloatField()
    monthly_extra_price_per_km_s = serializers.FloatField()
    monthly_extra_price_per_km_m = serializers.FloatField()
    monthly_extra_price_per_km_l = serializers.FloatField()


# -----------------------------------------------------------------------------
# 🔹 Fleet Serializer (core for Order views)
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# 🔹 Fleet Serializer (core for Order views)
# -----------------------------------------------------------------------------
class FleetSerializer(serializers.Serializer):
    vehicle_id = serializers.CharField(source="id", read_only=True)
    model_name = serializers.SerializerMethodField()
    pickup_point = serializers.SerializerMethodField()
    city = serializers.SerializerMethodField()
    submodel = serializers.SerializerMethodField()
    pricing = serializers.SerializerMethodField()
    calculated_price = serializers.SerializerMethodField()
    calculated_kms = serializers.SerializerMethodField()

    # -------------------------------------------------------------------------
    # 🔸 Helper Methods
    # -------------------------------------------------------------------------
    def get_model_name(self, obj):
        """Return vehicle model name."""
        if getattr(obj, "model_name", None):
            return obj.model_name
        return getattr(obj.model, "name", None)

    def get_pickup_point(self, obj):
        pickup = getattr(obj, "pickup_point", None)
        return getattr(pickup, "name", None)

    def get_city(self, obj):
        pickup = getattr(obj, "pickup_point", None)
        return getattr(pickup, "city", None)

    def get_submodel(self, obj):
        submodel = getattr(obj, "submodel", None)
        if not submodel:
            return None
        submodel_obj = VehicleSubModel.objects(id=submodel.id).first()
        return VehicleSubModelSerializer(submodel_obj).data if submodel_obj else None

    def get_pricing(self, obj):
        pricing = VehiclePricing.objects(vehicle=obj).first()
        return VehiclePricingSerializer(pricing).data if pricing else None

    # -------------------------------------------------------------------------
    # 🔸 Dynamic Calculations Based on Duration
    # -------------------------------------------------------------------------
    def get_calculated_price(self, obj):
        """
        Dynamically calculate price based on duration_type and hours/months.
        """
        request = self.context.get("request")
        duration_type = request.query_params.get("duration_type", "HOURS").upper()
        hours = float(request.query_params.get("hours", 0))
        months = float(request.query_params.get("months", 0))
        vehicle_type = request.query_params.get("vehicle_type", "S").upper()

        pricing = VehiclePricing.objects(vehicle=obj).first()
        if not pricing:
            return None

        # Base price defaults
        base_price = getattr(pricing, f"hourly_price_{vehicle_type.lower()}", 0)
        total_price = base_price

        if duration_type == "HOURS" and hours > 0:
            total_price = base_price * hours
        elif duration_type == "MONTHS" and months > 0:
            base_price = getattr(pricing, f"monthly_price_{vehicle_type.lower()}", 0)
            total_price = base_price * months

        return round(total_price, 2)

    def get_calculated_kms(self, obj):
        """
        Multiply base KM with hours or months based on duration type.
        Assuming VehiclePricing has base_km field, otherwise default = 10 KM/hr.
        """
        request = self.context.get("request")
        duration_type = request.query_params.get("duration_type", "HOURS").upper()
        hours = float(request.query_params.get("hours", 0))
        months = float(request.query_params.get("months", 0))

        # You can define default base_km or get it from pricing model
        base_km = getattr(VehiclePricing.objects(vehicle=obj).first(), "base_km", 10)

        if duration_type == "HOURS" and hours > 0:
            return base_km * hours
        elif duration_type == "MONTHS" and months > 0:
            # You can decide your logic for monthly km, e.g., 3000 base_km/month
            return base_km * (hours if hours else months * 720 / 24)
        return base_km


class CouponSerializer(serializers.Serializer):
    # ------------------- Basic Fields -------------------
    id = serializers.CharField(read_only=True)
    code = serializers.CharField(max_length=50)
    description = serializers.CharField(allow_blank=True, required=False)

    # ------------------- Coupon Type -------------------
    depends_on = serializers.ChoiceField(choices=[("PRICE", "Price"), ("KMS", "Kilometers"), ("TIME", "Time")])

    # ------------------- Discount Details -------------------
    discount_type = serializers.ChoiceField(choices=[("PERCENTAGE", "Percentage"), ("FIXED", "Fixed Amount")])
    discount_value = serializers.DecimalField(max_digits=10, decimal_places=2)

    # ------------------- Conditions -------------------
    min_price = serializers.DecimalField(max_digits=10, decimal_places=2, required=False, allow_null=True)
    min_kms = serializers.DecimalField(max_digits=10, decimal_places=2, required=False, allow_null=True)
    min_time_in_hours = serializers.IntegerField(required=False, allow_null=True)

    # ------------------- Validity -------------------
    valid_from = serializers.DateTimeField()
    valid_till = serializers.DateTimeField()

    # ------------------- Usage -------------------
    is_recurring = serializers.BooleanField(default=False)
    used_count = serializers.IntegerField(read_only=True)
    is_active = serializers.BooleanField(default=True)

    # ------------------- Metadata -------------------
    created_at = serializers.DateTimeField(read_only=True)
    updated_at = serializers.DateTimeField(read_only=True)

    # -----------------------------------------------------------------
    # 🔸 Create and Update Handlers (MongoEngine compatible)
    # -----------------------------------------------------------------
    def create(self, validated_data):
        """Create and save a new Coupon document."""
        from .models import Coupon
        coupon = Coupon(**validated_data)
        coupon.save()
        return coupon

    def update(self, instance, validated_data):
        """Update an existing Coupon document."""
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()
        return instance


class OrderedAccessorySerializer(serializers.Serializer):
    accessory_id = serializers.CharField()
    quantity = serializers.IntegerField(min_value=1, default=1)

    def validate(self, data):
        """Ensure accessory exists and is active."""
        try:
            acc = Accessories.objects.get(id=data["accessory_id"], status="Active")
        except Accessories.DoesNotExist:
            raise serializers.ValidationError("Accessory not found or inactive.")
        data["accessory"] = acc
        return data


# ---------------------------------------------------------------------
# 🔹 Order Serializer
# ---------------------------------------------------------------------
class OrderSerializer(serializers.Serializer):
    customer_id = serializers.CharField()
    vehicle_id = serializers.CharField()
    pickup_point_id = serializers.CharField()
    from_date = serializers.DateTimeField()
    to_date = serializers.DateTimeField()
    accessories = OrderedAccessorySerializer(many=True, required=False)
    coupon_code = serializers.CharField(required=False, allow_blank=True)

    # Response fields
    overall_price = serializers.DecimalField(max_digits=10, decimal_places=2, read_only=True)
    price_after_discount = serializers.DecimalField(max_digits=10, decimal_places=2, read_only=True)

    def validate(self, data):
        """Custom validation & price computation."""
        # -----------------------------------------------------------------
        # 🔸 Validate references
        # -----------------------------------------------------------------
        try:
            customer = Customer.objects.get(id=data["customer_id"])
        except Customer.DoesNotExist:
            raise serializers.ValidationError("Invalid customer_id")

        try:
            vehicle = Vehicle.objects.get(id=data["vehicle_id"], status="Active")
        except Vehicle.DoesNotExist:
            raise serializers.ValidationError("Vehicle not available or inactive")

        try:
            pickup_point = Place.objects.get(id=data["pickup_point_id"])
        except Place.DoesNotExist:
            raise serializers.ValidationError("Invalid pickup_point_id")

        # -----------------------------------------------------------------
        # 🔸 Validate dates
        # -----------------------------------------------------------------
        if data["from_date"] >= data["to_date"]:
            raise serializers.ValidationError("Invalid booking dates")

        # -----------------------------------------------------------------
        # 🔸 Calculate duration (in hours)
        # -----------------------------------------------------------------
        duration_hours = (data["to_date"] - data["from_date"]).total_seconds() / 3600
        if duration_hours <= 0:
            raise serializers.ValidationError("Duration must be greater than 0 hours")

        # -----------------------------------------------------------------
        # 🔸 Get vehicle pricing
        # -----------------------------------------------------------------
        pricing = VehiclePricing.objects(vehicle=vehicle, status="ASSIGNED").first()
        if not pricing:
            raise serializers.ValidationError("No pricing assigned to this vehicle")

        # Determine type by model (default to S)
        vehicle_type = getattr(vehicle, "vehicle_type", "S").lower()
        base_price_per_hour = getattr(pricing, f"hourly_price_{vehicle_type}", 0)
        base_km = getattr(pricing, f"hourly_base_km_{vehicle_type}", 0)

        total_vehicle_price = base_price_per_hour * duration_hours

        # -----------------------------------------------------------------
        # 🔸 Calculate accessories total
        # -----------------------------------------------------------------
        accessories_total = 0
        accessories_objs = []

        for item in data.get("accessories", []):
            acc = item["accessory"]
            qty = item["quantity"]
            accessories_total += float(acc.price) * qty

            accessories_objs.append(OrderedAccessory(accessory=acc, quantity=qty))

        # -----------------------------------------------------------------
        # 🔸 Coupon handling
        # -----------------------------------------------------------------
        coupon_obj = None
        total_before_discount = total_vehicle_price + accessories_total
        total_after_discount = total_before_discount

        if data.get("coupon_code"):
            coupon_obj = Coupon.objects(code=data["coupon_code"]).first()
            if not coupon_obj:
                raise serializers.ValidationError("Invalid coupon code")

            if not coupon_obj.is_valid():
                raise serializers.ValidationError("Coupon is expired or inactive")

            # Apply discount
            if coupon_obj.discount_type == "PERCENTAGE":
                discount_amount = (total_before_discount * float(coupon_obj.discount_value)) / 100
            else:
                discount_amount = float(coupon_obj.discount_value)

            total_after_discount = total_before_discount - discount_amount
            total_after_discount = max(total_after_discount, 0)

        # -----------------------------------------------------------------
        # 🔸 Attach calculated fields for create()
        # -----------------------------------------------------------------
        data["customer"] = customer
        data["vehicle"] = vehicle
        data["pickup_point"] = pickup_point
        data["accessories_objs"] = accessories_objs
        data["coupon"] = coupon_obj
        data["overall_price"] = round(total_before_discount, 2)
        data["price_after_discount"] = round(total_after_discount, 2)

        return data

    def create(self, validated_data):
        """Create order document."""
        order = Order(
            customer=validated_data["customer"],
            vehicle=validated_data["vehicle"],
            pickup_point=validated_data["pickup_point"],
            from_date=validated_data["from_date"],
            to_date=validated_data["to_date"],
            accessories=validated_data.get("accessories_objs", []),
            coupon=validated_data.get("coupon"),
            overall_price=validated_data["overall_price"],
            price_after_discount=validated_data["price_after_discount"],
        )
        order.save()
        return order