#!/usr/bin/env bash
set -uo pipefail

# Assistant d'ouverture d'un fichier .exe Windows.
#
# Ce que faisait la version precedente et pourquoi c'etait le pire choix:
# elle posait une question oui/non puis lancait `exec wine "$fichier"`. Wine
# utilise alors le prefixe PAR DEFAUT, ~/.wine, partage par TOUTES les
# applications. Une application qui installe un runtime casse, et ce sont
# toutes les autres qui cessent de fonctionner -- sans que l'utilisateur ait
# le moindre moyen de comprendre ni de nettoyer.
#
# Cette version propose trois chemins et n'utilise JAMAIS le prefixe partage.
# Par defaut, elle INSTALLE: c'est ce qu'attend celui qui ouvre un .exe.

target="${1:-}"

BOTTLES_ID="com.usebottles.bottles"
# Helper privilegie de l'assistant de premier demarrage: il installe un paquet
# systeme sous sa propre action polkit. Sert ici a ajouter wine32.
APPLY_HELPER="${AUXINUX_APPLY_HELPER:-/usr/libexec/auxinux/auxinux-assistant-apply}"
PREFIX_ROOT="${XDG_DATA_HOME:-${HOME}/.local/share}/auxinux/wine-prefixes"

# Langue des messages: la PREMIERE preference, comme gettext (LANGUAGE, puis
# LC_ALL, LC_MESSAGES, LANG). LANGUAGE est une liste de REPLI
# (« fr_CA:fr:en_CA:en », posee par l'image pour tout le monde): y chercher
# « en » n'importe ou affichait l'anglais a tous les francophones (constate en
# VM le 2026-10-08).
is_english() {
  local lang="${LANGUAGE:-}"
  lang="${lang%%:*}"
  [[ -n "${lang}" ]] || lang="${LC_ALL:-${LC_MESSAGES:-${LANG:-}}}"
  [[ "${lang}" == en || "${lang}" == en_* || "${lang}" == en.* ]]
}

t() {
  # t "francais" "english"
  if is_english; then printf '%s' "$2"; else printf '%s' "$1"; fi
}

# Toutes les interactions passent par zenity. Sans dialogue graphique
# disponible, l'assistant DOIT le dire sur stderr et sortir en erreur: se
# rabattre silencieusement sur une lecture clavier revenait a ne rien faire du
# tout quand le fichier est ouvert depuis le gestionnaire de fichiers.
if ! command -v zenity >/dev/null 2>&1; then
  echo "$(t "zenity est introuvable: assistant graphique indisponible." \
            "zenity not found: graphical assistant unavailable.")" >&2
  exit 69
fi

# Fenetre d'attente alimentee par une commande. Chaque ligne est prefixee par
# « # »: zenity l'affiche alors comme texte d'avancement. Sans prefixe, une
# ligne qui COMMENCE par un nombre (« 120 paquets peuvent etre mis a jour »)
# est lue comme un pourcentage; a 100, --auto-close ferme la fenetre, et la
# commande en amont meurt de SIGPIPE au milieu de son travail.
progress_window() {
  sed -u 's/^/# /' | zenity --progress --pulsate --auto-close --no-cancel "$@" 2>/dev/null
}

die() {
  zenity --error --no-wrap --title "AuxiNuxOS" --text "$1" 2>/dev/null
  exit "${2:-1}"
}

if [[ -z "${target}" ]]; then
  die "$(t "Aucun fichier Windows fourni." "No Windows file provided.")" 64
fi

if [[ ! -f "${target}" ]]; then
  die "$(t "Fichier introuvable :" "File not found:")
${target}" 66
fi

app_name="$(basename "${target}")"
# Nom de prefixe sur: on ne garde que des caracteres inoffensifs pour un nom
# de repertoire, et on refuse un resultat vide.
prefix_name="$(printf '%s' "${app_name%.*}" | tr -c 'A-Za-z0-9._-' '-' | sed 's/^-*//;s/-*$//')"
[[ -n "${prefix_name}" ]] || prefix_name="application"

# Terme de recherche tire du nom du fichier, pour proposer une alternative
# Linux: « vlc-3.0.20-win64.exe » -> « vlc », « ChromeSetup.exe » -> « chrome ».
# On retire les mots d'installateur, d'architecture et de version.
search_term() {
  local n="${1%.*}" word out=""
  n="$(printf '%s' "${n}" | sed 's/\([a-z]\)\([A-Z]\)/\1 \2/g' | tr '_.()[]-' '       ' | tr 'A-Z' 'a-z')"
  for word in ${n}; do
    case "${word}" in
      setup|install|installer|installation|x64|x86|x86_64|win|win32|win64|windows|amd64|arm64|portable|full|offline|online|web|release|final|bit|64bit|32bit) continue ;;
      v[0-9]*|[0-9]*) continue ;;
    esac
    out="${out:+${out} }${word}"
    [[ "${out}" == *" "* ]] && break
  done
  printf '%s' "${out}"
}

# Programmes ajoutes au menu par l'installateur (winemenubuilder ecrit leurs
# raccourcis dans ~/.local/share/applications/wine), depuis le repere $1.
new_menu_entries() {
  local dir="${XDG_DATA_HOME:-${HOME}/.local/share}/applications/wine"
  [[ -d "${dir}" ]] || return 0
  find "${dir}" -name '*.desktop' -newer "$1" -print0 2>/dev/null \
    | xargs -0 -r sed -n 's/^Name=//p' | sort -u | head -n 5
}

# PANNE RAPPORTEE LE 2026-10-08 (aporler): le choix par defaut etait
# « Chercher une alternative Linux », qui ouvrait le centre de controle sur sa
# page d'accueil, sans rapport avec le fichier: « rien ne se passe ». Bottles
# s'ouvrait avec une consigne a suivre a la main, et n'installait rien. Seul
# Wine installait vraiment. Desormais le choix par defaut INSTALLE, en un clic.
choice="$(zenity --list --radiolist \
  --title "$(t "Application Windows détectée" "Windows application detected")" \
  --width 720 --height 400 \
  --text "$(t \
      "« ${app_name} » est un programme conçu pour Windows.\n\nAuxiNux OS peut l'installer dans un espace qui lui est propre : s'il pose problème, rien d'autre n'est touché." \
      "'${app_name}' is a program built for Windows.\n\nAuxiNux OS can install it in a space of its own: if it misbehaves, nothing else is affected.")" \
  --column "" --column "$(t "Que voulez-vous faire ?" "What would you like to do?")" \
  TRUE  "$(t "Installer ce programme (recommandé)" "Install this program (recommended)")" \
  FALSE "$(t "Installer avec Bottles (jeux, logiciels exigeants)" "Install with Bottles (games, demanding software)")" \
  FALSE "$(t "Chercher une alternative Linux" "Look for a Linux alternative")" \
  2>/dev/null)"

# Annulation ou fermeture de la fenetre: on ne fait rien, sans message
# d'erreur -- refuser d'ouvrir un .exe est un choix legitime.
[[ -n "${choice}" ]] || exit 0

case "${choice}" in
  *"alternative"*|*"Alternative"*)
    # Le centre de controle s'ouvre SUR une recherche tiree du nom du
    # fichier, et non sur sa page d'accueil.
    if command -v auxinux-center >/dev/null 2>&1; then
      term="$(search_term "${app_name}")"
      if [[ -n "${term}" ]]; then
        exec auxinux-center --rechercher "${term}"
      fi
      exec auxinux-center
    fi
    die "$(t "Le centre de contrôle est introuvable. Ouvrez « AuxiNux OS Center » depuis le menu des applications." \
             "The control center was not found. Open 'AuxiNux OS Center' from the applications menu.")" 69
    ;;

  *"Bottles"*)
    if ! flatpak info "${BOTTLES_ID}" >/dev/null 2>&1; then
      if ! zenity --question --no-wrap --title "Bottles" \
        --text "$(t \
          "Bottles n'est pas encore installé.\n\nIl crée un espace séparé par application : si l'une casse, les autres continuent de fonctionner.\n\nL'installer maintenant ?" \
          "Bottles is not installed yet.\n\nIt creates a separate space per application: if one breaks, the others keep working.\n\nInstall it now?")" 2>/dev/null; then
        exit 0
      fi
      # La progression de flatpak est affichee dans une fenetre d'attente:
      # une installation de plusieurs centaines de Mo sans retour visuel
      # passe pour un plantage.
      flatpak install -y --noninteractive flathub "${BOTTLES_ID}" 2>&1 \
        | progress_window --title "Bottles" \
                          --text "$(t "Installation de Bottles…" "Installing Bottles…")"
      flatpak info "${BOTTLES_ID}" >/dev/null 2>&1 \
        || die "$(t "L'installation de Bottles a échoué." "Installing Bottles failed.")" 70
    fi

    # Une bouteille par programme, creee et utilisee par bottles-cli: avant,
    # Bottles s'ouvrait avec une consigne a suivre a la main. Le dossier du
    # fichier est ouvert en LECTURE SEULE au bac a sable de Bottles, pour cette
    # execution seulement (rien n'est ajoute a ses permissions permanentes).
    bottle="${prefix_name}"
    bottle_dir="${HOME}/.var/app/${BOTTLES_ID}/data/bottles/bottles/${bottle}"
    bottles_cli() {
      flatpak run --filesystem="$(dirname "${target}")":ro \
        --command=bottles-cli "${BOTTLES_ID}" "$@"
    }
    if [[ ! -d "${bottle_dir}" ]]; then
      bottles_cli new --bottle-name "${bottle}" --environment application 2>&1 \
        | progress_window --title "Bottles" \
                          --text "$(t "Préparation de l'espace « ${bottle} »…\nLa première fois, Bottles télécharge ses composants : comptez quelques minutes." \
                                      "Preparing the '${bottle}' space…\nThe first time, Bottles downloads its components: allow a few minutes.")"
    fi
    if [[ ! -d "${bottle_dir}" ]]; then
      # Repli: Bottles n'a pas pu creer la bouteille seul (premier lancement
      # jamais fait, composants absents). On ouvre Bottles avec la marche a
      # suivre, comme avant.
      zenity --info --no-wrap --title "Bottles" \
        --text "$(t \
          "Bottles n'a pas pu préparer l'espace automatiquement.\n\nIl va s'ouvrir : créez une bouteille, puis utilisez « Exécuter un fichier » et choisissez :\n${target}" \
          "Bottles could not prepare the space automatically.\n\nIt will now open: create a bottle, then use 'Run executable' and pick:\n${target}")" 2>/dev/null
      exec flatpak run "${BOTTLES_ID}"
    fi
    bottles_cli run -b "${bottle}" -e "${target}" >/dev/null 2>&1
    zenity --info --no-wrap --title "Bottles" \
      --text "$(t \
        "« ${app_name} » a été lancé dans Bottles, espace « ${bottle} ».\n\nPour retrouver le programme : ouvrez Bottles, puis cet espace." \
        "'${app_name}' was run in Bottles, space '${bottle}'.\n\nTo find the program again: open Bottles, then that space.")" 2>/dev/null
    exit 0
    ;;

  *)
    if ! command -v wine >/dev/null 2>&1; then
      die "$(t "Wine n'est pas installé sur ce système." "Wine is not installed on this system.")" 69
    fi

    # Wine 32 bits. PANNE CONSTATEE EN VM LE 2026-10-08: l'image n'installait
    # que Wine 64 bits (wine32:i386 est une simple recommandation, et
    # l'image est construite sans les recommandations). Or presque tous les
    # INSTALLATEURS Windows sont des programmes 32 bits -- celui de 7-Zip 64
    # bits compris: Wine refusait de les lancer (« wine32 is missing ») et
    # l'assistant annoncait quand meme « termine ». Les nouvelles images
    # l'ont; ici, on le propose aux machines installees avant.
    if ! dpkg-query -W -f='${Status}' wine32:i386 2>/dev/null | grep -q 'install ok installed'; then
      if ! zenity --question --no-wrap --title "Wine" \
        --text "$(t \
          "Le composant qui fait tourner les programmes Windows 32 bits n'est pas installé.\nLa plupart des installateurs en ont besoin.\n\nL'installer maintenant ? (environ 150 Mo, mot de passe administrateur)" \
          "The component that runs 32-bit Windows programs is not installed.\nMost installers need it.\n\nInstall it now? (about 150 MB, administrator password)")" 2>/dev/null; then
        exit 0
      fi
      # La fenetre d'attente ne s'ouvre qu'a la PREMIERE ligne du helper,
      # c'est-a-dire apres l'authentification: ouverte tout de suite, elle
      # recouvrait le champ du mot de passe de polkit (constate en VM).
      pkexec "${APPLY_HELPER}" --deb wine32:i386 2>&1 \
        | { IFS= read -r first || exit 0
            { printf '%s\n' "${first}"; cat; } \
              | progress_window --title "Wine" \
                                --text "$(t "Installation de Wine 32 bits…" "Installing 32-bit Wine…")"; }
      dpkg-query -W -f='${Status}' wine32:i386 2>/dev/null | grep -q 'install ok installed' \
        || die "$(t "L'installation de Wine 32 bits a échoué ou a été annulée." "Installing 32-bit Wine failed or was cancelled.")" 70
    fi

    prefix="${PREFIX_ROOT}/${prefix_name}"
    if ! mkdir -p "${prefix}"; then
      die "$(t "Impossible de créer l'espace Wine :" "Could not create the Wine space:")
${prefix}" 73
    fi

    # WINEPREFIX par application: JAMAIS le prefixe partage ~/.wine.
    # WINEDLLOVERRIDES desactive l'installateur automatique de mono/gecko, qui
    # ouvre sinon deux fenetres incomprehensibles au premier lancement.
    export WINEPREFIX="${prefix}"
    export WINEDLLOVERRIDES="mscoree,mshtml="

    log="${prefix}/auxinux-wine.log"

    # Premier lancement: l'espace est d'abord PREPARE (wineboot --init), et
    # le programme n'est lance qu'une fois cette preparation terminee.
    # CONSTATE EN VM LE 2026-10-08: lance directement, Wine prepare l'espace
    # et le programme en meme temps; sur une machine lente la preparation
    # depasse le delai d'attente de Wine (« boot event wait timed out ») et le
    # programme echoue (« could not load kernel32.dll »).
    if [[ ! -f "${prefix}/system.reg" ]]; then
      { wine wineboot --init >"${log}" 2>&1; wineserver -w 2>/dev/null; echo fin; } \
        | progress_window --title "Wine" \
                          --text "$(t "Préparation de l'espace Windows de « ${app_name} »…\nLa première fois, comptez une minute." \
                                      "Preparing the Windows space for '${app_name}'…\nThe first time, allow a minute.")"
    fi

    marker="${prefix}/.auxinux-debut"
    : > "${marker}"

    # Chaque format s'ouvre avec la commande qui lui correspond. `wine
    # fichier.msi` ECHOUE: un paquet MSI n'est pas un executable, il doit
    # passer par msiexec. Idem pour un raccourci .lnk, resolu par `start`.
    case "${target,,}" in
      *.msi) wine msiexec /i "${target}" >>"${log}" 2>&1 ;;
      *.lnk) wine start /unix "${target}" >>"${log}" 2>&1 ;;
      *)     wine "${target}" >>"${log}" 2>&1 ;;
    esac
    status=$?
    # L'installateur lance souvent un second processus et rend la main tout de
    # suite: on attend que TOUT ce qui tourne dans cet espace soit termine.
    wineserver -w 2>/dev/null || true

    installed="$(new_menu_entries "${marker}")"
    failed=0
    [[ "${status}" -ne 0 ]] && failed=1
    grep -qE 'failed to (open|load)|wine32 is missing' "${log}" 2>/dev/null && failed=1
    if [[ -z "${installed}" && "${failed}" -eq 1 ]]; then
      # Ne plus annoncer « termine » quand Wine n'a rien pu lancer.
      zenity --error --no-wrap --title "Wine" \
        --text "$(t \
          "« ${app_name} » n'a pas pu s'exécuter correctement (code ${status}).\n\nEssayez plutôt « Installer avec Bottles ». Détails techniques :\n${log}" \
          "'${app_name}' could not run correctly (code ${status}).\n\nTry 'Install with Bottles' instead. Technical details:\n${log}")" 2>/dev/null
      exit 1
    elif [[ -n "${installed}" ]]; then
      zenity --info --no-wrap --title "$(t "Installation terminée" "Installation complete")" \
        --text "$(t \
          "C'est installé. Vous trouverez dans le menu des applications (catégorie Wine) :\n\n${installed}" \
          "Installed. You will find in the applications menu (Wine category):\n\n${installed}")" 2>/dev/null
    else
      zenity --info --no-wrap --title "$(t "Terminé" "Done")" \
        --text "$(t \
          "« ${app_name} » s'est terminé.\n\nS'il s'agissait d'un installateur, le programme installé apparaît dans le menu des applications, catégorie Wine." \
          "'${app_name}' has finished.\n\nIf it was an installer, the installed program appears in the applications menu, Wine category.")" 2>/dev/null
    fi
    exit 0
    ;;
esac
