from django.shortcuts import get_object_or_404

from rest_framework.views import APIView
from rest_framework.permissions import AllowAny, IsAuthenticated

from rest_framework import status
from rest_framework.response import Response
from django.core.mail import EmailMessage
from django.db import transaction

from .serializers import *
from .services import *
from common.models.choiceModels import CertificateCodeUseType
from common.utils.codeManger import generate_code


CERTIFICATE_SERVICE_USE_TYPE = {
    "phone": SmsService,
    # "email": EmailService
}

INVITE_USE_TYPE = {
    "p": {
        "word": "project",
        "service": ProjectInviteService,
        "model": Project,
        "team_model": ProjectTeamList
    }
    # "h": HackathonInviteService
}

class CertificationAPIView(APIView):
    permission_classes = [AllowAny]

    # 인증 발송
    @transaction.atomic
    def post(self, request):
        use_type = request.query_params.get("type")
        if use_type not in CERTIFICATE_SERVICE_USE_TYPE:
            return Response({"message": "Not defined use_type"}, status=status.HTTP_400_BAD_REQUEST)
        serv = CERTIFICATE_SERVICE_USE_TYPE[use_type]
        serializer = CertificateCodeSerializer(data=request.data)
        if serializer.is_valid():
            create_code = generate_code(6)
            if serv.save_certificate_info(use_type, create_code, serializer.validated_data['identifier']):
                if serv.send(create_code, serializer.validated_data['identifier']):
                    return Response({'message': "success send and save"})
                else: # 전송 실패
                    return Response({"message": "failed send"})
            else: # 코드 저장 실패
                return Response({'message': "failed save"}, status=status.HTTP_400_BAD_REQUEST)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    
    # 인증 확인
    @transaction.atomic
    def patch(self, request):
        use_type = request.query_params.get("type")
        purpose = request.query_params.get("purpose")

        if use_type not in CERTIFICATE_SERVICE_USE_TYPE:
            return Response({"message": "Not defined use_type"}, status=status.HTTP_400_BAD_REQUEST)
        
        serv = CERTIFICATE_SERVICE_USE_TYPE[use_type]
        code = request.data.get('code', None)
        if not code:
            return Response({"message": "no code"}, status=status.HTTP_400_BAD_REQUEST)
        
        serializer = CertificateCodeSerializer(data=request.data)

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

        identifier = serializer.validated_data["identifier"]

        if not serv.check_code(use_type, code, identifier):
            return Response({"message": "wrong code or already used code, please retry send code"}, status=status.HTTP_400_BAD_REQUEST)
        
        if purpose == "password_reset":
            user = User.objects.filter(phone=identifier).first()
            if not user:
                return Response({"message": "user not found"}, status=status.HTTP_404_NOT_FOUND)

            temp_access_token = PasswordResetTokenService.issue_temp_access_token(
                user_id=user.id,
                identifier=identifier,
                use_type=use_type,
            )

            return Response(
                {"message": "certificated successfully", "temp_access_token": temp_access_token},
                status=status.HTTP_200_OK
            )

        return Response({"message": "certificated successfully"}, status=status.HTTP_200_OK)

class InviteByLinkAPIView(APIView):
    
    # 링크 초대(복사)
    @transaction.atomic
    def post(self, request):
        use_type = request.query_params.get("type")
        if use_type not in INVITE_USE_TYPE:
            return Response({"message": "Not defined use_type"}, status=status.HTTP_400_BAD_REQUEST)
        
        serv = INVITE_USE_TYPE[use_type]['service']
        user = request.user
        serializer = InviteCodeSerializer(data=request.data)
        if serializer.is_valid():
            work = get_object_or_404(INVITE_USE_TYPE[use_type]['model'], id=serializer.validated_data['identifier'])
            if user != work.owner: # 유저 권한 추가될 시 수정 필요
                return Response({"message": "Not owner"}, status=status.HTTP_403_FORBIDDEN)
            
            create_code = generate_code(10)
            invite_url = serv.create_invite_object_and_url(use_type, serializer.validated_data['identifier'], create_code)
            return Response({"invite_url": invite_url})

    # 링크 확인
    @transaction.atomic
    def patch(self, request):
        use_type = request.query_params.get("type")
        if use_type not in INVITE_USE_TYPE:
            return Response({"message": "Not defined use_type"}, status=status.HTTP_400_BAD_REQUEST)
        
        serv = INVITE_USE_TYPE[use_type]['service']
        user = request.user
        serializer = InviteCodeSerializer(data=request.data)
        if serializer.is_valid():
            if not serv.check_code(use_type, serializer.validated_data['identifier'], serializer.validated_data['code']):
                return Response({"message": "Not correct or expired code"}, status=status.HTTP_400_BAD_REQUEST)
            
            work = get_object_or_404(INVITE_USE_TYPE[use_type]['model'], id=serializer.validated_data['identifier'])
            filter_dict = {INVITE_USE_TYPE[use_type]['word']:work}
            
            if INVITE_USE_TYPE[use_type]['team_model'].objects.filter(user=user, **filter_dict).exists():
                return Response({"message": "already invited member"}, status=status.HTTP_400_BAD_REQUEST)
            
            if serv.add_member(user, work):
                return Response({"message": "invite success"}, status=status.HTTP_200_OK)
            return Response({"message": "invite failed"}, status=status.HTTP_400_BAD_REQUEST)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)