#!/usr/bin/env bash
set -Eeuo pipefail
umask 077
SCRIPT_ORIGEM="${BASH_SOURCE[0]:-}"

readonly VERSAO="1.0.4"
readonly ARQUIVOS="https://arquivos.muunit.com/cliente"
readonly WINE_NOME="wine-11.21-staging-amd64-wow64"
readonly WINE_URL="https://github.com/Kron4ek/Wine-Builds/releases/download/11.21/wine-11.21-staging-amd64-wow64.tar.xz"
readonly WINE_SHA256="a70a9691c42e35f32bab8a8a2deb8f0321aa3081b393c73575727ca76fa503ab"
readonly WINE_MB=98
readonly WV2_VERSAO="157.0.4341.57"
readonly WV2_URL="https://msedge.sf.dl.delivery.mp.microsoft.com/filestreamingservice/files/1a76b522-6d76-4107-955b-8eea7dc5068d/Microsoft.WebView2.FixedVersionRuntime.157.0.4341.57.x64.cab"
readonly WV2_SHA256="9a7ac986794cee0edf2403aac9560043592a599e33a9808a24761aaa4ac9c01f"
readonly WV2_MB=311
readonly WV2_ARGS="--disable-gpu --disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection"
readonly PREFIXO_REV="3"
readonly ESPACO_MB=4096
readonly ESTEIRA_PUB="-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAC22zQYPYFgU71+5KkadShlWQqwctoKKSyBl+8WgcIGg=
-----END PUBLIC KEY-----"

DADOS="${XDG_DATA_HOME:-}"
[[ "$DADOS" == /* ]] || DADOS="$HOME/.local/share"
DADOS="$(readlink -m -- "$DADOS" 2>/dev/null || printf '%s' "$DADOS")"
BASE="$DADOS/muunit"
BIN_DIR="$BASE/bin"
PROGRAMA="$BIN_DIR/muunit"
PREFIXO="$BASE/prefixo"
WINE_DIR="$BASE/wine/$WINE_NOME"
TMP_DIR="$BASE/tmp"
LOG_DIR="$BASE/logs"
LOG="$LOG_DIR/muunit.log"
APPS_DIR="$DADOS/applications"
ICONES_DIR="$DADOS/icons/hicolor/512x512/apps"
PACOTE_DESKTOP="/usr/share/applications/muunit.desktop"
IDIOMA=en
TERMINAL=0
UI_PID=""
UI_FIFO=""
CANAL=""
ATUALIZACAO_INICIADA=0
M_ID="" M_MANIFESTO="" M_PASTA="" M_EXE="" M_ESQUEMA="" M_DESKTOP="" M_NOME="" M_CLASSE=""

definir_idioma() {
  case "${LC_ALL:-${LC_MESSAGES:-${LANG:-}}}" in
    pt*) IDIOMA=pt ;;
    es*) IDIOMA=es ;;
    *) IDIOMA=en ;;
  esac
}

t() {
  local chave="$1" f=""
  shift
  case "$IDIOMA:$chave" in
    pt:raiz) f='Não rode o MU Unit como root (sudo). Rode com o seu usuário.' ;;
    es:raiz) f='No ejecutes MU Unit como root (sudo). Ejecútalo con tu usuario.' ;;
    en:raiz) f='Do not run MU Unit as root (sudo). Run it as your own user.' ;;
    pt:arquitetura) f='O MU Unit no Linux precisa de um sistema de 64 bits (x86_64). Este é %s.' ;;
    es:arquitetura) f='MU Unit en Linux necesita un sistema de 64 bits (x86_64). Este es %s.' ;;
    en:arquitetura) f='MU Unit on Linux needs a 64-bit (x86_64) system. This one is %s.' ;;
    pt:comando) f='Falta o programa %s. Instale-o e tente de novo.' ;;
    es:comando) f='Falta el programa %s. Instálalo e inténtalo de nuevo.' ;;
    en:comando) f='The program %s is missing. Install it and try again.' ;;
    pt:bibliotecas) f='Faltam bibliotecas do sistema: %s\n\nInstale com:\n%s\n\nDepois abra o MU Unit de novo.' ;;
    es:bibliotecas) f='Faltan bibliotecas del sistema: %s\n\nInstálalas con:\n%s\n\nLuego abre MU Unit de nuevo.' ;;
    en:bibliotecas) f='System libraries are missing: %s\n\nInstall them with:\n%s\n\nThen open MU Unit again.' ;;
    pt:openssl_falta) f='Falta o programa openssl, que o MU Unit usa para conferir as assinaturas do launcher e das atualizações.\n\nInstale com:\n%s\n\nDepois rode o instalador de novo.' ;;
    es:openssl_falta) f='Falta el programa openssl, que MU Unit usa para comprobar las firmas del launcher y de las actualizaciones.\n\nInstálalo con:\n%s\n\nLuego ejecuta el instalador de nuevo.' ;;
    en:openssl_falta) f='The openssl program is missing. MU Unit uses it to check the signatures of the launcher and of updates.\n\nInstall it with:\n%s\n\nThen run the installer again.' ;;
    pt:espaco) f='Pouco espaço livre: o MU Unit precisa de %s GB livres em %s.' ;;
    es:espaco) f='Poco espacio libre: MU Unit necesita %s GB libres en %s.' ;;
    en:espaco) f='Not enough free space: MU Unit needs %s GB free in %s.' ;;
    pt:memoria) f='Este computador tem %s GB de memória e o MU Unit no Linux precisa de 8 GB. Com menos, a janela do launcher pode ficar preta e o jogo pode fechar sozinho. A instalação continua.' ;;
    es:memoria) f='Este equipo tiene %s GB de memoria y MU Unit en Linux necesita 8 GB. Con menos, la ventana del launcher puede quedarse en negro y el juego puede cerrarse solo. La instalación continúa.' ;;
    en:memoria) f='This computer has %s GB of memory and MU Unit on Linux needs 8 GB. With less, the launcher window may stay black and the game may close by itself. The installation will continue.' ;;
    pt:grafico) f='Não achei a área de trabalho (X11 ou Wayland). Abra o MU Unit pelo menu de aplicativos.' ;;
    es:grafico) f='No encontré el escritorio (X11 o Wayland). Abre MU Unit desde el menú de aplicaciones.' ;;
    en:grafico) f='No desktop session found (X11 or Wayland). Open MU Unit from the applications menu.' ;;
    pt:trava) f='Outra instalação do MU Unit está em andamento. Espere ela terminar.' ;;
    es:trava) f='Hay otra instalación de MU Unit en curso. Espera a que termine.' ;;
    en:trava) f='Another MU Unit installation is running. Wait for it to finish.' ;;
    pt:passo_wine) f='Baixando o Wine (%s MB)...' ;;
    es:passo_wine) f='Descargando Wine (%s MB)...' ;;
    en:passo_wine) f='Downloading Wine (%s MB)...' ;;
    pt:passo_webview2) f='Baixando o WebView2 da Microsoft (%s MB)...' ;;
    es:passo_webview2) f='Descargando WebView2 de Microsoft (%s MB)...' ;;
    en:passo_webview2) f='Downloading Microsoft WebView2 (%s MB)...' ;;
    pt:passo_prefixo) f='Preparando o ambiente do jogo...' ;;
    es:passo_prefixo) f='Preparando el entorno del juego...' ;;
    en:passo_prefixo) f='Preparing the game environment...' ;;
    pt:passo_launcher) f='Baixando o launcher do MU Unit...' ;;
    es:passo_launcher) f='Descargando el launcher de MU Unit...' ;;
    en:passo_launcher) f='Downloading the MU Unit launcher...' ;;
    pt:passo_atalho) f='Criando o atalho no menu...' ;;
    es:passo_atalho) f='Creando el acceso en el menú...' ;;
    en:passo_atalho) f='Creating the menu shortcut...' ;;
    pt:pronto) f='Pronto! O MU Unit está no menu de aplicativos.' ;;
    es:pronto) f='¡Listo! MU Unit está en el menú de aplicaciones.' ;;
    en:pronto) f='Done! MU Unit is in your applications menu.' ;;
    pt:hash) f='O arquivo baixado não confere (%s). Nada foi alterado. Confira a internet e tente de novo.' ;;
    es:hash) f='El archivo descargado no coincide (%s). No se cambió nada. Revisa tu conexión e inténtalo de nuevo.' ;;
    en:hash) f='The downloaded file does not match (%s). Nothing was changed. Check your connection and try again.' ;;
    pt:rede) f='Não consegui baixar %s. Confira a internet e tente de novo.' ;;
    es:rede) f='No pude descargar %s. Revisa tu conexión e inténtalo de nuevo.' ;;
    en:rede) f='Could not download %s. Check your connection and try again.' ;;
    pt:erro) f='Algo deu errado. O registro está em %s' ;;
    es:erro) f='Algo salió mal. El registro está en %s' ;;
    en:erro) f='Something went wrong. The log is at %s' ;;
    pt:confirmar) f='Remover o MU Unit deste usuário (Wine, launcher e arquivos do jogo)?' ;;
    es:confirmar) f='¿Quitar MU Unit de este usuario (Wine, launcher y archivos del juego)?' ;;
    en:confirmar) f='Remove MU Unit for this user (Wine, launcher and game files)?' ;;
    pt:removido) f='MU Unit removido.' ;;
    es:removido) f='MU Unit eliminado.' ;;
    en:removido) f='MU Unit removed.' ;;
    pt:removido_pacote) f='Para tirar também o pacote do sistema: %s' ;;
    es:removido_pacote) f='Para quitar también el paquete del sistema: %s' ;;
    en:removido_pacote) f='To also remove the system package: %s' ;;
    pt:link) f='Link recusado: %s' ;;
    es:link) f='Enlace rechazado: %s' ;;
    en:link) f='Link refused: %s' ;;
    pt:nao_instalado) f='O MU Unit não está instalado para este usuário.' ;;
    es:nao_instalado) f='MU Unit no está instalado para este usuario.' ;;
    en:nao_instalado) f='MU Unit is not installed for this user.' ;;
    pt:caminho) f='A pasta %s tem caracteres que o atalho do menu não aceita (aspas, crase, cifrão, barra invertida ou porcentagem). Nada foi alterado.' ;;
    es:caminho) f='La carpeta %s tiene caracteres que el acceso del menú no acepta (comillas, acento grave, dólar, barra invertida o porcentaje). No se cambió nada.' ;;
    en:caminho) f='The folder %s has characters the menu shortcut does not accept (quotes, backtick, dollar, backslash or percent). Nothing was changed.' ;;
    pt:pasta_alheia) f='A pasta %s já existe e não é do MU Unit. Nada foi alterado.' ;;
    es:pasta_alheia) f='La carpeta %s ya existe y no es de MU Unit. No se cambió nada.' ;;
    en:pasta_alheia) f='The folder %s already exists and does not belong to MU Unit. Nothing was changed.' ;;
    pt:sem_openssl3) f='Neste sistema falta o OpenSSL 3, então o MU Unit não se atualiza sozinho. O jogo funciona; para atualizar, baixe de novo o instalador no site.' ;;
    es:sem_openssl3) f='En este sistema falta OpenSSL 3, así que MU Unit no se actualiza solo. El juego funciona; para actualizar, descarga de nuevo el instalador en el sitio.' ;;
    en:sem_openssl3) f='OpenSSL 3 is missing on this system, so MU Unit cannot update itself. The game works; to update, download the installer again from the website.' ;;
    pt:desinstalar_terminal) f='Para remover o MU Unit, abra o terminal e rode: muunit desinstalar --sim' ;;
    es:desinstalar_terminal) f='Para quitar MU Unit, abre la terminal y ejecuta: muunit desinstalar --sim' ;;
    en:desinstalar_terminal) f='To remove MU Unit, open a terminal and run: muunit desinstalar --sim' ;;
    pt:desligado) f='O instalador do MU Unit para Linux está fora do ar no momento. Tente mais tarde.' ;;
    es:desligado) f='El instalador de MU Unit para Linux no está disponible en este momento. Inténtalo más tarde.' ;;
    en:desligado) f='The MU Unit installer for Linux is unavailable right now. Try again later.' ;;
    pt:instalando) f='Instalando o MU Unit. Leva alguns minutos e o launcher abre sozinho no fim.' ;;
    es:instalando) f='Instalando MU Unit. Tarda unos minutos y el launcher se abre solo al final.' ;;
    en:instalando) f='Installing MU Unit. It takes a few minutes and the launcher opens by itself at the end.' ;;
    pt:launcher_sem_assinatura) f='O launcher publicado não veio com a assinatura do MU Unit, então ele não foi instalado. Tente de novo mais tarde.' ;;
    es:launcher_sem_assinatura) f='El launcher publicado no vino con la firma de MU Unit, así que no se instaló. Inténtalo de nuevo más tarde.' ;;
    en:launcher_sem_assinatura) f='The published launcher did not come with the MU Unit signature, so it was not installed. Try again later.' ;;
    pt:sem_openssl3_launcher) f='Para conferir a assinatura do launcher, o MU Unit no Linux precisa do OpenSSL 3, que vem no Ubuntu 22.04, no Debian 12, no Fedora 39 e nos mais novos. Nada foi instalado.' ;;
    es:sem_openssl3_launcher) f='Para comprobar la firma del launcher, MU Unit en Linux necesita OpenSSL 3, que viene en Ubuntu 22.04, Debian 12, Fedora 39 y versiones más nuevas. No se instaló nada.' ;;
    en:sem_openssl3_launcher) f='To check the launcher signature, MU Unit on Linux needs OpenSSL 3, which comes with Ubuntu 22.04, Debian 12, Fedora 39 and newer. Nothing was installed.' ;;
    pt:launcher_em_troca) f='O launcher do MU Unit está sendo atualizado agora. Tente de novo em alguns minutos.' ;;
    es:launcher_em_troca) f='El launcher de MU Unit se está actualizando ahora. Inténtalo de nuevo en unos minutos.' ;;
    en:launcher_em_troca) f='The MU Unit launcher is being updated right now. Try again in a few minutes.' ;;
    pt:uso) f='uso: muunit [abrir|instalar|reparar|desinstalar|diagnostico|versao] [--teste]' ;;
    es:uso) f='uso: muunit [abrir|instalar|reparar|desinstalar|diagnostico|versao] [--teste]' ;;
    en:uso) f='usage: muunit [abrir|instalar|reparar|desinstalar|diagnostico|versao] [--teste]' ;;
    *) f="$chave" ;;
  esac
  # shellcheck disable=SC2059
  printf -- "$f" "$@"
}

agora() { date '+%Y-%m-%d %H:%M:%S'; }

log() {
  [[ -d "$LOG_DIR" ]] || return 0
  printf '%s %s\n' "$(agora)" "$*" >> "$LOG" 2>/dev/null || true
}

girar_log() {
  local arq="$1" teto="$2"
  [[ -f "$arq" ]] || return 0
  if [[ "$(stat -c %s "$arq" 2>/dev/null || echo 0)" -gt "$teto" ]]; then
    mv -f "$arq" "$arq.1" 2>/dev/null || true
  fi
}

sem_marcacao() {
  printf '%s' "$1" | sed -e 's/&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g'
}

exibir_link() {
  local s="${1:0:120}"
  printf '%s' "${s//[^A-Za-z0-9._~:\/?#@!()*+,;=%-]/?}"
}

ui_inicio() {
  [[ "$TERMINAL" -eq 1 ]] && return 0
  [[ -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]] || return 0
  if ! command -v zenity >/dev/null 2>&1; then
    command -v notify-send >/dev/null 2>&1 && { notify-send "MU Unit" "$(t instalando)" >/dev/null 2>&1 || true; }
    return 0
  fi
  UI_FIFO="$TMP_DIR/ui.$$"
  rm -f "$UI_FIFO"
  mkfifo -m 600 "$UI_FIFO"
  zenity --progress --pulsate --auto-close --no-cancel --width=440 --title="MU Unit" --text="$(t passo_prefixo)" < "$UI_FIFO" >/dev/null 2>&1 &
  UI_PID=$!
  exec 9<>"$UI_FIFO"
}

ui_passo() {
  local texto="$1"
  log "$texto"
  if [[ "$TERMINAL" -eq 1 ]]; then
    printf '%s\n' "$texto" >&2
  elif [[ -n "$UI_PID" ]]; then
    printf '# %s\n' "$texto" >&9 2>/dev/null || true
  fi
}

ui_fim() {
  if [[ -n "$UI_PID" ]]; then
    printf '100\n' >&9 2>/dev/null || true
    exec 9>&-
    wait "$UI_PID" 2>/dev/null || true
    UI_PID=""
  fi
  [[ -n "$UI_FIFO" ]] && rm -f "$UI_FIFO"
  UI_FIFO=""
}

aviso() {
  local texto="$1" tipo="${2:-info}"
  log "$tipo: $texto"
  if [[ "$TERMINAL" -ne 1 && -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]]; then
    if command -v zenity >/dev/null 2>&1; then
      local marcado
      marcado="$(sem_marcacao "$texto")"
      case "$tipo" in
        erro) zenity --error --width=460 --title="MU Unit" --text="$marcado" >/dev/null 2>&1 || true ;;
        *) zenity --info --width=460 --title="MU Unit" --text="$marcado" >/dev/null 2>&1 || true ;;
      esac
      return 0
    elif command -v kdialog >/dev/null 2>&1; then
      case "$tipo" in
        erro) kdialog --title "MU Unit" --error "$texto" >/dev/null 2>&1 || true ;;
        *) kdialog --title "MU Unit" --msgbox "$texto" >/dev/null 2>&1 || true ;;
      esac
      return 0
    elif command -v notify-send >/dev/null 2>&1; then
      notify-send "MU Unit" "$texto" >/dev/null 2>&1 || true
      return 0
    fi
  fi
  printf '%s\n' "$texto" >&2 || true
}

falhar() {
  ui_fim
  aviso "$1" erro
  exit 1
}

ao_erro() {
  local linha="$1"
  [[ "$BASH_SUBSHELL" -gt 0 ]] && return 0
  trap - ERR
  log "erro na linha $linha"
  falhar "$(t erro "$LOG")"
}

perguntar() {
  local texto="$1" resposta=""
  if [[ "$TERMINAL" -eq 1 && -r /dev/tty ]]; then
    printf '%s [s/N] ' "$texto" > /dev/tty
    read -r resposta < /dev/tty || true
    [[ "$resposta" =~ ^[sSyY] ]]
    return
  fi
  if [[ -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]]; then
    if command -v zenity >/dev/null 2>&1; then
      zenity --question --width=460 --title="MU Unit" --text="$(sem_marcacao "$texto")" >/dev/null 2>&1
      return
    fi
    if command -v kdialog >/dev/null 2>&1; then
      kdialog --title "MU Unit" --yesno "$texto" >/dev/null 2>&1
      return
    fi
  fi
  aviso "$(t desinstalar_terminal)"
  return 1
}

definir_mundo() {
  case "$1" in
    producao)
      M_ID=producao M_MANIFESTO="$ARQUIVOS/manifest.json" M_PASTA="MUUnit" M_EXE="MUUnitLauncher.exe"
      M_ESQUEMA="muunit" M_DESKTOP="muunit" M_NOME="MU Unit" M_CLASSE="muunitlauncher.exe" ;;
    teste)
      M_ID=teste M_MANIFESTO="$ARQUIVOS/teste/manifest.json" M_PASTA="MUUnit-Teste" M_EXE="MUUnitTesteLauncher.exe"
      M_ESQUEMA="muunit-teste" M_DESKTOP="muunit-teste" M_NOME="MU Unit Teste" M_CLASSE="muunittestelauncher.exe" ;;
    *) return 1 ;;
  esac
}

versao_de() {
  sed -n 's/^readonly VERSAO="\([0-9][0-9.]*\)"$/\1/p' "$1" 2>/dev/null | head -n 1
}

versao_menor() {
  [[ "$1" != "$2" && "$(printf '%s\n%s\n' "$1" "$2" | sort -V | head -n 1)" == "$1" ]]
}

curl_moderno() {
  local v
  v="$(curl --version 2>/dev/null | awk 'NR==1 {print $2}')"
  [[ "$v" =~ ^[0-9]+\.[0-9]+\.[0-9]+ ]] || return 1
  ! versao_menor "${BASH_REMATCH[0]}" "7.71.0"
}

baixar() {
  local url="$1" destino="$2" nome="${3:-$1}" limite_mb="${4:-64}"
  [[ "$url" == https://* ]] || falhar "$(t rede "$nome")"
  rm -f "$destino"
  local ok=1 blocos=$((limite_mb * 1024))
  if command -v curl >/dev/null 2>&1; then
    local opcoes=(-sS)
    [[ "$TERMINAL" -eq 1 && "${MUUNIT_SILENCIO:-0}" != 1 ]] && opcoes=(--progress-bar)
    curl_moderno && opcoes+=(--retry-all-errors)
    ( ulimit -S -f "$blocos" 2>/dev/null || true; exec curl "${opcoes[@]}" --proto '=https' --proto-redir '=https' --tlsv1.2 -fL --max-redirs 6 --retry 3 --retry-delay 2 --connect-timeout 20 --speed-limit 1024 --speed-time 60 -o "$destino" "$url" ) && ok=0
  elif command -v wget >/dev/null 2>&1; then
    ( ulimit -S -f "$blocos" 2>/dev/null || true; exec wget -q --https-only --max-redirect=6 --tries=3 --timeout=30 -O "$destino" "$url" ) && ok=0
  else
    falhar "$(t comando "curl")"
  fi
  if [[ "$ok" -ne 0 ]]; then
    rm -f "$destino"
    return 1
  fi
}

baixar_texto() {
  local url="$1" destino="$2" segundos="${3:-15}" limite_mb="${4:-1}"
  local blocos=$((limite_mb * 1024))
  rm -f "$destino"
  if command -v curl >/dev/null 2>&1; then
    ( ulimit -S -f "$blocos" 2>/dev/null || true; exec curl -sS --proto '=https' --proto-redir '=https' --tlsv1.2 -fL --max-redirs 3 --max-time "$segundos" -o "$destino" "$url" ) 2>/dev/null || { rm -f "$destino"; return 1; }
  elif command -v wget >/dev/null 2>&1; then
    ( ulimit -S -f "$blocos" 2>/dev/null || true; exec wget -q --https-only --max-redirect=3 --timeout="$segundos" -O "$destino" "$url" ) 2>/dev/null || { rm -f "$destino"; return 1; }
  else
    return 1
  fi
}

conferir_hash() {
  local arq="$1" esperado="$2" tipo="$3" medido=""
  case "$tipo" in
    sha256) medido="$(sha256sum "$arq" | cut -d' ' -f1)" ;;
    sha1) medido="$(sha1sum "$arq" | cut -d' ' -f1)" ;;
  esac
  if [[ "$medido" != "$esperado" ]]; then
    log "hash errado em $arq: esperado $esperado, medido $medido"
    rm -f "$arq"
    return 1
  fi
}

ausente_na_rede() {
  local url="$1" codigo=""
  [[ "$url" == https://* ]] || return 1
  command -v curl >/dev/null 2>&1 || return 1
  codigo="$(curl -sIL --proto '=https' --proto-redir '=https' --tlsv1.2 --max-redirs 6 --connect-timeout 10 --max-time 20 -o /dev/null -w '%{http_code}' "$url" 2>/dev/null)" || true
  [[ "$codigo" == 404 || "$codigo" == 410 ]]
}

baixar_conferido() {
  local destino="$1" nome="$2" hash="$3" limite_mb="$4" url baixou=0 n=0
  shift 4
  for url in "$@"; do
    n=$((n + 1))
    if [[ "$n" -lt "$#" ]] && ausente_na_rede "$url"; then
      log "$nome indisponivel em $url"
      continue
    fi
    if baixar "$url" "$destino" "$nome" "$limite_mb"; then
      baixou=1
      conferir_hash "$destino" "$hash" sha256 && return 0
      log "$nome de $url nao confere com o sha256 fixado; tentando a proxima fonte"
    else
      log "$nome indisponivel em $url"
    fi
  done
  [[ "$baixou" -eq 1 ]] && falhar "$(t hash "$nome")"
  falhar "$(t rede "$nome")"
}

json_texto() {
  sed -n "s/.*\"$2\"[[:space:]]*:[[:space:]]*\"\\([^\"]*\\)\".*/\\1/p" "$1" | head -n 1
}

openssl3() {
  command -v openssl >/dev/null 2>&1 || return 1
  local v
  v="$(openssl version 2>/dev/null | awk '$1 == "OpenSSL" {print $2}')"
  [[ "${v%%.*}" =~ ^[0-9]+$ && "${v%%.*}" -ge 3 ]]
}

assinatura_valida() {
  local arq="$1" sig="$2"
  openssl3 || return 2
  local pub="$arq.pub" bin="$arq.sigbin"
  printf '%s\n' "$ESTEIRA_PUB" > "$pub"
  base64 -d < "$sig" > "$bin" 2>/dev/null || return 1
  openssl pkeyutl -verify -pubin -inkey "$pub" -rawin -in "$arq" -sigfile "$bin" >/dev/null 2>&1
}

indice_url() { printf '%s/%slinux.json' "$ARQUIVOS" "$CANAL"; }

ler_indice() {
  local destino="$1" exigir_assinatura="$2" q
  q="?t=$(date +%s)"
  baixar_texto "$(indice_url)$q" "$destino" 15 || return 1
  if ! baixar_texto "$(indice_url).sig$q" "$destino.sig" 15; then
    if [[ "$exigir_assinatura" == 1 ]]; then
      log "indice sem assinatura"
      return 1
    fi
  fi
  if [[ -f "$destino.sig" ]]; then
    local r=0
    assinatura_valida "$destino" "$destino.sig" || r=$?
    case "$r" in
      0) ;;
      2)
        if [[ "$exigir_assinatura" == 1 ]]; then
          log "sem OpenSSL 3 para conferir a assinatura do indice"
          return 1
        fi ;;
      *)
        log "assinatura do indice invalida"
        return 1 ;;
    esac
  fi
  if grep -q '"desligado"[[:space:]]*:[[:space:]]*true' "$destino"; then
    return 3
  fi
  return 0
}

exigencia() {
  if openssl3; then printf '1'; else printf '0'; fi
}

caminho_seguro() { [[ "$1" =~ ^linux/[0-9]+\.[0-9]+\.[0-9]+/[A-Za-z0-9][A-Za-z0-9._-]*$ ]]; }

nova_pasta_temporaria() {
  mktemp -d "$TMP_DIR/run.XXXXXX"
}

baixar_programa_em() {
  local d="$1" destino="$2" exigir="$3" indice="$4"
  if [[ -z "$indice" ]]; then
    indice="$d/linux.json"
    ler_indice "$indice" "$exigir" || return $?
  fi
  local versao script hash novo="$d/muunit.novo"
  versao="$(json_texto "$indice" versao)"
  script="$(json_texto "$indice" script)"
  hash="$(json_texto "$indice" script_sha256)"
  [[ "$versao" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ && "$hash" =~ ^[0-9a-f]{64}$ ]] || return 1
  caminho_seguro "$script" || return 1
  baixar "$ARQUIVOS/$CANAL$script" "$novo" "muunit" 4 || return 1
  conferir_hash "$novo" "$hash" sha256 || return 1
  [[ "$(versao_de "$novo")" == "$versao" ]] || return 1
  programa_sao "$novo" "$versao" || { log "muunit $versao baixado nao passou na fumaca"; return 1; }
  chmod 700 "$novo" || return 1
  [[ -f "$destino" ]] && cp -f "$destino" "$destino.anterior" 2>/dev/null
  mv -f "$novo" "$destino"
}

programa_sao() {
  local arq="$1" versao="${2:-}" saida
  bash -n "$arq" 2>/dev/null || return 1
  saida="$(MUUNIT_DIRETO=1 timeout 20 bash "$arq" versao 2>/dev/null)" || return 1
  [[ "$saida" =~ ^muunit\ [0-9]+\.[0-9]+\.[0-9]+$ ]] || return 1
  [[ -z "$versao" || "$saida" == "muunit $versao" ]]
}

baixar_programa() {
  local destino="$1" exigir="$2" indice="${3:-}" d r=0
  d="$(nova_pasta_temporaria)" || return 1
  baixar_programa_em "$d" "$destino" "$exigir" "$indice" || r=$?
  rm -rf -- "$d"
  return "$r"
}

autoatualizar() {
  local d versao
  d="$(nova_pasta_temporaria)" || return 0
  if ler_indice "$d/linux.json" 1; then
    local forcar=0
    versao="$(json_texto "$d/linux.json" versao)"
    grep -q '"forcar"[[:space:]]*:[[:space:]]*true' "$d/linux.json" && forcar=1
    if [[ "$versao" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ && "$versao" != "$VERSAO" ]] && { versao_menor "$VERSAO" "$versao" || [[ "$forcar" -eq 1 ]]; }; then
      exec 7>"$BASE/.trava-programa"
      if flock -n 7 && [[ "$(versao_de "$PROGRAMA")" != "$versao" ]]; then
        if MUUNIT_SILENCIO=1 baixar_programa "$PROGRAMA" 1 "$d/linux.json"; then
          log "programa atualizado de $VERSAO para $versao"
        fi
      fi
      exec 7>&-
    fi
  fi
  rm -rf -- "$d"
}

iniciar_autoatualizacao() {
  [[ "$ATUALIZACAO_INICIADA" -eq 1 ]] && return 0
  ATUALIZACAO_INICIADA=1
  ( trap - ERR; set +e; autoatualizar >/dev/null 2>&1 & ) || true
}

garantir_pastas() {
  case "$BASE" in
    *[\"\`\$%]*|*\\*|*$'\n'*) falhar "$(t caminho "$BASE")" ;;
  esac
  if [[ -d "$BASE" && ! -f "$BASE/.instalacao-muunit" && ! -f "$BASE/instalado" && ! -f "$BIN_DIR/muunit" ]]; then
    [[ -z "$(ls -A -- "$BASE" 2>/dev/null)" ]] || falhar "$(t pasta_alheia "$BASE")"
  fi
  mkdir -p "$BASE" "$BIN_DIR" "$TMP_DIR" "$LOG_DIR" "$BASE/wine" "$BASE/cache"
  chmod 700 "$BASE"
  [[ -f "$BASE/.instalacao-muunit" ]] || : > "$BASE/.instalacao-muunit"
  find "$TMP_DIR" -mindepth 1 -maxdepth 1 -name 'run.*' -mmin +120 -exec rm -rf -- {} + 2>/dev/null || true
}

bootstrap() {
  local proprio="$1"
  shift
  if [[ "$EUID" -eq 0 ]]; then
    printf '%s\n' "$(t raiz)" >&2
    exit 1
  fi
  garantir_pastas
  exec 7>"$BASE/.trava-programa"
  if command -v flock >/dev/null 2>&1; then
    flock -w 120 7 || { printf '%s\n' "$(t trava)" >&2; exit 1; }
  fi
  export MUUNIT_DIRETO=1
  local instalada=""
  [[ -f "$PROGRAMA" ]] && instalada="$(versao_de "$PROGRAMA")"
  if [[ -n "$instalada" ]] && ! versao_menor "$instalada" "$VERSAO" && programa_sao "$PROGRAMA"; then
    exec 7>&-
    exec bash "$PROGRAMA" "$@"
  fi
  if [[ -n "$proprio" && -f "$proprio" ]]; then
    install -m 700 "$proprio" "$PROGRAMA.novo"
    mv -f "$PROGRAMA.novo" "$PROGRAMA"
    exec 7>&-
    exec bash "$PROGRAMA" "$@"
  fi
  local i r=0
  for i in "$@"; do [[ "$i" == "--canal-teste" ]] && CANAL="teste/"; done
  baixar_programa "$PROGRAMA" "$(exigencia)" || r=$?
  exec 7>&-
  if [[ "$r" -eq 3 ]]; then
    printf '%s\n' "$(t desligado)" >&2
    exit 1
  fi
  if [[ "$r" -ne 0 ]]; then
    printf '%s\n' "$(t rede "$(indice_url)")" >&2
    exit 1
  fi
  if [[ "$#" -eq 0 ]]; then
    exec bash "$PROGRAMA" instalar < /dev/null
  fi
  exec bash "$PROGRAMA" "$@" < /dev/null
}

ldconfig_lista() {
  local c
  for c in ldconfig /sbin/ldconfig /usr/sbin/ldconfig /usr/bin/ldconfig; do
    if command -v "$c" >/dev/null 2>&1; then
      "$c" -p 2>/dev/null
      return 0
    fi
  done
  return 1
}

comando_pacotes() {
  if command -v apt-get >/dev/null 2>&1; then
    printf 'sudo apt install libgnutls30 libfreetype6 libfontconfig1 libx11-6 libxext6 libgl1 libegl1 libpulse0'
  elif command -v dnf >/dev/null 2>&1; then
    printf 'sudo dnf install gnutls freetype fontconfig libX11 libXext mesa-libGL mesa-libEGL pulseaudio-libs'
  elif command -v pacman >/dev/null 2>&1; then
    printf 'sudo pacman -S --needed gnutls freetype2 fontconfig libx11 libxext libglvnd libpulse'
  elif command -v zypper >/dev/null 2>&1; then
    printf 'sudo zypper install libgnutls30 libfreetype6 fontconfig libX11-6 libXext6 Mesa-libGL1 Mesa-libEGL1 libpulse0'
  else
    printf 'gnutls, freetype, fontconfig, libX11, libXext, libGL, libEGL, libpulse'
  fi
}

comando_openssl() {
  if command -v apt-get >/dev/null 2>&1; then
    printf 'sudo apt install openssl'
  elif command -v dnf >/dev/null 2>&1; then
    printf 'sudo dnf install openssl'
  elif command -v pacman >/dev/null 2>&1; then
    printf 'sudo pacman -S --needed openssl'
  elif command -v zypper >/dev/null 2>&1; then
    printf 'sudo zypper install openssl'
  else
    printf 'openssl'
  fi
}

conferir_sistema() {
  [[ "$EUID" -ne 0 ]] || falhar "$(t raiz)"
  local arq
  arq="$(uname -m)"
  [[ "$arq" == "x86_64" ]] || falhar "$(t arquitetura "$arq")"
  local c
  for c in tar xz gzip sha256sum sha1sum flock sed awk grep install mkfifo find mktemp stat readlink timeout; do
    command -v "$c" >/dev/null 2>&1 || falhar "$(t comando "$c")"
  done
  command -v curl >/dev/null 2>&1 || command -v wget >/dev/null 2>&1 || falhar "$(t comando "curl")"
  command -v openssl >/dev/null 2>&1 || falhar "$(t openssl_falta "$(comando_openssl)")"
  openssl3 || falhar "$(t sem_openssl3_launcher)"
  local lista
  if lista="$(ldconfig_lista)"; then
    local faltam=() l
    for l in libgnutls.so.30 libfreetype.so.6 libfontconfig.so.1 libX11.so.6 libXext.so.6 libGL.so.1; do
      grep -q -E "[[:space:]]${l}[[:space:]]" <<< "$lista" || faltam+=("$l")
    done
    if ! grep -q -E "[[:space:]](libpulse\.so\.0|libasound\.so\.2)[[:space:]]" <<< "$lista"; then
      faltam+=("libpulse.so.0")
    fi
    if [[ "${#faltam[@]}" -gt 0 ]]; then
      falhar "$(t bibliotecas "${faltam[*]}" "$(comando_pacotes)")"
    fi
  else
    log "sem ldconfig: bibliotecas nao conferidas"
  fi
  local livre
  livre="$(df -Pm "$BASE" 2>/dev/null | awk 'NR==2 {print $4}')"
  if [[ "$livre" =~ ^[0-9]+$ && "$livre" -lt "$ESPACO_MB" ]]; then
    falhar "$(t espaco "$((ESPACO_MB / 1024))" "$BASE")"
  fi
}

conferir_grafico() {
  [[ -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]] || falhar "$(t grafico)"
}

wine_ambiente() {
  export WINEPREFIX="$PREFIXO"
  export WINEDEBUG="${MUUNIT_WINEDEBUG:--all}"
  export WINEDLLOVERRIDES="mscoree,mshtml=;winemenubuilder.exe=d"
  export WEBVIEW2_BROWSER_EXECUTABLE_FOLDER="C:\\MUUnit-Runtime\\WebView2\\$WV2_VERSAO"
  export PATH="$WINE_DIR/bin:$PATH"
  unset WINEARCH WINELOADER WINESERVER WINEDLLPATH
}

wine_garantir() {
  [[ -x "$WINE_DIR/bin/wine" && -f "$WINE_DIR/.muunit-ok" ]] && return 0
  ui_passo "$(t passo_wine "$WINE_MB")"
  local tar="$BASE/cache/$WINE_NOME.tar.xz"
  if [[ ! -f "$tar" ]] || ! conferir_hash "$tar" "$WINE_SHA256" sha256; then
    baixar_conferido "$tar" "Wine" "$WINE_SHA256" $((WINE_MB * 2 + 64)) "$ARQUIVOS/linux/terceiros/$WINE_NOME.tar.xz" "$WINE_URL"
  fi
  rm -rf "$WINE_DIR.parcial"
  mkdir -p "$WINE_DIR.parcial"
  tar -xJf "$tar" -C "$WINE_DIR.parcial" --strip-components=1 --no-same-owner --no-same-permissions 2>> "$LOG_DIR/wine-instalacao.log"
  rm -rf "$WINE_DIR.parcial/include" "$WINE_DIR.parcial/share/man"
  find "$WINE_DIR.parcial/lib" -name '*.a' -type f -delete 2>/dev/null || true
  chmod -R go-w "$WINE_DIR.parcial"
  [[ -x "$WINE_DIR.parcial/bin/wine" ]] || falhar "$(t hash "Wine")"
  rm -rf "$WINE_DIR"
  mv "$WINE_DIR.parcial" "$WINE_DIR"
  touch "$WINE_DIR/.muunit-ok"
  rm -f "$tar"
  local velho
  for velho in "$BASE"/wine/*; do
    [[ -d "$velho" && "$velho" != "$WINE_DIR" ]] && rm -rf "$velho"
  done
  return 0
}

prefixo_higiene() {
  rm -f "$PREFIXO/dosdevices/z:"
  local usuario item
  for usuario in "$PREFIXO"/drive_c/users/*; do
    [[ -d "$usuario" ]] || continue
    for item in "$usuario"/* "$usuario"/AppData/Roaming/Microsoft/Windows/Templates; do
      if [[ -L "$item" ]]; then
        rm -f "$item"
        mkdir -p "$item"
      fi
    done
  done
  printf 'disable\n' > "$PREFIXO/.update-timestamp"
  chmod 700 "$PREFIXO"
}

guid_da_maquina() {
  local arq id=""
  for arq in /etc/machine-id /var/lib/dbus/machine-id; do
    [[ -r "$arq" ]] || continue
    id="$(tr -dc '0-9a-f' < "$arq" | head -c 32)"
    [[ "${#id}" -eq 32 ]] && break
    id=""
  done
  [[ -n "$id" ]] || return 1
  local h
  h="$(printf 'muunit-maquina:%s' "$id" | sha256sum | cut -c1-32)"
  printf '%s-%s-%s-%s-%s' "${h:0:8}" "${h:8:4}" "${h:12:4}" "${h:16:4}" "${h:20:12}"
}

prefixo_ajustar() {
  wine_ambiente
  local politica='HKLM\Software\Policies\Microsoft\Edge\WebView2' guid=""
  wine reg add "$politica\\BrowserExecutableFolder" /v '*' /t REG_SZ /d "C:\\MUUnit-Runtime\\WebView2\\$WV2_VERSAO" /f >> "$LOG_DIR/wine-instalacao.log" 2>&1
  wine reg add "$politica\\AdditionalBrowserArguments" /v '*' /t REG_SZ /d "$WV2_ARGS" /f >> "$LOG_DIR/wine-instalacao.log" 2>&1
  if guid="$(guid_da_maquina)"; then
    wine reg add 'HKLM\SOFTWARE\Microsoft\Cryptography' /v MachineGuid /t REG_SZ /d "$guid" /f /reg:64 >> "$LOG_DIR/wine-instalacao.log" 2>&1
  fi
  timeout 30 wineserver -w || true
}

prefixo_garantir() {
  local marca="$PREFIXO/.muunit-wine" esperado="$WINE_NOME rev $PREFIXO_REV" atual=""
  atual="$(cat "$marca" 2>/dev/null || true)"
  if [[ -f "$PREFIXO/system.reg" && "$atual" == "$esperado" ]]; then
    [[ -e "$PREFIXO/dosdevices/z:" ]] && prefixo_higiene
    return 0
  fi
  if [[ -f "$PREFIXO/system.reg" && "${atual%% rev *}" == "$WINE_NOME" ]]; then
    prefixo_ajustar
    prefixo_higiene
    printf '%s\n' "$esperado" > "$marca"
    return 0
  fi
  ui_passo "$(t passo_prefixo)"
  wine_ambiente
  mkdir -p "$PREFIXO"
  chmod 700 "$PREFIXO"
  rm -f "$PREFIXO/.update-timestamp"
  wine wineboot -u >> "$LOG_DIR/wine-instalacao.log" 2>&1
  timeout 120 wineserver -w || true
  prefixo_ajustar
  prefixo_higiene
  printf '%s\n' "$esperado" > "$marca"
}

webview2_garantir() {
  local raiz="$PREFIXO/drive_c/MUUnit-Runtime/WebView2" dest
  dest="$raiz/$WV2_VERSAO"
  [[ -f "$dest/msedgewebview2.exe" ]] && return 0
  ui_passo "$(t passo_webview2 "$WV2_MB")"
  local cab="$BASE/cache/WebView2-$WV2_VERSAO-x64.cab"
  if [[ ! -f "$cab" ]] || ! conferir_hash "$cab" "$WV2_SHA256" sha256; then
    baixar_conferido "$cab" "WebView2" "$WV2_SHA256" $((WV2_MB * 2 + 64)) "$ARQUIVOS/linux/terceiros/WebView2-$WV2_VERSAO-x64.cab" "$WV2_URL"
  fi
  rm -rf "$dest.parcial"
  mkdir -p "$dest.parcial"
  if command -v cabextract >/dev/null 2>&1; then
    cabextract -q -d "$dest.parcial" "$cab" >> "$LOG_DIR/wine-instalacao.log" 2>&1
  else
    wine_ambiente
    cp -f "$cab" "$raiz/pacote.cab"
    wine extrac32 /Y /E /L "C:\\MUUnit-Runtime\\WebView2\\$WV2_VERSAO.parcial" "C:\\MUUnit-Runtime\\WebView2\\pacote.cab" >> "$LOG_DIR/wine-instalacao.log" 2>&1
    timeout 120 wineserver -w || true
    rm -f "$raiz/pacote.cab"
  fi
  local exe
  exe="$(find "$dest.parcial" -maxdepth 3 -iname msedgewebview2.exe -type f | head -n 1)"
  [[ -n "$exe" ]] || falhar "$(t hash "WebView2")"
  rm -rf "$dest"
  mv "$(dirname "$exe")" "$dest"
  rm -rf "$dest.parcial"
  rm -f "$cab"
  local velho
  for velho in "$raiz"/*; do
    [[ -d "$velho" && "$velho" != "$dest" ]] && rm -rf "$velho"
  done
  return 0
}

rodando_no_prefixo() {
  local padrao="$1" pid
  command -v pgrep >/dev/null 2>&1 || return 1
  for pid in $(pgrep -u "$(id -u)" -f -- "$padrao" 2>/dev/null || true); do
    if tr '\0' '\n' < "/proc/$pid/environ" 2>/dev/null | grep -qxF "WINEPREFIX=$PREFIXO"; then
      return 0
    fi
  done
  return 1
}

launcher_balde() {
  local id h
  id="$(awk '/^\[Software\\\\Microsoft\\\\Cryptography\]/ {s = 1; next} /^\[/ {s = 0} s && /^"MachineGuid"="/ {print; exit}' "$PREFIXO/system.reg" 2>/dev/null | sed -n 's/^"MachineGuid"="\([0-9A-Fa-f-]\{36\}\)"$/\1/p' | tr 'A-F' 'a-f')"
  [[ -n "$id" ]] || return 1
  h="$(printf 'passagem-unit|%s' "$id" | sha1sum | cut -c1-8)"
  printf '%s' "$((16#$h % 100))"
}

launcher_no_percentual() {
  local percentual="$1" equipe="$2" balde
  [[ "$equipe" -eq 1 ]] && return 0
  [[ "$percentual" -gt 0 ]] || return 1
  [[ "$percentual" -ge 100 ]] && return 0
  balde="$(launcher_balde)" || return 1
  [[ "$balde" -lt "$percentual" ]]
}

launcher_recusado() {
  local sha="$1" arq
  while IFS= read -r arq; do
    grep -qix -- "$sha" "$arq" 2>/dev/null && return 0
  done < <(find "$PREFIXO/drive_c/users" -maxdepth 7 -name 'unit-launcher-ruim.txt' -type f 2>/dev/null || true)
  return 1
}

launcher_versao_registrada() {
  local sha_atual="$1" s="" v=""
  [[ -f "$BASE/launcher-$M_ID" ]] || return 1
  read -r s v < "$BASE/launcher-$M_ID" || true
  [[ -n "$s" && "$s" == "$sha_atual" && "$v" =~ ^[0-9]+(\.[0-9]+)*$ ]] || return 1
  printf '%s' "$v"
}

launcher_assinatura_ok() {
  local sha="$1" assinatura="$2" exigir="${3:-0}" d r=0
  if [[ -z "$assinatura" ]]; then
    [[ "$exigir" -eq 1 ]] || return 0
    log "launcher $M_ID: bloco sem assinatura"
    return 3
  fi
  d="$(nova_pasta_temporaria)" || return 1
  printf '%s' "$sha" > "$d/sha1"
  printf '%s\n' "$assinatura" > "$d/sha1.sig"
  assinatura_valida "$d/sha1" "$d/sha1.sig" || r=$?
  rm -rf -- "$d"
  case "$r" in
    0) return 0 ;;
    2)
      log "launcher $M_ID: sem OpenSSL 3 para conferir a assinatura do bloco"
      [[ "$exigir" -eq 1 ]] && return 4
      return 0 ;;
    *) return 1 ;;
  esac
}

launcher_manter() {
  local exe="$1" motivo="$2" chave="$3" alvo="$4"
  if [[ -f "$exe" ]]; then
    log "launcher $M_ID mantido: $motivo"
    return 0
  fi
  falhar "$(t "$chave" "$alvo")"
}

launcher_garantir() {
  local pasta="$PREFIXO/drive_c/$M_PASTA" exe
  exe="$pasta/$M_EXE"
  mkdir -p "$pasta"
  local manifesto="$TMP_DIR/manifesto-$M_ID.json"
  if ! baixar_texto "$M_MANIFESTO" "$manifesto" 120 64; then
    launcher_manter "$exe" "manifesto indisponivel" rede "$M_MANIFESTO"
    return 0
  fi
  local bloco sha tamanho versao percentual minima assinatura equipe=0
  bloco="$(grep -o '"launcher_unit"[[:space:]]*:[[:space:]]*{[^}]*}' "$manifesto" | head -n 1 || true)"
  rm -f "$manifesto"
  sha="$(sed -n 's/.*"sha1"[[:space:]]*:[[:space:]]*"\([0-9a-f]\{40\}\)".*/\1/p' <<< "$bloco")"
  tamanho="$(sed -n 's/.*"tamanho"[[:space:]]*:[[:space:]]*\([0-9]\{1,12\}\)[[:space:]]*[,}].*/\1/p' <<< "$bloco")"
  versao="$(sed -n 's/.*"versao"[[:space:]]*:[[:space:]]*"\([0-9][0-9.]\{0,30\}\)".*/\1/p' <<< "$bloco")"
  percentual="$(sed -n 's/.*"percentual"[[:space:]]*:[[:space:]]*\([0-9]\{1,3\}\)[[:space:]]*[,}].*/\1/p' <<< "$bloco")"
  minima="$(sed -n 's/.*"minima"[[:space:]]*:[[:space:]]*"\([0-9][0-9.]\{0,30\}\)".*/\1/p' <<< "$bloco")"
  assinatura="$(sed -n 's/.*"assinatura"[[:space:]]*:[[:space:]]*"\([A-Za-z0-9+\/=]\{1,200\}\)".*/\1/p' <<< "$bloco")"
  grep -q '"equipe"[[:space:]]*:[[:space:]]*true' <<< "$bloco" && equipe=1
  percentual="${percentual:-0}"
  if [[ -z "$sha" || -z "$tamanho" || "$tamanho" -eq 0 ]]; then
    launcher_manter "$exe" "bloco launcher_unit ausente ou incompleto" rede "$M_MANIFESTO"
    return 0
  fi
  if [[ -f "$exe" ]]; then
    local atual forcado=0 registrada=""
    atual="$(sha1sum "$exe" | cut -d' ' -f1)"
    if [[ "$atual" == "$sha" ]]; then
      if [[ -n "$versao" && "$(cat "$BASE/launcher-$M_ID" 2>/dev/null || true)" != "$sha $versao" ]]; then
        printf '%s %s\n' "$sha" "$versao" > "$BASE/launcher-$M_ID"
      fi
      return 0
    fi
    if [[ "$percentual" -le 0 && "$equipe" -ne 1 ]]; then
      log "launcher $M_ID mantido: bloco com percentual 0"
      return 0
    fi
    if [[ -n "$minima" ]]; then
      registrada="$(launcher_versao_registrada "$atual" || true)"
      if [[ -z "$registrada" ]] || versao_menor "$registrada" "$minima"; then
        forcado=1
      fi
    fi
    if [[ "$forcado" -ne 1 ]] && ! launcher_no_percentual "$percentual" "$equipe"; then
      log "launcher $M_ID mantido: fora do percentual $percentual"
      return 0
    fi
    if launcher_recusado "$sha"; then
      log "launcher $M_ID mantido: $sha recusado neste prefixo"
      return 0
    fi
    rodando_no_prefixo "$M_EXE" && return 0
  elif [[ "$percentual" -le 0 && "$equipe" -ne 1 ]]; then
    falhar "$(t launcher_em_troca)"
  fi
  local exigir=0 conferida=0
  [[ "$M_ID" == producao ]] && exigir=1
  launcher_assinatura_ok "$sha" "$assinatura" "$exigir" || conferida=$?
  case "$conferida" in
    0) ;;
    3) launcher_manter "$exe" "bloco sem assinatura" launcher_sem_assinatura ""; return 0 ;;
    4) launcher_manter "$exe" "sem OpenSSL 3 para conferir o bloco" sem_openssl3_launcher ""; return 0 ;;
    *) launcher_manter "$exe" "assinatura do bloco invalida" hash launcher; return 0 ;;
  esac
  ui_passo "$(t passo_launcher)"
  local novo="$TMP_DIR/$M_EXE.novo" limite=$((tamanho / 1048576 + 4))
  rm -f "$novo" "$novo.gz"
  if baixar "$ARQUIVOS/obj/$sha.gz" "$novo.gz" "launcher" "$limite"; then
    ( ulimit -S -f $((limite * 1024)) 2>/dev/null || true; exec gzip -dc "$novo.gz" ) > "$novo" 2>/dev/null || rm -f "$novo"
    rm -f "$novo.gz"
  fi
  if [[ ! -s "$novo" ]] && ! baixar "$ARQUIVOS/obj/$sha" "$novo" "launcher" "$limite"; then
    launcher_manter "$exe" "download do launcher falhou" rede launcher
    return 0
  fi
  if [[ "$(stat -c %s "$novo")" != "$tamanho" ]] || ! conferir_hash "$novo" "$sha" sha1; then
    rm -f "$novo"
    launcher_manter "$exe" "launcher baixado nao confere" hash launcher
    return 0
  fi
  chmod 600 "$novo"
  mv -f "$novo" "$exe"
  if [[ -n "$versao" ]]; then
    printf '%s %s\n' "$sha" "$versao" > "$BASE/launcher-$M_ID"
  else
    rm -f "$BASE/launcher-$M_ID"
  fi
  local sobra
  for sobra in "$pasta"/*.old "$pasta"/*.new "$pasta"/*.part "$pasta"/*.ruim "$pasta"/*.velho "$pasta"/*.unit.exe; do
    [[ -e "$sobra" ]] && rm -f "$sobra"
  done
  log "launcher $M_ID atualizado para $sha"
}

icone_garantir() {
  local destino="$ICONES_DIR/$M_DESKTOP.png" d chave caminho hash
  [[ -f "$destino" ]] && return 0
  d="$(nova_pasta_temporaria)" || return 0
  if ler_indice "$d/linux.json" "$(exigencia)"; then
    chave="icone"
    [[ "$M_ID" == teste ]] && chave="icone_teste"
    caminho="$(json_texto "$d/linux.json" "$chave")"
    hash="$(json_texto "$d/linux.json" "${chave}_sha256")"
    if [[ "$hash" =~ ^[0-9a-f]{64}$ ]] && caminho_seguro "$caminho"; then
      mkdir -p "$ICONES_DIR"
      if baixar "$ARQUIVOS/$CANAL$caminho" "$d/icone.png" "icone" 4 && conferir_hash "$d/icone.png" "$hash" sha256; then
        chmod 644 "$d/icone.png"
        mv -f "$d/icone.png" "$destino"
      fi
    fi
  fi
  rm -rf -- "$d"
  return 0
}

integrar() {
  if [[ "$M_ID" == producao && -f "$PACOTE_DESKTOP" ]]; then
    return 0
  fi
  icone_garantir
  mkdir -p "$APPS_DIR"
  local arq="$APPS_DIR/$M_DESKTOP.desktop" extra=""
  [[ "$M_ID" == teste ]] && extra=" --teste"
  atalho_conteudo "$extra" > "$arq.novo"
  if [[ -f "$arq" && "$(cat "$arq.novo")" == "$(cat "$arq")" ]]; then
    rm -f "$arq.novo"
    return 0
  fi
  ui_passo "$(t passo_atalho)"
  chmod 644 "$arq.novo"
  mv -f "$arq.novo" "$arq"
  command -v xdg-mime >/dev/null 2>&1 && xdg-mime default "$M_DESKTOP.desktop" "x-scheme-handler/$M_ESQUEMA" >/dev/null 2>&1 || true
  command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q "$APPS_DIR" >/dev/null 2>&1 || true
  return 0
}

atalho_conteudo() {
  local extra="$1"
  {
    printf '[Desktop Entry]\n'
    printf 'Type=Application\n'
    printf 'Version=1.5\n'
    printf 'Name=%s\n' "$M_NOME"
    printf 'Comment=MMORPG MU Unit\n'
    printf 'Comment[pt_BR]=MMORPG MU Unit\n'
    printf 'Comment[es]=MMORPG MU Unit\n'
    printf 'Exec="%s" abrir%s %%u\n' "$PROGRAMA" "$extra"
    printf 'Icon=%s\n' "$M_DESKTOP"
    printf 'Terminal=false\n'
    printf 'Categories=Game;RolePlaying;\n'
    printf 'MimeType=x-scheme-handler/%s;\n' "$M_ESQUEMA"
    printf 'StartupWMClass=%s\n' "$M_CLASSE"
    printf 'StartupNotify=true\n'
    printf 'Actions=desinstalar;\n'
    printf '\n[Desktop Action desinstalar]\n'
    printf 'Name=Uninstall\n'
    printf 'Name[pt_BR]=Desinstalar\n'
    printf 'Name[es]=Desinstalar\n'
    printf 'Exec="%s" desinstalar\n' "$PROGRAMA"
  }
}

instalado() {
  [[ -x "$WINE_DIR/bin/wine" && -f "$WINE_DIR/.muunit-ok" && -f "$PREFIXO/system.reg" ]] || return 1
  [[ -f "$PREFIXO/drive_c/MUUnit-Runtime/WebView2/$WV2_VERSAO/msedgewebview2.exe" ]] || return 1
  [[ -f "$PREFIXO/drive_c/$M_PASTA/$M_EXE" ]] || return 1
}

preparar_mundo() {
  definir_mundo "$1"
  launcher_garantir
  integrar
}

limpar_instalacao() {
  ui_fim
  rm -rf -- "$WINE_DIR.parcial" "$PREFIXO/drive_c/MUUnit-Runtime/WebView2/$WV2_VERSAO.parcial"
}

avisar_sem_openssl3() {
  openssl3 && return 0
  [[ -f "$BASE/.aviso-openssl3" ]] && return 0
  : > "$BASE/.aviso-openssl3"
  log "sem OpenSSL 3: autoatualizacao do programa desligada"
  aviso "$(t sem_openssl3)"
}

memoria_kb() {
  awk '/^MemTotal:/ {print $2; exit}' /proc/meminfo 2>/dev/null || true
}

avisar_pouca_memoria() {
  [[ -f "$BASE/.aviso-memoria" ]] && return 0
  local kb
  kb="$(memoria_kb)"
  [[ "$kb" =~ ^[0-9]+$ ]] || return 0
  [[ "$kb" -lt 6291456 ]] || return 0
  log "pouca memoria: $kb kB"
  aviso "$(t memoria "$(((kb + 524288) / 1048576))")"
  : > "$BASE/.aviso-memoria"
}

cmd_instalar() {
  local teste=0 abrir=1 a
  for a in "$@"; do
    case "$a" in
      --teste) teste=1 ;;
      --sem-abrir) abrir=0 ;;
    esac
  done
  conferir_sistema
  avisar_pouca_memoria
  exec 8>"$BASE/.trava"
  if ! flock -w 900 8; then
    falhar "$(t trava)"
  fi
  trap 'limpar_instalacao; exit 130' INT TERM HUP
  ui_inicio
  wine_garantir
  prefixo_garantir
  webview2_garantir
  preparar_mundo producao
  [[ "$teste" -eq 1 ]] && preparar_mundo teste
  printf '%s\n' "$VERSAO" > "$BASE/instalado"
  ui_fim
  trap - INT TERM HUP
  flock -u 8
  log "instalado $VERSAO (teste=$teste)"
  avisar_sem_openssl3
  if [[ "$abrir" -eq 1 && -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]]; then
    local mundo=producao
    [[ "$teste" -eq 1 && ! -f "$PREFIXO/drive_c/MUUnit/MUUnitLauncher.exe" ]] && mundo=teste
    if [[ "$mundo" == teste ]]; then cmd_abrir --teste; else cmd_abrir; fi
  fi
  [[ "$TERMINAL" -eq 1 ]] && printf '%s\n' "$(t pronto)" >&2
  return 0
}

cmd_abrir() {
  local mundo=producao link="" a
  for a in "$@"; do
    case "$a" in
      --teste) mundo=teste ;;
      muunit://*|muunit-teste://*) link="$a" ;;
      "") ;;
      --*) ;;
      *) falhar "$(t link "$(exibir_link "$a")")" ;;
    esac
  done
  if [[ -n "$link" ]]; then
    [[ "$link" == muunit-teste://* ]] && mundo=teste
    local padrao='^muunit(-teste)?://[A-Za-z0-9._~:/?#@!$&()*+,;=%-]*$'
    if [[ "${#link}" -gt 2048 || ! "$link" =~ $padrao ]]; then
      falhar "$(t link "$(exibir_link "$link")")"
    fi
  fi
  definir_mundo "$mundo"
  conferir_grafico
  if ! instalado; then
    exec 8>"$BASE/.trava"
    flock -w 900 8 || falhar "$(t trava)"
    flock -u 8
    if ! instalado; then
      if [[ "$mundo" == teste ]]; then cmd_instalar --teste --sem-abrir; else cmd_instalar --sem-abrir; fi
      definir_mundo "$mundo"
    fi
  fi
  iniciar_autoatualizacao
  exec 8>"$BASE/.trava"
  if flock -w 120 8; then
    prefixo_garantir
    launcher_garantir || true
    integrar || true
    flock -u 8
  fi
  wine_ambiente
  girar_log "$LOG_DIR/wine-$M_ID.log" 5242880
  local argumentos=()
  [[ -n "$link" ]] && argumentos=(--link "$link")
  log "abrindo $M_ID ${link:+com link}"
  cd "$PREFIXO/drive_c/$M_PASTA"
  exec wine "C:\\$M_PASTA\\$M_EXE" "${argumentos[@]}" >> "$LOG_DIR/wine-$M_ID.log" 2>&1 < /dev/null
}

cmd_reparar() {
  conferir_sistema
  exec 8>"$BASE/.trava"
  flock -w 900 8 || falhar "$(t trava)"
  wine_ambiente
  [[ -x "$WINE_DIR/bin/wineserver" ]] && wineserver -k >/dev/null 2>&1 || true
  rm -f "$WINE_DIR/.muunit-ok" "$PREFIXO/.muunit-wine"
  rm -rf "$PREFIXO/drive_c/MUUnit-Runtime/WebView2/$WV2_VERSAO"
  flock -u 8
  cmd_instalar --sem-abrir "$@"
}

cmd_desinstalar() {
  local sim=0 a
  for a in "$@"; do [[ "$a" == "--sim" ]] && sim=1; done
  if [[ "$sim" -ne 1 ]] && ! perguntar "$(t confirmar)"; then
    return 0
  fi
  [[ -f "$BASE/.instalacao-muunit" && "$BASE" == /*/muunit ]] || falhar "$(t nao_instalado)"
  if [[ -x "$WINE_DIR/bin/wineserver" && -d "$PREFIXO" ]]; then
    WINEPREFIX="$PREFIXO" timeout 30 "$WINE_DIR/bin/wineserver" -k >/dev/null 2>&1 || true
  fi
  local d
  for d in muunit muunit-teste; do
    rm -f "$APPS_DIR/$d.desktop" "$ICONES_DIR/$d.png" "$DADOS/icons/hicolor/256x256/apps/$d.png"
  done
  local ml="${XDG_CONFIG_HOME:-$HOME/.config}/mimeapps.list"
  if [[ -f "$ml" ]] && grep -Eq '=muunit(-teste)?\.desktop;?$' "$ml" 2>/dev/null; then
    sed -i --follow-symlinks '/=muunit\(-teste\)\?\.desktop;\?$/d' "$ml" 2>/dev/null || true
  fi
  command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q "$APPS_DIR" >/dev/null 2>&1 || true
  rm -rf -- "${BASE:?}/prefixo" "${BASE:?}/wine" "${BASE:?}/bin" "${BASE:?}/tmp" "${BASE:?}/logs" "${BASE:?}/cache"
  rm -f -- "${BASE:?}/canal" "${BASE:?}/instalado" "${BASE:?}/.trava" "${BASE:?}/.trava-programa" "${BASE:?}/.aviso-openssl3" "${BASE:?}/.aviso-memoria" \
    "${BASE:?}/launcher-producao" "${BASE:?}/launcher-teste" "${BASE:?}/.instalacao-muunit"
  if [[ -L "$BASE" ]]; then
    { rmdir -- "$(readlink -f -- "$BASE")" 2>/dev/null && rm -f -- "$BASE"; } || true
  else
    rmdir -- "$BASE" 2>/dev/null || true
  fi
  local texto
  texto="$(t removido)"
  if [[ -f "$PACOTE_DESKTOP" ]]; then
    local remover="sudo apt remove muunit"
    command -v dpkg >/dev/null 2>&1 || remover="sudo rpm -e muunit"
    texto="$texto"$'\n'"$(t removido_pacote "$remover")"
  fi
  aviso "$texto"
}

cmd_diagnostico() {
  local so="?" sessao="${XDG_SESSION_TYPE:-?}"
  [[ -r /etc/os-release ]] && so="$(sed -n 's/^PRETTY_NAME="\{0,1\}\([^"]*\)"\{0,1\}$/\1/p' /etc/os-release | head -n 1)"
  printf 'muunit %s\n' "$VERSAO"
  printf 'sistema: %s | kernel %s | %s\n' "$so" "$(uname -r)" "$(ldd --version 2>/dev/null | head -n 1)"
  printf 'sessao: %s | DISPLAY=%s | WAYLAND_DISPLAY=%s\n' "$sessao" "${DISPLAY:-}" "${WAYLAND_DISPLAY:-}"
  printf 'pasta: %s (livre: %s MB)\n' "$BASE" "$(df -Pm "$DADOS" 2>/dev/null | awk 'NR==2 {print $4}')"
  printf 'wine: %s %s\n' "$WINE_NOME" "$([[ -f "$WINE_DIR/.muunit-ok" ]] && echo ok || echo ausente)"
  printf 'webview2: %s %s\n' "$WV2_VERSAO" "$([[ -f "$PREFIXO/drive_c/MUUnit-Runtime/WebView2/$WV2_VERSAO/msedgewebview2.exe" ]] && echo ok || echo ausente)"
  printf 'openssl3: %s\n' "$(openssl3 && echo ok || echo 'ausente (sem autoatualizacao)')"
  printf 'canal: %s\n' "${CANAL:-producao}"
  local m
  for m in producao teste; do
    definir_mundo "$m"
    local exe="$PREFIXO/drive_c/$M_PASTA/$M_EXE"
    if [[ -f "$exe" ]]; then
      printf 'launcher %s: %s\n' "$m" "$(sha1sum "$exe" | cut -d' ' -f1)"
    fi
  done
  if command -v glxinfo >/dev/null 2>&1; then
    glxinfo -B 2>/dev/null | grep -E 'OpenGL (renderer|version|core profile version)' | sed 's/^/gl: /' || true
  fi
  local lista
  if lista="$(ldconfig_lista)"; then
    local l
    for l in libgnutls.so.30 libfreetype.so.6 libfontconfig.so.1 libX11.so.6 libXext.so.6 libGL.so.1; do
      grep -q -E "[[:space:]]${l}[[:space:]]" <<< "$lista" && printf 'ok    %s\n' "$l" || printf 'falta %s\n' "$l"
    done
    local opcionais=(libEGL.so.1 libgstreamer-1.0.so.0)
    if grep -q -E "[[:space:]](libpulse\.so\.0|libasound\.so\.2)[[:space:]]" <<< "$lista"; then
      opcionais=(libpulse.so.0 libasound.so.2 "${opcionais[@]}")
    else
      printf 'falta libpulse.so.0 ou libasound.so.2\n'
    fi
    for l in "${opcionais[@]}"; do
      grep -q -E "[[:space:]]${l}[[:space:]]" <<< "$lista" && printf 'ok    %s\n' "$l" || printf 'sem   %s (opcional)\n' "$l"
    done
  fi
  printf 'registros: %s\n' "$LOG_DIR"
}

principal() {
  definir_idioma
  [[ -t 1 || -t 2 ]] && TERMINAL=1
  local proprio=""
  [[ -n "$SCRIPT_ORIGEM" ]] && proprio="$(readlink -f -- "$SCRIPT_ORIGEM" 2>/dev/null || true)"
  if [[ "${MUUNIT_DIRETO:-0}" != 1 ]] && ! [[ -n "$proprio" && "$proprio" -ef "$PROGRAMA" ]]; then
    bootstrap "$proprio" "$@"
  fi
  [[ "$EUID" -ne 0 ]] || { printf '%s\n' "$(t raiz)" >&2; exit 1; }
  garantir_pastas
  [[ -f "$BASE/canal" ]] && CANAL="$(tr -dc 'a-z/' < "$BASE/canal")"
  [[ "$CANAL" == "" || "$CANAL" == "teste/" ]] || CANAL=""
  girar_log "$LOG" 1048576
  trap 'ao_erro $LINENO' ERR
  local comando="${1:-}"
  [[ "$#" -gt 0 ]] && shift
  local a
  for a in "$@"; do
    if [[ "$a" == "--canal-teste" ]]; then
      CANAL="teste/"
      printf 'teste/\n' > "$BASE/canal"
    fi
  done
  case "$comando" in
    ""|abrir|muunit://*|muunit-teste://*) [[ -f "$BASE/instalado" ]] && iniciar_autoatualizacao ;;
  esac
  case "$comando" in
    "") if [[ -f "$BASE/instalado" ]]; then cmd_abrir "$@"; else cmd_instalar "$@"; fi ;;
    abrir) cmd_abrir "$@" ;;
    instalar) cmd_instalar "$@" ;;
    reparar) cmd_reparar "$@" ;;
    desinstalar) cmd_desinstalar "$@" ;;
    diagnostico) cmd_diagnostico ;;
    versao|--versao|-v) printf 'muunit %s\n' "$VERSAO" ;;
    muunit://*|muunit-teste://*) cmd_abrir "$comando" "$@" ;;
    *) printf '%s\n' "$(t uso)" >&2; exit 2 ;;
  esac
}

principal "$@"
