"""
Validation request models.
"""

from typing import TYPE_CHECKING, Dict, Any, Literal, Optional, TypedDict, Union
from pydantic import BaseModel, Field, model_validator, RootModel, ConfigDict

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

from ApiEvents.abstract_class import MethodToEvent
from ApiEvents.base_request_model import BaseRequestModel, DictRequestModel

from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
from ApiValidations.Request.base_validations import ListOptions

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


if TYPE_CHECKING:
    from fastapi import Request


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)
        print("return_single_model", return_single_model, type(return_single_model))
        # 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)
        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]:
        return {}


class ValidationsHeaders(MethodToEvent):

    @classmethod
    def retrieve_headers(
        cls, event: ValidationsPydantic
    ) -> Dict[str, Any]:
        return {}