"""Junior view file"""
from rest_framework import viewsets, status, generics,views
from rest_framework.permissions import IsAuthenticated
from rest_framework.pagination import PageNumberPagination
from rest_framework.response import Response
from PIL import Image
"""Django app import"""
from junior.models import Junior
from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
                          RemoveJuniorSerializer)
from guardian.models import Guardian
from base.messages import ERROR_CODE, SUCCESS_CODE
from base.constants import NUMBER
from account.utils import custom_response, custom_error_response
from guardian.utils import upload_image_to_alibaba
# Create your views here.
class UpdateJuniorProfile(viewsets.ViewSet):
    """Update junior profile"""
    queryset = Junior.objects.all()
    serializer_class = CreateJuniorSerializer
    permission_classes = [IsAuthenticated]

    def create(self, request, *args, **kwargs):
        """Use CreateJuniorSerializer"""
        request_data = request.data
        image = request.data.get('image')
        image_url = ''
        if image.size == NUMBER['zero']:
            return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
        if image:
            filename = f"images/{image.name}"
            image_url = upload_image_to_alibaba(image, filename)
            request_data = {"image": image_url}
        serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url,
                                                     "first_name": request.data.get('first_name'),
                                                     "last_name": request.data.get('last_name')
                                                     },
                                            data=request_data)
        if serializer.is_valid():
            """save serializer"""
            serializer.save()
            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
        return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)

class ValidateGuardianCode(viewsets.ViewSet):
    """Check guardian code exist or not"""
    queryset = Guardian.objects.all()
    permission_classes = [IsAuthenticated]

    def list(self, request, *args, **kwargs):
        """check guardian code"""
        guardian_code = self.request.GET.get('guardian_code').split(',')
        for code in guardian_code:
            guardian_data = Guardian.objects.filter(guardian_code=code).exists()
            if guardian_data:
                return custom_response(SUCCESS_CODE['3013'], response_status=status.HTTP_200_OK)
            else:
                return custom_error_response(ERROR_CODE["2022"], response_status=status.HTTP_400_BAD_REQUEST)

class JuniorListAPIView(viewsets.ModelViewSet):
    """Junior list of assosicated guardian"""

    serializer_class = JuniorDetailListSerializer
    queryset = Junior.objects.all()
    def list(self, request, *args, **kwargs):
        """ junior list"""
        guardian_data = Guardian.objects.filter(user__email=request.user).last()
        queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
        serializer = JuniorDetailListSerializer(queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)

class AddJuniorAPIView(viewsets.ModelViewSet):
    """Add Junior by guardian"""
    queryset = Junior.objects.all()
    serializer_class = AddJuniorSerializer
    permission_classes = [IsAuthenticated]
    def create(self, request, *args, **kwargs):
        """ junior list"""
        info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
                'last_name': request.data['last_name']}
        serializer = AddJuniorSerializer(data=request.data, context=info)
        if serializer.is_valid():
            serializer.save()
            return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK)
        return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)

class InvitedJuniorAPIView(viewsets.ModelViewSet):
    """Junior list of assosicated guardian"""

    serializer_class = JuniorDetailListSerializer
    queryset = Junior.objects.all()
    permission_classes = [IsAuthenticated]
    pagination_class = PageNumberPagination

    def get_queryset(self):
        """Get the queryset for the view"""
        guardian = Guardian.objects.filter(user__email=self.request.user).last()
        junior_queryset = Junior.objects.filter(guardian_code__icontains=str(guardian.guardian_code),
                                         is_invited=True)
        return junior_queryset
    def list(self, request, *args, **kwargs):
        """ junior list"""
        queryset = self.get_queryset()
        paginator = self.pagination_class()
        paginated_queryset = paginator.paginate_queryset(queryset, request)
        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)


class FilterJuniorAPIView(viewsets.ModelViewSet):
    """Update guardian profile"""
    serializer_class = JuniorDetailListSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = PageNumberPagination
    queryset = Junior.objects.all()

    def get_queryset(self):
        """Get the queryset for the view"""
        title = self.request.GET.get('title')
        guardian_data = Guardian.objects.filter(user__email=self.request.user).last()
        queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code),
                                         is_invited=True, auth__first_name=title)
        return queryset

    def list(self, request, *args, **kwargs):
        """Create guardian profile"""
        queryset = self.get_queryset()
        paginator = self.pagination_class()
        paginated_queryset = paginator.paginate_queryset(queryset, request)
        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)


class RemoveJuniorAPIView(views.APIView):
    """Eater Update API"""
    serializer_class = RemoveJuniorSerializer
    model = Junior
    permission_classes = [IsAuthenticated]

    def put(self, request, format=None):
        junior_id = self.request.GET.get('id')
        guardian = Guardian.objects.filter(user__email=self.request.user).last()
        junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code),
                                                is_invited=True).last()
        if junior_queryset:
            serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
            if serializer.is_valid():
                serializer.save()
                return custom_response(SUCCESS_CODE['3022'], serializer.data, response_status=status.HTTP_200_OK)
            return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
        else:
            return custom_error_response(ERROR_CODE['2034'], response_status=status.HTTP_400_BAD_REQUEST)