install.sh

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

ROOT="$(cd "$(dirname "$0")" && pwd)"
VERSION="$(tr -d '[:space:]' < "$ROOT/VERSION")"

XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-$HOME/.config}"
XDG_CACHE_HOME="${XDG_CACHE_HOME:-$HOME/.cache}"
XDG_DATA_HOME="${XDG_DATA_HOME:-$HOME/.local/share}"

INSTALL_DIR="${KEYPROFILE_BRIDGE_INSTALL_DIR:-$HOME/.local/lib/keyprofile-bridge}"
BIN_LINK_DIR="$HOME/.local/bin"
SYSTEMD_DIR="$XDG_CONFIG_HOME/systemd/user"
KWIN_LINK="$XDG_DATA_HOME/kwin/scripts/de.solocodes.keyprofilebridge"
CONFIG_DIR="$XDG_CONFIG_HOME/keyprofile-bridge"
CACHE_DIR="$XDG_CACHE_HOME/keyprofile-bridge"
AUTOSTART_DIR="$XDG_CONFIG_HOME/autostart"
APPLICATIONS_DIR="$XDG_DATA_HOME/applications"

MAIN_UNIT="keyprofile-bridge.service"
TRAY_UNIT="keyprofile-bridge-tray.service"
BACKGROUND_START_UNIT="keyprofile-bridge-wootility-start.service"
UPDATE_UNIT="keyprofile-bridge-update.service"
UPDATE_TIMER_UNIT="keyprofile-bridge-update.timer"
KWIN_PLUGIN_ID="de.solocodes.keyprofilebridge"
SETTINGS_FILE="$CONFIG_DIR/settings.json"
SETTINGS_BACKUP_FILE="$CONFIG_DIR/settings.backup.json"
MODE_FILE="$CONFIG_DIR/mode.json"
MODE_BACKUP_FILE="$CONFIG_DIR/mode.backup.json"
MANIFEST="$CONFIG_DIR/background-service-autostart-overrides.tsv"
BACKUPS="$CONFIG_DIR/autostart-backups"
NOTICE_VERSION="1"
IN_APP_UPDATE="${KEYPROFILE_BRIDGE_IN_APP_UPDATE:-0}"

LEGACY_CONFIG_DIRS=(
  "$XDG_CONFIG_HOME/wootility-bridge"
  "$XDG_CONFIG_HOME/lynn-wooting-bridge-direct"
)
LEGACY_CACHE_DIRS=(
  "$XDG_CACHE_HOME/wootility-bridge"
  "$XDG_CACHE_HOME/lynn-wooting-bridge-direct"
)
LEGACY_INSTALL_DIRS=(
  "$HOME/.local/lib/wootility-bridge"
  "$HOME/.local/share/wootility-bridge"
  "$HOME/.local/share/lynn-wooting-bridge-direct"
)
LEGACY_KWIN_DIRS=(
  "$XDG_DATA_HOME/kwin/scripts/de.solocodes.wootilitybridge"
  "$XDG_DATA_HOME/kwin/scripts/com.lynn.wootingbridge"
)
LEGACY_MAIN_UNITS=(
  "wootility-bridge.service"
  "lynn-wooting-bridge-direct.service"
  "lynn-wooting-bridge.service"
  "lynn-wootility-host.service"
)
LEGACY_TRAY_UNITS=(
  "wootility-bridge-tray.service"
  "lynn-wooting-bridge-tray.service"
)

require_file() {
  if [ ! -f "$1" ]; then
    printf 'ERROR: Required file is missing: %s\n' "$1" >&2
    exit 1
  fi
}

for required in \
  "$ROOT/VERSION" \
  "$ROOT/bin/keyprofile-bridge" \
  "$ROOT/bin/keyprofile-bridge-tray" \
  "$ROOT/bin/keyprofile-bridge-settings" \
  "$ROOT/systemd/$MAIN_UNIT" \
  "$ROOT/systemd/$TRAY_UNIT" \
  "$ROOT/systemd/$BACKGROUND_START_UNIT" \
  "$ROOT/kwin/$KWIN_PLUGIN_ID/metadata.json" \
  "$ROOT/kwin/$KWIN_PLUGIN_ID/contents/code/main.js" \
  "$ROOT/README.md" \
  "$ROOT/NOTICE.md" \
  "$ROOT/LICENSE"; do
  require_file "$required"
done


install_arch_dependency() {
  local module="$1"
  local package="$2"
  if python3 -c "import $module" >/dev/null 2>&1; then
    return 0
  fi
  if command -v pacman >/dev/null 2>&1; then
    printf 'Installing required dependency: %s\n' "$package"
    sudo pacman -S --needed "$package"
  else
    printf 'ERROR: Python module %s is missing. Install the matching package with your distribution package manager.\n' "$module" >&2
    exit 1
  fi
}

restore_autostart_overrides() {
  local config_dir="$1"
  local manifest="$config_dir/background-service-autostart-overrides.tsv"
  [ -f "$manifest" ] || return 0

  while IFS=$'\t' read -r action target backup; do
    [ -n "${target:-}" ] || continue
    case "$action" in
      restore)
        if [ -n "${backup:-}" ] && [ -f "$backup" ]; then
          mkdir -p "$(dirname "$target")"
          cp -f -- "$backup" "$target"
        fi
        ;;
      remove)
        rm -f -- "$target"
        ;;
    esac
  done < "$manifest"

  rm -f -- "$manifest"
  rm -rf -- "$config_dir/autostart-backups"
}

migrate_user_data() {
  mkdir -p "$CONFIG_DIR" "$CACHE_DIR"

  for legacy in "${LEGACY_CONFIG_DIRS[@]}"; do
    [ -d "$legacy" ] || continue
    [ "$legacy" = "$CONFIG_DIR" ] && continue
    python3 - "$legacy" "$CONFIG_DIR" <<'PY_MIGRATE'
import json
import shutil
import sys
from pathlib import Path

legacy = Path(sys.argv[1])
target = Path(sys.argv[2])
target.mkdir(parents=True, exist_ok=True)

for source in legacy.iterdir():
    destination = target / source.name
    if source.name in {"background-service-autostart-overrides.tsv", "autostart-backups"}:
        continue
    if source.is_dir():
        if not destination.exists():
            shutil.copytree(source, destination)
        continue
    if source.name in {"settings.json", "settings.backup.json", "mode.json", "mode.backup.json"}:
        def read(path: Path):
            try:
                value = json.loads(path.read_text(encoding="utf-8"))
                return value if isinstance(value, dict) else {}
            except Exception:
                return {}
        old = read(source)
        new = read(destination)
        merged = dict(old)
        merged.update(new)
        destination.write_text(json.dumps(merged, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        destination.chmod(0o600)
    elif not destination.exists():
        shutil.copy2(source, destination)
PY_MIGRATE
  done

  for legacy in "${LEGACY_CACHE_DIRS[@]}"; do
    [ -d "$legacy" ] || continue
    [ "$legacy" = "$CACHE_DIR" ] && continue
    cp -an -- "$legacy/." "$CACHE_DIR/" 2>/dev/null || true
  done
}

mkdir -p \
  "$BIN_LINK_DIR" \
  "$SYSTEMD_DIR" \
  "$(dirname "$KWIN_LINK")" \
  "$CONFIG_DIR" \
  "$AUTOSTART_DIR" \
  "$APPLICATIONS_DIR" \
  "$(dirname "$INSTALL_DIR")"

install_arch_dependency dbus_next python-dbus-next
install_arch_dependency PySide6 pyside6

restore_autostart_overrides "$CONFIG_DIR"
for legacy in "${LEGACY_CONFIG_DIRS[@]}"; do
  restore_autostart_overrides "$legacy"
done
migrate_user_data

if [ "$IN_APP_UPDATE" = "1" ]; then
  systemctl --user stop "$MAIN_UNIT" "$BACKGROUND_START_UNIT" "$UPDATE_TIMER_UNIT" 2>/dev/null || true
else
  systemctl --user disable --now "$MAIN_UNIT" "$TRAY_UNIT" "$BACKGROUND_START_UNIT" "$UPDATE_TIMER_UNIT" 2>/dev/null || true
fi
for unit in "${LEGACY_MAIN_UNITS[@]}" "${LEGACY_TRAY_UNITS[@]}"; do
  systemctl --user disable --now "$unit" 2>/dev/null || true
done

if [ "${KEYPROFILE_BRIDGE_IN_APP_UPDATE:-0}" != "1" ]; then
  pkill -f -- "$HOME/.local/bin/keyprofile-bridge-settings" 2>/dev/null || true
  pkill -f -- "$HOME/.local/bin/wootility-bridge-settings" 2>/dev/null || true
  pkill -f -- "$HOME/.local/bin/lynn-wooting-settings" 2>/dev/null || true
  for legacy_dir in "${LEGACY_INSTALL_DIRS[@]}"; do
    pkill -f -- "$legacy_dir/bin/keyprofile-bridge-settings" 2>/dev/null || true
    pkill -f -- "$legacy_dir/bin/wootility-bridge-settings" 2>/dev/null || true
  done
  pkill -f -- "$INSTALL_DIR/bin/keyprofile-bridge-settings" 2>/dev/null || true
  sleep 0.2
fi

STAGING="$(mktemp -d "$HOME/.local/lib/.keyprofile-bridge-install.XXXXXX")"
PREVIOUS_INSTALL="${INSTALL_DIR}.previous"
cleanup() {
  [ -z "${STAGING:-}" ] || rm -rf -- "$STAGING"
}
trap cleanup EXIT

mkdir -p "$STAGING/bin" "$STAGING/systemd" "$STAGING/kwin" "$STAGING/assets"
install -m 755 "$ROOT/bin/keyprofile-bridge" "$STAGING/bin/keyprofile-bridge"
install -m 755 "$ROOT/bin/keyprofile-bridge-tray" "$STAGING/bin/keyprofile-bridge-tray"
install -m 755 "$ROOT/bin/keyprofile-bridge-settings" "$STAGING/bin/keyprofile-bridge-settings"
install -m 755 "$ROOT/bin/keyprofile-bridge-updater" "$STAGING/bin/keyprofile-bridge-updater"
install -m 755 "$ROOT/install.sh" "$STAGING/install.sh"
install -m 755 "$ROOT/install-online.sh" "$STAGING/install-online.sh"
install -m 755 "$ROOT/uninstall.sh" "$STAGING/uninstall.sh"
install -m 644 "$ROOT/VERSION" "$STAGING/VERSION"
install -m 644 "$ROOT/README.md" "$STAGING/README.md"
install -m 644 "$ROOT/NOTICE.md" "$STAGING/NOTICE.md"
[ ! -f "$ROOT/README_DE.md" ] || install -m 644 "$ROOT/README_DE.md" "$STAGING/README_DE.md"
install -m 644 "$ROOT/LICENSE" "$STAGING/LICENSE"
cp -a "$ROOT/assets/." "$STAGING/assets/"
[ ! -f "$ROOT/CHANGELOG.md" ] || install -m 644 "$ROOT/CHANGELOG.md" "$STAGING/CHANGELOG.md"
install -m 644 "$ROOT/systemd/$MAIN_UNIT" "$STAGING/systemd/$MAIN_UNIT"
install -m 644 "$ROOT/systemd/$TRAY_UNIT" "$STAGING/systemd/$TRAY_UNIT"
install -m 644 "$ROOT/systemd/$BACKGROUND_START_UNIT" "$STAGING/systemd/$BACKGROUND_START_UNIT"
install -m 644 "$ROOT/systemd/$UPDATE_UNIT" "$STAGING/systemd/$UPDATE_UNIT"
install -m 644 "$ROOT/systemd/$UPDATE_TIMER_UNIT" "$STAGING/systemd/$UPDATE_TIMER_UNIT"
cp -a "$ROOT/kwin/$KWIN_PLUGIN_ID" "$STAGING/kwin/$KWIN_PLUGIN_ID"

rm -rf -- "$PREVIOUS_INSTALL"
if [ -d "$INSTALL_DIR" ]; then
  mv -- "$INSTALL_DIR" "$PREVIOUS_INSTALL"
fi
mv -- "$STAGING" "$INSTALL_DIR"
STAGING=""

installed_version="$("$INSTALL_DIR/bin/keyprofile-bridge-settings" --version 2>/dev/null || true)"
if [ "$installed_version" != "$VERSION" ]; then
  printf 'ERROR: Installation verification failed. Expected %s, found %s.\n' \
    "$VERSION" "${installed_version:-unknown}" >&2
  rm -rf -- "$INSTALL_DIR"
  if [ -d "$PREVIOUS_INSTALL" ]; then
    mv -- "$PREVIOUS_INSTALL" "$INSTALL_DIR"
  fi
  exit 1
fi

settings_self_test="$("$INSTALL_DIR/bin/keyprofile-bridge-settings" --self-test 2>&1)" || {
  printf 'ERROR: Settings application self-test failed:\n%s\n' "$settings_self_test" >&2
  rm -rf -- "$INSTALL_DIR"
  if [ -d "$PREVIOUS_INSTALL" ]; then
    mv -- "$PREVIOUS_INSTALL" "$INSTALL_DIR"
  fi
  exit 1
}

for name in \
  keyprofile-bridge \
  keyprofile-bridge-tray \
  keyprofile-bridge-settings \
  keyprofile-bridge-updater \
  wootility-bridge \
  wootility-bridge-tray \
  wootility-bridge-settings \
  lynn-wooting-bridge \
  lynn-wooting-tray \
  lynn-wooting-settings; do
  rm -f -- "$BIN_LINK_DIR/$name"
done
ln -s "$INSTALL_DIR/bin/keyprofile-bridge" "$BIN_LINK_DIR/keyprofile-bridge"
ln -s "$INSTALL_DIR/bin/keyprofile-bridge-tray" "$BIN_LINK_DIR/keyprofile-bridge-tray"
ln -s "$INSTALL_DIR/bin/keyprofile-bridge-settings" "$BIN_LINK_DIR/keyprofile-bridge-settings"
ln -s "$INSTALL_DIR/bin/keyprofile-bridge-updater" "$BIN_LINK_DIR/keyprofile-bridge-updater"

for unit in "$MAIN_UNIT" "$TRAY_UNIT" "$BACKGROUND_START_UNIT" "$UPDATE_UNIT" "$UPDATE_TIMER_UNIT"; do
  rm -f -- "$SYSTEMD_DIR/$unit"
  install -m 644 "$INSTALL_DIR/systemd/$unit" "$SYSTEMD_DIR/$unit"
done

for unit in "$MAIN_UNIT" "$TRAY_UNIT" "$BACKGROUND_START_UNIT" "$UPDATE_UNIT" "$UPDATE_TIMER_UNIT"; do
  if [ ! -f "$SYSTEMD_DIR/$unit" ]; then
    printf 'ERROR: Failed to install systemd user unit: %s\n' "$unit" >&2
    exit 1
  fi
done

for unit in "${LEGACY_MAIN_UNITS[@]}" "${LEGACY_TRAY_UNITS[@]}"; do
  rm -f -- "$SYSTEMD_DIR/$unit"
done

rm -rf -- "$KWIN_LINK"
for legacy in "${LEGACY_KWIN_DIRS[@]}"; do
  rm -rf -- "$legacy"
done
ln -s "$INSTALL_DIR/kwin/$KWIN_PLUGIN_ID" "$KWIN_LINK"

rm -f -- \
  "$APPLICATIONS_DIR/keyprofile-bridge.desktop" \
  "$APPLICATIONS_DIR/wootility-bridge.desktop" \
  "$APPLICATIONS_DIR/lynn-wooting-bridge.desktop"

cat > "$APPLICATIONS_DIR/keyprofile-bridge.desktop" <<EOF_DESKTOP_ENTRY
[Desktop Entry]
Type=Application
Name=KeyProfile Bridge
Name[de]=KeyProfile Bridge
GenericName=Keyboard profile switching
GenericName[de]=Tastatur-Profilwechsel
Comment=Configure automatic Wooting profile switching on KDE Plasma Wayland
Comment[de]=Automatischen Wooting-Profilwechsel unter KDE Plasma Wayland konfigurieren
Exec=$INSTALL_DIR/bin/keyprofile-bridge-settings
Icon=$INSTALL_DIR/assets/app.svg
Terminal=false
Categories=Settings;Utility;
Keywords=Wooting;Wootility;Keyboard;Profile;Wayland;
StartupNotify=true
EOF_DESKTOP_ENTRY
chmod 644 "$APPLICATIONS_DIR/keyprofile-bridge.desktop"

mkdir -p "$BACKUPS"
: > "$MANIFEST"
declare -A handled_targets=()
while IFS= read -r source; do
  [ -n "$source" ] || continue
  base="$(basename "$source")"
  target="$AUTOSTART_DIR/$base"
  [ -z "${handled_targets[$target]+x}" ] || continue
  handled_targets[$target]=1

  backup=""
  if [ -f "$target" ]; then
    safe="$(printf '%s' "$base" | tr -c 'A-Za-z0-9._-' '_')"
    backup="$BACKUPS/$safe"
    cp -f -- "$target" "$backup"
    printf 'restore\t%s\t%s\n' "$target" "$backup" >> "$MANIFEST"
  else
    printf 'remove\t%s\t\n' "$target" >> "$MANIFEST"
  fi

  cat > "$target" <<EOF_DESKTOP
[Desktop Entry]
Type=Application
Name=Wooting Background Service
Hidden=true
X-GNOME-Autostart-enabled=false
EOF_DESKTOP
done < <(
  find /etc/xdg/autostart /usr/share/applications \
       "$XDG_DATA_HOME/applications" "$XDG_CONFIG_HOME/autostart" \
       -maxdepth 2 -type f -name '*.desktop' -print 2>/dev/null | while IFS= read -r file; do
    if grep -Eiq '^(Name=.*Wooting.*Background|Exec=.*wooting-bg-service|Exec=.*Wooting.*Background)' "$file"; then
      printf '%s\n' "$file"
    fi
  done
)

if command -v kwriteconfig6 >/dev/null 2>&1; then
  kwriteconfig6 --file kwinrc --group Plugins --key com.lynn.wootingbridgeEnabled false
  kwriteconfig6 --file kwinrc --group Plugins --key de.solocodes.wootilitybridgeEnabled false
  kwriteconfig6 --file kwinrc --group Plugins --key "${KWIN_PLUGIN_ID}Enabled" true
fi

python3 - "$SETTINGS_FILE" "$SETTINGS_BACKUP_FILE" "$MODE_FILE" "$MODE_BACKUP_FILE" "$NOTICE_VERSION" <<'PY_CONFIG'
import json
import os
import sys
import tempfile
from pathlib import Path

settings_file, settings_backup, mode_file, mode_backup = map(Path, sys.argv[1:5])
notice_version = str(sys.argv[5])
settings_defaults = {
    "config_version": 6,
    "language": "en",
    "bridge_enabled": True,
    "start_bridge_on_login": True,
    "check_wootility_background_service_on_login": True,
    "auto_update": False,
    "update_notifications": True,
    "activation_delay_ms": 120,
    "fallback_delay_ms": 1200,
    "catalog_refresh_seconds": 60,
    "device_rescan_seconds": 5,
    "pause_while_wootility_is_open": False,
    "background_transition_timeout_seconds": 8,
    "fallback_profile_index": 0,
    "fallback_profile_namespace": "onboard",
    "manual_overrides": [],
    "wootility_path": "",
}
mode_defaults = {"mode": "bridge"}


def read_object(path: Path):
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
        return value if isinstance(value, dict) else None
    except Exception:
        return None


def atomic_write(path: Path, value: dict):
    path.parent.mkdir(parents=True, exist_ok=True)
    fd, temporary = tempfile.mkstemp(prefix=path.name + ".", suffix=".tmp", dir=path.parent)
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as handle:
            json.dump(value, handle, ensure_ascii=False, indent=2)
            handle.write("\n")
            handle.flush()
            os.fsync(handle.fileno())
        os.replace(temporary, path)
        path.chmod(0o600)
    finally:
        try:
            os.unlink(temporary)
        except FileNotFoundError:
            pass


def merge_persistent(primary: Path, backup: Path, defaults: dict):
    current = read_object(primary)
    saved_backup = read_object(backup)

    if current is None and primary.exists():
        corrupt = primary.with_name(primary.name + ".corrupt")
        counter = 1
        while corrupt.exists():
            corrupt = primary.with_name(primary.name + f".corrupt-{counter}")
            counter += 1
        primary.replace(corrupt)
        print(f"Invalid config preserved as: {corrupt}")

    source = current if current is not None else (saved_backup or {})
    if current is not None:
        atomic_write(backup, current)

    merged = dict(defaults)
    merged.update(source)
    atomic_write(primary, merged)


merge_persistent(settings_file, settings_backup, settings_defaults)
merge_persistent(mode_file, mode_backup, mode_defaults)

settings = read_object(settings_file) or dict(settings_defaults)
try:
    previous_config_version = int(settings.get("config_version", 0))
except (TypeError, ValueError):
    previous_config_version = 0
settings.pop("manage_wootility_background_service", None)
settings.setdefault("bridge_enabled", True)
settings.setdefault("check_wootility_background_service_on_login", True)
if previous_config_version < 6:
    settings["bridge_enabled"] = True
    mode = read_object(mode_file) or dict(mode_defaults)
    mode["mode"] = "bridge"
    atomic_write(mode_file, mode)
settings["config_version"] = 6
settings.setdefault("auto_update", False)
settings.setdefault("update_notifications", True)
if settings.get("catalog_refresh_seconds") == 300:
    settings["catalog_refresh_seconds"] = 60
atomic_write(settings_file, settings)

PY_CONFIG

start_on_login="$(python3 - "$SETTINGS_FILE" <<'PY'
import json, sys
try:
    data = json.load(open(sys.argv[1], encoding="utf-8"))
except Exception:
    data = {}
print("true" if bool(data.get("start_bridge_on_login", True)) else "false")
PY
)"
bridge_enabled="$(python3 - "$SETTINGS_FILE" <<'PY'
import json, sys
try:
    data = json.load(open(sys.argv[1], encoding="utf-8"))
except Exception:
    data = {}
print("true" if bool(data.get("bridge_enabled", True)) else "false")
PY
)"
background_check_on_login="$(python3 - "$SETTINGS_FILE" <<'PY'
import json, sys
try:
    data = json.load(open(sys.argv[1], encoding="utf-8"))
except Exception:
    data = {}
print("true" if bool(data.get("check_wootility_background_service_on_login", True)) else "false")
PY
)"
auto_update="$(python3 - "$SETTINGS_FILE" <<'PY'
import json, sys
try:
    data = json.load(open(sys.argv[1], encoding="utf-8"))
except Exception:
    data = {}
print("true" if bool(data.get("auto_update", False)) else "false")
PY
)"
notice_accepted="$(python3 - "$SETTINGS_FILE" "$NOTICE_VERSION" <<'PY'
import json, sys
try:
    data = json.load(open(sys.argv[1], encoding="utf-8"))
except Exception:
    data = {}
notice = data.get("legal_notice") if isinstance(data, dict) else None
accepted = (
    isinstance(notice, dict)
    and notice.get("accepted") is True
    and str(notice.get("notice_version", "")) == str(sys.argv[2])
)
print("true" if accepted else "false")
PY
)"
systemctl --user daemon-reload
systemctl --user reset-failed "$MAIN_UNIT" "$TRAY_UNIT" "$BACKGROUND_START_UNIT" "$UPDATE_UNIT" "$UPDATE_TIMER_UNIT" 2>/dev/null || true
systemctl --user enable "$TRAY_UNIT"
if [ "$background_check_on_login" = true ]; then
  systemctl --user enable "$BACKGROUND_START_UNIT"
else
  systemctl --user disable --now "$BACKGROUND_START_UNIT" 2>/dev/null || true
fi
if [ "$auto_update" = true ]; then
  systemctl --user enable --now "$UPDATE_TIMER_UNIT"
else
  systemctl --user disable --now "$UPDATE_TIMER_UNIT" 2>/dev/null || true
fi
if [ "$background_check_on_login" = true ]; then
  if ! systemctl --user restart "$BACKGROUND_START_UNIT"; then
    printf 'WARNING: The original Wootility background service could not be checked immediately. It will be checked again automatically after the next system login.
' >&2
  fi
fi
if [ "$start_on_login" = true ] && [ "$bridge_enabled" = true ]; then
  systemctl --user enable "$MAIN_UNIT"
else
  systemctl --user disable "$MAIN_UNIT" 2>/dev/null || true
fi

if [ "$notice_accepted" = true ]; then
  if [ "$bridge_enabled" = true ]; then
    "$INSTALL_DIR/bin/keyprofile-bridge" automation on
  else
    "$INSTALL_DIR/bin/keyprofile-bridge" automation off
  fi
else
  systemctl --user stop "$MAIN_UNIT" 2>/dev/null || true
fi
if [ "$IN_APP_UPDATE" = "1" ]; then
  systemd_run="$(command -v systemd-run || true)"
  systemctl_bin="$(command -v systemctl || true)"
  if [ -n "$systemd_run" ] && [ -n "$systemctl_bin" ]; then
    "$systemd_run" --user --quiet --collect \
      --unit="keyprofile-bridge-post-update-$$" \
      --on-active=3s \
      "$systemctl_bin" --user restart "$TRAY_UNIT" >/dev/null 2>&1 || true
  fi
else
  systemctl --user restart "$TRAY_UNIT"
fi

if command -v kbuildsycoca6 >/dev/null 2>&1; then
  kbuildsycoca6 >/dev/null 2>&1 || true
fi
if command -v qdbus6 >/dev/null 2>&1; then
  qdbus6 org.kde.KWin /KWin reconfigure >/dev/null 2>&1 || true
  qdbus6 org.kde.KWin /Scripting start >/dev/null 2>&1 || true
elif command -v busctl >/dev/null 2>&1; then
  busctl --user call org.kde.KWin /KWin org.kde.KWin reconfigure >/dev/null 2>&1 || true
fi

sleep 1
if ! systemctl --user is-active --quiet "$TRAY_UNIT"; then
  printf '\nERROR: %s is not active. Recent messages:\n' "$TRAY_UNIT" >&2
  journalctl --user -u "$TRAY_UNIT" -n 30 --no-pager >&2 || true
  exit 1
fi
if [ "$notice_accepted" = true ] && [ "$bridge_enabled" = true ] && ! systemctl --user is-active --quiet "$MAIN_UNIT"; then
  printf '\nERROR: %s is not active. Recent messages:\n' "$MAIN_UNIT" >&2
  journalctl --user -u "$MAIN_UNIT" -n 30 --no-pager >&2 || true
  exit 1
fi

for legacy in "${LEGACY_INSTALL_DIRS[@]}"; do
  [ "$legacy" = "$INSTALL_DIR" ] || rm -rf -- "$legacy"
done
for legacy in "${LEGACY_CONFIG_DIRS[@]}"; do
  [ "$legacy" = "$CONFIG_DIR" ] || rm -rf -- "$legacy"
done
for legacy in "${LEGACY_CACHE_DIRS[@]}"; do
  [ "$legacy" = "$CACHE_DIR" ] || rm -rf -- "$legacy"
done
rm -rf -- "$PREVIOUS_INSTALL"

printf '\nInstalled: KeyProfile Bridge %s\n' "$VERSION"
printf 'Complete installation: %s\n' "$INSTALL_DIR"
printf 'Persistent configuration: %s\n' "$SETTINGS_FILE"
printf 'Application menu: KeyProfile Bridge\n'
printf 'Commands: keyprofile-bridge, keyprofile-bridge-settings, keyprofile-bridge-updater\n'
printf 'Bridge log: journalctl --user -u %s -f\n' "$MAIN_UNIT"
printf 'Tray log:   journalctl --user -u %s -f\n' "$TRAY_UNIT"
printf 'Wootility startup log: journalctl --user -u %s -b\n' "$BACKGROUND_START_UNIT"
printf 'Update log: journalctl --user -u %s -n 50\n\n' "$UPDATE_UNIT"