#!/bin/sh
# Sesja środowiska Luna — uruchamia kompozytor Selene.
#
# Domyślnie startujemy na DRM/KMS (własny ekran, bez nadrzędnego kompozytora).
# Gdy master DRM trzyma inna sesja, Selene sam to zgłosi i spadnie do wyjścia
# nested — ustaw wtedy SELENE_BACKEND=nested (albo wyloguj bieżącą sesję).
set -eu

# Ctrl+C / Ctrl+\ w terminalu nie mogą kończyć sesji. Sygnały z terminala trafiają
# do grupy procesów, w której działają też selene i luna-shell — ignorujemy je tutaj,
# a dzieci dziedziczą SIG_IGN. Dziecko PTY w luna-terminal resetuje SIGINT do SIG_DFL,
# więc powłoka w terminalu nadal normalnie dostaje przerwanie.
#
# Sama ignorancja nie wystarczała: konsola jądra wysyłała SIGINT do procesu `greetd`
# nadzorującego sesję (logind kończył wtedy sesję = „wylogowanie”). Dlatego Selene
# przejmuje pierwszy plan VT (zob. `selene/src/vt.rs`).
trap '' INT QUIT

# Diagnostyka: gdy sesję kończy sygnał (np. `loginctl terminate-session` z menu
# zasilania albo greeter), w logu zostaje ślad — bez tego sesja po prostu znikała.
trap 'ts "sygnał TERM — kończę sesję"; exit 143' TERM
trap 'ts "sygnał HUP — kończę sesję"; exit 129' HUP

export XDG_CURRENT_DESKTOP=Luna
# Pełny, przewidywalny PATH: menedżery logowania potrafią go obciąć (bez `/usr/sbin`
# nie uruchomi się np. `thunar` czy `xclock`, bo ich binarki tam leżą).
export PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin${PATH:+:$PATH}"

# Powłoka użytkownika: greetd/menedżery logowania NIE eksportują SHELL.
# Bez tego luna-terminal (czyta $SHELL) uruchamiał /bin/sh zamiast zsh.
if [ -z "${SHELL:-}" ]; then
    SHELL="$(awk -F: -v u="$(id -un)" '$1==u {print $7; exit}' /etc/passwd 2>/dev/null)"
    [ -n "$SHELL" ] || SHELL=/bin/sh
    export SHELL
fi

export XDG_SESSION_TYPE=wayland
export XDG_SESSION_DESKTOP=Luna

# XDG_RUNTIME_DIR normalnie ustawia menedżer sesji (logind/pam_systemd). Gdy go brak
# (np. pam_systemd nie zdołał założyć sesji), wskazujemy katalog per-uid, żeby Selene
# i klienci mieli gdzie założyć gniazdo Wayland. Selene sam waliduje ten katalog.
if [ -z "${XDG_RUNTIME_DIR:-}" ] && [ -d "/run/user/$(id -u)" ]; then
    XDG_RUNTIME_DIR="/run/user/$(id -u)"
    export XDG_RUNTIME_DIR
fi

: "${SELENE_BACKEND:=drm}"
export SELENE_BACKEND

# Tryb DRM nie ma nadrzędnego kompozytora — wejście czytamy wprost z /dev/input
# (wymaga dostępu do urządzeń: grupa `input` albo root).
if [ "$SELENE_BACKEND" = "drm" ]; then
    : "${SELENE_INPUT:=evdev}"
    export SELENE_INPUT
fi

# GPU: domyślnie włączone (`LUNA_GPU=1`), z automatycznym fallbackiem do CPU w Selene,
# jeśli EGL nie jest dostępny. W razie problemów na konkretnym sterowniku można
# wymusić tryb czysto programowy przez `LUNA_GPU=0 luna-session`.
: "${LUNA_GPU:=1}"
export LUNA_GPU

# NVIDIA: VA-API przez NVDEC (pakiet `nvidia-vaapi-driver`). Sterowniki 525+
# mają zepsuty backend EGL tego drivera, więc jedyną działającą ścieżką jest
# `direct` (wymaga `nvidia_drm.modeset=1`). Zmienne są obojętne dla innych kart,
# a `LIBVA_DRIVER_NAME` ustawiamy **tylko** gdy driver naprawdę leży na dysku —
# inaczej zepsulibyśmy VA-API na Intelu/AMD.
if [ -e /sys/module/nvidia ] || [ -e /proc/driver/nvidia ]; then
    : "${NVD_BACKEND:=direct}"
    export NVD_BACKEND
    if [ -f /usr/lib/dri/nvidia_drv_video.so ] || [ -f /usr/lib64/dri/nvidia_drv_video.so ]; then
        : "${LIBVA_DRIVER_NAME:=nvidia}"
        # Sandbox procesu RDD odcina /dev/nvidia* — bez tego Firefox/Zen nie
        # zainicjuje VA-API mimo poprawnej konfiguracji.
        : "${MOZ_DISABLE_RDD_SANDBOX:=1}"
        export LIBVA_DRIVER_NAME MOZ_DISABLE_RDD_SANDBOX
    fi
fi

# Diagnostyka wydajności (fps DRM + tempo kursora w Selene, fps powłoki w luna-shell).
# Domyślnie **włączona**, bo log sesji jest trwały i tylko wtedy da się po fakcie ustalić,
# gdzie znikają klatki. Wyłącz jawnie wolnym zerem:  SELENE_STATS=0 LUNA_STATS=0 luna-session
: "${SELENE_STATS:=1}"
: "${LUNA_STATS:=1}"
export SELENE_STATS LUNA_STATS

# Binarki zainstalowane przez użytkownika (np. `install -m755 ... ~/.local/bin`)
# mają pierwszeństwo przed systemowymi — pozwala to testować/aktualizować Lunę
# bez roota, a sesja zawsze uruchamia najnowszą powłokę i kompozytor. Robimy to
# **przed** logiem, żeby `command -v selene` pokazywał faktycznie uruchomiony plik
# (wcześniej log twierdził `"/usr/bin/selene"`, a proces brał starszy z `~/.local/bin`).
export PATH="$HOME/.local/bin:$PATH"

# Trwały log sesji: LightDM trzyma tylko 2 pliki `.xsession-errors` i obraca je przy
# każdym starcie sesji, przez co logi Luny przepadają. Piszemy do stałego pliku w
# katalogu stanu użytkownika, żeby każdą próbę dało się obejrzeć po fakcie.
log_dir="${XDG_STATE_HOME:-$HOME/.local/state}/luna"
if mkdir -p "$log_dir" 2>/dev/null; then
    log="$log_dir/session.log"
    # Pochodzenie binarek: który plik i z jaką datą faktycznie wystartował. Bez tego
    # łatwo testować stary build i szukać błędu, którego już nie ma.
    selene_path="$(command -v selene 2>/dev/null || echo '<brak>')"
    shell_path="$(command -v luna-shell 2>/dev/null || echo '<brak>')"
    printf '=== luna-session %s ===\nXDG_RUNTIME_DIR=%s SELENE_BACKEND=%s SELENE_INPUT=%s\nselene: %s [%s]\nluna-shell: %s [%s]\nSELENE_STATS=%s LUNA_STATS=%s LUNA_GPU=%s\n' \
        "$(date -Is)" "${XDG_RUNTIME_DIR:-<brak>}" "$SELENE_BACKEND" "${SELENE_INPUT:-<brak>}" \
        "$selene_path" "$(stat -c %y "$selene_path" 2>/dev/null | cut -d. -f1 || echo '?')" \
        "$shell_path" "$(stat -c %y "$shell_path" 2>/dev/null | cut -d. -f1 || echo '?')" \
        "$SELENE_STATS" "$LUNA_STATS" "${LUNA_GPU:-<brak>}" \
        >>"$log" 2>/dev/null || true
    exec >>"$log" 2>&1
fi

# Kompozytor w tle, a po nim powłoka Luna (panel/OSD).
rt="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
ts() { printf '%s luna-session: %s\n' "$(date +%H:%M:%S)" "$*"; }
# Start licznika całej sesji (od pierwszych instrukcji skryptu), żeby w logu
# było widać pełny czas „logowanie → działający panel”, a nie tylko fragment.
t_session="$(date +%s%3N 2>/dev/null || echo 0)"
# `locale -a` wypisuje `pl_PL.utf8`, a my używamy tagów typu `pl_PL.UTF-8`.
# Porównujemy po usunięciu myślników i wielkości liter.
has_locale() {
    [ -n "$1" ] || return 1
    command -v locale >/dev/null 2>&1 || return 1
    # Lista generowanych locale jest stała w czasie sesji, a `locale -a` to
    # osobny proces (kilka–kilkadziesiąt ms). Pytamy raz i trzymamy wynik.
    if [ -z "${locales_ready:-}" ]; then
        locales_list="$(locale -a 2>/dev/null | tr '[:upper:]' '[:lower:]' | tr -d '-')"
        locales_ready=1
    fi
    norm="$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -d '-')"
    printf '%s\n' "$locales_list" | grep -Fxq "$norm"
}

# Język wybrany w Ustawieniach Luny. Ustawiamy `LANGUAGE` (gettext) i — gdy locale
# jest wygenerowane — `LANG`; reszta aplikacji libLuny czyta ten sam plik sama.
luna_locale_file="${XDG_CONFIG_HOME:-$HOME/.config}/luna/locale.conf"
if [ -r "$luna_locale_file" ]; then
    luna_lang="$(sed -n 's/^[[:space:]]*language[[:space:]]*=[[:space:]]*//p' "$luna_locale_file" | head -n 1 | tr -d '[:space:]')"
    case "$luna_lang" in
        pl) luna_locale="pl_PL.UTF-8" ;;
        en) luna_locale="en_US.UTF-8" ;;
        de) luna_locale="de_DE.UTF-8" ;;
        fr) luna_locale="fr_FR.UTF-8" ;;
        es) luna_locale="es_ES.UTF-8" ;;
        pt) luna_locale="pt_PT.UTF-8" ;;
        it) luna_locale="it_IT.UTF-8" ;;
        nl) luna_locale="nl_NL.UTF-8" ;;
        ru) luna_locale="ru_RU.UTF-8" ;;
        uk) luna_locale="uk_UA.UTF-8" ;;
        tr) luna_locale="tr_TR.UTF-8" ;;
        sv) luna_locale="sv_SE.UTF-8" ;;
        cs) luna_locale="cs_CZ.UTF-8" ;;
        sw) luna_locale="sw_KE.UTF-8" ;;
        *)  luna_locale="" ;;
    esac
    if [ -n "$luna_lang" ]; then
        export LANGUAGE="$luna_lang"
        if [ -n "$luna_locale" ] && has_locale "$luna_locale"; then
            export LANG="$luna_locale"
        elif [ -n "$luna_locale" ] && [ -d "$HOME/.local/share/locale/$luna_locale" ]; then
            # Locale wygenerowane bez roota przez Ustawienia (`localedef`).
            export LANG="$luna_locale"
            export LOCPATH="$HOME/.local/share/locale"
        fi
        ts "język z Ustawień: $luna_lang${luna_locale:+ ($luna_locale)}"
    fi
fi

# Region, formaty i strefa czasowa z Ustawień Luny (`region.conf`).
# To ustawienia użytkownika — nie wymagają roota; systemowa strefa zostaje nietknięta.
luna_region_file="${XDG_CONFIG_HOME:-$HOME/.config}/luna/region.conf"
if [ -r "$luna_region_file" ]; then
    luna_region_locale="$(sed -n 's/^[[:space:]]*locale[[:space:]]*=[[:space:]]*//p' "$luna_region_file" | head -n 1 | tr -d '[:space:]')"
    luna_region_tz="$(sed -n 's/^[[:space:]]*timezone[[:space:]]*=[[:space:]]*//p' "$luna_region_file" | head -n 1 | tr -d '[:space:]')"
    if [ -n "$luna_region_locale" ]; then
        if has_locale "$luna_region_locale"; then
            export LC_TIME="$luna_region_locale"
        elif [ -d "$HOME/.local/share/locale/$luna_region_locale" ]; then
            export LC_TIME="$luna_region_locale"
            export LOCPATH="$HOME/.local/share/locale"
            ts "format czasu z Ustawień: $luna_region_locale"
        else
            ts "locale z Ustawień niewygenerowane: $luna_region_locale (pomijam)"
        fi
    fi
    if [ -n "$luna_region_tz" ] && [ -f "/usr/share/zoneinfo/$luna_region_tz" ]; then
        export TZ="$luna_region_tz"
        ts "strefa czasowa z Ustawień: $luna_region_tz"
    fi
fi

# Język ma obowiązywać w **całej sesji**, nie tylko w aplikacjach libLuny.
# `dbus-update-activation-environment` / `systemctl --user import-environment`
# wykonujemy w tle, razem z resztą środowiska (niżej) — wywołane tutaj, przed
# powłoką, potrafią czekać na start menedżera użytkownika nawet kilkadziesiąt
# sekund i przez ten czas widać tylko tapetę. Powłoka dziedziczy `LANGUAGE`
# bezpośrednio z tego procesu, więc niczego nie traci.

ts "uruchamiam selene"
# Znacznik do pomiaru „jak szybko po kompozytorze wstaje panel” w logu sesji.
t0="$(date +%s%3N 2>/dev/null || echo 0)"
# Sprzątanie po poprzedniej sesji: zamki gniazd zostają po nagłym zabiciu kompozytora.
# Katalog jest per-użytkownik, więc nie ruszamy niczego cudzego.
marker="$rt/luna-wayland"
rm -f "$marker" 2>/dev/null || true
# Marker X11 z poprzedniej sesji jest bezużyteczny, a wręcz szkodliwy: sesja
# ustawiłaby `DISPLAY` na ekran, który już nie istnieje (albo o innym numerze),
# zanim nowy Xwayland w ogóle wstanie. Kasujemy zawsze.
rm -f "$rt/luna-display" 2>/dev/null || true
# Liczba monitorów z poprzedniej sesji też jest nieaktualna.
rm -f "$rt/luna-outputs" 2>/dev/null || true
rm -f "$rt"/wayland-*.lock 2>/dev/null || true
# Selene potrzebuje deskryptora terminala sesji, żeby przejąć pierwszy plan VT
# (patrz `selene/src/vt.rs`) — inaczej Ctrl+C na konsoli wysyła SIGINT do całej grupy
# procesów VT, ginie proces `greetd` nadzorujący sesję i logind ją kończy.
# Uwaga: `selene &` w nieinteraktywnej powłoce dostaje stdin=/dev/null, dlatego
# przekazujemy kopię naszego stdin jawnie.
if [ -t 0 ]; then
    exec 3<&0
    selene 0<&3 &
    selene_pid=$!
    exec 3<&-
else
    selene &
    selene_pid=$!
fi

# Czekamy na **marker gotowości** zapisany przez Selene (a nie na plik gniazda, który
# mógł zostać po poprzedniej sesji). Marker zawiera nazwę gniazda, na którym Selene
# naprawdę słucha — dzięki temu działa też `wayland-1`.
sock=""
waited=0
while [ "$waited" -lt 100 ] && [ ! -f "$marker" ]; do
    sleep 0.05
    waited=$((waited + 1))
done
if [ -f "$marker" ]; then
    sock="$(cat "$marker" 2>/dev/null)"
    ts "gniazdo Wayland gotowe: ${sock:-?} (po $((waited * 50)) ms)"
else
    ts "UWAGA: Selene nie zgłosił gotowości w 5 s — powłoka może się nie połączyć"
fi

# Standardowe integracje toolkitów z Waylandem (Firefox, Qt, GTK, SDL, Electron)
export WAYLAND_DISPLAY="${WAYLAND_DISPLAY:-${sock:-wayland-0}}"

# Aplikacje X11: Selene uruchamia Xwayland i zapisuje numer ekranu w markerze.
# Czekamy krótko (zwykle pojawia się od razu), żeby powłoka — a przez nią aplikacje —
# dostały poprawne `DISPLAY`.
# Aplikacje X11: Selene uruchamia Xwayland i zapisuje numer ekranu w markerze.
# Powłoki **nie blokujemy** czekaniem na X11 — panel ma pojawić się natychmiast.
# Gdy marker już jest, ustawiamy DISPLAY od razu; gdy jeszcze nie, luna-shell odczyta
# go przy starcie każdej aplikacji, a wątek w tle uzupełni środowisko aktywacji D-Bus.
display_marker="$rt/luna-display"
xnum=""
if [ -f "$display_marker" ]; then
    xnum="$(cat "$display_marker" 2>/dev/null)"
fi
if [ -n "$xnum" ] && [ -S "/tmp/.X11-unix/X$xnum" ]; then
    export DISPLAY=":$xnum"
    ts "X11 gotowe: DISPLAY=$DISPLAY"
else
    # Bez Xwaylanda **nie zostawiamy odziedziczonego `DISPLAY`** (np. `:0` z pulpitu
    # gospodarza) — inaczej aplikacje X11 lądują na tamtym ekranie i widać je
    # z obcymi dekoracjami, poza Luną.
    unset DISPLAY
    ts "X11 jeszcze nie zgłosił ekranu — startuję powłokę od razu"
    (
        i=0
        while [ "$i" -lt 100 ]; do
            if [ -f "$display_marker" ]; then
                n="$(cat "$display_marker" 2>/dev/null)"
                if [ -n "$n" ] && [ -S "/tmp/.X11-unix/X$n" ]; then
                    if command -v dbus-update-activation-environment >/dev/null 2>&1; then
                        dbus-update-activation-environment DISPLAY=":$n" 2>/dev/null || true
                    fi
                    break
                fi
            fi
            sleep 0.05
            i=$((i + 1))
        done
    ) &
fi
# Diagnostyka: jakie ekrany X w ogóle istnieją (pomaga, gdy coś idzie nie tam).
if [ -d /tmp/.X11-unix ]; then
    ts "ekrany X w systemie: $(ls /tmp/.X11-unix 2>/dev/null | tr '\n' ' ')"
fi
export MOZ_ENABLE_WAYLAND=1
export QT_QPA_PLATFORM="wayland;xcb"
export GDK_BACKEND="wayland,x11"
export SDL_VIDEODRIVER="wayland"
export CLUTTER_BACKEND="wayland"
export ELECTRON_OZONE_PLATFORM_HINT="auto"
# Java/AWT: nasz XWM nie reparentuje okien (brak ramek X11), więc bez tej zmiennej okna
# aplikacji Javy (IDE, narzędzia AWT/Swing) potrafią się źle rysować albo nie pojawiać.
export _JAVA_AWT_WM_NONREPARENTING=1

# Motyw kursora dla X11/Xwayland. Xwayland bez motywu zgłasza wbudowany
# `X_cursor` („X”) dla okien bez własnego kursora — a tak zachowuje się m.in.
# Zed. Wybieramy pierwszy motyw, który **naprawdę** ma pliki kursorów
# (`Pagan-Cursors` bywa pustym opakowaniem z samym `Inherits`), oraz ustawiamy
# `XCURSOR_PATH`, bo libXcursor domyślnie nie zagląda do /usr/local/share/icons.
if [ -z "${XCURSOR_PATH:-}" ]; then
    XCURSOR_PATH="${HOME:-}/.icons:${HOME:-}/.local/share/icons:/usr/local/share/icons:/usr/share/icons:/usr/share/pixmaps"
    export XCURSOR_PATH
fi
if [ -z "${XCURSOR_THEME:-}" ]; then
    for theme in Luna-Cursors Pagan-Cursors Adwaita DMZ-Black DMZ-White; do
        for dir in "${HOME:-}/.icons" "${HOME:-}/.local/share/icons" /usr/local/share/icons /usr/share/icons; do
            if [ -d "$dir/$theme/cursors" ] && [ -n "$(ls -A "$dir/$theme/cursors" 2>/dev/null)" ]; then
                XCURSOR_THEME="$theme"
                break 2
            fi
        done
    done
    if [ -n "${XCURSOR_THEME:-}" ]; then
        export XCURSOR_THEME
    fi
fi
if [ -z "${XCURSOR_SIZE:-}" ]; then
    XCURSOR_SIZE=24
    export XCURSOR_SIZE
fi
ts "krok: motyw kursora gotowy (${XCURSOR_THEME:-wbudowany})"

# ── Powłoka startuje **natychmiast** ─────────────────────────────────────────
#
# Wszystko, czego potrzebuje panel (gniazdo Waylanda, `DISPLAY`, motyw kursora),
# jest już gotowe. Portale, keyring, polkit i aktualizacja środowiska D-Bus /
# systemd idą **po** powłoce — w tle. Wcześniej blokujące `systemctl --user
# start xdg-desktop-portal` potrafiło zjeść 75 s (limit zadania systemd),
# a panel pojawiał się dopiero po nim.
if command -v luna-security >/dev/null 2>&1; then
    # Monitor prywatności: startuje przed panelem, żeby wskaźniki mikrofonu /
    # kamery / sieci miały stan od pierwszej klatki.
    ts "uruchamiam luna-security"
    luna-security daemon >/dev/null 2>&1 &
fi

# Powłoka Luna (panel, launcher, OSD).
#
# Domyślnie **jeden** panel na monitorze głównym (pierwszym) — popupy (kalendarz, Wi‑Fi,
# głośność) są rysowane w tym samym buforze co pasek, więc mają sens tylko na jednym
# ekranie. Panel na każdym monitorze (osobna instancja powłoki na wyjście) włączasz
# jawnie:  LUNA_PANELS=all luna-session
if command -v luna-shell >/dev/null 2>&1; then
    if [ "${LUNA_PANELS:-primary}" = "all" ]; then
        nouts=1
        if [ -f "$rt/luna-outputs" ]; then
            n="$(cat "$rt/luna-outputs" 2>/dev/null)"
            case "$n" in
                ''|*[!0-9]*) n=1 ;;
            esac
            if [ "$n" -ge 1 ]; then nouts="$n"; fi
        fi
        ts "uruchamiam luna-shell x$nouts (panel na każdym monitorze)"
        i=0
        while [ "$i" -lt "$nouts" ]; do
            LUNA_OUTPUT="$i" luna-shell &
            i=$((i + 1))
        done
    else
        ts "uruchamiam luna-shell (panel na monitorze głównym)"
        luna-shell &
    fi
else
    ts "brak luna-shell w PATH"
fi
if [ "${t0:-0}" != 0 ] && command -v date >/dev/null 2>&1; then
    t1="$(date +%s%3N 2>/dev/null || echo 0)"
    if [ "$t1" != 0 ] && [ "$t1" -ge "$t0" ]; then
        ts "powłoka uruchomiona po $((t1 - t0)) ms od startu kompozytora"
    fi
    if [ "${t_session:-0}" != 0 ] && [ "$t1" != 0 ] && [ "$t1" -ge "$t_session" ]; then
        ts "sesja gotowa po $((t1 - t_session)) ms od startu skryptu"
    fi
fi

# Ikony pulpitu (pliki, foldery, skróty `.desktop`). Osobny proces na każde
# wyjście: powierzchnia warstwowa wiąże się z konkretnym monitorem przez
# `LUNA_OUTPUT`, więc bez tego drugi ekran nie ma ikon, menu PPM ani
# przeciągania. Pozycje ikon są zapisywane per monitor (`pos1:` w `desktop.conf`).
if command -v luna-desktop >/dev/null 2>&1; then
    nouts=1
    panels=1
    if [ -f "$rt/luna-outputs" ]; then
        n="$(cat "$rt/luna-outputs" 2>/dev/null)"
        case "$n" in
            ''|*[!0-9]*) n=1 ;;
        esac
        if [ "$n" -ge 1 ]; then nouts="$n"; fi
    fi
    if [ "${LUNA_PANELS:-primary}" = "all" ]; then
        panels="$nouts"
    fi
    ts "uruchamiam luna-desktop x$nouts (ikony na każdym monitorze)"
    i=0
    while [ "$i" -lt "$nouts" ]; do
        # Rezerwa na panel tylko tam, gdzie panel naprawdę jest.
        if [ "$i" -lt "$panels" ]; then inset=1; else inset=0; fi
        LUNA_OUTPUT="$i" LUNA_DESKTOP_INSET="$inset" luna-desktop >/dev/null 2>&1 &
        i=$((i + 1))
    done
else
    ts "brak luna-desktop w PATH"
fi

# Aktualizacja środowiska aktywacji D-Bus i systemd (wymagane m.in. dla xdg-desktop-portal).
#
# **Nie mogą blokować startu powłoki.** `dbus-update-activation-environment --systemd`
# i `systemctl --user` potrafią zawiesić się do limitu systemd (90 s) — a przez ten
# czas widać tylko tapetę rysowaną przez Selene, bez panelu. Każdy krok ma własny
# krótki limit, a start jednostek jest `--no-block`.
tmo=""
if command -v timeout >/dev/null 2>&1; then
    tmo="timeout 3"
fi
# Cały blok idzie w tło: powłoka nie może czekać na D-Bus/systemd nawet wtedy,
# gdy menedżer użytkownika dopiero wstaje (D-Bus ma 25 s limitu, a dwa oczekiwania
# dawały 50 s samej tapety przed pierwszym panelem).
(
    if command -v dbus-update-activation-environment >/dev/null 2>&1; then
        $tmo dbus-update-activation-environment --systemd LANGUAGE LANG LC_TIME TZ WAYLAND_DISPLAY DISPLAY XDG_CURRENT_DESKTOP XDG_SESSION_TYPE XDG_SESSION_DESKTOP MOZ_ENABLE_WAYLAND QT_QPA_PLATFORM GDK_BACKEND XCURSOR_THEME XCURSOR_SIZE XCURSOR_PATH _JAVA_AWT_WM_NONREPARENTING 2>/dev/null || true
    fi
    ts "krok: środowisko dbus"
    if command -v systemctl >/dev/null 2>&1; then
        $tmo systemctl --user import-environment LANGUAGE LANG LC_TIME TZ WAYLAND_DISPLAY DISPLAY XDG_CURRENT_DESKTOP XDG_SESSION_TYPE XDG_SESSION_DESKTOP MOZ_ENABLE_WAYLAND QT_QPA_PLATFORM GDK_BACKEND XCURSOR_THEME XCURSOR_SIZE XCURSOR_PATH _JAVA_AWT_WM_NONREPARENTING 2>/dev/null || true
        ts "krok: środowisko systemd"

        # `graphical-session.target` ma `RefuseManualStart=yes` — wciągamy go
        # zależnością z własnego targetu. Usługi portali
        # (`Requisite=graphical-session.target`) bez tego nie startują przez D-Bus.
        $tmo systemctl --user start --no-block luna-session.target >/dev/null 2>&1 || true
        ts "krok: target sesji uruchomiony"
    fi
) &
ts "krok: dbus/systemd w tle"

# Portal XDG (aplikacje GTK4/flatpak/Steam): startujemy jawnie, z poprawnym
# środowiskiem sesji. Bez tego aktywacja D-Bus bywała bez WAYLAND_DISPLAY /
# XDG_CURRENT_DESKTOP, a aplikacje czekały ~25 s na odpowiedź („Cannot get portal …
# Przekroczono czas oczekiwania”).
#
# Frontend `xdg-desktop-portal` sam nic nie robi — każde żądanie kieruje do backendu
# wybranego przez `luna-portals.conf`:
#   * `gtk`  — FileChooser, Settings, Notification, Print, Access, …
#   * `wlr`  — ScreenCast i Screenshot (Selene implementuje `wlr-screencopy`).
# Backendy sprawdzamy **osobno**. Wcześniej brak jednej biblioteki GTK wyłączał
# cały portal, więc nawet poprawny backend wlr nie mógł udostępnić ekranu.
portal_bin=""
for p in /usr/libexec/xdg-desktop-portal /usr/lib/xdg-desktop-portal; do
    if [ -x "$p" ]; then portal_bin="$p"; break; fi
done

# Wynik: `ok`, `uszkodzony` (brakuje bibliotek) albo `brak`.
portal_gtk=brak
portal_gtk_missing=""
for backend in /usr/libexec/xdg-desktop-portal-gtk /usr/lib/xdg-desktop-portal-gtk; do
    [ -x "$backend" ] || continue
    portal_gtk=ok
    if command -v ldd >/dev/null 2>&1; then
        portal_gtk_missing="$($tmo ldd "$backend" 2>/dev/null | sed -n 's/^[[:space:]]*\([^[:space:]]*\) => not found.*/\1/p' | tr '\n' ' ')"
        [ -n "$portal_gtk_missing" ] && portal_gtk=uszkodzony
    fi
    break
done
portal_wlr=brak
portal_wlr_missing=""
for backend in /usr/libexec/xdg-desktop-portal-wlr /usr/lib/xdg-desktop-portal-wlr; do
    [ -x "$backend" ] || continue
    portal_wlr=ok
    if command -v ldd >/dev/null 2>&1; then
        portal_wlr_missing="$($tmo ldd "$backend" 2>/dev/null | sed -n 's/^[[:space:]]*\([^[:space:]]*\) => not found.*/\1/p' | tr '\n' ' ')"
        [ -n "$portal_wlr_missing" ] && portal_wlr=uszkodzony
    fi
    break
done
ts "krok: backendy portali sprawdzone (gtk=$portal_gtk wlr=$portal_wlr)"

case "$portal_gtk" in
    uszkodzony)
        ts "portal/gtk: uszkodzony backend (brak: $portal_gtk_missing)"
        ts "  → okna wyboru plików/Ustawienia pójdą przez inny backend albo bez portalu"
        ;;
    brak)
        ts "portal/gtk: brak pakietu xdg-desktop-portal-gtk"
        ;;
esac
case "$portal_wlr" in
    uszkodzony)
        ts "portal/wlr: uszkodzony backend (brak: $portal_wlr_missing) — ScreenCast nie zadziała"
        ;;
    brak)
        ts "portal/wlr: brak xdg-desktop-portal-wlr — udostępnianie ekranu (OBS, Discord, Meet) nie zadziała"
        ts "  sudo pag install xdg-desktop-portal-wlr"
        ;;
esac

# Mapowanie ScreenCast → wlr. Starsze wydania pakietu Luny dostarczały
# `luna-portals.conf` tylko z `default=gtk`, więc mimo zainstalowanego backendu
# wlr każde udostępnienie ekranu kończyło się błędem. Dopisujemy mapowanie
# wyłącznie w configu użytkownika i tylko wtedy, gdy systemowy plik go nie ma;
# gdy pakiet zostanie zaktualizowany, nasz plik zniknie sam.
portal_conf=/usr/share/xdg-desktop-portal/luna-portals.conf
portal_conf_ok=0
portal_conf_generated=0
if [ -r "$portal_conf" ] && grep -q 'ScreenCast=wlr' "$portal_conf"; then
    portal_conf_ok=1
fi
user_portal_dir="${XDG_CONFIG_HOME:-$HOME/.config}/xdg-desktop-portal"
user_portal_conf="$user_portal_dir/luna-portals.conf"
if [ "$portal_conf_ok" = 1 ]; then
    if [ -r "$user_portal_conf" ] && grep -q 'wygenerowane przez luna-session' "$user_portal_conf"; then
        rm -f "$user_portal_conf" 2>/dev/null || true
    fi
elif [ "$portal_wlr" = ok ]; then
    if [ ! -e "$user_portal_conf" ]; then
        mkdir -p "$user_portal_dir" 2>/dev/null || true
        cat >"$user_portal_conf" <<'PORTAL_CONF'
# wygenerowane przez luna-session — pakiet nie dostarczył mapowania ScreenCast
[preferred]
default=gtk;
org.freedesktop.impl.portal.ScreenCast=wlr;
org.freedesktop.impl.portal.Screenshot=wlr;
PORTAL_CONF
        ts "uzupełniam $user_portal_conf (stary luna-portals.conf bez ScreenCast=wlr)"
        portal_conf_generated=1
    fi
fi

portal_log="${log_dir:-${XDG_STATE_HOME:-$HOME/.local/state}/luna}/portal.log"

# Decyzja o środowisku dla aplikacji GTK zapada **synchronicznie** (jest tania),
# bo `GTK_USE_PORTAL` / `GDK_DEBUG` muszą odziedziczyć wszystkie późniejsze
# aplikacje. Sam start usług idzie już w tle.
if [ -z "$portal_bin" ]; then
    ts "xdg-desktop-portal: brak frontendu — aplikacje użyją własnych okien"
    export GTK_USE_PORTAL=0
elif [ "$portal_gtk" != ok ]; then
    if [ "$portal_wlr" != ok ]; then
        ts "xdg-desktop-portal: żaden backend nie jest kompletny — pomijam portal"
        ts "  Flatpak/Steam bez portalu nie uruchomi gier (timeout org.freedesktop.portal.Flatpak)"
    else
        # Backend GTK uszkodzony, ale wlr działa: nie każmy aplikacjom GTK czekać
        # na portal, który i tak nie obsłuży wyboru pliku.
        ts "portal/gtk: pomijam w aplikacjach GTK (GTK_USE_PORTAL=0)"
    fi
    export GTK_USE_PORTAL=0
fi
if [ "${GTK_USE_PORTAL:-}" = 0 ]; then
    if [ -n "${GDK_DEBUG:-}" ]; then
        export GDK_DEBUG="$GDK_DEBUG,no-portals"
    else
        export GDK_DEBUG="no-portals"
    fi
fi

# Start portalu i backendów **w tle**.
#
# `systemctl --user start` bez `--no-block` czeka na zakończenie zadania — przy
# wolno wstającym menedżerze użytkownika to 75 s (limit systemd). Powłoka
# startowała wtedy dopiero po portalu, czyli po ponad minucie tapety.
if [ -n "$portal_bin" ] && { [ "$portal_gtk" = ok ] || [ "$portal_wlr" = ok ]; }; then
    (
        portal_started=0
        # Preferujemy usługę systemd: ma własny cgroup i nie zostawia sieroty po sesji.
        if command -v systemctl >/dev/null 2>&1; then
            if $tmo systemctl --user start --no-block xdg-desktop-portal.service >>"$portal_log" 2>&1; then
                portal_started=1
            fi
        fi
        if [ "$portal_started" = 0 ]; then
            "$portal_bin" >>"$portal_log" 2>&1 &
        fi
        ts "uruchamiam xdg-desktop-portal (gtk=$portal_gtk wlr=$portal_wlr, log: $portal_log)"
        # Backendy startujemy jawnie — usługa aktywowana przez D-Bus dostaje środowisko
        # z chwili aktywacji, a nie z chwili startu sesji (np. po restarcie D-Busa).
        if command -v systemctl >/dev/null 2>&1; then
            if [ "$portal_gtk" = ok ]; then
                $tmo systemctl --user start --no-block xdg-desktop-portal-gtk.service >>"$portal_log" 2>&1 || true
            fi
            if [ "$portal_wlr" = ok ]; then
                if ! $tmo systemctl --user start --no-block xdg-desktop-portal-wlr.service >>"$portal_log" 2>&1; then
                    ts "portal/wlr: usługa nie wystartowała — sprawdź log: $portal_log"
                fi
            fi
            # Frontend cache'uje `luna-portals.conf` przy starcie — po wygenerowaniu
            # brakującego mapowania trzeba go przeładować, inaczej ScreenCast nadal
            # trafiałby do backendu GTK.
            if [ "$portal_conf_generated" = 1 ]; then
                $tmo systemctl --user restart --no-block xdg-desktop-portal.service >>"$portal_log" 2>&1 || true
            fi
        fi
        # Dowód, że frontend i backend GTK naprawdę odpowiadają. Bez tego usterka
        # portalu ujawnia się dopiero po 25 s w aplikacji (jak w RapidRAW).
        # `Settings.Read` obsługuje backend GTK — przy jego braku test nie ma sensu.
        if [ "$portal_gtk" != ok ]; then
            ts "portal/Settings: backend gtk niedostępny — pomijam test Settings.Read"
        elif command -v gdbus >/dev/null 2>&1 && command -v timeout >/dev/null 2>&1; then
            # Start jest nieblokujący, więc frontend potrzebuje kilku prób.
            portal_reply=""
            tries=0
            while [ "$tries" -lt 6 ] && [ -z "$portal_reply" ]; do
                portal_reply="$(timeout 2 gdbus call --session \
                    --dest org.freedesktop.portal.Desktop \
                    --object-path /org/freedesktop/portal/desktop \
                    --method org.freedesktop.portal.Settings.Read \
                    org.freedesktop.appearance color-scheme 2>/dev/null || true)"
                tries=$((tries + 1))
                if [ -z "$portal_reply" ] && [ "$tries" -lt 6 ]; then
                    sleep 0.5
                fi
            done
            if [ -n "$portal_reply" ]; then
                ts "portal odpowiada (Settings.Read: $portal_reply)"
            else
                ts "UWAGA: portal nie odpowiedział — sprawdź $portal_log"
            fi
        fi
    ) &
    ts "krok: portal startuje w tle"
fi
# Aplikacje uruchamiane przez D-Bus (zsynchronizuj też środowisko aktywacji).
if command -v dbus-update-activation-environment >/dev/null 2>&1; then
    $tmo dbus-update-activation-environment \
        ${GTK_USE_PORTAL:+GTK_USE_PORTAL} ${GDK_DEBUG:+GDK_DEBUG} 2>/dev/null || true
fi

# Baza kluczy i haseł (Luna Keyring — Secret Service API)
rm -f "$rt/luna-keyring-ready" 2>/dev/null || true
if command -v luna-keyring >/dev/null 2>&1; then
    ts "uruchamiam luna-keyring"
    luna-keyring &

    # Korektor (PipeWire + LADSPA): jeśli użytkownik włączył go w ustawieniach,
    # łańcuch filtrów wstaje razem z sesją. `luna-eq start` nic nie robi, gdy
    # korektor jest wyłączony; błędy trafiają do ~/.cache/luna/equalizer.log.
    if command -v luna-eq >/dev/null 2>&1; then
        ( luna-eq start >/dev/null 2>&1 || true ) &
    fi
    # Krótkie oczekiwanie na zajęcie nazwy `org.freedesktop.secrets`. Aplikacje
    # uruchamiane zaraz po zalogowaniu (Zed, VS Code) inaczej nie widzą keyringu.
    k=0
    while [ "$k" -lt 40 ] && [ ! -f "$rt/luna-keyring-ready" ]; do
        sleep 0.05
        k=$((k + 1))
    done
    if [ -f "$rt/luna-keyring-ready" ]; then
        ts "luna-keyring gotowy (po $((k * 50)) ms)"
    else
        ts "luna-keyring: brak potwierdzenia gotowości po 2 s"
    fi
fi

# Agent uwierzytelniania Polkit (okienka autoryzacji uprawnień)
if command -v luna-polkit >/dev/null 2>&1; then
    ts "uruchamiam luna-polkit"
    luna-polkit &
else
    for agent in \
        /usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1 \
        /usr/libexec/polkit-gnome-authentication-agent-1 \
        /usr/lib/policykit-1-gnome/polkit-gnome-authentication-agent-1 \
        lxpolkit
    do
        if command -v "$agent" >/dev/null 2>&1 || [ -x "$agent" ]; then
            "$agent" &
            break
        fi
    done
fi

# Powitanie: „Co nowego” i (na obrazie live) skrót do instalatora.
#
# Okno pokazuje się przy każdym logowaniu, chyba że użytkownik zaznaczył
# w nim „Nie uruchamiaj ponownie po zalogowaniu”. Wtedy w `welcome.conf`
# leży `autostart = false` i ten blok je pomija. Plik można usunąć, żeby
# przywrócić powitanie.
if command -v luna-welcome >/dev/null 2>&1; then
    welcome_conf=""
    if [ -n "${XDG_CONFIG_HOME:-}" ]; then
        welcome_conf="$XDG_CONFIG_HOME/luna/welcome.conf"
    elif [ -n "${HOME:-}" ]; then
        welcome_conf="$HOME/.config/luna/welcome.conf"
    fi
    if [ -n "$welcome_conf" ] && [ -r "$welcome_conf" ] \
        && grep -qiE '^[[:space:]]*autostart[[:space:]]*=[[:space:]]*(0|false|no|off)[[:space:]]*$' "$welcome_conf"; then
        ts "powitanie wyłączone przez użytkownika ($welcome_conf)"
    else
        ts "uruchamiam luna-welcome"
        luna-welcome >/dev/null 2>&1 &
    fi
else
    ts "brak luna-welcome w PATH"
fi

# Sesja żyje, dopóki działa kompozytor.
status=0
wait "$selene_pid" || status=$?
ts "selene zakończył się (status $status) — kończę sesję"
exit "$status"
