#!/bin/sh
# Instalador de The Squad (macOS y Linux).
#
#   curl -fsSL https://<web>/install.sh | sh                 # la última versión
#   curl -fsSL https://<web>/install.sh | sh -s -- --version 0.2.0
#   sh install.sh --gh                                        # de las Releases con tu `gh`
#   sh install.sh --file the-squad-0.2.0-linux-x86_64.tar.gz  # un paquete ya descargado
#   ./the-squad/install.sh                                    # desde un paquete descomprimido
#   sh install.sh --uninstall
#
# Sin sudo. Linux: ~/.local/lib/the-squad, el lanzador `the-squad` en ~/.local/bin y el icono y
# el .desktop en ~/.local/share. macOS: ~/Applications/The Squad.app. Contrato de versiones y
# ficheros: docs/versiones.md.
set -eu

# La web la rellena al servir este fichero (ver docs/versiones.md).
SQUAD_BASE_URL="${SQUAD_BASE_URL:-https://the-squad-web-production.up.railway.app}"
REPO="thehwlz/the-squad"

say() { printf '%s\n' "$*"; }
warn() { printf 'The Squad: %s\n' "$*" >&2; }
die() { warn "$*"; exit 1; }

usage() {
  cat <<'EOF'
Instala o actualiza The Squad.

  --version X.Y.Z   una versión concreta (por defecto, la última; sin --version nunca baja de versión)
  --gh              descarga de las Releases de GitHub con tu `gh` autenticado
  --file RUTA       instala un paquete .tar.gz ya descargado
  --prefix RUTA     Linux: dónde instalar (por defecto ~/.local)
  --open            abre la app al terminar
  --uninstall       desinstala (no toca tus datos)
  -h, --help        esta ayuda

Variables: SQUAD_BASE_URL (web de descargas), SQUAD_INSTALL_DIR (macOS: carpeta de la .app).
EOF
}

version=""
source_kind=""   # web | gh | file | dir
file=""
prefix="${HOME}/.local"
open_after=0
uninstall=0

while [ $# -gt 0 ]; do
  case "$1" in
    --version) [ $# -ge 2 ] || die "falta la versión tras --version"; version="${2#v}"; shift 2 ;;
    --gh) source_kind="gh"; shift ;;
    --file) [ $# -ge 2 ] || die "falta la ruta tras --file"; source_kind="file"; file="$2"; shift 2 ;;
    --prefix) [ $# -ge 2 ] || die "falta la ruta tras --prefix"; prefix="$2"; shift 2 ;;
    --open) open_after=1; shift ;;
    --uninstall) uninstall=1; shift ;;
    -h|--help) usage; exit 0 ;;
    *) die "opción desconocida: $1 (mira --help)" ;;
  esac
done

# ---------- Sistema y plataforma ----------

os=$(uname -s)
arch=$(uname -m)
case "$os" in
  Darwin)
    case "$arch" in
      arm64|aarch64) platform=macos-arm64 ;;
      *) die "en Mac solo hay versión para Apple Silicon (este es $arch)" ;;
    esac ;;
  Linux)
    case "$arch" in
      x86_64|amd64) platform=linux-x86_64 ;;
      aarch64|arm64) platform=linux-aarch64 ;;
      *) die "no hay versión para Linux $arch (solo x86_64 y aarch64)" ;;
    esac ;;
  *) die "sistema no soportado: $os (solo macOS y Linux)" ;;
esac

app_dir="${SQUAD_INSTALL_DIR:-$HOME/Applications}"
# Ruta real (en macOS /tmp es /private/tmp): así se reconoce el proceso de la app abierta.
[ -d "$app_dir" ] && app_dir=$(cd "$app_dir" && pwd -P)
app_path="$app_dir/The Squad.app"
# Siempre absoluto: el enlace de bin/ y el Exec= del .desktop apuntan a $lib_dir, y una ruta
# relativa se leería desde otra carpeta (la de bin/, la del menú de aplicaciones).
case "$prefix" in
  "") die "--prefix vacío" ;;
  *"
"*) die "--prefix no puede llevar saltos de línea" ;;
  "~") prefix="$HOME" ;;
  "~/"*) prefix="$HOME/${prefix#"~/"}" ;;
esac
if [ -d "$prefix" ]; then
  prefix=$(cd "$prefix" && pwd -P)
else
  case "$prefix" in /*) ;; *) prefix="$(pwd -P)/${prefix#./}" ;; esac
fi
prefix="${prefix%/}"
[ -n "$prefix" ] || prefix=/
lib_dir="$prefix/lib/the-squad"
bin_link="$prefix/bin/the-squad"
data_home="${XDG_DATA_HOME:-$HOME/.local/share}"
case "$data_home" in /*) ;; *) data_home="$HOME/.local/share" ;; esac

# ---------- macOS: cerrar la app si está abierta ----------

# El pid del primer proceso cuya orden es el ejecutable $1, solo o con argumentos. Compara la
# ruta literalmente (con pgrep era un patrón: una carpeta como «Apps (pruebas)» no coincidía) y
# sin confundir bin/squad con bin/squad-mux. `ps -A` incluye a los antepasados: lanzado desde una
# terminal de la propia app (el botón «Actualizar», o a mano), la app lo es. `-ww`: sin recortar
# órdenes largas.
running_pid() {
  ps -A -ww -o pid= -o command= 2>/dev/null | SQUAD_CMD="$1" awk '{
    pid = $1; c = $0; sub(/^[ \t]*[0-9]+[ \t]+/, "", c); want = ENVIRON["SQUAD_CMD"]
    if (c == want || index(c, want " ") == 1) { print pid; exit }
  }'
}

# El pid de esta app (su ejecutable exacto).
mac_pid() {
  running_pid "$app_path/Contents/MacOS/squad"
}

mac_data_dir="${SQUAD_DATA_DIR:-$HOME/Library/Application Support/TheSquad}"
mac_reopen=0

# Cierra la app con su cierre ordenado (SIGTERM: guarda notas y estado). Con `keep`, como
# `bundle.sh --install`: la marca keep-terminals le dice que deje vivas sus terminales (viven en
# squad-mux) para reengancharse al volver a abrirse; entre ellas, la de este instalador si se
# lanzó desde la app. Una versión sin mux la ignora.
mac_quit() {
  keep=$1
  pid=$(mac_pid)
  [ -n "$pid" ] || return 0
  if [ "$keep" = 1 ]; then
    say "Cerrando The Squad para actualizarla (sus terminales siguen abiertas y vuelve a abrirse sola)…"
    mkdir -p "$mac_data_dir" && touch "$mac_data_dir/keep-terminals"
    # Si algo falla de aquí al final, la marca no se queda (valdría para el siguiente ⌘Q).
    trap 'rm -f "$mac_data_dir/keep-terminals"; rm -rf "$work"' EXIT INT TERM
  else
    say "Cerrando The Squad…"
  fi
  kill -TERM "$pid" 2>/dev/null || true
  n=0
  while kill -0 "$pid" 2>/dev/null && [ $n -lt 300 ]; do sleep 0.1; n=$((n + 1)); done
  if kill -0 "$pid" 2>/dev/null; then
    rm -f "$mac_data_dir/keep-terminals"
    die "The Squad no se cerró en 30 s: ciérrala (⌘Q) y vuelve a lanzar el instalador"
  fi
  [ "$keep" = 1 ] && mac_reopen=1
  return 0
}

# La vuelve a abrir tras actualizar, con un entorno limpio: `open` le pasa a la app el de quien
# lo lanza y desde una terminal de un agente eso son sus variables (SQUAD_IN_AGENT, CLAUDECODE…),
# que heredarían todas sus terminales nuevas. Con SQUAD_DATA_DIR, en segundo plano y con su carpeta.
mac_open() {
  if [ -n "${SQUAD_DATA_DIR:-}" ]; then
    env -i HOME="$HOME" USER="${USER:-}" LOGNAME="${LOGNAME:-${USER:-}}" SHELL="${SHELL:-/bin/zsh}" \
      TMPDIR="${TMPDIR:-/tmp}" LANG="${LANG:-es_ES.UTF-8}" PATH=/usr/bin:/bin:/usr/sbin:/sbin \
      open -g --env "SQUAD_DATA_DIR=$SQUAD_DATA_DIR" "$app_path"
  else
    env -i HOME="$HOME" USER="${USER:-}" LOGNAME="${LOGNAME:-${USER:-}}" SHELL="${SHELL:-/bin/zsh}" \
      TMPDIR="${TMPDIR:-/tmp}" LANG="${LANG:-es_ES.UTF-8}" PATH=/usr/bin:/bin:/usr/sbin:/sbin \
      open "$app_path"
  fi
}

# ---------- Desinstalar ----------

if [ "$uninstall" = 1 ]; then
  if [ "$os" = Darwin ]; then
    mac_quit 0
    rm -rf "$app_path"
    say "Desinstalada: $app_path"
    say "Tus datos siguen en ~/Library/Application Support/TheSquad (bórralos a mano si quieres)."
  else
    rm -rf "$lib_dir" "$bin_link" "$data_home/applications/the-squad.desktop"
    for s in 16 32 48 64 128 256 512; do rm -f "$data_home/icons/hicolor/${s}x${s}/apps/the-squad.png"; done
    command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q "$data_home/applications" 2>/dev/null || true
    say "Desinstalada de $lib_dir"
    say "Tus datos siguen en ${XDG_DATA_HOME:-~/.local/share}/TheSquad (bórralos a mano si quieres)."
  fi
  exit 0
fi

# ---------- De dónde sale el paquete ----------

# Solo si se lanzó como fichero: con `curl … | sh`, $0 es «sh» y dirname daría el directorio
# actual (que puede ser justo la instalación de la app, si la lanza el botón «Actualizar»).
script_dir=""
[ -f "$0" ] && script_dir=$(cd "$(dirname "$0")" 2>/dev/null && pwd || echo "")
if [ -z "$source_kind" ]; then
  # ¿Lanzado desde un paquete de Linux descomprimido (the-squad/install.sh)?
  if [ "$os" = Linux ] && [ -n "$script_dir" ] && [ -x "$script_dir/bin/squad" ] && [ -f "$script_dir/VERSION" ]; then
    source_kind=dir
  else
    source_kind=web
  fi
fi

work=$(mktemp -d "${TMPDIR:-/tmp}/the-squad-install.XXXXXX")
trap 'rm -rf "$work"' EXIT INT TERM

need() { command -v "$1" >/dev/null 2>&1 || die "hace falta \`$1\`"; }

# ¿La versión a es mayor que la b? (X.Y.Z; lo que no es un número cuenta como 0.)
version_gt() {
  awk -v a="$1" -v b="$2" 'BEGIN {
    split(a, x, "."); split(b, y, ".")
    for (i = 1; i <= 3; i++) { if (x[i] + 0 > y[i] + 0) exit 0; if (x[i] + 0 < y[i] + 0) exit 1 }
    exit 1 }'
}

# Pidiendo «la última» (sin --version, de la web o de GitHub), nunca baja de versión. Si lo
# publicado como la última es más viejo que lo instalado (una Release vieja que alguien rehízo
# y quedó como Latest), no se toca nada. Con --version o --file, se instala lo que se pide.
keep_newer() { # versión instalada (vacía si no hay)
  [ -z "$version" ] || return 0
  case "$source_kind" in web|gh) ;; *) return 0 ;; esac
  # Las dos tienen que parecer versiones (un error de PlistBuddy sale por stdout).
  case "$new_version" in [0-9]*.[0-9]*.[0-9]*) ;; *) return 0 ;; esac
  case "$1" in [0-9]*.[0-9]*.[0-9]*) ;; *) return 0 ;; esac
  version_gt "$1" "$new_version" || return 0
  say "Ya tienes The Squad $1, más nueva que la $new_version publicada como la última: no se cambia nada."
  say "Para instalar la $new_version de todas formas: --version $new_version"
  exit 0
}

sha256_of() {
  if command -v sha256sum >/dev/null 2>&1; then sha256sum "$1" | cut -d' ' -f1
  else shasum -a 256 "$1" | cut -d' ' -f1; fi
}

# Del SHA256SUMS, el fichero tar.gz de esta plataforma: «<hash> <nombre>».
pick_from_sums() {
  grep -E "[[:space:]]\*?the-squad-[0-9][^[:space:]]*-$platform\.tar\.gz\$" "$1" | head -n 1
}

# Solo HTTPS, salvo contra esta misma máquina (pruebas con un servidor local).
curl_proto='=https'
case "$SQUAD_BASE_URL" in http://localhost[:/]*|http://127.0.0.1[:/]*) curl_proto='=http,https' ;; esac

download() { # url destino
  curl -fSL --proto "$curl_proto" --retry 3 --progress-bar -o "$2" "$1"
}

package=""
case "$source_kind" in
  web)
    need curl
    case "$SQUAD_BASE_URL" in
      __SQUAD_BASE_URL__|"") die "no sé de qué web descargar: usa SQUAD_BASE_URL=https://… , --gh (con gh autenticado) o --file" ;;
    esac
    base="${SQUAD_BASE_URL%/}"
    tag=latest; [ -n "$version" ] && tag="v$version"
    say "Buscando la versión ($tag) para ${platform}…"
    curl -fsSL --proto "$curl_proto" --retry 3 -o "$work/SHA256SUMS" "$base/download/$tag/SHA256SUMS" \
      || die "no se pudo leer $base/download/$tag/SHA256SUMS"
    line=$(pick_from_sums "$work/SHA256SUMS") || true
    [ -n "$line" ] || die "esa versión no tiene paquete para $platform"
    want=$(printf '%s' "$line" | awk '{print $1}')
    name=$(printf '%s' "$line" | awk '{print $2}' | sed 's/^\*//')
    say "Descargando ${name}…"
    download "$base/download/$tag/$name" "$work/$name"
    got=$(sha256_of "$work/$name")
    [ "$got" = "$want" ] || die "el sha256 de $name no cuadra (esperado $want, llegó $got)"
    package="$work/$name" ;;
  gh)
    need gh
    set -- --repo "$REPO" --dir "$work" --pattern "the-squad-*-$platform.tar.gz" --pattern SHA256SUMS
    if [ -n "$version" ]; then gh release download "v$version" "$@"; else gh release download "$@"; fi \
      || die "gh no pudo descargar la versión (¿gh auth login?)"
    line=$(pick_from_sums "$work/SHA256SUMS") || true
    [ -n "$line" ] || die "esa versión no tiene paquete para $platform"
    want=$(printf '%s' "$line" | awk '{print $1}')
    name=$(printf '%s' "$line" | awk '{print $2}' | sed 's/^\*//')
    got=$(sha256_of "$work/$name")
    [ "$got" = "$want" ] || die "el sha256 de $name no cuadra"
    package="$work/$name" ;;
  file)
    [ -f "$file" ] || die "no existe $file"
    package="$file" ;;
  dir) ;;
esac

# ---------- Descomprimir ----------

src=""
if [ "$source_kind" = dir ]; then
  src="$script_dir"
else
  mkdir -p "$work/x"
  tar -xzf "$package" -C "$work/x" || die "no se pudo descomprimir $package"
  if [ "$os" = Darwin ]; then
    src="$work/x/The Squad.app"
    [ -d "$src" ] || die "el paquete no trae The Squad.app (¿es de Linux?)"
  else
    src="$work/x/the-squad"
    [ -x "$src/bin/squad" ] || die "el paquete no trae the-squad/bin/squad (¿es de Mac?)"
  fi
fi

# ---------- Instalar: macOS ----------

if [ "$os" = Darwin ]; then
  new_version=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$src/Contents/Info.plist" 2>/dev/null || echo "?")
  old_version=""
  [ -f "$app_path/Contents/Info.plist" ] \
    && old_version=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$app_path/Contents/Info.plist" 2>/dev/null || true)
  keep_newer "$old_version"
  mac_quit 1
  mkdir -p "$app_dir"
  # Primero al lado (misma carpeta, mismo disco) y luego se cambia por la vieja de golpe.
  rm -rf "$app_dir/.The Squad.app.new" "$app_dir/.The Squad.app.old"
  cp -R "$src" "$app_dir/.The Squad.app.new"
  xattr -dr com.apple.quarantine "$app_dir/.The Squad.app.new" 2>/dev/null || true
  [ -d "$app_path" ] && mv "$app_path" "$app_dir/.The Squad.app.old"
  mv "$app_dir/.The Squad.app.new" "$app_path"
  rm -rf "$app_dir/.The Squad.app.old"
  rm -f "$mac_data_dir/keep-terminals"
  say "The Squad $new_version instalada en $app_path"
  if [ "$mac_reopen" = 1 ] || [ "$open_after" = 1 ]; then
    mac_open
    [ "$mac_reopen" = 1 ] && say "Reabierta: sus terminales siguen donde estaban."
  fi
  exit 0
fi

# ---------- Instalar: Linux ----------

new_version=$(cat "$src/VERSION" 2>/dev/null || echo "?")
keep_newer "$(cat "$lib_dir/VERSION" 2>/dev/null || true)"
mkdir -p "$prefix/lib" "$prefix/bin"
rm -rf "$lib_dir.new" "$lib_dir.old"
cp -R "$src" "$lib_dir.new"
# Cambiar la carpeta de golpe: una app abierta sigue con sus ficheros (ya cargados) hasta que
# se reinicia.
[ -d "$lib_dir" ] && mv "$lib_dir" "$lib_dir.old"
mv "$lib_dir.new" "$lib_dir"
rm -rf "$lib_dir.old"
ln -sfn "$lib_dir/bin/squad" "$bin_link"

# Icono y entrada en el menú de aplicaciones.
for s in 16 32 48 64 128 256 512; do
  if [ -f "$lib_dir/share/icons/hicolor/${s}x${s}/apps/the-squad.png" ]; then
    mkdir -p "$data_home/icons/hicolor/${s}x${s}/apps"
    cp "$lib_dir/share/icons/hicolor/${s}x${s}/apps/the-squad.png" "$data_home/icons/hicolor/${s}x${s}/apps/the-squad.png"
  fi
done
mkdir -p "$data_home/applications"
# Exec= con la ruta entre comillas y escapada como pide la especificación de .desktop: dentro de
# las comillas, \ " ` $ llevan \ delante; % se dobla; y luego cada \ se dobla otra vez (el valor
# es una cadena de .desktop). awk lee el valor de ENVIRON, sin reinterpretarlo: con sed, un & o
# un | de la ruta rompían la sustitución.
exec_path=$(printf '%s' "$lib_dir/bin/squad" | sed -e 's/[\\"`$]/\\&/g' -e 's/%/%%/g' -e 's/\\/\\\\/g')
SQUAD_EXEC="$exec_path" awk '/^Exec=/ { print "Exec=\"" ENVIRON["SQUAD_EXEC"] "\""; next } { print }' \
  "$lib_dir/share/applications/the-squad.desktop" > "$data_home/applications/the-squad.desktop"
command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q "$data_home/applications" 2>/dev/null || true
command -v gtk-update-icon-cache >/dev/null 2>&1 && gtk-update-icon-cache -q -t "$data_home/icons/hicolor" 2>/dev/null || true

say "The Squad $new_version instalada en $lib_dir"

# ¿Faltan cosas del sistema? Se dice qué instalar (no se usa sudo).
missing=""
have_lib() { ldconfig -p 2>/dev/null | grep -q "$1" || [ -e "/usr/lib/$1" ] || [ -e "/usr/lib64/$1" ] || ls /usr/lib/*-linux-gnu/"$1" >/dev/null 2>&1; }
for l in libvulkan.so.1 libxkbcommon.so.0 libxkbcommon-x11.so.0 libwayland-client.so.0 libfontconfig.so.1 libfreetype.so.6 libxcb.so.1 libpng16.so.16; do
  have_lib "$l" || missing="$missing $l"
done
no_icd=1
for f in /usr/share/vulkan/icd.d/*.json /etc/vulkan/icd.d/*.json /usr/local/share/vulkan/icd.d/*.json; do
  [ -e "$f" ] && { no_icd=0; break; }
done
# Una fuente de ancho fijo y otra con los símbolos de la app (✓ ✦ ❯…).
if command -v fc-list >/dev/null 2>&1; then
  { [ -n "$(fc-list :spacing=mono family 2>/dev/null | head -n 1)" ] && [ -n "$(fc-list ':charset=2713' family 2>/dev/null | head -n 1)" ]; } || missing="$missing fuentes"
fi
command -v notify-send >/dev/null 2>&1 || missing="$missing notify-send"
command -v xdg-open >/dev/null 2>&1 || missing="$missing xdg-open"

if [ -n "$missing" ] || [ "$no_icd" = 1 ]; then
  id_like=""
  # shellcheck disable=SC1091
  [ -r /etc/os-release ] && id_like=$(. /etc/os-release; echo "${ID:-} ${ID_LIKE:-}")
  say ""
  say "Falta algo del sistema:${missing:- }$( [ "$no_icd" = 1 ] && echo ' (y un driver de Vulkan)')"
  case " $id_like " in
    *" arch "*|*" manjaro "*)
      say "  sudo pacman -S --needed vulkan-icd-loader libxkbcommon libxkbcommon-x11 wayland fontconfig freetype2 libxcb libpng libnotify xdg-utils ttf-dejavu"
      say "  y el driver Vulkan de tu gráfica: vulkan-intel, vulkan-radeon o nvidia-utils (sin GPU: vulkan-swrast)" ;;
    *" fedora "*|*" rhel "*|*" centos "*)
      say "  sudo dnf install vulkan-loader mesa-vulkan-drivers libxkbcommon libxkbcommon-x11 libwayland-client fontconfig freetype libxcb libpng libnotify xdg-utils dejavu-sans-fonts dejavu-sans-mono-fonts" ;;
    *" opensuse"*|*" suse "*)
      say "  sudo zypper install libvulkan1 Mesa-vulkan-device-select libxkbcommon0 libxkbcommon-x11-0 libwayland-client0 fontconfig libfreetype6 libxcb1 libpng16-16 libnotify-tools xdg-utils dejavu-fonts" ;;
    *" debian "*|*" ubuntu "*)
      say "  sudo apt install libvulkan1 mesa-vulkan-drivers libxkbcommon0 libxkbcommon-x11-0 libwayland-client0 libfontconfig1 libfreetype6 libxcb1 libpng16-16 libnotify-bin xdg-utils fonts-dejavu-core" ;;
    *)
      say "  Instala con tu gestor de paquetes: el cargador de Vulkan y un driver, libxkbcommon(-x11), wayland-client, fontconfig, freetype, libxcb, libpng, libnotify, xdg-utils y fuentes con símbolos (DejaVu)." ;;
  esac
fi

case ":$PATH:" in
  *":$prefix/bin:"*) say "Ábrela desde el menú de aplicaciones o con: the-squad" ;;
  *) say "Ábrela desde el menú de aplicaciones o con: $bin_link"
     say "(Añade $prefix/bin a tu PATH para escribir solo «the-squad».)" ;;
esac
if [ -n "$(running_pid "$lib_dir/bin/squad")" ] || [ -n "$(running_pid "$bin_link")" ]; then
  say "The Squad está abierta: ciérrala y vuelve a abrirla para usar la versión nueva."
fi
[ "$open_after" = 1 ] && (nohup "$lib_dir/bin/squad" >/dev/null 2>&1 &)
exit 0
