from rest_framework.views import APIView
from .models import TermType, Terms
from utils.helper import success_response, failed_response ,generate_random_text
from .serializers import TermTypeSerializer, TermsSerializer
from rest_framework import status
from utils.validation import validate_required_params, validate, ValidationError
from utils.logger import record
from utils.data import logger_settings 


log_msg=logger_settings["msg"]
class TermTypeCRUDView(APIView):
    def get(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermTypeCRUDView GET request started')

        try:
            if pk:
                listing_term_type = TermType.objects.get(pk=pk)
                serializer = TermTypeSerializer(listing_term_type)
                record('info', f'{process_code}: {log_msg["completed"]} - Term Type retrieved successfully')
                return success_response(data=serializer.data, msg='Term Type retrieved successfully')
            else:
                listing_term_type = TermType.objects.all()
                serializer = TermTypeSerializer(listing_term_type, many=True)
                record('info', f'{process_code}: {log_msg["completed"]} - Term Types retrieved successfully')
                return success_response(data=serializer.data, msg='Term Types retrieved successfully')

        except TermType.DoesNotExist:
            record('warn', f'{process_code}: Term Type not found')
            return failed_response(msg='Term Type not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term Type retrieval')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def post(self, request, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermTypeCRUDView POST request started')

        try:
            serializer = TermTypeSerializer(data=request.data)
            if serializer.is_valid():
                serializer.save()
                record('info', f'{process_code}: {log_msg["completed"]} - Term Type created successfully')
                return success_response(data=serializer.data, msg='Term Type created successfully')

            record('warn', f'{process_code}: {serializer.errors} - Validation errors during Term Type creation')
            return failed_response(msg=serializer.errors, code=status.HTTP_400_BAD_REQUEST)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term Type creation')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def put(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermTypeCRUDView PUT request started')

        try:
            validate_required_params(request, ['title'])
            validate('title', request.data.get('title', ''), ['title:max:25'])
            term_type = TermType.objects.get(pk=pk)
            serializer = TermTypeSerializer(term_type, data=request.data)
            if serializer.is_valid():
                serializer.save()
                record('info', f'{process_code}: {log_msg["completed"]} - Term Type updated successfully')
                return success_response(data=serializer.data, msg='Term Type updated successfully')

            record('warn', f'{process_code}: {serializer.errors} - Validation errors during Term Type update')
            return failed_response(msg=serializer.errors, code=status.HTTP_400_BAD_REQUEST)

        except TermType.DoesNotExist:
            record('warn', f'{process_code}: Term Type not found for update')
            return failed_response(msg='Term Type not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term Type update')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def delete(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermTypeCRUDView DELETE request started')

        try:
            term_type = TermType.objects.get(pk=pk)
            term_type.delete()
            record('info', f'{process_code}: {log_msg["completed"]} - Term Type deleted successfully')
            return success_response(msg='Term Type deleted successfully')

        except TermType.DoesNotExist:
            record('warn', f'{process_code}: Term Type not found for deletion')
            return failed_response(msg='Term Type not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term Type deletion')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)


class TermsCRUDView(APIView):
    
    def get(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermsCRUDView GET request started')

        try:
            if pk:
                term = Terms.objects.get(pk=pk)
                serializer = TermsSerializer(term)
                record('info', f'{process_code}: {log_msg["completed"]} - Term retrieved successfully')
                return success_response(data=serializer.data, msg='Term retrieved successfully')
            else:
                terms = Terms.objects.all()
                serializer = TermsSerializer(terms, many=True)
                record('info', f'{process_code}: {log_msg["completed"]} - Terms retrieved successfully')
                return success_response(data=serializer.data, msg='Terms retrieved successfully')

        except Terms.DoesNotExist:
            record('warn', f'{process_code}: Term not found')
            return failed_response(msg='Term not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Terms retrieval')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def post(self, request, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermsCRUDView POST request started')

        try:
            serializer = TermsSerializer(data=request.data)
            if serializer.is_valid():
                serializer.save()
                record('info', f'{process_code}: {log_msg["completed"]} - Term created successfully')
                return success_response(data=serializer.data, msg='Term created successfully')

            record('warn', f'{process_code}: {serializer.errors} - Validation errors during Term creation')
            return failed_response(msg=serializer.errors, code=status.HTTP_400_BAD_REQUEST)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term creation')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def put(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermsCRUDView PUT request started')

        try:
            validate_required_params(request, ['title', 'term_type'])
            validate('title', request.data.get('title', ''), ['title:max:100'])
            term = Terms.objects.get(pk=pk)
            serializer = TermsSerializer(term, data=request.data)
            if serializer.is_valid():
                serializer.save()
                record('info', f'{process_code}: {log_msg["completed"]} - Term updated successfully')
                return success_response(data=serializer.data, msg='Term updated successfully')

            record('warn', f'{process_code}: {serializer.errors} - Validation errors during Term update')
            return failed_response(msg=serializer.errors, code=status.HTTP_400_BAD_REQUEST)

        except Terms.DoesNotExist:
            record('warn', f'{process_code}: Term not found for update')
            return failed_response(msg='Term not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term update')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def delete(self, request, pk=None, format=None):
        process_code = generate_random_text(6)
        record('info', f'{process_code}: {log_msg["started"]} - TermsCRUDView DELETE request started')

        try:
            term = Terms.objects.get(pk=pk)
            term.delete()
            record('info', f'{process_code}: {log_msg["completed"]} - Term deleted successfully')
            return success_response(msg='Term deleted successfully')

        except Terms.DoesNotExist:
            record('warn', f'{process_code}: Term not found for deletion')
            return failed_response(msg='Term not found', code=status.HTTP_404_NOT_FOUND)

        except Exception as e:
            record('error', f'{process_code}: {str(e)} - Unexpected error occurred during Term deletion')
            return failed_response(msg='An unexpected error occurred', code=status.HTTP_500_INTERNAL_SERVER_ERROR)