from rest_framework import serializers
from .models import VehicleAttributes, VehicleMake, VehicleMakeModel, VehicleModel, VehicleSubModel
import json
from mongoengine.errors import NotUniqueError

class VehicleMakeModelSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField(required=True)
    parent = serializers.CharField(required=False, allow_null=True)

    def create(self, validated_data):
        parent_id = validated_data.pop("parent", None)
        parent = None
        if parent_id:
            parent = VehicleMakeModel.objects(id=parent_id).first()
        return VehicleMakeModel.objects.create(parent=parent, **validated_data)

    def update(self, instance, validated_data):
        instance.name = validated_data.get("name", instance.name)

        parent_id = validated_data.get("parent", None)
        if parent_id is not None:
            parent = VehicleMakeModel.objects(id=parent_id).first()
            instance.parent = parent
        instance.save()
        return instance


class VehicleTreeSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField()
    children = serializers.SerializerMethodField()

    def get_children(self, obj):
        print("obj",obj, "==" ,VehicleTreeSerializer(obj))
        return VehicleTreeSerializer(obj.children, many=True).data

    
# attributes serializer (flat, no recursion)
class VehicleAttributesSerializer(serializers.Serializer):
    fueltype = serializers.CharField(required=True)
    vehicletype = serializers.CharField(required=True)
    displacement = serializers.CharField(required=True)
    weight = serializers.CharField(required=True)
    mileage = serializers.CharField(required=True)
    power = serializers.CharField(required=True)
    torque = serializers.CharField(required=True)
    category = serializers.CharField(required=True)
    transmission = serializers.CharField(required=True)


class VehicleSubModelSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField(required=True)
    status = serializers.BooleanField(required=False)
    model = serializers.CharField(read_only=True)
    model_name = serializers.SerializerMethodField(read_only=True)
    image = serializers.ImageField(write_only=True, required=False)
    image_url = serializers.SerializerMethodField()
    # Use JSONField to automatically parse stringified JSON from FormData
    attributes = serializers.JSONField(required=False)

    class Meta:
        fields = ["id", "name", "model", "model_name", "image", "image_url", "attributes"]

    def get_model_name(self, obj):
        return obj.model.name if obj.model else None

    def get_image_url(self, obj):
        request = self.context.get("request")
        if obj.image:
            return request.build_absolute_uri(f"/media/{obj.image}")
        return None

    def to_representation(self, instance):
        rep = super().to_representation(instance)
        attrs = VehicleAttributes.objects(vehicle=instance).first()
        rep["attributes"] = VehicleAttributesSerializer(attrs).data if attrs else None
        return rep

    # --- CREATE ---
    def create(self, validated_data):
        image_file = validated_data.pop("image", None)
        attributes_data = validated_data.pop("attributes", None)
        model = self.context.get("model")

        # Ensure attributes_data is a dict
        if isinstance(attributes_data, str):
            try:
                attributes_data = json.loads(attributes_data)
            except json.JSONDecodeError:
                raise serializers.ValidationError({"attributes": "Invalid JSON."})

        # Validate attributes using nested serializer
        if attributes_data:
            attr_serializer = VehicleAttributesSerializer(data=attributes_data)
            attr_serializer.is_valid(raise_exception=True)
            attributes_data = attr_serializer.validated_data

        # Create submodel
        submodel = VehicleSubModel(**validated_data, model=model)
        if image_file:
            submodel.save_image(image_file)

        try:
            submodel.save()
            if attributes_data:
                VehicleAttributes(vehicle=submodel, **attributes_data).save()
        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle submodel already exists."})

        return submodel

    # --- UPDATE ---
    def update(self, instance, validated_data):
        image_file = validated_data.pop("image", None)
        attributes_data = validated_data.pop("attributes", None)

        # Update main fields
        for attr, value in validated_data.items():
            setattr(instance, attr, value)

        if image_file:
            instance.delete_image_file()
            instance.save_image(image_file)

        try:
            instance.save()

            # Handle attributes
            if attributes_data:
                # Parse JSON if string
                if isinstance(attributes_data, str):
                    try:
                        attributes_data = json.loads(attributes_data)
                    except json.JSONDecodeError:
                        raise serializers.ValidationError({"attributes": "Invalid JSON."})

                # Validate attributes using serializer
                attr_serializer = VehicleAttributesSerializer(data=attributes_data)
                attr_serializer.is_valid(raise_exception=True)
                attributes_data = attr_serializer.validated_data

                # One-to-one relation
                attrs = VehicleAttributes.objects(vehicle=instance).first()
                if attrs:
                    for key, value in attributes_data.items():
                        setattr(attrs, key, value)
                    attrs.save()
                else:
                    VehicleAttributes(vehicle=instance, **attributes_data).save()

        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle submodel already exists."})

        return instance

class VehicleModelSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField(required=True)
    status = serializers.BooleanField(required=False)
    make = serializers.CharField(read_only=True)  # auto set from URL or context
    make_name = serializers.SerializerMethodField(read_only=True)
    type = serializers.CharField(required=False, allow_blank=True, allow_null=True)  # ✅ Added type field
    submodels = VehicleSubModelSerializer(many=True, read_only=True)

    class Meta:
        fields = ["id", "name", "make", "make_name", "status", "type", "submodels"]

    def get_make_name(self, obj):
        return obj.make.name if obj.make else None

    def create(self, validated_data):
        make = self.context.get("make")
        vehicle_model = VehicleModel(**validated_data, make=make)
        try:
            vehicle_model.save()
        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle model already exists."})
        except Exception as e:
            raise serializers.ValidationError({"error": str(e)})

        return vehicle_model

    def update(self, instance, validated_data):
        if "name" in validated_data:
            instance.name = validated_data["name"]
        if "status" in validated_data:
            instance.status = validated_data["status"]
        if "type" in validated_data:  # ✅ Added type update
            instance.type = validated_data["type"]

        try:
            instance.save()
        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle model already exists."})
        except Exception as e:
            raise serializers.ValidationError({"error": str(e)})

        return instance

class VehicleMakeSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField()
    status = serializers.BooleanField(required=False)
    image = serializers.ImageField(write_only=True, required=False)
    image_url = serializers.SerializerMethodField()
    models = VehicleModelSerializer(many=True, read_only=True)
    company_name = serializers.CharField()

    class Meta:
        model = VehicleMake
        fields = ["id", "name", "image", "image_url"]

    def get_image_url(self, obj):
        request = self.context.get("request")
        if obj.image:
            return request.build_absolute_uri(f"/media/{obj.image}")
        return None

    def create(self, validated_data):
        image_file = validated_data.pop("image", None)
        vehicle = VehicleMake(**validated_data)
        if image_file:
            vehicle.save_image(image_file)
        try:
            vehicle.save()
        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle make already exists."})
        return vehicle

    def update(self, instance, validated_data):
        
        print(">>> validated_data:", validated_data)  # DEBUG
        image_file = validated_data.pop("image", None)

        print(">>> validated_data:---", validated_data)  # DEBUG
        # overwrite all attributes (PUT = full update)
           # update only provided fields
        if "name" in validated_data:
            instance.name = validated_data["name"]
        if "status" in validated_data:
            instance.status = validated_data["status"]
        if "company_name" in validated_data:
            instance.company_name = validated_data["company_name"]
        # instance.name = validated_data.get("name", instance.name)

        if image_file:
            instance.delete_image_file()
            instance.save_image(image_file)
        try:
            instance.save()
        except NotUniqueError:
            raise serializers.ValidationError({"name": "This vehicle make already exists."})
        return instance