from rest_framework.pagination import PageNumberPagination
from rest_framework.response import Response
from rest_framework.views import APIView
from api.serializers import UserSerializer, SellerSerializer, CategorySerializer, EventPageTemplateSerializer, EventSerializer, TicketTypeTemplateSerializer, TicketTypeSerializer, TicketSerializer
from backoffice.models import *

 

class UserAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = User.objects.get(pk=id)
            serializer = UserSerializer(item)
            return Response(serializer.data)
        except User.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = User.objects.get(pk=id)
        except User.DoesNotExist:
            return Response(status=404)
        serializer = UserSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = User.objects.get(pk=id)
        except User.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class UserAPIListView(APIView):

    def get(self, request, format=None):
        items = User.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = UserSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class SellerAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = Seller.objects.get(pk=id)
            serializer = SellerSerializer(item)
            return Response(serializer.data)
        except Seller.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = Seller.objects.get(pk=id)
        except Seller.DoesNotExist:
            return Response(status=404)
        serializer = SellerSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = Seller.objects.get(pk=id)
        except Seller.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class SellerAPIListView(APIView):

    def get(self, request, format=None):
        items = Seller.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = SellerSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = SellerSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class CategoryAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = Category.objects.get(pk=id)
            serializer = CategorySerializer(item)
            return Response(serializer.data)
        except Category.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = Category.objects.get(pk=id)
        except Category.DoesNotExist:
            return Response(status=404)
        serializer = CategorySerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = Category.objects.get(pk=id)
        except Category.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class CategoryAPIListView(APIView):

    def get(self, request, format=None):
        items = Category.objects.order_by('name')
        paginator = PageNumberPagination()
        paginator.page_size = 30
        result_page = paginator.paginate_queryset(items, request)
        serializer = CategorySerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)
       

    def post(self, request, format=None):
        serializer = CategorySerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class EventPageTemplateAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = EventPageTemplate.objects.get(pk=id)
            serializer = EventPageTemplateSerializer(item)
            return Response(serializer.data)
        except EventPageTemplate.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = EventPageTemplate.objects.get(pk=id)
        except EventPageTemplate.DoesNotExist:
            return Response(status=404)
        serializer = EventPageTemplateSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = EventPageTemplate.objects.get(pk=id)
        except EventPageTemplate.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class EventPageTemplateAPIListView(APIView):

    def get(self, request, format=None):
        items = EventPageTemplate.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = EventPageTemplateSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = EventPageTemplateSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class EventAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = Event.objects.get(pk=id)
            serializer = EventSerializer(item)
            return Response(serializer.data)
        except Event.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = Event.objects.get(pk=id)
        except Event.DoesNotExist:
            return Response(status=404)
        serializer = EventSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = Event.objects.get(pk=id)
        except Event.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class EventAPIListView(APIView):

    def get(self, request, format=None):
        items = Event.objects.order_by('name')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = EventSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = EventSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

    def get_queryset(self):
        """
        Optionally restricts the returned events to a given refOrganizer,
        by filtering against a `refOrganizer` query parameter in the URL.
        """
        queryset = Event.objects.all().select_related("refOrganizer").select_related("refCategory").select_related("refEventPageTemplate")
        refOrganizer = self.request.query_params.get('refOrganizer')
        if refOrganizer is not None:
            queryset = queryset.filter(refOrganizer=refOrganizer)
        return queryset

 


class TicketTypeTemplateAPIListView(APIView):

    def get(self, request, format=None):
        items = TicketTypeTemplate.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = TicketTypeTemplateSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = TicketTypeTemplateSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class TicketTypeAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = TicketType.objects.get(pk=id)
            serializer = TicketTypeSerializer(item)
            return Response(serializer.data)
        except TicketType.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = TicketType.objects.get(pk=id)
        except TicketType.DoesNotExist:
            return Response(status=404)
        serializer = TicketTypeSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = TicketType.objects.get(pk=id)
        except TicketType.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class TicketTypeAPIListView(APIView):

    def get(self, request, format=None):
        items = TicketType.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = TicketTypeSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = TicketTypeSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)


class TicketAPIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = Ticket.objects.get(pk=id)
            serializer = TicketSerializer(item)
            return Response(serializer.data)
        except Ticket.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = Ticket.objects.get(pk=id)
        except Ticket.DoesNotExist:
            return Response(status=404)
        serializer = TicketSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = Ticket.objects.get(pk=id)
        except Ticket.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)


class TicketAPIListView(APIView):

    def get(self, request, format=None):
        items = Ticket.objects.order_by('pk')
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = TicketSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = TicketSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)