from actions.dynamic_import.dynamic_import import DynamicImport
from packages.v1.administrativo.schemas.log_schema import (
    LogSchema,
    LogAuthenticateSchema,
    LogSaveSchema,
    LogUpdateSchema,
    LogIdSchema,
    LogFileSchema,
    LogClientIdSchema
)

import json # Necessário para carregar o arquivo app.json
import math

# Carrega as configurações de paginação do app.json
with open('config/app.json', 'r') as f:
    app_config = json.load(f)
    PAGINATION_FIRST = app_config.get('pagination', {}).get('first', 20)
    PAGINATION_SKIP = app_config.get('pagination', {}).get('skip', 0)


class LogController:
    """
    Controller responsável por orquestrar as operações (CRUD e outras buscas) 
    para a tabela 'log'.
    """

    def __init__(self):
        # Action responsável por carregar as services de acordo 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
        self.dynamic_import.set_table("log")
        pass

    # Efetua a busca por algum critério de autenticação/filtro
    def authenticate(self, log_authenticate_schema: LogAuthenticateSchema):
        
        # Importação de service de Authenticate
        authenticate_service = self.dynamic_import.service("log_authenticate_service", "AuthenticateService")

        # Instânciamento da service
        self.authenticate_service = authenticate_service()

        # Retorna o log ou logs localizados
        return {
            'message': 'Log(s) localizado(s) com sucesso',
            'data': self.authenticate_service.execute(log_authenticate_schema)
        }

    # Carrega os dados de um log (adaptado de 'me' para logs, se aplicável)
    def me(self, current_log):
        # Esta função é incomum para um log, mas adaptada do original 'me' (usuário logado)
        
        # Importação de service de me
        me_service = self.dynamic_import.service("log_me_service", "MeService")

        # Instânciamento da service
        self.me_service = me_service()

        # Retorna o log completo
        return {
            'message': 'Log localizado com sucesso',
            'data': self.me_service.execute(current_log)
        }

    # Lista todos os logs com paginação
    def index(self, first: int = PAGINATION_FIRST, skip: int = PAGINATION_SKIP):
        
        # Importação da classe desejada
        indexService = self.dynamic_import.service("log_index_service", "IndexService")

        # Instânciamento da classe service
        self.indexService = indexService()

        # Lista todos os logs, recebendo a lista de dados e o total de registros
        data, total_records = self.indexService.execute(first, skip)

        # Cálculo dos metadados de paginação
        total_pages = math.ceil(total_records / first)
        current_page = (skip // first) + 1
        
        next_page = None
        # Verifica se existe uma próxima página
        if current_page < total_pages:
            next_page = current_page + 1

        # Retorna a lista de logs e os metadados de paginação
        return {
            'message': 'Logs localizados com sucesso',
            'data': data,
            'pagination': {
                'total_records': total_records,
                'total_pages': total_pages,
                'current_page': current_page,
                'next_page': next_page,
                'first': first, # Total de registros por página
                'skip': skip # Registros pulados
            }
        }

    # Busca um log específico pelo ID (log_id)
    def show(self, log_schema: LogSchema):

        #Importação da classe desejada
        show_service = self.dynamic_import.service('log_show_service', 'ShowService')

        # Instânciamento da classe desejada
        self.show_service = show_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Log localizado com sucesso',
            'data': self.show_service.execute(log_schema)
        }

    # Busca um log específico pelo campo 'file' (adaptado de getEmail)
    def getFile(self, log_schema: LogFileSchema):

        # Importação da classe desejada
        get_file_service = self.dynamic_import.service('log_get_file_service', 'GetFileService')

        # Instânciamento da classe desejada
        self.get_file_service = get_file_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Arquivo localizado com sucesso no log',
            'data': self.get_file_service.execute(log_schema, True) 
        }       

    # Cadastra um novo log
    def save(self, log_schema: LogSaveSchema):

        #Importação da classe desejada
        save_service = self.dynamic_import.service('log_save_service', 'LogSaveService')

        # Instânciamento da classe desejada
        self.save_service = save_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Log salvo com sucesso',
            'data': self.save_service.execute(log_schema)
        }

    # Atualiza os dados de um log
    def update(self, log_id: int, log_schema: LogUpdateSchema):

        #Importação da classe desejada
        update_service = self.dynamic_import.service('log_update_service', 'LogUpdateService')

        # Instânciamento da classe desejada
        self.update_service = update_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Log atualizado com sucesso',
            'data': self.update_service.execute(log_id, log_schema)
        }

    # Exclui um log
    def delete(self, log_schema: LogIdSchema):

        #Importação da classe desejada
        delete_service = self.dynamic_import.service('log_delete_service', 'DeleteService')

        # Instânciamento da classe desejada
        self.delete_service = delete_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Log removido com sucesso',
            'data': self.delete_service.execute(log_schema)
        }
    

    # Localiza os dados do GED pelo ID do cliente
    def getGed(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_ged_service = self.dynamic_import.service('log_show_ged_service', 'ShowGedService')

        # Instânciamento da classe desejada
        self.log_show_ged_service = log_show_ged_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_ged_service.execute(log_schema)
        }
    

    # Localiza os dados do GED pelo ID do cliente
    def getServer(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_server_service = self.dynamic_import.service('log_show_server_service', 'ShowServerService')

        # Instânciamento da classe desejada
        self.log_show_server_service = log_show_server_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_server_service.execute(log_schema)
        }  


    # Localiza os dados do database pelo ID do cliente
    def getDatabase(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_database_service = self.dynamic_import.service('log_show_database_service', 'ShowDatabaseService')

        # Instânciamento da classe desejada
        self.log_show_database_service = log_show_database_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_database_service.execute(log_schema)
        }   


    # Localiza os dados do database pelo ID do cliente
    def getBackup(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_backup_service = self.dynamic_import.service('log_show_backup_service', 'ShowBackupService')

        # Instânciamento da classe desejada
        self.log_show_backup_service = log_show_backup_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_backup_service.execute(log_schema)
        }  


    # Localiza os dados do database pelo ID do cliente
    def getDisk(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_disk_service = self.dynamic_import.service('log_show_disk_service', 'ShowDiskService')

        # Instânciamento da classe desejada
        self.log_show_disk_service = log_show_disk_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_disk_service.execute(log_schema)
        } 


    # Localiza os dados do database pelo ID do cliente
    def getWarning(self, log_schema: LogClientIdSchema):

        #Importação da classe desejada
        log_show_warning_service = self.dynamic_import.service('log_show_warning_service', 'ShowWarningService')

        # Instânciamento da classe desejada
        self.log_show_warning_service = log_show_warning_service()

        # Busca e retorna o log desejado
        return {
            'message': 'Visualização de LOG',
            'data': self.log_show_warning_service.execute(log_schema)
        }