"""
Validation request models.
"""

from typing import TYPE_CHECKING, Dict, Any

from ApiEvents.abstract_class import MethodToEvent
from ApiLibrary.common.line_number import get_line_number_for_error
from ApiValidations.Custom.validation_response import ValidationModel, ValidationParser

from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
from .models import ValidationsPydantic


class AllModelsImport:

    @classmethod
    def import_all_models(cls):
        from ApiEvents.events.account.account_records import (
            AccountListEventMethod,
            AccountUpdateEventMethod,
            AccountCreateEventMethod,
        )
        from ApiEvents.events.address.address import (
            AddressListEventMethod,
            AddressUpdateEventMethod,
            AddressCreateEventMethod,
            AddressSearchEventMethod,
        )
        return dict(
            AccountListEventMethod=AccountListEventMethod,
            AccountUpdateEventMethod=AccountUpdateEventMethod,
            AccountCreateEventMethod=AccountCreateEventMethod,
            AddressListEventMethod=AddressListEventMethod,
            AddressUpdateEventMethod=AddressUpdateEventMethod,
            AddressCreateEventMethod=AddressCreateEventMethod,
            AddressSearchEventMethod=AddressSearchEventMethod,
        )


class ValidationsBoth(MethodToEvent):

    @classmethod
    def retrieve_both_validations_and_headers(cls, event: ValidationsPydantic) -> Dict[str, Any]:
        EVENT_MODELS = AllModelsImport.import_all_models()
        return_single_model = EVENT_MODELS.get(event.class_model, None)
        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
        if not return_single_model:
            raise HTTPExceptionApi(
                error_code="",
                lang="en",
                loc=get_line_number_for_error(),
                sys_msg="Validation code not found",
            )
        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
        language_model_all = return_single_model.retrieve_language_parameters(
            function_code=event.reachable_event_code, language=event.lang
        )
        language_model = language_model_all.get("language_model", None)
        language_models = language_model_all.get("language_models", None)

        validation = ValidationModel(response_model, language_model, language_models)
        """
            Headers: Headers which is merged with response model && language models of event 
            Validation: Validation of event which is merged with response model && language models of event
        """
        return {
            "headers": validation.headers,
            "validation": validation.validation,
            # "language_models": language_model_all,
        }


class ValidationsValidations(MethodToEvent):

    @classmethod
    def retrieve_validations(cls, event: ValidationsPydantic) -> Dict[str, Any]:
        EVENT_MODELS = AllModelsImport.import_all_models()
        return_single_model = EVENT_MODELS.get(event.class_model, None)
        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
        if not return_single_model:
            raise HTTPExceptionApi(
                error_code="",
                lang="en",
                loc=get_line_number_for_error(),
                sys_msg="Validation code not found",
            )
        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
        language_model_all = return_single_model.retrieve_language_parameters(
            function_code=event.reachable_event_code, language=event.lang
        )
        language_model = language_model_all.get("language_model", None)
        language_models = language_model_all.get("language_models", None)

        validation = ValidationModel(response_model, language_model, language_models)
        """
            Headers: Headers which is merged with response model && language models of event 
            Validation: Validation of event which is merged with response model && language models of event
        """
        return {
            "validation": validation.validation,
            # "headers": validation.headers,
            # "language_models": language_model_all,
        }


class ValidationsHeaders(MethodToEvent):

    @classmethod
    def retrieve_headers(cls, event: ValidationsPydantic
) -> Dict[str, Any]:
        EVENT_MODELS = AllModelsImport.import_all_models()
        return_single_model = EVENT_MODELS.get(event.class_model, None)
        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
        if not return_single_model:
            raise HTTPExceptionApi(
                error_code="",
                lang="en",
                loc=get_line_number_for_error(),
                sys_msg="Validation code not found",
            )
        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
        language_model_all = return_single_model.retrieve_language_parameters(
            function_code=event.reachable_event_code, language=event.lang
        )
        language_model = language_model_all.get("language_model", None)
        language_models = language_model_all.get("language_models", None)

        validation = ValidationModel(response_model, language_model, language_models)
        """
            Headers: Headers which is merged with response model && language models of event 
            Validation: Validation of event which is merged with response model && language models of event
        """
        return {
            "headers": validation.headers,
            # "validation": validation.validation,
            # "language_models": language_model_all,
        }