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 (
    AccessoriesReadSerializer,
    AccessoriesStatusSerializer,
)
from mongoengine.errors import NotUniqueError
from rest_framework import status
from rest_framework.response import Response
from .models import Accessories
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
from django.conf import settings


class AccessoriesView(APIView):
    """
    Handles creating (POST), updating (PUT), and retrieving (GET) Accessories.
    Supports multipart/form-data and base64-encoded image uploads.
    """

    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]

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

    # ---------------- Helper: Resolve References ----------------
    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

    # ---------------- Helper: Process References ----------------
    def process_references(self, data):
        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

    # ---------------- Helper: Base64 → File ----------------
    def base64_to_file(self, b64_string, filename):
        """Convert 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

    # ---------------- Helper: Handle Images ----------------
    def process_images(self, accessory, request, is_update=False):
        """Process uploaded or base64 images"""
        files = request.FILES.getlist("images", [])

        # If no multipart files, try JSON base64 uploads
        if not files:
            b64_list = request.data.get("images", [])
            if isinstance(b64_list, list):
                for i, b64_str in enumerate(b64_list):
                    f = self.base64_to_file(b64_str, f"image_{i}.png")
                    if f:
                        files.append(f)

        if not files:
            return

        try:
            if is_update:
                accessory.replace_images(files)
            else:
                accessory.save_images(files)
        except Exception as e:
            print(f"Image processing failed: {str(e)}")

    # ---------------- POST ----------------
    def post(self, request):
        data = request.data

        # Validate required field
        if not data.get("dop"):
            return Response({"error": "Date of Purchase (dop) is required."}, status=status.HTTP_400_BAD_REQUEST)

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

        try:
            # Create accessory
            accessory = Accessories(
            dop=datetime.strptime(data["dop"], "%Y-%m-%d"),
            colour=data.get("colour"),
            price=float(data.get("price")) if data.get("price") else None,  # ✅ NEW
            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()},
        )


            accessory.save()  # <-- Might throw NotUniqueError if duplicate combo exists

            # Handle images
            self.process_images(accessory, request, is_update=False)
            accessory.save()

            message = "Waiting for approval" if missing_reasons else "Accessory created successfully"

            return Response(
                {
                    "message": message,
                    "accessory_id": str(accessory.id),
                    "verification_status": accessory.verification_status,
                    "reason": accessory.reason or "",
                },
                status=status.HTTP_201_CREATED,
            )

        except NotUniqueError:
            return Response(
                {
                    "error": "An accessory with the same Partner, Submodel, and Pickup Point already exists."
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
        except Exception as e:
            return Response(
                {
                    "error": f"Something went wrong: {str(e)}"
                },
                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
            )

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

        accessory = Accessories.objects(id=accessory_id).first()
        if not accessory:
            raise NotFound("Accessory not found")

        data = request.data
        missing_reasons = []

        # Update basic fields
        if "dop" in data:
            accessory.dop = datetime.strptime(data["dop"], "%Y-%m-%d")
        if "colour" in data:
            accessory.colour = data["colour"]
        if "price" in data:  # ✅ NEW
            try:
                accessory.price = float(data["price"])
            except (ValueError, TypeError):
                return Response({"error": "Invalid price format"}, status=status.HTTP_400_BAD_REQUEST)


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

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

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

        # Verification logic
        accessory.reason = " | ".join(missing_reasons) if missing_reasons else None
        if "verification_status" in data and getattr(request.user, "role", "") == "admin":
            accessory.verification_status = data["verification_status"]
        else:
            accessory.verification_status = "Pending"

        accessory.save()

        message = "Accessory updated successfully" if not missing_reasons else "Accessory updated with warnings"
        return Response(
            {
                "message": message,
                "accessory_id": str(accessory.id),
                "verification_status": accessory.verification_status,
                "reason": accessory.reason or "",
            },
            status=status.HTTP_200_OK,
        )

    # ---------------- GET ----------------
    def get(self, request, accessory_id=None):
        accessories = [Accessories.objects(id=accessory_id).first()] if accessory_id else Accessories.objects.all()
        accessories = [a for a in accessories if a]

        serializer = AccessoriesReadSerializer(accessories, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


# ---------------- STATUS VIEW ----------------
class AccessoriesStatusView(APIView):
    """Lightweight list view for accessories status tracking"""

    def get(self, request):
        accessories = Accessories.objects.all()
        serializer = AccessoriesStatusSerializer(accessories, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)
