path: root/arch-update-full

#!/bin/bash

# --- PALETA DE CORES NEON ---
ASSINATURA_COR='\033[1;37m' 
NEON_BLUE='\033[1;36m' 
PINK_NEON='\033[1;35m'
GREEN_NEON='\033[1;32m'
YELLOW_NEON='\033[1;33m'
#GRAY_NEON='\033[0;90m'  
NC='\033[0m' 
WHITE='\033[1;37m'
CYAN_NEON='\033[1;36m'
MAGENTA_NEON='\033[1;35m'
RED_NEON='\033[1;31m'
WHITE_NEON='\033[1;37m'
COLUMNS=$(tput cols)
LARGURA_BOX=64

SHELL=${SHELL:-/bin/bash}

# os comentarios estão separados por//the comments are separated by ----------------------<<< para facilitar leitura dos blocos//to make the blocks easier to read


# --- [SISTEMA] MODO SENTINELA: APENAS CHECAGEM // [SYSTEM] SENTINEL MODE: CHECK ONLY ----------------------------------------------------------------<<<

LOG_SENTINEL_DIR="$HOME/.logs_sentinel_check"
mkdir -p "$LOG_SENTINEL_DIR"

ROTATE_SENTINEL_LOGS() {
    # Mantém apenas os 3 logs mais recentes da sentinela//Keeps only the 3 most recent sentinel logs
    local LOG_COUNT
LOG_COUNT=$(find "$LOG_SENTINEL_DIR" -maxdepth 1 -name "check_*.log" | wc -l)
    if [ "$LOG_COUNT" -ge 3 ]; then
        find "$LOG_SENTINEL_DIR" -maxdepth 1 -name "check_*.log" -type f -printf '%T@ %p\n' | sort -n | head -n 1 | cut -d' ' -f2- | xargs rm
    fi
}


CHECK_FOR_UPDATES() {
    ROTATE_SENTINEL_LOGS
    
    local LOG_FILE
    LOG_FILE="$LOG_SENTINEL_DIR/check_$(date '+%Y-%m-%d_%H-%M-%S').log"
    
    {
        echo "--- CHECK INICIADO EM: $(date) ---"
        
        local AUR_H U_PACMAN U_AUR U_FLAT U_SNAP TOTAL
        
        AUR_H=$(command -v yay || command -v paru)
        
        # 1. PACMAN - Limpeza de espaços agressiva//Aggressive whitespace trimming
        U_PACMAN=$(checkupdates 2>/dev/null | wc -l | tr -d '[:space:]')
        : "${U_PACMAN:=0}"
        
        # 2. AUR
        U_AUR=0
        if [[ -n "$AUR_H" ]]; then
            U_AUR=$($AUR_H -Qu 2>/dev/null | wc -l | tr -d '[:space:]')
        fi
        : "${U_AUR:=0}"
        
        # 3. FLATPAK
        U_FLAT=0
        if command -v flatpak &>/dev/null; then
            U_FLAT=$(flatpak remote-ls --updates 2>/dev/null | wc -l | tr -d '[:space:]')
        fi
        : "${U_FLAT:=0}"

        # 4. SNAP
        U_SNAP=0
        if command -v snap &>/dev/null; then
            U_SNAP=$(snap refresh --list 2>/dev/null | grep -c '^[^Name]' | tr -d '[:space:]')
        fi
        : "${U_SNAP:=0}"

        # SOMA SEGURA//Safe summation
        TOTAL=$(( U_PACMAN + U_AUR + U_FLAT + U_SNAP ))

        echo "Pacman: $U_PACMAN | AUR: $U_AUR | Flatpak: $U_FLAT | Snap: $U_SNAP"
        echo "Total: $TOTAL"

      if [ "$TOTAL" -gt 0 ]; then
            # Envia a notificação com o botão e captura a resposta na variável // Sends the notification with the button and captures the response in the variable
            ACAO_ESCOLHIDA=$(notify-send -w -u normal -a "Arch Update Full" \
            --action="run_update=Click to Launch App" \
            "🛡️ Sentinela Alert" \
            "$(echo -e "🔄 Pending packages: $TOTAL\nRun Arch Update Full to update now. [!]")")

            echo "Status: Notificação enviada ao operador."
            echo "[info] Notification sent to operator."

            echo "[debug] gtk-launch: $(command -v gtk-launch)"
            echo "[debug] kioclient: $(command -v kioclient)"
            echo "[debug] kioclient5: $(command -v kioclient5)"
            echo "[debug] dex: $(command -v dex)"

            # Verifica qual foi a ação escolhida pelo operador // Checks which action was chosen by the operator
            if [[ "$ACAO_ESCOLHIDA" == "run_update" ]]; then
                echo "Status: Operador confirmou. Lançando o aplicativo..."
                echo "[info] Operator confirmed. Launching application..."
                echo "[debug] Tentando localizar o lançador .desktop para execução..."

                echo "DISPLAY=$DISPLAY"
                echo "WAYLAND_DISPLAY=$WAYLAND_DISPLAY"
                echo "XDG_RUNTIME_DIR=$XDG_RUNTIME_DIR"
                echo "DBUS_SESSION_BUS_ADDRESS=$DBUS_SESSION_BUS_ADDRESS"
                echo "XDG_CURRENT_DESKTOP=$XDG_CURRENT_DESKTOP"
                echo "DESKTOP_SESSION=$DESKTOP_SESSION"

#Pequeno atraso para garantir que a ação da notificação seja finalizada // Small delay to ensure the notification action is completed

                if command -v gio &> /dev/null; then
                    echo "[debug] usando gio"
                    sleep 0.5
                    gio launch /usr/share/applications/arch-update-full.desktop &
                    RET=$?
                    PID=$!

                    echo "[debug] retorno=$RET"
                    echo "[debug] pid=$PID"
                    disown "$PID"
                    echo "[debug] retorno do disown=$?"
                    sleep 0.5
                    
                elif command -v gtk-launch &> /dev/null; then
                    echo "[debug] usando gtk-launch"
                    sleep 0.5
                    gtk-launch arch-update-full.desktop &
                    RET=$?
                    PID=$!

                    echo "[debug] retorno=$RET"
                    echo "[debug] pid=$PID"
                    disown "$PID"
                    echo "[debug] retorno do disown=$?"
                    sleep 0.5

                elif command -v kioclient &> /dev/null; then
                    echo "[debug] usando kioclient"
                    sleep 0.5
                    kioclient exec arch-update-full.desktop &
                    RET=$?
                    PID=$!

                    echo "[debug] retorno=$RET"
                    echo "[debug] pid=$PID"
                    disown "$PID"
                    echo "[debug] retorno do disown=$?"
                    sleep 0.5

                elif command -v kioclient5 &> /dev/null; then
                    echo "[debug] usando kioclient5"
                    sleep 0.5
                    kioclient5 exec arch-update-full.desktop &
                    RET=$?
                    PID=$!

                    echo "[debug] retorno=$RET"
                    echo "[debug] pid=$PID"
                    disown "$PID"
                    echo "[debug] retorno do disown=$?"
                    sleep 0.5

                elif command -v dex &> /dev/null; then 
                    echo "[debug] usando dex"       
                    sleep 0.5     
                    dex /usr/share/applications/arch-update-full.desktop &
                    RET=$?
                    PID=$!

                    echo "[debug] retorno=$RET"
                    echo "[debug] pid=$PID"
                    disown "$PID"
                    echo "[debug] retorno do disown=$?"
                    sleep 0.5

                else
                    echo "[debug] nenhum lançador .desktop encontrado"
                    echo "[warn] Nenhum lançador .desktop encontrado. Extraindo comando direto..."
                    CMD_EXEC=$(awk '/^Exec=/ {sub(/^Exec=/, ""); gsub(/ *%[a-zA-Z]/, ""); print; exit}' \
                        /usr/share/applications/arch-update-full.desktop)
                    if [ -n "$CMD_EXEC" ]; then
                        sleep 0.5
                        bash -c "$CMD_EXEC" &
                        RET=$?
                        PID=$!

                        echo "[debug] retorno=$RET"
                        echo "[debug] pid=$PID"
        
                        disown "$PID"
                        echo "[debug] retorno do disown=$?"
                        sleep 0.5

                    else
                        echo "[warn] Falha ao extrair do .desktop. Tentando binário direto..."
                        sleep 0.5
                        arch-update-full &
                        RET=$?
                        PID=$!

                        echo "[debug] retorno=$RET"
                        echo "[debug] pid=$PID"
                        disown "$PID"
                        echo "[debug] retorno do disown=$?"
                        sleep 0.5

                    fi
                fi
            else
                # Se fechar, ignorar ou o tempo acabar, o script cai aqui e morre silenciosamente // If closed, ignored, or the time runs out, the script falls here and dies silently
                echo "Status: Nenhuma ação tomada pelo operador."
                echo "[info] No action taken by the operator."
            fi
        else
            echo "Status: No pending updates detected. System is up to date."
            echo "Status: Sistema atualizado. Nenhuma ação necessária."
        fi
        echo "[debug] ACAO_ESCOLHIDA='$ACAO_ESCOLHIDA'" 
        echo "--- CHECK FINALIZADO ---"
        echo "--- CHECK ENDED ---"

    } > "$LOG_FILE" 2>&1
}



# --- [SISTEMA] PROTOCOLO DE AUTO-INSTALAÇÃO DA SENTINELA // Sentinel Self-Installation Protocol -------------------------------------------------------<<<

SETUP_SENTINEL() {
    local SERVICE_DIR="$HOME/.config/systemd/user"
    local SCRIPT_PATH
SCRIPT_PATH=$(realpath "$0") # Descobre onde o script está no seu SSD//Finds where the script is on your SSD
    
    mkdir -p "$SERVICE_DIR"

    # Cria o arquivo de Serviço//Creates the Service file
    cat <<EOF > "$SERVICE_DIR/arch-sentinel.service"
[Unit]
Description=Sentinela de Atualizações Arch Update Full
After=network-online.target

[Service]
Type=oneshot
ExecStart=$SCRIPT_PATH --check

[Install]
WantedBy=default.target
EOF

    # Cria o arquivo de Timer (3 horas)//Creates the Timer file (3 hours)
    cat <<EOF > "$SERVICE_DIR/arch-sentinel.timer"
[Unit]
Description=Roda o Sentinela a cada 3 horas

[Timer]
OnBootSec=7min
OnUnitActiveSec=3h
Persistent=true

[Install]
WantedBy=timers.target
EOF

    # Recarrega e Ativa a Sentinela no Espaço do Usuário//Reloads and activates the sentinel in the user space

    systemctl --user daemon-reload
    systemctl --user enable --now arch-sentinel.timer >/dev/null 2>&1
}

# --- INTERCEPTADOR DE SINAL (MODO SENTINELA) //SIGNAL INTERCEPTOR -------------------------------------------------------------------<<
#nessa parte especifica mantive a verificaçao no google para apenas garantir conexao com a internet apenas checa se tem atualização não executa nada
#In this specific section, I kept the Google verification running only to ensure an internet connection; it just checks for updates and doesn't execute anything.

if [[ "$1" == "--check" ]]; then
    if ping -c 3 -W 7 8.8.8.8 &>/dev/null; then
        CHECK_FOR_UPDATES
    else
        echo -e "${YELLOW_NEON}[!][lang: PT-BR] Nenhuma conexão com a internet disponível, protocolo abortado. ${NC}"
        echo -e "${YELLOW_NEON}[!] Sentinel Protocol aborted. Please check your network connection ${NC}"
        exit 1
    fi
    exit 0

fi

SETUP_SENTINEL


# --- CONFIGURAÇÃO DE LOGS ROTATIVOS // ROTATING LOGS CONFIGURATION -----------------------------------------------------------------------------------<<<

LOG_DIR="$HOME/.logs_arch_update_full"
mkdir -p "$LOG_DIR"  

DATA_LOG=$(date "+%Y-%m-%d_%H-%M-%S")
LOG_ATUAL="$LOG_DIR/update_$DATA_LOG.log"

# Função para Limpeza logs (FIFO - Keep 13) // Log cleanup function (FIFO - Keep 13)

rotate_logs() {
    local LOG_COUNT
    local OLD_LOG

    LOG_COUNT=$(find "$LOG_DIR" -maxdepth 1 -name "update_*.log" 2>/dev/null | wc -l)
    
    if [ "$LOG_COUNT" -ge 13 ]; then
        OLD_LOG=$(find "$LOG_DIR" -maxdepth 1 -name "update_*.log" -type f -printf '%T@ %p\n' | sort -n | head -n 1 | cut -d' ' -f2-)
        
        if [ -n "$OLD_LOG" ]; then
            rm "$OLD_LOG"
            echo -e "${RED_NEON}[LOG_SYSTEM] Ciclo de rotação ativo. Log antigo removido: $(basename "$OLD_LOG")${NC}"
        fi
    fi
}


rotate_logs


exec > >(tee -i "$LOG_ATUAL") 2>&1

echo -e "${PINK_NEON}--- INICIANDO REGISTRO DE SESSÃO: $DATA_LOG ---${NC}"


# --- CABEÇALHO: ARCH UPDATE FULL BLOCK EDITION) -------------------------------------------------------------------------------------------<<<
clear
echo -e "${NEON_BLUE}"
echo "  █████╗ ██████╗  ██████╗██╗  ██╗    ██╗   ██╗██████╗ ██████╗  █████╗ ████████╗███████╗"
echo "  ██╔══██╗██╔══██╗██╔════╝██║  ██║    ██║   ██║██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝"
echo "  ███████║██████╔╝██║     ███████║    ██║   ██║██████╔╝██║  ██║███████║   ██║   █████╗  "
echo "  ██╔══██║██╔══██╗██║     ██╔══██║    ██║   ██║██╔═══╝ ██║  ██║██╔══██║   ██║   ██╔══╝  "
echo "  ██║  ██║██║  ██║╚██████╗██║  ██║    ╚██████╔╝██║     ██████╔╝██║  ██║   ██║   ███████╗"
echo "  ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝     ╚═════╝ ╚═╝     ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝"
echo -e "                              ${NEON_BLUE}███████╗██╗   ██╗██╗     ██╗${NC}"
echo -e "                              ${NEON_BLUE}██╔════╝██║   ██║██║     ██║${NC}"
echo -e "                              ${NEON_BLUE}█████╗  ██║   ██║██║     ██║${NC}"
echo -e "                              ${NEON_BLUE}██╔══╝  ██║   ██║██║     ██║${NC}"
echo -e "                              ${NEON_BLUE}██║     ╚██████╔╝███████╗███████╗${NC}"
echo -e "                              ${NEON_BLUE}╚═╝      ╚═════╝ ╚══════╝╚══════╝${NC}"
echo ""
echo -e "  ${PINK_NEON}──────────────────────────────── ${RED_NEON}-->VERSION 3.9-6 <--${PINK_NEON} ─────────────────────────────────${NC}"
echo -e "  ${PINK_NEON}───────────────────────>> UPDATING • AUTOMATING • SECURING <<───────────────────────${NC}"
echo ""
echo -e "  ${NEON_BLUE}─────────────>>[ MODULES: ROLLING_SYNC | AUR_INJECTION | INTEGRITY_AUDIT ]<<─────────────${NC}"
echo -e "  ${NEON_BLUE}-----------------------------------------------------------------------------------------${NC}"
sleep 1.5

# --- VERIFICAÇÃO DE CONECTIVIDADE // CONNECTIVITY VERIFICATION ---------------------------------------------------------------------------------------------<<<
echo ""
echo -e "${NEON_BLUE}[LANG: PT-BR] Verificando conectividade de rede...${NC}"
texto_net="ESTABLISHING_UPLINK: CHECKING SECTOR_NETWORK"
TAM_TEXTO=${#texto_net}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "\n${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${YELLOW_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$texto_net" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

# Extrai o primeiro mirror ativo da lista do usuário // Extracts the first active mirror from the user's list
echo ""
MIRROR_ALVO=$(sed -n '/^[[:space:]]*Server[[:space:]]*=/ { s|.*https?://\([^/:]*\).*|\1|p; q }' /etc/pacman.d/mirrorlist)
TARGET_1=${MIRROR_ALVO:-"archlinux.org"} # Se a lista estiver vazia por algum bug, assume o oficial // If the list is empty due to some bug, it defaults to the official one
TARGET_2="archlinux.org"

# TENTATIVA 1: Testa a rota do Mirror local // Attempt 1: Tests the route of the local Mirror

if PING_RES=$(ping -c 3 -W 13 "$TARGET_1" 2>/dev/null); then
   
    LATENCY=$(echo "$PING_RES" | awk -F'/' '/^rtt/ {print $5}')
    LATENCY=${LATENCY:-0.00}
    
    echo -e "${GREEN_NEON}[SUCCESS]${NC} CONNECTION_OK (Mirror) | LATENCY: ${LATENCY}ms"
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

# TENTATIVA 2: Se o Mirror falhar, site oficial do Arch // Attempt 2: If the Mirror fails, it uses the official Arch site

elif PING_RES=$(ping -c 3 -W 13 "$TARGET_2" 2>/dev/null); then
    LATENCY=$(echo "$PING_RES" | awk -F'/' '/^rtt/ {print $5}')
    LATENCY=${LATENCY:-0.00}
    
    echo -e "${GREEN_NEON}[SUCCESS]${NC} CONNECTION_OK (Arch.org) | LATENCY: ${LATENCY}ms"
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

# FALHA TOTAL: Sem internet ou rotas caídas // Total failure: No internet or routes down

else
    echo -e "${RED_NEON}[ERROR] NO INTERNET CONNECTION${NC}"
    echo -e "${YELLOW_NEON}[!][lang: PT-BR] Nenhuma conexão com a internet disponível, protocolo abortado. ${NC}"
    echo -e "${YELLOW_NEON}[!] Sentinel Protocol aborted. Please check your network connection ${NC}"
    echo -e "${YELLOW_NEON}--------------------------------------------------------------------------------------${NC}"
    exit 1
fi

echo "" 
# --- FUNÇÃO DE ERRO PADRONIZADA (CAIXA VERMELHA) // STANDARDIZED ERROR FUNCTION ------------------------------------------------------------------------------<<<

BOX_ERROR() {
    local TEXTO="$1"
    local LARGURA=64
    local INTERNO=$((LARGURA - 4))
    
    echo -e "\n${RED_NEON}╔$(printf '═%.0s' $(seq 1 $((LARGURA-2))))╗${NC}"
    
    echo "$TEXTO" | fold -s -w "$INTERNO" | while IFS= read -r LINHA; do
        printf "${RED_NEON}║${NC} %-${INTERNO}s ${RED_NEON}║${NC}\n" "$LINHA"
    done
    
    echo -e "${RED_NEON}╚$(printf '═%.0s' $(seq 1 $((LARGURA-2))))╝${NC}"
}

# ---  VERIFICAÇÃO DE ESPAÇO EM DISCO // DISK SPACE CHECK  --------------------------------------------------------------------------------------------------<<<

CHECK_DISK_SPACE() {
    echo ""
    echo -e "${NEON_BLUE}[LANG: PT-BR] Verificando integridade do armazenamento...${NC}"
    TEXTO_DISK=" ANALYZING STORAGE: CHECKING DISK INTEGRITY RESERVE"
    TAM_TEXTO=${#TEXTO_DISK}
    ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

    echo -e "${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
    printf "${NEON_BLUE}║${NC}${PINK_NEON}%s%*s${NC}${NEON_BLUE}║${NC}\n" "$TEXTO_DISK" "$ESPACOS" ""
    echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

    FREE_SPACE=$(df -BG / | awk 'NR==2 {print $4}' | sed 's/G//')
    echo ""
    if [ "$FREE_SPACE" -lt 5 ]; then
       
        MENSAGEM="${RED_NEON}[FATAL ERROR] Insufficient space (${FREE_SPACE}GB). Aborting to prevent corruption. [!] Sentinel Protocol requires at least 5GB free. Clear some space and try again. ${NC}\n${RED_NEON}[ERRO FATAL] [!]pt-br: (${FREE_SPACE}GB) O Protocolo Sentinela exige pelo menos 5GB livres. Libere algum espaço e tente novamente.${NC}"
        
        BOX_ERROR "$MENSAGEM"
        
        echo "[LOG] Aborting due to insufficient space (${FREE_SPACE}GB) on $(date)" >> "$LOG_ATUAL"
        echo -e "${YELLOW_NEON}--------------------------------------------------------------------------------------${NC}"
        exit 1
    else
        echo -e "${GREEN_NEON}[OK]${NC} Disk reserve confirmed: ${FREE_SPACE}GB available."
        echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
    fi
}



CHECK_DISK_SPACE

sleep 0.6
echo ""
# 1. OTIMIZAÇÃO DE ESPELHOS (MIRRORS) // MIRRORS OPTIMIZATION ------------------------------------------------------------------------------<<<

echo -e "${NEON_BLUE}[LANG: PT-BR] Otimizando os espelhos de rede...${NC}"


TEXTO_REFLECTOR="OPTIMIZING_NETWORK_MIRRORS"
TAM_TEXTO=${#TEXTO_REFLECTOR}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${GREEN_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$TEXTO_REFLECTOR" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

if command -v reflector &> /dev/null; then
    echo ""
    echo -e "${GREEN_NEON}[SEARCHING]${NC} Selecting the 5 fastest HTTPS mirrors..."
    sudo reflector --protocol https --latest 5 --sort rate --save /etc/pacman.d/mirrorlist
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
else
    echo ""
    echo -e "${YELLOW_NEON}[WARNING]${NC}[lang: pt-br] Refletor não detectado."
    echo -e "${YELLOW_NEON}[WARNING]${NC} Reflector not detected. Skipping network optimization sector."
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
fi

sleep 0.6

echo "" 
# 2. REPOSITÓRIOS OFICIAIS (PACMAN) // OFFICIAL REPOSITORIES (PACMAN) --------------------------------------------------------------------------------<<<

echo -e "${NEON_BLUE}[LANG: PT-BR] Sincronizando repositórios oficiais...${NC}"
texto_pacman="CORE_SYSTEM_SYNCHRONIZATION (PACMAN-UPDATES)"
TAM_TEXTO=${#texto_pacman}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${YELLOW_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$texto_pacman" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

echo -e "${RED_NEON} USER INTERACTION REQUIRED:${NC}${CYAN_NEON}\n Confirm updates and resolve dependencies when prompted.${NC}"
sleep 1.5

echo ""
if sudo pacman -Syu; then
    echo -e "${NEON_BLUE}[OK]${NC} Synchronization completed successfully."
else
    echo -e "${YELLOW_NEON}[!] Standard sync failed. Attempting forced refresh (Syyu)...${NC}"
    sleep 1
    if sudo pacman -Syyu; then
        echo -e "${NEON_BLUE}[OK]${NC} Synchronization completed via forced refresh."
    else
        echo -e "${RED_NEON}[FATAL ERROR] System synchronization failed even with forced refresh.${NC}"
        echo "[LOG] Critical sync failure on $(date)" >> "$LOG_ATUAL"
        exit 1
    fi
fi
echo -e "${CYAN_NEON}--------------------------------------------------------------------------------------${NC}"

sleep 0.7

# 3. ATUALIZAÇÃO DO AUR (DETECÇÃO INTELIGENTE)// AUR (Smart Detection) Update --------------------------------------------------------------------<<<
echo ""

echo -e "${NEON_BLUE}[LANG: PT-BR] Detectando helpers do AUR...${NC}"

TEXTO_AUR=" AUR_SUBSYSTEM_DETECTION: SCANNING FOR HELPERS"
TAM_TEXTO=${#TEXTO_AUR}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "\n${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${PINK_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$TEXTO_AUR" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

YAY_INSTALLED=$(command -v yay)
PARU_INSTALLED=$(command -v paru)

if [ -n "$YAY_INSTALLED" ] && [ -n "$PARU_INSTALLED" ]; then
    echo -e "${YELLOW_NEON}[LANG: PT-BR]${NC} Detectamos múltiplos helpers do AUR (YAY e PARU)."
    echo -e "${YELLOW_NEON}[INFO]${NC} Multiple AUR helpers detected (YAY and PARU)."
    echo "" 
    echo -e "${NEON_BLUE}[LANG: PT-BR] Qual você deseja utilizar para esta sessão?${NC}"
    echo -e "${NEON_BLUE}[INFO] Which one do you want to use for this session?${NC}"
    echo ""
    echo -e "  ${PINK_NEON}(1)${NC} YAY"
    echo -e "  ${PINK_NEON}(2)${NC} PARU"
    echo ""
    read -rn 1 -p "[ESCOLHA]: " AUR_CHOICE
    echo ""

    case $AUR_CHOICE in
        1) AUR_HELPER="yay" ;;
        2) AUR_HELPER="paru" ;;
        *) echo -e "${RED_NEON}[!]${NC} Escolha inválida. Usando YAY por padrão.\nInvalid selection. Defaulting to YAY "; AUR_HELPER="yay" ;;
    esac
elif [ -n "$YAY_INSTALLED" ]; then
    AUR_HELPER="yay"
    echo -e "${GREEN_NEON}[DETECTADO] [LANG: PT-BR]${NC} Helper AUR encontrado: YAY"
    echo -e "${GREEN_NEON}[INFO]${NC} AUR helper detected: YAY"
elif [ -n "$PARU_INSTALLED" ]; then
    AUR_HELPER="paru"
    echo -e "${GREEN_NEON}[DETECTADO] [LANG: PT-BR]${NC} Helper AUR encontrado: PARU"
    echo -e "${GREEN_NEON}[INFO]${NC} AUR helper detected: PARU"
else
    AUR_HELPER=""
    echo -e "${YELLOW_NEON}[LANG: PT-BR] Nenhum helper AUR detectado. Pulando setor de atualização do AUR.${NC}"
    echo -e "${YELLOW_NEON}[INFO] No AUR helper detected. Skipping AUR update sector.${NC}"
fi

echo ""
# --- Execução com Helper // Execution with Helper  ------------------------------------------------------------------------------------------<<<

if [ -n "$AUR_HELPER" ]; then
    echo -e "${NEON_BLUE}[LANG: PT-BR] ATUALIZAÇÃO DE AUR...${NC}"
    TEXTO=" INJECTING AUR DATA STREAMS: UPDATING VIA $(echo $AUR_HELPER | tr '[:lower:]' '[:upper:]')"
    
    TAM_TEXTO=${#TEXTO}
    ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))
    
    echo -e "\n${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
    printf "${NEON_BLUE}║${NC}${PINK_NEON}%s%*s${NC}${NEON_BLUE}║${NC}\n" "$TEXTO" "$ESPACOS" ""
    echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"
    
    # Menu de seleção de modo//Mode selection menu
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

    echo -e "${YELLOW_NEON}(LANG: EN-US) SELECT AUR UPDATE MODE:${NC}"
    echo -e "${YELLOW_NEON}{lang: PT-BR} SELECIONE O MODO DE ATUALIZAÇÃO DO AUR:${NC}"
    echo -e ""
    echo -e " 1) {lang: EN-US} Automatic (do not read the pkgbuild, --noconfirm)"
    echo -e " 1) {lang: PT-BR} Automático (não ler o pkgbuild, --noconfirm)"
    echo -e ""
    echo -e " 2) {lang: EN-US} Manual (Interactive, read pkgbuilds and confirm)"
    echo -e " 2) {lang: PT-BR} Manual (Interativo, ler pkgbuilds e confirmar)"
    echo -e ""
    echo -ne "${NEON_BLUE}{lang: EN-US}Choose an option [1-2]:${NC}"
    echo -e "${NEON_BLUE}{lang: PT-BR}Escolha uma opção [1-2]:${NC}"
    echo ""
    read -r AUR_MODE
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

    case "$AUR_MODE" in
        1)
            echo -e "${BLUE_NEON}{lang: PT-BR} executando em modo automático...${NC}"
            echo -e "${BLUE_NEON}[INFO] Executing in automatic mode...${NC}"
            echo ""
            $AUR_HELPER -Syu --noconfirm
            ;;
        2)
            echo -e "${GREEN_NEON}{lang: PT-BR} executando em modo manual... INTERAÇÃO DO USUÁRIO NECESSÁRIA.${NC}"
            echo -e "${GREEN_NEON}[INFO] Executing in manual mode... USER INTERACTION REQUIRED.${NC}"
            echo ""
            $AUR_HELPER -Syu
            ;;
        *)
            # Fallback de segurança para escolhas inválidas ou vazias//Safety fallback for invalid or empty choices
            echo -e "${YELLOW_NEON}[LANG: PT-BR] Opção não detectada. Executando modo manual por segurança.${NC}"
            echo -e "${YELLOW_NEON}[WARNING] Option not detected. Executing manual mode for safety.${NC}"
            echo ""
            sleep 1.5
            $AUR_HELPER -Syu
            ;;
    esac
    echo ""
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
fi


sleep 0.7

# 4. ATUALIZAÇÃO DE FLATPAKS (DETECÇÃO AUTOMÁTICA)// FLATPAK UPDATE -----------------------------------------------------------------------------<<<
echo ""

if command -v flatpak &> /dev/null; then
    echo -e "${NEON_BLUE}[lang: PT-BR] ATUALIZAÇÃO DE FLATPAKS...${NC}"

    TEXTO_FP=" SCANNING SANDBOX: UPDATING FLATPAK REPOSITORIES"
    TAM_TEXTO=${#TEXTO_FP}
    ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

    echo -e "${PINK_NEON}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
    printf "${PINK_NEON}║${NC}${NEON_BLUE}%s%*s${NC}${PINK_NEON}║${NC}\n" "$TEXTO_FP" "$ESPACOS" ""
    echo -e "${PINK_NEON}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"
    
    echo ""
    flatpak update -y
    echo -e "\n${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
else
    echo ""
    echo -e "${YELLOW_NEON}[lang: PT-BR] Flatpak não detectado.${NC}"
    echo -e "${YELLOW_NEON}[lang: EN_US] Flatpak environment not detected. Skipping sector.${NC}"
    echo -e "\n${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
fi

sleep 0.7

# 5. ATUALIZAÇÃO DE SNAPS (DETECÇÃO AUTOMÁTICA)// SNAPS UPDATE -----------------------------------------------------------------------------<<<

if command -v snap &> /dev/null; then
    echo ""
    echo -e "${NEON_BLUE}[lang: PT-BR] ATUALIZAÇÃO DE SNAPS...${NC}"
    
    TEXTO_SNAP=" STABILIZING SNAP PACKAGES: REFRESHING ALL SNAPS"
    TAM_TEXTO=${#TEXTO_SNAP}
    ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

    echo -e "${YELLOW_NEON}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
    printf "${YELLOW_NEON}║${NC}${NEON_BLUE}%s%*s${NC}${YELLOW_NEON}║${NC}\n" "$TEXTO_SNAP" "$ESPACOS" ""
    echo -e "${YELLOW_NEON}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

    echo ""
    sudo snap refresh
    echo ""
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
else
    echo ""
    echo -e "${YELLOW_NEON}[lang: PT-BR] Snaps não detectados.${NC}"
    echo -e "${YELLOW_NEON}[lang: EN_US] Snap environment not detected. Skipping sector.${NC}"
    echo ""
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
fi

sleep 0.7

# ---  AUDITORIA DE NÚCLEO (REBOOT CHECK)// CORE AUDIT ------------------------------------------------------------------------------<<<

CHECK_REBOOT_NEEDED() {
    local CRITICAL_PACKAGES="linux|nvidia|mesa|ucode|systemd|wayland|xorg"
    
    
    BOOT_TIME=$(uptime -s)
    BOOT_TIMESTAMP=$(date -d "$BOOT_TIME" +%s)

    REBOOT_REQUIRED=false
    REBOOT_REASON=""

    
   while read -r line; do
       
        UPDATE_TIME=$(echo "$line" | awk '{print $1}' | tr -d '[]')
        
        UPDATE_TIMESTAMP=$(date -d "$UPDATE_TIME" +%s 2>/dev/null) || continue
        
        
        if [[ -n "$UPDATE_TIMESTAMP" && "$UPDATE_TIMESTAMP" -gt "$BOOT_TIMESTAMP" ]]; then
           
            PKG_NAME=$(echo "$line" | awk '{print $4}')
            REBOOT_REASON+="$PKG_NAME "
            REBOOT_REQUIRED=true
        fi
    done < <(grep "$(date "+%Y-%m-%d")" /var/log/pacman.log | grep -E "upgraded.*($CRITICAL_PACKAGES)")

    if [ "$REBOOT_REQUIRED" = true ]; then
        echo -e "${RED_NEON}╔══════════════════════════════════════════════════════════════╗${NC}"
        echo -e "${RED_NEON}║ [⚠️  INTEGRITY ALERT // [lang: PT-BR] ALERTA DE INTEGRIDADE]  ║${NC}"
        echo -e "${RED_NEON}╚══════════════════════════════════════════════════════════════╝${NC}"


        echo -e "${YELLOW_NEON}[lang: PT-BR] Componentes críticos foram alterados o reboot do sistema é necessário e recomendado:${NC} "
        echo -e "${YELLOW_NEON}[info] Critical components have been altered; a system reboot is necessary and recommended.${NC}"
        echo -e ""

        echo -e "${WHITE_NEON}$REBOOT_REASON${NC}" 

        echo -e ""
        echo -e "${PINK_NEON}>>[lang: PT-BR] RECOMENDAÇÃO: Reinicie o sistema para aplicar as mudanças.<<${NC}"
        echo -e "${PINK_NEON}>>[info] RECOMMENDATION: Please reboot the system to apply changes.<<${NC}"
    fi
}



# 6 Limpeza de pacotes órfãos // Cleaning up orphaned packages -----------------------------------------------------------------------------------<<<
echo ""

echo -e "${NEON_BLUE}[lang: PT-BR] Verificando por pacotes órfãos...${NC}"

texto_orfao="PURGING RESIDUAL FRAGMENTS (ORPHANS)"
TAM_TEXTO=${#texto_orfao}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${YELLOW_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$texto_orfao" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

mapfile -t ORPHANS_LIST < <(pacman -Qdtq 2>/dev/null)

ORPHANS_CLEAN=()
for pkg in "${ORPHANS_LIST[@]}"; do
    [[ -n "$pkg" ]] && ORPHANS_CLEAN+=("$pkg")
done
ORPHANS_LIST=("${ORPHANS_CLEAN[@]}")
unset ORPHANS_CLEAN

if [ ${#ORPHANS_LIST[@]} -gt 0 ]; then
    echo "" 
    echo -e "${YELLOW_NEON}[lang: PT-BR] Pacotes órfãos detectados. Eliminando resíduos...${NC}"
    echo -e "${YELLOW_NEON}[lang: EN-US] Orphan packages detected. Wiping them out...${NC}"


    sudo pacman -Rns "${ORPHANS_LIST[@]}" --noconfirm

    echo -e "${GREEN_NEON}[lang: PT-BR] Fragmentos residuais eliminados com sucesso.${NC}"
    echo -e "${GREEN_NEON}[SUCCESS] Residual data erased.${NC}"
    echo ""
else
    echo ""
    echo -e "${YELLOW_NEON}[lang: PT-BR] Nenhum fragmento encontrado nos setores.${NC}"
    echo -e "${YELLOW_NEON}[lang: EN-US] No fragments found in sectors.${NC}"
    echo "" 
fi

echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
sleep 0.7

# 7. LIMPEZA DO CACHE // CLEARING THE CACHE ---------------------------------------------------------------------------------------------<<<<
echo "" 

echo -e "${NEON_BLUE}[lang: PT-BR]Procurando e Limpando o cache de pacotes...${NC}"

texto_cache="STABILIZING_CACHE_RESERVES (PACCACHE)"
TAM_TEXTO=${#texto_cache}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "${NEON_BLUE}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${NEON_BLUE}║${NC}${YELLOW_NEON} %s%*s${NC}${NEON_BLUE}║${NC}\n" "$texto_cache" "$((ESPACOS-1))" ""
echo -e "${NEON_BLUE}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

if command -v paccache &> /dev/null; then
    echo ""
    echo -e "${GREEN_NEON}[lang: PT-BR]${NC}Procurando paccache. Limpando cache e mantendo as 3 últimas versões..."
    echo -e "${GREEN_NEON}[lang: EN-US]${NC} Paccache detected. Cleaning cache while retaining the last 3 versions..."
    echo ""
    echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
    echo ""
    sudo paccache -rk3
    echo "" 
else
    echo ""
    echo -e "${YELLOW_NEON}[WARNING] paccache command not found!${NC}"
    echo -e "${YELLOW_NEON}[lang: PT-BR] Comando paccache não encontrado!${NC}"
    echo "" 
    echo -e "${RED_NEON}[⚠️ ALERT](lang : EN) pacman -Sc keeps ONLY the currently installed version (1 version).${NC}"
    echo -e "${RED_NEON}[⚠️ ALERTA](lang : PT-BR) pacman -Sc mantém APENAS a versão atual instalada (1 versão).${NC}"
    echo -e ""
    echo -e "${YELLOW_NEON}{lang: EN-US} Do you want to proceed with pacman -Sc?${NC}"
    echo -e "${YELLOW_NEON}{lang: PT-BR} Deseja prosseguir com pacman -Sc? ${NC}"
    echo -e ""
    echo -e "${PINK_NEON}(1)${NC}{lang: EN-US} Yes, clean it anyway!$"
    echo -e "${PINK_NEON}(1)${NC}{lang: PT-BR} Sim, limpar mesmo assim!"
    echo -e ""
    echo -e "${PINK_NEON}(2)${NC}{lang: EN-US} No, skip cache cleaning!"
    echo -e "${PINK_NEON}(2)${NC}{lang: PT-BR} Não, pular limpeza de cache$"
    echo -e ""
    echo -ne "${CYAN_NEON}{lang: EN-US} Choose an option [1-2]: ${NC}"
    echo -ne "${CYAN_NEON}{lang: PT-BR} Escolha uma opção : [1-2]: ${NC}"
    echo ""
    read -r CACHE_CHOICE

    case "$CACHE_CHOICE" in
        1)
            echo -e "${RED_NEON}[INFO] Wiping old cache streams...${NC}"
            echo -e "${RED_NEON}[LANG: PT-BR] Limpando cache antigo...${NC}"
            sudo pacman -Sc --noconfirm
            ;;

        2) echo -e "${GREEN_NEON}[INFO] Cache cleaning skipped for safety.${NC}"
            echo -e "${GREEN_NEON}[LANG: PT-BR] Limpeza de cache pulada por segurança.${NC}"
            ;;

        *)
            echo -e "${GREEN_NEON}[INFO] Cache cleaning skipped for safety.${NC}"
            echo -e "${GREEN_NEON}[LANG: PT-BR] Limpeza de cache pulada por segurança.${NC}"
            ;;
    esac
fi
echo ""
echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

sleep 0.7

# 8. AUDITORIA DE INTEGRIDADE (OPCIONAL) // INTEGRITY AUDIT (OPTIONAL) -----------------------------------------------------------------------------<<<
echo ""

echo -e "${NEON_BLUE}[LANG: PT-BR] Deseja auditar a integridade dos arquivos do sistema?${NC}"

TEXTO_AUDIT=" INTEGRITY SCAN: DO YOU WANT TO AUDIT SYSTEM FILES?"
TAM_TEXTO=${#TEXTO_AUDIT}
ESPACOS=$((LARGURA_BOX - TAM_TEXTO - 2))

echo -e "${YELLOW_NEON}╔$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╗${NC}"
printf "${YELLOW_NEON}║${NC}${NEON_BLUE}%s%*s${NC}${YELLOW_NEON}║${NC}\n" "$TEXTO_AUDIT" "$ESPACOS" ""
echo -e "${YELLOW_NEON}╚$(printf '═%.0s' $(seq 1 $((LARGURA_BOX-2))))╝${NC}"

echo "" 

read -rp "(SsYy/Nn): " escolha_auditoria 

echo ""
if [[ "$escolha_auditoria" =~ ^[SsYy]$ ]]; then
    status_msg "SYSTEM_INTEGRITY_CHECK"
    echo -e "${YELLOW_NEON}[info] (lang: en) ${NC}The Seventh is verifying Arch's fingerprints... "
    echo -e "${YELLOW_NEON}[AUDITANDO] (lang: pt-BR) ${NC}The Seventh está verificando as digitais do Arch... "
    
    lista_real=$(LANG=C sudo pacman -Qkk 2>&1 | grep -E "mismatch|[1-9][0-9]* altered")
    
    if [ -n "$lista_real" ]; then
        echo -e "${PINK_NEON}[ALERTA]${NC}[lang: pt-BR] Foi detectado que arquivos foram alterados:"
        echo -e "${YELLOW_NEON}[WARNING] The Seventh has detected that files have been modified:${NC}"
        echo ""
        echo -e "${CYAN_NEON}--------------------------------------------------------${NC}"
        echo -e "${YELLOW_NEON}$lista_real${NC}"
        echo -e "${CYAN_NEON}--------------------------------------------------------${NC}"
        echo ""
        echo -e "${NEON_BLUE}[DICA]${NC}[lang: pt-BR] Verifique se são configurações ou binários do sistema."
        echo -e "${NEON_BLUE}[TIP] The Seventh recommends checking if these are system configurations or binaries."
    else
        echo -e "${GREEN_NEON}[LIMPO]${NC}[lang: pt-BR] Integridade 100%. Nenhuma alteração suspeita."
        echo -e "${GREEN_NEON}[CLEAN]${NC}[INFO] Integrity 100%. No suspicious alterations found."
    fi
else
    echo -e "${RED_NEON}[PULADO]${NC}[lang: pt-BR] Auditoria ignorada pelo operador."
    echo -e "${RED_NEON}[SKIPPED]${NC}[INFO] Audit skipped by the operator."
fi

sleep 0.7

# --- FINALIZAÇÃO //FINALIZATION ---------------------------------------------------------------------------------<<<
echo "" 

echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"
echo -e "${GREEN_NEON}   [!] ARCH UPDATE PROTOCOL COMPLETE: YOUR SYSTEM IS NOW REINFORCED [!]${NC}"
echo -e "${PINK_NEON}   >> STATUS: SECURE | ENCRYPTED | OPTIMIZED <<${NC}"
echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

echo -e "${NEON_BLUE}[LOG][lang: pt-BR] Registro desta sessão salvo em:${NC}"
echo -e "${NEON_BLUE}[LOG][lang: en_US] Log of this session saved in:${NC}"
echo -e "${YELLOW_NEON}📂 $LOG_ATUAL${NC}"
echo -e "${NEON_BLUE}--------------------------------------------------------------------------------------${NC}"

echo -e "      ${ASSINATURA_COR}© [2026] 𝑨𝑹𝑪𝑯 𝑼𝑷𝑫𝑨𝑻𝑬𝑹 𝑭𝑼𝑳𝑳 𝑷𝑹𝑶𝑻𝑶𝑪𝑶𝑳| 𝒃𝒚 𝑮𝒖𝒔𝒕𝒂𝒗𝒐 𝑮𝒊𝒂𝒏𝒆𝒍𝒊 (𝓣𝓱𝓮 𝓢𝓮𝓿𝓮𝓷𝓽𝓱)${NC}"

echo -e "${CYAN_NEON}--------------------------------------------------------------------------------------${NC}"
echo -e "${MAGENTA_NEON}   >> STATUS: SEGURO  | O QUE DESEJA FAZER AGORA ? <<${NC}"
echo -e "${MAGENTA_NEON}   >> STATUS: SECURE  | WHAT DO YOU WANT TO DO NOW ? <<${NC}"
echo -e "${CYAN_NEON}--------------------------------------------------------------------------------------${NC}"
echo "" 

# --- NOTIFICAÇÃO UNIVERSAL (SINALIZAÇÃO VISUAL) // NOTIFICAÇÃO UNIVERSAL (SINALIZAÇÃO VISUAL) -------------------------------<<<

NOTIFY_FINISH() {
    
    if command -v notify-send >/dev/null 2>&1; then
        notify-send -u critical -a "Arch Update Full" \
        "🔄 [!] ARCH UPDATE SUCCESSFUL" \
        "$(echo -e "🛡️ THE SYSTEM IS NOW FULLY UPDATED [!].\n📂 Log successfully saved to: $LOG_ATUAL")"
    
    else
        echo -e "${YELLOW_NEON}[AVISO]${NC}[lang: pt-BR] Utilitário de notificação não encontrado. Pulando alerta visual."
        echo -e "${YELLOW_NEON}[WARNING]${NC}[lang: en_US] Notification utility not found. Skipping visual alert."
    fi
}


# --- [SISTEMA] NOTIFICAÇÃO E AUDITORIA FINAL //[SYSTEM] FINAL NOTIFICATION AND AUDIT ---------------------------------------------------------------------<<<

NOTIFY_FINISH


CHECK_REBOOT_NEEDED

echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"
echo -e "${NEON_BLUE}[lang: pt-BR]          MENU DE ENCERRAMENTO ${NC}"
echo -e "${NEON_BLUE}[lang: en_US]          CLOSING MENU         ${NC}" 
echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"

echo -e "${MAGENTA_NEON}(A)${NC} ${WHITE}[lang: pt-BR]Encerrar sessão e fechar terminal${NC}\n${WHITE}[lang: en_US] Close terminal ${NC} ${CYAN_NEON}(Kill Switch)${NC}"
echo -e ""
echo -e "${MAGENTA_NEON}(B)${NC} ${WHITE}[lang: pt-BR]Encerrar sessão (Modo Leitura)${NC}\n${WHITE}[lang: en_US] Close session (Read-only Mode) ${NC} ${CYAN_NEON}(Security Buffer)${NC}"
echo -e ""
echo -e "${MAGENTA_NEON}(C)${NC} ${WHITE}[lang: pt-BR]Continuar na sessão${NC}\n${WHITE}[lang: en_US] Continue in session ${NC} ${CYAN_NEON}(Return to Prompt)${NC}"
echo -e ""


if [ "$REBOOT_REQUIRED" = true ]; then
    echo -e "${RED_NEON}(D)[lang: pt-BR] [RECOMENDADO] Reiniciar o sistema ${NC}\n${RED_NEON}[lang: en_US][RECOMMENDED] Reboot system(Reboot Protocol)${NC}"
   
else
    echo -e "${MAGENTA_NEON}(D)${NC} ${WHITE}[lang: pt-BR]Reiniciar o sistema ${NC}\n${WHITE}[lang: en_US] Reboot system ${NC} ${CYAN_NEON}(Reboot Protocol)${NC}"
fi

echo ""
echo -ne "${CYAN_NEON}[ESCOLHA]:${NC} "
read -rn 1 OPCAO
echo ""

case $OPCAO in
    [Aa])
        echo -e "${RED_NEON}[!][lang: pt-BR] Encerrando conexão e fechando hardware...${NC}"
        echo -e "${RED_NEON}[!][lang: en_US] Closing connection and shutting down hardware...${NC}"
        echo -e ""
         for i in {3..1}; do
            printf "\r${RED_NEON}[CLOSING IN] ${CYAN_NEON}%d seconds...${NC}" "$i"
            sleep 1
        done
        echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"
        kill -9 "$(ps -o ppid= -p $$)"
        ;;

    [Bb])
        echo -e "${YELLOW_NEON}[!][lang: pt-BR] Sessão em modo leitura. Analise os logs.${NC}"
        echo -e "${YELLOW_NEON}[!][lang: en_US] Session in read-only mode. Analyze the logs.${NC}"
        echo -e ""
        echo -e "${WHITE}[lang: pt-BR] Pressione ${MAGENTA_NEON}[ENTER]${NC} para encerrar o terminal...${NC}"
        echo -ne "${WHITE}[lang: en_US] Press ${MAGENTA_NEON}[ENTER]${NC} to close the terminal...${NC}"
        echo -e ""

        while true; do
            # O -s esconde o que a pessoa digita // The -s hides what the person types
            read -rs input
            
            if [ -z "$input" ]; then
                break
            else
                # Alerta reativo caso o usuário digite letras ou espaços antes do ENTER
                echo -e "${RED_NEON}[!][lang: pt-BR] Entrada inválida. Pressione APENAS o [ENTER] vazio!${NC}"
                echo -e "${RED_NEON}[!][lang: en_US] Invalid input. Press ONLY empty [ENTER]!${NC}"
                echo -e ""
            fi
        done

        echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"
        sleep 0.5
        exec "$SHELL"
        ;;

   [Cc])
        echo -e "${GREEN_NEON}[!][lang: pt-BR] Protocolo encerrado. Invocando Shell persistente...${NC}"
        echo -e "${GREEN_NEON}[!][lang: en_US] Protocol closed. Invoking persistent Shell...${NC}"
        echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"
        exec "$SHELL"
        ;;

    [Dd])
        echo -e "${RED_NEON}[!][lang: pt-BR] INICIANDO PROTOCOLO DE REBOOT...${NC}"
        echo -e "${RED_NEON}[!][lang: en_US] INITIATING REBOOT PROTOCOL...${NC}"
        echo -e ""
        for i in {5..1}; do
            printf "\r${RED_NEON}[REBOOTING IN] ${CYAN_NEON}%d seconds...${NC}" "$i"
            sleep 1
        done
        echo -e "${CYAN_NEON}------------------------------------------------------------${NC}"
        sudo reboot
        ;;

    *)
        echo -e "${RED_NEON}[!][lang: pt-BR] Opção inválida. Retornando ao prompt por segurança.${NC}"
        echo -e "${RED_NEON}[!][lang: en_US] Invalid option. Returning to prompt for safety.${NC}"
        sleep 1.5
        exec "$SHELL"
        ;;

esac