from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

from accounts.models import Partner
from .models import Place
from .serializers import PlaceSerializer, PlaceSummarySerializer
from .authentication import JWTAuthentication
from .permissions import MethodRolePermission


class PlaceCreateView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"POST": ["admin", "partner"]}
    serializer_class = PlaceSerializer
    model = Place

    def post(self, request):
        role = getattr(request.user, "role", "partner")  # get from token/user

        # Combine data + files for serializer
        data = request.data.copy()
        if "images" in request.FILES:
            data.setlist("images", request.FILES.getlist("images"))

        serializer = self.serializer_class(data=data, context={"role": role})

        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        try:
            place = serializer.save()
            return Response(
                {
                    "message": f"Place '{place.name}' created successfully.",
                    "data": self.serializer_class(place).data,
                },
                status=status.HTTP_201_CREATED,
            )
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)


class PartnerPickupPointsView(APIView):
    """
    GET /api/places/partner/<partner_id>/
    Fetch all pickup points belonging to a specific partner.
    Linked through partner's phone number.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"GET": ["admin", "partner"]}

    def get(self, request, partner_id):
        try:
            # Step 1: Find the partner by ID
            partner = Partner.objects(id=partner_id).first()
            if not partner:
                return Response(
                    {"error": "Partner not found"},
                    status=status.HTTP_404_NOT_FOUND
                )

            # Step 2: Get partner phone number
            partner_phone = partner.phone_number

            # Step 3: Fetch all places with that phone number
            places = Place.objects(poc=partner_phone)

            if not places:
                return Response(
                    {"message": "No pickup points found for this partner"},
                    status=status.HTTP_404_NOT_FOUND
                )

            # Step 4: Serialize and return
            serializer = PlaceSerializer(places, many=True)
            return Response({
                "partner_id": str(partner.id),
                "partner_phone_number": partner_phone,
                "pickup_points": serializer.data
            }, status=status.HTTP_200_OK)

        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
                
class PlaceDetailView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"],  # Public
        "PUT": ["admin", "partner"],  # Restricted
    }
    serializer_class = PlaceSerializer
    model = Place

    def get(self, request, pk=None):
        if pk:
            try:
                place = self.model.objects.get(id=pk)
            except self.model.DoesNotExist:
                return Response({"error": "Place not found"}, status=status.HTTP_404_NOT_FOUND)
            return Response(self.serializer_class(place).data, status=status.HTTP_200_OK)

        places = self.model.objects()
        return Response(self.serializer_class(places, many=True).data, status=status.HTTP_200_OK)

    def put(self, request, pk=None):
        if not pk:
            return Response({"error": "Place ID is required"}, status=status.HTTP_400_BAD_REQUEST)

        try:
            place = self.model.objects.get(id=pk)
        except self.model.DoesNotExist:
            return Response({"error": "Place not found"}, status=status.HTTP_404_NOT_FOUND)

        role = getattr(request.user, "role", "partner")
        data = request.data.copy()

        print("==== Incoming request data ====")
        print(data)

        # Handle uploaded files
        if "images" in request.FILES:
            file_list = request.FILES.getlist("images")
            data.setlist("images", file_list)
            print("==== Incoming files ====")
            for f in file_list:
                print(f.name, f.size)

        serializer = self.serializer_class(place, data=data, context={"role": role})
        if not serializer.is_valid():
            print("==== Serializer errors ====")
            print(serializer.errors)
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        # Serializer handles replacing old images with new ones
        place = serializer.save()

        print("==== Updated place images ====")
        print(place.images)

        return Response({
            "status": True,
            "message": f"Place '{place.name}' updated successfully.",
            "data": self.serializer_class(place).data,
        }, status=status.HTTP_200_OK)


class PlacesByCityView(APIView):
    """
    GET /api/places/by-city/?city=<city_name>
    Fetch all places belonging to a specific city.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"GET": ["admin", "partner","customer"]}

    def get(self, request):
        city_name = request.query_params.get("city")
        if not city_name:
            return Response({"error": "City name is required in query params"}, status=status.HTTP_400_BAD_REQUEST)

        try:
            places = Place.objects(city__iexact=city_name)
            if not places:
                return Response({"message": f"No places found for city '{city_name}'"}, status=status.HTTP_404_NOT_FOUND)

            serializer = PlaceSerializer(places, many=True)
            return Response({
                "city": city_name,
                "places": serializer.data
            }, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)

class CityListView(APIView):
    """
    GET /api/places/cities/
    Fetch all unique city names where places exist.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"GET": ["admin", "partner","customer"]}

    def get(self, request):
        try:
            cities = Place.objects.distinct("city")
            if not cities:
                return Response({"message": "No cities found"}, status=status.HTTP_404_NOT_FOUND)

            return Response({"cities": sorted(cities)}, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)

    
class PlaceSummaryListView(APIView):
    """
    List all places (Admin only) with summarized fields: ID, Name, Address, Status1, Status2.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"]
    }

    def get(self, request):
        places = Place.objects()
        place_list = []
        for place in places:
            serialized = PlaceSummarySerializer(place).data
            place_list.append(serialized)
        return Response({"places": place_list}, status=status.HTTP_200_OK)