<?php

/**
 * Sistema de Logs para MySQL
 * Funções para registrar atividades do sistema
 */

require_once __DIR__ . '/conexao.php';

/**
 * Registra um log no sistema
 * 
 * @param int $id_tipo_log ID do tipo de log (1-7)
 * @param string $modulo Nome do módulo onde ocorreu a ação
 * @param int $id_usuario ID do usuário que executou a ação
 * @param string $nome_usuario Nome do usuário
 * @return bool True se o log foi registrado com sucesso, False caso contrário
 */


function resolverIdModulo(mysqli $connectionmysql, $modulo)
{
    // 1) Se já for numérico, use direto
    if (is_numeric($modulo)) {
        return (int)$modulo;
    }

    // 2) Tenta encontrar por caminho
    $sql = "SELECT id_modulo FROM modulo WHERE caminho = ? LIMIT 1";
    if ($stmt = $connectionmysql->prepare($sql)) {
        $stmt->bind_param("s", $modulo);
        $stmt->execute();
        $res = $stmt->get_result();
        if ($res && $row = $res->fetch_assoc()) {
            $stmt->close();
            return (int)$row['id_modulo'];
        }
        $stmt->close();
    }

    // 3) Tenta encontrar por nome (se houver coluna 'modulo' ou 'nome' na sua tabela)
    $sqlAlternativos = [
        "SELECT id_modulo FROM modulo WHERE modulo = ? LIMIT 1",
        "SELECT id_modulo FROM modulo WHERE nome = ? LIMIT 1",
        "SELECT id_modulo FROM modulo WHERE descricao = ? LIMIT 1",
    ];
    foreach ($sqlAlternativos as $sqlAlt) {
        if ($stmt = $connectionmysql->prepare($sqlAlt)) {
            $stmt->bind_param("s", $modulo);
            $stmt->execute();
            $res = $stmt->get_result();
            if ($res && $row = $res->fetch_assoc()) {
                $stmt->close();
                return (int)$row['id_modulo'];
            }
            $stmt->close();
        }
    }

    // 4) Fallback: 0 (não bloqueia o log)
    return 0;
}

function registrarLog($id_tipo_log, $modulo, $id_usuario, $nome_usuario)
{
    try {
        global $connectionmysql;

        if (!is_numeric($id_tipo_log) || $id_tipo_log < 1 || $id_tipo_log > 7) {
            throw new Exception("ID do tipo de log inválido: $id_tipo_log");
        }
        if (empty($modulo) || empty($nome_usuario)) {
            throw new Exception("Módulo ou nome do usuário não podem estar vazios");
        }

        // Resolve id do módulo a partir de id/caminho/nome
        $id_modulo = resolverIdModulo($connectionmysql, $modulo);

        // Cooldown de 5 minutos para logs de acesso
        if ($id_tipo_log == 1) {
            $cooldown_seconds = 300;
            $query_ultimo_log = "SELECT MAX(data_criacao) AS ultimo_log
                                 FROM logs
                                 WHERE id_tipo_log = 1
                                 AND id_usuario = ?
                                 AND modulo = ?";
            if ($stmt = $connectionmysql->prepare($query_ultimo_log)) {
                $stmt->bind_param("ii", $id_usuario, $id_modulo);
                $stmt->execute();
                $result = $stmt->get_result();
                $row = $result ? $result->fetch_assoc() : null;
                $stmt->close();

                if ($row && $row['ultimo_log']) {
                    $ultimo_log_time = strtotime($row['ultimo_log']);
                    if ((time() - $ultimo_log_time) < $cooldown_seconds) {
                        return true; // ignora repetição em curto intervalo
                    }
                }
            }
        }
        // Evitar registrar logs sobre a própria página de Logs
        if (is_string($modulo) && strtolower(trim($modulo)) === 'logs') {
            return true;
        }

        // Insere (assumindo logs.id AUTO_INCREMENT e coluna data_criacao com default)
        $sqlInsert = "INSERT INTO logs (id_tipo_log, modulo, id_usuario, nome_usuario, data_criacao)
                      VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)";
        if (!$stmt = $connectionmysql->prepare($sqlInsert)) {
            throw new Exception("Erro ao preparar a query de inserção: " . $connectionmysql->error);
        }
        $stmt->bind_param("iiis", $id_tipo_log, $id_modulo, $id_usuario, $nome_usuario);
        $ok = $stmt->execute();
        $stmt->close();

        if (!$ok) {
            throw new Exception("Erro ao inserir log no banco de dados: " . $connectionmysql->error);
        }

        return true;
    } catch (Exception $e) {
        error_log("Erro ao registrar log: " . $e->getMessage());
        return false;
    }
}


/**
 * Registra log de acesso ao sistema
 */
function registrarLogAcesso($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(1, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Registra log de criação de registro
 */
function registrarLogCriacao($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(2, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Registra log de atualização de registro
 */
function registrarLogAtualizacao($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(3, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Registra log de exclusão de registro
 */
function registrarLogExclusao($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(4, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Registra log de consulta de registros
 */
function registrarLogConsulta($modulo, $id_usuario, $nome_usuario)
{
    $cooldown_seconds = 300; // 5 minutos

    // Cria uma chave única para controle de cooldown
    $chave = "log_consulta_{$modulo}_{$id_usuario}";

    // Se nunca registrou ou já passou o cooldown
    if (!isset($_SESSION[$chave]) || time() - $_SESSION[$chave] >= $cooldown_seconds) {
        // Atualiza o último horário em sessão
        $_SESSION[$chave] = time();

        // Registra o log
        return registrarLog(5, $modulo, $id_usuario, $nome_usuario);
    }

    // Ainda não passou o cooldown → não registra
    return false;
}


/**
 * Registra log de exportação de dados
 */
function registrarLogExportacao($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(6, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Registra log de importação de dados
 */
function registrarLogImportacao($modulo, $id_usuario, $nome_usuario)
{
    return registrarLog(7, $modulo, $id_usuario, $nome_usuario);
}

/**
 * Busca logs com filtros opcionais
 * 
 * @param array $filtros Array com filtros (id_tipo_log, modulo, id_usuario, data_inicio, data_fim)
 * @param int $limite Número máximo de registros
 * @param int $offset Offset para paginação
 * @return array Array com os logs encontrados
 */
function buscarLogs($filtros = array(), $limite = null, $offset = 0)
{
    global $connectionmysql;

    $sql = "
        SELECT 
            l.id,
            l.id_tipo_log,
            tl.nome as tipo_log_nome,
            l.modulo AS id_modulo,
            m.modulo AS nome_modulo,
            m.descricao AS descricao_modulo,
            l.id_usuario,
            l.nome_usuario,
            l.data_criacao,
            l.detalhes_alteracao,
            l.dados_antes,
            l.dados_depois,
            l.id_registro
        FROM logs l
        LEFT JOIN tipos_log tl ON l.id_tipo_log = tl.id
        LEFT JOIN modulo m ON l.modulo = m.id_modulo
        WHERE 1=1
    ";

    $params = array();
    $types = "";

    // Aplicar filtros
    if (!empty($filtros['id_tipo_log'])) {
        $sql .= " AND l.id_tipo_log = ?";
        $params[] = $filtros['id_tipo_log'];
        $types .= "i";
    }

    if (!empty($filtros['modulo'])) {
        if (is_array($filtros['modulo'])) {
            $todos_numericos = count(array_filter($filtros['modulo'], 'is_numeric')) === count($filtros['modulo']);
            $placeholders = str_repeat('?,', count($filtros['modulo']) - 1) . '?';
            if ($todos_numericos) {
                $sql .= " AND l.modulo IN ($placeholders)";
                foreach ($filtros['modulo'] as $modulo) {
                    $params[] = (int)$modulo;
                    $types .= "i";
                }
            } else {
                $sql .= " AND m.modulo IN ($placeholders)";
                foreach ($filtros['modulo'] as $modulo) {
                    $params[] = $modulo;
                    $types .= "s";
                }
            }
        } else {
            if (is_numeric($filtros['modulo'])) {
                $sql .= " AND l.modulo = ?";
                $params[] = (int)$filtros['modulo'];
                $types .= "i";
            } elseif (strpos($filtros['modulo'], ',') !== false) {
                $modulos_filtro = array_map('trim', explode(',', $filtros['modulo']));
                $placeholders = str_repeat('?,', count($modulos_filtro) - 1) . '?';
                $sql .= " AND m.modulo IN ($placeholders)";
                foreach ($modulos_filtro as $modulo) {
                    $params[] = $modulo;
                    $types .= "s";
                }
            } else {
                $sql .= " AND (m.modulo LIKE ? OR m.caminho LIKE ?)";
                $params[] = '%' . $filtros['modulo'] . '%';
                $params[] = '%' . $filtros['modulo'] . '%';
                $types .= "ss";
            }
        }
    }

    if (!empty($filtros['id_usuario'])) {
        $sql .= " AND l.id_usuario = ?";
        $params[] = $filtros['id_usuario'];
        $types .= "i";
    }

    if (!empty($filtros['data_inicial'])) {
        $sql .= " AND l.data_criacao >= ?";
        $params[] = $filtros['data_inicial'];
        $types .= "s";
    }

    if (!empty($filtros['data_final'])) {
        $sql .= " AND l.data_criacao <= ?";
        $params[] = $filtros['data_final'];
        $types .= "s";
    }

    // Ordenar
    $sql .= " ORDER BY l.data_criacao DESC";
    
    // Adicionar limite apenas se especificado
    if ($limite !== null) {
        $sql .= " LIMIT ? OFFSET ?";
        $params[] = $limite;
        $params[] = $offset;
        $types .= "ii";
    }

    $stmt = mysqli_prepare($connectionmysql, $sql);
    if (!$stmt) {
        error_log("Erro ao preparar statement: " . mysqli_error($connectionmysql));
        return array();
    }

    if (!empty($params)) {
        mysqli_stmt_bind_param($stmt, $types, ...$params);
    }

    if (!mysqli_stmt_execute($stmt)) {
        error_log("Erro ao buscar logs: " . mysqli_stmt_error($stmt));
        mysqli_stmt_close($stmt);
        return array();
    }

    $result_set = mysqli_stmt_get_result($stmt);
    $logs = array();
    while ($row = mysqli_fetch_assoc($result_set)) {
        $logs[] = $row;
    }

    mysqli_stmt_close($stmt);
    return $logs;
}


/**
 * Conta total de logs com filtros
 */
function contarLogs($filtros = array())
{
    global $connectionmysql;

    $sql = "SELECT COUNT(*) as total FROM logs l LEFT JOIN modulo m ON l.modulo = m.id_modulo WHERE 1=1";
    $params = array();
    $types = "";

    // Aplicar filtros
    if (!empty($filtros['id_tipo_log'])) {
        $sql .= " AND l.id_tipo_log = ?";
        $params[] = $filtros['id_tipo_log'];
        $types .= "i";
    }

    if (!empty($filtros['modulo'])) {
        if (is_array($filtros['modulo'])) {
            $todos_numericos = count(array_filter($filtros['modulo'], 'is_numeric')) === count($filtros['modulo']);
            $placeholders = str_repeat('?,', count($filtros['modulo']) - 1) . '?';
            if ($todos_numericos) {
                $sql .= " AND l.modulo IN ($placeholders)";
                foreach ($filtros['modulo'] as $modulo) {
                    $params[] = (int)$modulo;
                    $types .= "i";
                }
            } else {
                $sql .= " AND m.modulo IN ($placeholders)";
                foreach ($filtros['modulo'] as $modulo) {
                    $params[] = $modulo;
                    $types .= "s";
                }
            }
        } else {
            if (is_numeric($filtros['modulo'])) {
                $sql .= " AND l.modulo = ?";
                $params[] = (int)$filtros['modulo'];
                $types .= "i";
            } elseif (strpos($filtros['modulo'], ',') !== false) {
                $modulos_filtro = array_map('trim', explode(',', $filtros['modulo']));
                $placeholders = str_repeat('?,', count($modulos_filtro) - 1) . '?';
                $sql .= " AND m.modulo IN ($placeholders)";
                foreach ($modulos_filtro as $modulo) {
                    $params[] = $modulo;
                    $types .= "s";
                }
            } else {
                $sql .= " AND (m.modulo LIKE ? OR m.caminho LIKE ?)";
                $params[] = '%' . $filtros['modulo'] . '%';
                $params[] = '%' . $filtros['modulo'] . '%';
                $types .= "ss";
            }
        }
    }

    if (!empty($filtros['id_usuario'])) {
        $sql .= " AND l.id_usuario = ?";
        $params[] = $filtros['id_usuario'];
        $types .= "i";
    }

    if (!empty($filtros['data_inicio'])) {
        $sql .= " AND l.data_criacao >= ?";
        $params[] = $filtros['data_inicio'];
        $types .= "s";
    }

    if (!empty($filtros['data_fim'])) {
        $sql .= " AND l.data_criacao <= ?";
        $params[] = $filtros['data_fim'];
        $types .= "s";
    }

    $stmt = mysqli_prepare($connectionmysql, $sql);

    if (!$stmt) {
        return 0;
    }

    if (!empty($params)) {
        mysqli_stmt_bind_param($stmt, $types, ...$params);
    }

    $result = mysqli_stmt_execute($stmt);

    if (!$result) {
        mysqli_stmt_close($stmt);
        return 0;
    }

    $result_set = mysqli_stmt_get_result($stmt);
    $row = mysqli_fetch_assoc($result_set);
    mysqli_stmt_close($stmt);

    return (int)$row['total'];
}

/**
 * Busca tipos de log disponíveis
 */
function buscarTiposLog()
{
    global $connectionmysql;

    $sql = "SELECT id, nome FROM tipos_log ORDER BY id";
    $result = mysqli_query($connectionmysql, $sql);

    if (!$result) {
        return array();
    }

    $tipos = array();
    while ($row = mysqli_fetch_assoc($result)) {
        $tipos[] = $row;
    }

    return $tipos;
}

/**
 * Registra log com detalhes das alterações
 * 
 * @param int $id_tipo_log ID do tipo de log (1-7)
 * @param string $modulo Nome do módulo onde ocorreu a ação
 * @param int $id_usuario ID do usuário que executou a ação
 * @param string $nome_usuario Nome do usuário
 * @param string $detalhes_alteracao Detalhes das alterações feitas
 * @param string $dados_antes Dados antes da alteração (JSON)
 * @param string $dados_depois Dados depois da alteração (JSON)
 * @param int $id_registro ID do registro alterado (opcional)
 * @return bool True se o log foi registrado com sucesso, False caso contrário
 */
function registrarLogDetalhado($id_tipo_log, $modulo, $id_usuario, $nome_usuario, $detalhes_alteracao = '', $dados_antes = '', $dados_depois = '', $id_registro = null)
{
    global $connectionmysql;

    // Validar parâmetros
    if (!is_numeric($id_tipo_log) || $id_tipo_log < 1 || $id_tipo_log > 7) {
        error_log("Erro: ID do tipo de log inválido: $id_tipo_log");
        return false;
    }

    if (empty($modulo) || empty($nome_usuario)) {
        error_log("Erro: Módulo ou nome do usuário não podem estar vazios");
        return false;
    }

    // Resolver id do módulo
    $id_modulo = resolverIdModulo($connectionmysql, $modulo);

    // Preparar a query incluindo campos adicionais, assumindo AUTO_INCREMENT para logs.id
    if ($id_registro === null) {
        $sql = "INSERT INTO logs (id_tipo_log, modulo, id_usuario, nome_usuario, detalhes_alteracao, dados_antes, dados_depois, id_registro) VALUES (?, ?, ?, ?, ?, ?, ?, NULL)";
        $stmt = mysqli_prepare($connectionmysql, $sql);
        if (!$stmt) {
            error_log("Erro ao preparar statement: " . mysqli_error($connectionmysql));
            return false;
        }
        mysqli_stmt_bind_param($stmt, "iiissss", $id_tipo_log, $id_modulo, $id_usuario, $nome_usuario, $detalhes_alteracao, $dados_antes, $dados_depois);
    } else {
        $sql = "INSERT INTO logs (id_tipo_log, modulo, id_usuario, nome_usuario, detalhes_alteracao, dados_antes, dados_depois, id_registro) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
        $stmt = mysqli_prepare($connectionmysql, $sql);
        if (!$stmt) {
            error_log("Erro ao preparar statement: " . mysqli_error($connectionmysql));
            return false;
        }
        mysqli_stmt_bind_param($stmt, "iiissssi", $id_tipo_log, $id_modulo, $id_usuario, $nome_usuario, $detalhes_alteracao, $dados_antes, $dados_depois, $id_registro);
    }

    // Executar a inserção
    $result = mysqli_stmt_execute($stmt);

    if (!$result) {
        error_log("Erro ao registrar log detalhado: " . mysqli_stmt_error($stmt));
        mysqli_stmt_close($stmt);
        return false;
    }

    mysqli_stmt_close($stmt);
    return true;
}

/**
 * Registra log de criação com detalhes
 */
function registrarLogCriacaoDetalhado($modulo, $id_usuario, $nome_usuario, $dados_depois, $id_registro = null)
{
    $detalhes = "Novo registro criado";
    return registrarLogDetalhado(2, $modulo, $id_usuario, $nome_usuario, $detalhes, '', $dados_depois, $id_registro);
}

/**
 * Registra log de atualização com detalhes
 */
function registrarLogAtualizacaoDetalhado($modulo, $id_usuario, $nome_usuario, $dados_antes, $dados_depois, $id_registro = null)
{
    $detalhes = "Registro atualizado";
    return registrarLogDetalhado(3, $modulo, $id_usuario, $nome_usuario, $detalhes, $dados_antes, $dados_depois, $id_registro);
}

/**
 * Registra log de exclusão com detalhes
 */
function registrarLogExclusaoDetalhado($modulo, $id_usuario, $nome_usuario, $dados_antes, $id_registro = null)
{
    $detalhes = "Registro excluído";
    return registrarLogDetalhado(4, $modulo, $id_usuario, $nome_usuario, $detalhes, $dados_antes, '', $id_registro);
}

/**
 * Compara dois arrays e retorna as diferenças
 */
function compararDados($dados_antes, $dados_depois)
{
    $alteracoes = [];

    // Campos que foram alterados
    foreach ($dados_depois as $campo => $valor_depois) {
        $valor_antes = $dados_antes[$campo] ?? '';

        // Normalizar valores vazios
        $valor_antes_normalizado = is_string($valor_antes) ? trim($valor_antes) : $valor_antes;
        $valor_depois_normalizado = is_string($valor_depois) ? trim($valor_depois) : $valor_depois;

        // Converter arrays e objetos para string para comparação
        if (is_array($valor_antes_normalizado)) {
            $valor_antes_normalizado = json_encode($valor_antes_normalizado);
        }
        if (is_array($valor_depois_normalizado)) {
            $valor_depois_normalizado = json_encode($valor_depois_normalizado);
        }
        if (is_object($valor_antes_normalizado)) {
            $valor_antes_normalizado = json_encode($valor_antes_normalizado);
        }
        if (is_object($valor_depois_normalizado)) {
            $valor_depois_normalizado = json_encode($valor_depois_normalizado);
        }

        if ($valor_antes_normalizado !== $valor_depois_normalizado) {
            $tipo_alteracao = '';

            // Detectar tipo de alteração
            if (empty($valor_antes_normalizado) && !empty($valor_depois_normalizado)) {
                $tipo_alteracao = ' [ADICIONADO]';
            } elseif (!empty($valor_antes_normalizado) && empty($valor_depois_normalizado)) {
                $tipo_alteracao = ' [REMOVIDO]';
            } elseif (!empty($valor_antes_normalizado) && !empty($valor_depois_normalizado)) {
                $tipo_alteracao = ' [ALTERADO]';
            }

            $alteracoes[] = [
                'campo' => $campo,
                'valor_antes' => is_string($valor_antes) ? $valor_antes : json_encode($valor_antes),
                'valor_depois' => is_string($valor_depois) ? $valor_depois : json_encode($valor_depois),
                'tipo' => $tipo_alteracao
            ];
        }
    }

    // Campos que foram removidos (estavam nos dados antes mas não nos depois)
    foreach ($dados_antes as $campo => $valor_antes) {
        if (!isset($dados_depois[$campo])) {
            $alteracoes[] = [
                'campo' => $campo,
                'valor_antes' => is_string($valor_antes) ? $valor_antes : json_encode($valor_antes),
                'valor_depois' => '[REMOVIDO]',
                'tipo' => ' [REMOVIDO]'
            ];
        }
    }

    return $alteracoes;
}

/**
 * Gera texto legível das alterações
 */
function gerarTextoAlteracoes($alteracoes)
{
    if (empty($alteracoes)) {
        return "Nenhuma alteração detectada";
    }

    $texto = "Alterações realizadas:\n";
    foreach ($alteracoes as $alteracao) {
        $tipo = isset($alteracao['tipo']) ? $alteracao['tipo'] : '';
        $texto .= "- {$alteracao['campo']}{$tipo}: '{$alteracao['valor_antes']}' → '{$alteracao['valor_depois']}'\n";
    }

    return trim($texto);
}

/**
 * Registra log de atualização com comparação automática
 */
function registrarLogAtualizacaoComparacao($modulo, $id_usuario, $nome_usuario, $dados_antes, $dados_depois, $id_registro = null)
{
    $alteracoes = compararDados($dados_antes, $dados_depois);
    $detalhes = gerarTextoAlteracoes($alteracoes);

    return registrarLogDetalhado(3, $modulo, $id_usuario, $nome_usuario, $detalhes, json_encode($dados_antes), json_encode($dados_depois), $id_registro);
}

/**
 * Registra log de atualização inteligente - apenas campos alterados
 */
function registrarLogAtualizacaoInteligente($modulo, $id_usuario, $nome_usuario, $dados_antes, $dados_depois, $id_registro = null)
{
    $alteracoes = compararDados($dados_antes, $dados_depois);

    // Se não há alterações, não registrar log
    if (empty($alteracoes)) {
        return true;
    }

    $detalhes = gerarTextoAlteracoes($alteracoes);

    // Criar arrays apenas com os campos alterados
    $dados_antes_alterados = [];
    $dados_depois_alterados = [];

    foreach ($alteracoes as $alteracao) {
        $dados_antes_alterados[$alteracao['campo']] = $alteracao['valor_antes'];
        $dados_depois_alterados[$alteracao['campo']] = $alteracao['valor_depois'];
    }

    return registrarLogDetalhado(3, $modulo, $id_usuario, $nome_usuario, $detalhes, json_encode($dados_antes_alterados), json_encode($dados_depois_alterados), $id_registro);
}

/**
 * Registra log de login forçado com detalhes específicos
 */
function registrarLogLoginForcado($admin_id, $admin_nome, $usuario_alvo_id, $usuario_alvo_nome)
{
    global $connectionmysql;

    try {
        // Escapar caracteres especiais para evitar problemas de SQL
        $admin_id = mysqli_real_escape_string($connectionmysql, $admin_id);
        $admin_nome = mysqli_real_escape_string($connectionmysql, $admin_nome);
        $usuario_alvo_id = mysqli_real_escape_string($connectionmysql, $usuario_alvo_id);
        $usuario_alvo_nome = mysqli_real_escape_string($connectionmysql, $usuario_alvo_nome);
        $ip = mysqli_real_escape_string($connectionmysql, $_SERVER['REMOTE_ADDR']);

        $detalhes = "Login forçado: Admin {$admin_nome} (ID: {$admin_id}) fez login como {$usuario_alvo_nome} (ID: {$usuario_alvo_id})";

        // Inserir na tabela de logs de acesso (tabela já foi criada antes de chamar esta função)
        $sql_log_acesso = "INSERT INTO logs_acesso (id_usuario, usuario, acao, detalhes, data_hora, ip) 
                           VALUES ('{$admin_id}', '{$admin_nome}', 'LOGIN_FORCADO', '{$detalhes}', NOW(), '{$ip}')";

        $result_log = mysqli_query($connectionmysql, $sql_log_acesso);

        // Registrar no sistema de logs padrão
        $result_standard = registrarLog(1, 'Sistema - Login Forçado', $admin_id, $admin_nome);

        return $result_log || $result_standard; // Retorna true se pelo menos um funcionou

    } catch (Exception $e) {
        // Se houver erro, registrar no log de erros do PHP
        error_log("Erro ao registrar log de login forçado: " . $e->getMessage());
        return false;
    }
}
