from actions.dynamic_import.dynamic_import import DynamicImport

# Importa os serviços com o prefixo 'ato_principal'
from packages.v1.administrativo.services.ato_principal.ato_principal_index_service import (
    IndexService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_save_service import (
    SaveService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_save_multiple_service import (
    SaveMultipleService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_show_service import (
    ShowService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_show_atos_service import (
    ShowAtosService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_update_service import (
    UpdateService,
)
from packages.v1.administrativo.services.ato_principal.ato_principal_delete_service import (
    DeleteService,
)

# Importa os Schemas com o prefixo 'ato_principal'
from packages.v1.administrativo.schemas.ato_principal_schema import (
    AtoPrincipalSchema,
    AtoPrincipalSaveSchema,
    AtoPrincipalUpdateSchema,
    AtoPrincipalIdSchema,
    AtoPrincipalCodigoAtoSchema,
)


# Mantendo o padrão de nome de classe
class AtoPrincipalController:
    """
    Controller responsável pelas operações CRUD da entidade Ato Principal.
    """

    def __init__(self):
        # Action responsável por carregar as services de acodo com o estado
        self.dynamic_import = DynamicImport()

        # Define o pacote que deve ser carregado
        self.dynamic_import.set_package("administrativo")

        # Define a tabela que o pacote pertence (agora 'ato_principal')
        self.dynamic_import.set_table("ato_principal")
        pass

    # Lista todos os atos principais
    def index(self):

        # Instânciamento da classe service
        index_service = IndexService()

        # Lista todos os atos principais
        return {
            "message": "Atos Principais localizados com sucesso",
            "data": index_service.execute(),
        }

    # Busca um ato principal especifica pelo ID
    def show(self, ato_principal_schema: AtoPrincipalSchema):

        # Instânciamento da classe desejada
        show_service = ShowService()

        # Busca e retorna o ato principal desejado
        return {
            "message": "Ato Principal localizado com sucesso",
            "data": show_service.execute(ato_principal_schema),
        }

    # Busca um ato principal especifico e suas dependências pelo codigo do ato
    def showAtos(self, ato_principal_schema: AtoPrincipalCodigoAtoSchema):

        # Instânciamento da classe desejada
        show_service = ShowAtosService()

        # Busca e retorna o ato principal desejado com suas dependências
        return {
            show_service.execute(ato_principal_schema),
        }

    # Cadastra um novo ato principal
    def save(self, ato_principal_schema: AtoPrincipalSaveSchema):

        # Instânciamento da classe desejada
        save_service = SaveService()

        # Salva e retorna o ato principal
        return {
            "message": "Ato Principal salvo com sucesso",
            "data": save_service.execute(ato_principal_schema),
        }

    # Cadastra múltiplos itens
    def save_multiple(self, atos_principais: list[AtoPrincipalSaveSchema]):
        # A lista completa é passada diretamente para o Service.
        # O Service e o Action também devem ser corrigidos para parar de iterar.
        save_service = SaveMultipleService()

        responses = save_service.execute(atos_principais)

        return {
            "message": "Processamento de múltiplos atos concluído",
            "results": responses,  # O Service já retorna a lista de resultados
        }

    # Atualiza os dados de um ato principal
    def update(
        self, ato_principal_id: int, ato_principal_schema: AtoPrincipalUpdateSchema
    ):

        # Instânciamento da classe desejada
        update_service = UpdateService()

        # Atualiza e retorna o ato principal
        return {
            "message": "Ato Principal atualizado com sucesso",
            "data": update_service.execute(ato_principal_id, ato_principal_schema),
        }

    # Exclui um ato principal
    def delete(self, ato_principal_schema: AtoPrincipalSchema):

        # Instânciamento da classe desejada
        delete_service = DeleteService()

        # Exclui e retorna a parte desejada
        return {
            "message": "Ato Principal removido com sucesso",
            "data": delete_service.execute(ato_principal_schema),
        }