from datetime import datetime
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.exceptions import NotFound
from .serializers import VehicleReadSerializer, VehicleStatusSerializer
from .models import Vehicle
from vehiclemakemodels.models import VehicleMake, VehicleModel, VehicleSubModel
from accounts.models import Partner
from explorePlaces.models import Place
from .permissions import MethodRolePermission
from .authentication import JWTAuthentication
import base64
import os
from django.core.files.uploadedfile import SimpleUploadedFile
class VehicleCreateView(APIView):
    """
    Handles creating (POST), updating (PUT), and retrieving (GET) Vehicles.
    Supports multipart/form-data for multiple image uploads.
    """

    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]

    allowed_roles = {
        "POST": ["admin", "partner"],
        "PUT": ["admin"],
        "GET": ["admin", "partner"],
    }

    def resolve_reference(self, model_class, ref_id=None, ref_name=None, label="Reference"):
        """Resolve object by ID or fallback to name."""
        if ref_id:
            obj = model_class.objects(id=ref_id).first()
            if obj:
                name = obj.first_name if model_class == Partner else getattr(obj, "name", None)
                return obj, name, None
            elif ref_name:
                return None, ref_name, f"{label} '{ref_name}' does not exist"
            else:
                return None, None, f"{label} with ID {ref_id} not found"
        elif ref_name:
            return None, ref_name, f"{label} '{ref_name}' does not exist"
        return None, None, None

    def handle_images(self, vehicle, files, save_method_name):
        """Handles multiple file uploads for a given field."""
        if not files:
            return
        for f in files:
            try:
                getattr(vehicle, save_method_name)(f)
            except Exception as e:
                # Log the error, but continue saving other files
                print(f"Failed to save {f.name} for {save_method_name}: {str(e)}")

    def process_references(self, data):
        """Helper to resolve all references and collect missing reasons."""
        refs = [
            ("make", VehicleMake, "Make"),
            ("model", VehicleModel, "Model"),
            ("submodel", VehicleSubModel, "Submodel"),
            ("partner", Partner, "Partner"),
            ("pickup_point", Place, "Pickup Point")
        ]
        resolved = {}
        missing_reasons = []

        for field, model_cls, label in refs:
            obj, name, reason = self.resolve_reference(model_cls, data.get(f"{field}_id"), data.get(f"{field}_name"), label)
            resolved[field] = {"obj": obj, "name": name}
            if reason:
                missing_reasons.append(reason)

        return resolved, missing_reasons

    def base64_to_file(self, b64_string, filename):
        """Convert a base64 string to Django SimpleUploadedFile"""
        try:
            decoded_file = base64.b64decode(b64_string)
            return SimpleUploadedFile(name=filename, content=decoded_file, content_type="image/png")
        except Exception:
            return None

    def process_images(self, vehicle, request, is_update=False):
        """
        Deletes old images and inserts new images on every request.
        Handles both multipart files and base64 JSON uploads.
        """
        from django.conf import settings

        file_fields = {
            "rc_details_images": "save_rc_images",
            "vehicle_images": "save_vehicle_images",
            "insurance_images": "save_insurance_images",
            "puc_images": "save_puc_images",
        }

        for field, save_method in file_fields.items():
            files = request.FILES.getlist(field, [])  # Multipart upload
            if not files:
                # Check JSON base64 field
                b64_list = request.data.get(field, [])
                files = []
                for i, b64_str in enumerate(b64_list):
                    f = self.base64_to_file(b64_str, f"{field}_{i}.png")
                    if f:
                        files.append(f)

            if not files:
                continue  # No files for this field

            try:
                if is_update:
                    # Delete old files from disk
                    existing_paths = getattr(vehicle, field, [])
                    for img_path in existing_paths:
                        abs_path = os.path.join(settings.MEDIA_ROOT, img_path)
                        if os.path.exists(abs_path):
                            os.remove(abs_path)

                    # Reset the field to empty list
                    setattr(vehicle, field, [])
                    vehicle.save()  # save after clearing old images

                # Save new files
                getattr(vehicle, save_method)(files)

            except Exception as e:
                print(f"Failed to save {field}: {str(e)}")
    

    def post(self, request):
        data = request.data

        # ---------------- Validate required fields ----------------
        required_fields = ["registration_date", "chassis_number", "engine_number",
                        "owner_name", "colour", "doi", "doe", "vehicle_class", "address", "tax_upto"]
        missing_fields = [f for f in required_fields if not data.get(f)]
        if missing_fields:
            return Response({"error": f"Missing required fields: {', '.join(missing_fields)}"},
                            status=status.HTTP_400_BAD_REQUEST)

        # ---------------- Resolve references ----------------
        resolved, missing_reasons = self.process_references(data)

        # ---------------- Create Vehicle instance ----------------
        vehicle = Vehicle(
            registration_date=data["registration_date"],
            chassis_number=data["chassis_number"],
            engine_number=data["engine_number"],
            owner_name=data["owner_name"],
            colour=data["colour"],
            doi=data["doi"],
            doe=data["doe"],
            vehicle_class=data["vehicle_class"],
            address=data["address"],
            tax_upto=data["tax_upto"],
            verification_status="Pending",
            reason=" | ".join(missing_reasons) if missing_reasons else None,
            **{f"{k}": v["obj"] for k, v in resolved.items()},
            **{f"{k}_name": v["name"] for k, v in resolved.items()},
        )

        vehicle.save()  # Save first to generate ID for folders

        # ---------------- Process and save images ----------------
        self.process_images(vehicle, request, is_update=False)

        vehicle.save()  # Final save after adding images

        # ---------------- Response ----------------
        message = "Waiting for approval" if missing_reasons else "Vehicle created successfully"
        return Response({
            "message": message,
            "vehicle_id": str(vehicle.id),
            "verification_status": vehicle.verification_status,
            "reason": vehicle.reason or ""
        }, status=status.HTTP_201_CREATED)


    def put(self, request, vehicle_id=None):
        if not vehicle_id:
            return Response({"error": "vehicle_id is required in URL"}, status=status.HTTP_400_BAD_REQUEST)

        vehicle = Vehicle.objects(id=vehicle_id).first()
        if not vehicle:
            raise NotFound("Vehicle not found")

        data = request.data
        missing_reasons = []

        # ---------------- Update basic fields ----------------
        update_fields = ["registration_date", "chassis_number", "engine_number", "owner_name",
                        "colour", "doi", "doe", "vehicle_class", "address", "tax_upto"]

        for field in update_fields:
            if field in data:
                setattr(vehicle, field, data[field])

        # ---------------- Resolve references ----------------
        resolved, ref_missing_reasons = self.process_references(data)
        missing_reasons.extend(ref_missing_reasons)

        # Update resolved references
        for k, v in resolved.items():
            setattr(vehicle, k, v["obj"])
            setattr(vehicle, f"{k}_name", v["name"])

        # ---------------- Process images ----------------
        self.process_images(vehicle, request, is_update=True)

        # ---------------- Set reason & verification status ----------------
        vehicle.reason = " | ".join(missing_reasons) if missing_reasons else None

        if "verification_status" in data and getattr(request.user, "role", "") == "admin":
            vehicle.verification_status = data["verification_status"]
        else:
            vehicle.verification_status = "Pending"

        vehicle.save()

        message = "Vehicle updated successfully" if not missing_reasons else "Vehicle updated but references missing"
        return Response({
            "message": message,
            "vehicle_id": str(vehicle.id),
            "verification_status": vehicle.verification_status,
            "reason": vehicle.reason or ""
        }, status=status.HTTP_200_OK)


    def get(self, request, vehicle_id=None):
        # Fetch either a single vehicle or all vehicles
        vehicles = [Vehicle.objects(id=vehicle_id).first()] if vehicle_id else Vehicle.objects.all()

        # Filter out None values
        vehicles = [v for v in vehicles if v]

        # Serialize the data using VehicleReadSerializer
        serializer = VehicleReadSerializer(vehicles, many=True)

        return Response(serializer.data, status=status.HTTP_200_OK)


class VehicleStatusView(APIView):
    def get(self, request):
        vehicles = Vehicle.objects.all()
        serializer = VehicleStatusSerializer(vehicles, many=True)
        return Response(serializer.data)