#!/bin/bash
# Copyright 2026 ANNE Media - https://anne.media
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
#  EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# setup-annode.sh -- install the annode application into the target system.
#
# Called by install.sh as an optional final step. Runs from the ISO boot
# environment, operates on $TARGET_ROOT via chroot.
#
# Expects these env vars to be set by the caller:
#   TARGET_ROOT      mounted target root
#   ISO_SRC          mounted ISO
#   MYSQL_ROOT_PW    MariaDB root password (already set)
#
# Optional env:
#   ANNODE_DIALOG_MODE=1   emit dialog --gauge XXX-framed output on stdout
#   ANNODE_SKIP_IMPORT=yes skip the SQL data load (leaves schema empty)
#
# Overridable:
#   ANNODE_USER      unix user for the app          (default: annode)
#   ANNODE_DB        application database name      (default: annedb)
#
# Expects on the ISO:
#   install/annode/setup-annode.sh    (this script)
#   install/annode/amosfeed           (built from amosfeed.c)
#   install/annode/peers
#   payload/annode/anne-node.zip
#   payload/annode/annedb-latest.sql.zip
#   rc/rc.annode

set -eu

ANNODE_SKIP_IMPORT="${ANNODE_SKIP_IMPORT:-yes}"
ANNODE_DIALOG_MODE="${ANNODE_DIALOG_MODE:-0}"
ISO_PROFILE=$1
# -----------------------------------------------------------------------------
#  Presentation
# -----------------------------------------------------------------------------
#  Two modes:
#
#    dialog mode  (ANNODE_DIALOG_MODE=1)
#      stdout is a pipe into `dialog --gauge`. Every visible line is
#      emitted as an XXX-framed message + percentage pair, which dialog
#      reads and renders as a message line + redrawing gauge bar.
#
#    direct mode  (default)
#      stdout is a terminal. Same messages are printed as plain lines
#      with ANSI colours. The import progress bar uses \r to redraw in
#      place, identical to the original implementation.
#
#  In BOTH modes, every line also lands in /root/annode-setup.log on
#  the target.

if [ "$ANNODE_DIALOG_MODE" != "1" ] && [ -t 1 ] && [ "${TERM:-dumb}" != "dumb" ]; then
  C_RESET=$'\033[0m'
  C_BOLD=$'\033[1m'
  C_DIM=$'\033[2m'
  C_RED=$'\033[31m'
  C_GREEN=$'\033[32m'
  C_LGREEN=$'\033[92m'
  C_YELLOW=$'\033[33m'
  C_CYAN=$'\033[36m'
  IS_TTY=1
else
  C_RESET= C_BOLD= C_DIM= C_RED= C_GREEN= C_LGREEN= C_YELLOW= C_CYAN=
  IS_TTY=0
fi

if [ "$ANNODE_DIALOG_MODE" != "1" ] && [ -t 1 ] && [ -w /dev/tty ]; then
  BAR_TTY=/dev/tty
else
  BAR_TTY=
fi

# Current gauge percentage. Every emit carries this value; the
# surrounding code nudges it forward at milestones, and the import
# loop drives it live.
CURRENT_PCT=0

ANNODE_BANNER='ANNE: peer-to-peer data system and web server over Tor

Every annode is reachable at a nid-derived .onion address.
Tor is bundled inside every annode, and clearnet users can
reach your hidden service via AM·OS Edge Stateless Ingress 
Relay or via ADDNS service providers with a normal browser. 
Your IP stays hidden.

Visit https://anne.media for more info.
'

# -----------------------------------------------------------------------------
#  Config
# -----------------------------------------------------------------------------

ANNODE_USER="${ANNODE_USER:-annode}"
ANNODE_DB="${ANNODE_DB:-annedb}"
ANNODE_HOME="/home/$ANNODE_USER"
ANNODE_DIR="$ANNODE_HOME/annode"
PAYLOAD="$ISO_SRC/payload/annode"           # zips
SELF_DIR="$ISO_SRC/install/annode"          # this script, amosfeed, peers

[ -n "${TARGET_ROOT:-}" ]   || { echo "TARGET_ROOT not set" >&2; exit 1; }
[ -n "${ISO_SRC:-}" ]       || { echo "ISO_SRC not set" >&2; exit 1; }
[ -n "${MYSQL_ROOT_PW:-}" ] || { echo "MYSQL_ROOT_PW not set" >&2; exit 1; }

# -----------------------------------------------------------------------------
#  Persistent log on the target -- survives reboot, unlike /tmp on the ISO
# -----------------------------------------------------------------------------

TARGET_LOG="$TARGET_ROOT/root/annode-setup.log"
mkdir -p "$TARGET_ROOT/root"
: > "$TARGET_LOG"

# -----------------------------------------------------------------------------
#  Logging + emission primitives
# -----------------------------------------------------------------------------

annode_log() {
    printf '%s\n' "${1//$'\n'/ }" >> "$TARGET_LOG"
}

annode_emit() {
    local msg="$1"

    if [ "$CURRENT_PCT" -lt 0 ];   then CURRENT_PCT=0;   fi
    if [ "$CURRENT_PCT" -gt 100 ]; then CURRENT_PCT=100; fi

    if [ "$ANNODE_DIALOG_MODE" = "1" ]; then
        printf 'XXX\n%s\n\n%s\nXXX\n%d\n' \
            "$ANNODE_BANNER" "$msg" "$CURRENT_PCT"
    else
        printf '%s\n' "$msg"
    fi

    printf '%s\n' "${msg//$'\n'/ }" >> "$TARGET_LOG"
}

# Detect if we can reasonably use Unicode
if locale charmap 2>/dev/null | grep -qi 'utf-\?8'; then
  SYM_OK="✓"
  SYM_WARN="⚠"
  SYM_ERR="✗"
  SYM_INFO="·"
else
  SYM_OK="[OK]"
  SYM_WARN="[!!]"
  SYM_ERR="[XX]"
  SYM_INFO="[*]"
fi

ok()   { annode_emit "  $SYM_OK  $*"; }
warn() { annode_emit "  $SYM_WARN  $*"; }
err()  { annode_emit "  $SYM_ERR  $*"; }
info() { annode_emit "  $SYM_INFO  $*"; }
say()  { annode_emit "  $*"; }

kv()   {
    local label
    label=$(printf '%-18s' "$1")
    annode_emit "  ${label} $2"
}

die() {
    local msg="$*"
    annode_log ""
    annode_log "  ✗  $msg"
    annode_log ""
    if [ "$ANNODE_DIALOG_MODE" = "1" ]; then
        printf 'XXX\n  ✗  %s\nXXX\n%d\n' "$msg" "$CURRENT_PCT"
    else
        printf '\n  %s✗%s  %s%s%s\n\n' "$C_RED" "$C_RESET" "$C_RED" "$msg" "$C_RESET"
    fi
    exit 1
}

# -----------------------------------------------------------------------------
#  Startup banner
# -----------------------------------------------------------------------------

annode_log "setup-annode.sh started at $(date '+%Y-%m-%d %H:%M:%S')"
annode_log "  TARGET_ROOT=$TARGET_ROOT"
annode_log "  ISO_SRC=$ISO_SRC"
annode_log "  ANNODE_USER=$ANNODE_USER  ANNODE_DB=$ANNODE_DB  DIALOG_MODE=$ANNODE_DIALOG_MODE"

# -----------------------------------------------------------------------------
#  Progress bar for the SQL import
# -----------------------------------------------------------------------------

IMPORT_BAR_WIDTH=32
IMPORT_PCT_START=10
IMPORT_PCT_END=90

draw_import_bar() {
    local done=$1 total=$2 elapsed_ms=$3
    local import_pct=0
    [ "$total" -gt 0 ] && import_pct=$(( done * 100 / total ))

    # Map the import's 0-100% onto the overall bar's 10-90% range, so
    # the pre-import milestones and post-import phases each get a slice.
    CURRENT_PCT=$(( IMPORT_PCT_START + import_pct * (IMPORT_PCT_END - IMPORT_PCT_START) / 100 ))

    local rate_kbps=0
    if [ "$elapsed_ms" -gt 0 ]; then
        rate_kbps=$(( done / (elapsed_ms / 1000 + 1) / 1024 ))
    fi

    local done_mb=$(( done  / 1048576 ))
    local tot_mb=$(( total / 1048576 ))

    local eta_s=0
    if [ "$rate_kbps" -gt 0 ]; then
        eta_s=$(( (total - done) / 1024 / rate_kbps ))
    fi
    local eta_m=$(( eta_s / 60 ))
    local eta_ss=$(( eta_s % 60 ))

    if [ "$ANNODE_DIALOG_MODE" = "1" ]; then
        local elapsed_s=$(( elapsed_ms / 1000 ))
        local em=$(( elapsed_s / 60 ))
        local es=$(( elapsed_s % 60 ))
        local msg
        msg=$(printf 'Importing database...\n\n  Progress   %d / %d MB   (%d%%)\n  Rate       %d KB/s\n  Elapsed    %dm %ds\n  Remaining  %dm %ds' \
            "$done_mb" "$tot_mb" "$import_pct" \
            "$rate_kbps" "$em" "$es" "$eta_m" "$eta_ss")
        annode_emit "$msg"
        return
    fi

    # Direct terminal mode: original \r-redrawing bar.
    local filled=$(( import_pct * IMPORT_BAR_WIDTH / 100 ))
    local empty=$(( IMPORT_BAR_WIDTH - filled ))
    local fb eb
    printf -v fb '%*s' "$filled" ''
    printf -v eb '%*s' "$empty"  ''
    fb="${fb// /█}"
    eb="${eb// /░}"

    if [ -n "$BAR_TTY" ]; then
        printf '\r\033[K    %s[%s%s%s%s%s]%s %3d%%  %d/%d MB  %d KB/s' \
          "$C_DIM" "$C_CYAN" "$fb" "$C_DIM" "$eb" "$C_DIM" "$C_RESET" \
          "$import_pct" "$done_mb" "$tot_mb" "$rate_kbps" > "$BAR_TTY"
    else
        if [ $(( import_pct % 10 )) -eq 0 ]; then
            printf '    [%3d%%] %d/%d MB\n' "$import_pct" "$done_mb" "$tot_mb"
        fi
    fi
}

[ -d "$PAYLOAD" ] || die "No payload/annode/ on the ISO"
[ -f "$PAYLOAD/anne-node.zip" ] || die "Missing anne-node.zip"
[ -f "$PAYLOAD/annedb-latest.sql.zip" ] || die "Missing annedb-latest.sql.zip"
[ -f "$SELF_DIR/peers" ] || die "Missing peers file at $SELF_DIR/peers"
[ -x "$SELF_DIR/amosfeed" ] || die "Missing amosfeed at $SELF_DIR/amosfeed"

ANNODE_MARIADBD_PID=""

cleanup() {
    if [ -n "$ANNODE_MARIADBD_PID" ] && \
       kill -0 "$ANNODE_MARIADBD_PID" 2>/dev/null; then
        kill "$ANNODE_MARIADBD_PID" 2>/dev/null || true
        sleep 1
        kill -9 "$ANNODE_MARIADBD_PID" 2>/dev/null || true
    fi
}
trap cleanup EXIT

trap 'rc=$?; if [ $rc -ne 0 ]; then CURRENT_PCT=0; annode_emit "  ✗  setup-annode.sh aborted at line $LINENO (exit $rc)"; fi' ERR

# -----------------------------------------------------------------------------
#  1. Unix user
# -----------------------------------------------------------------------------

CURRENT_PCT=2
info "Creating unix user '$ANNODE_USER'"

if chroot "$TARGET_ROOT" id "$ANNODE_USER" >/dev/null 2>&1; then
    info "  already exists"
else
    chroot "$TARGET_ROOT" /usr/sbin/useradd \
        -m -d "$ANNODE_HOME" -s /bin/bash "$ANNODE_USER"
    chroot "$TARGET_ROOT" /usr/bin/passwd -l "$ANNODE_USER" 2>/dev/null || true
    ok "user created (home $ANNODE_HOME, login locked)"
fi

# -----------------------------------------------------------------------------
#  2. Start mariadbd
# -----------------------------------------------------------------------------

CURRENT_PCT=4
info "Starting mariadbd for import"

MYSQL_UID=$(awk -F: '$1=="mysql"{print $3}' "$TARGET_ROOT/etc/passwd" 2>/dev/null || true)
MYSQL_GID=$(awk -F: '$1=="mysql"{print $4}' "$TARGET_ROOT/etc/passwd" 2>/dev/null || true)
[ -n "$MYSQL_UID" ] || die "mysql user not found in target"
[ -n "$MYSQL_GID" ] || MYSQL_GID="$MYSQL_UID"

mkdir -p "$TARGET_ROOT/run/mysql"
chown "$MYSQL_UID:$MYSQL_GID" "$TARGET_ROOT/run/mysql"

chroot "$TARGET_ROOT" /usr/libexec/mariadbd \
    --user=mysql --skip-networking \
    --socket=/run/mysql/mysql.sock \
    --datadir=/var/lib/mysql \
    --pid-file=/run/mysql/mysql.pid \
    > /tmp/annode-mariadbd.log 2>&1 &
ANNODE_MARIADBD_PID=$!

SOCK_READY=0
for _ in $(seq 1 30); do
    [ -S "$TARGET_ROOT/run/mysql/mysql.sock" ] && { SOCK_READY=1; break; }
    sleep 1
done
[ "$SOCK_READY" = "1" ] || die "mariadbd did not start (see /tmp/annode-mariadbd.log)"
CURRENT_PCT=6
ok "mariadbd up"

# -----------------------------------------------------------------------------
#  3. Create database
# -----------------------------------------------------------------------------

CURRENT_PCT=7
info "Creating database '$ANNODE_DB'"

chroot "$TARGET_ROOT" /usr/bin/mariadb \
  --socket=/run/mysql/mysql.sock \
  -u root -p"$MYSQL_ROOT_PW" <<SQLEOF
CREATE DATABASE IF NOT EXISTS \`$ANNODE_DB\`
  DEFAULT CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_520_ci;
FLUSH PRIVILEGES;
SQLEOF

CURRENT_PCT=10
ok "database ready"

# -----------------------------------------------------------------------------
#  4. Import SQL -- byte-accurate progress via amosfeed
# -----------------------------------------------------------------------------
#
#  Set ANNODE_SKIP_IMPORT=yes to skip the SQL import. Useful during
#  installer retests where the DB contents are irrelevant and the
#  800-second import is pure overhead.

if [ "$ANNODE_SKIP_IMPORT" = "yes" ]; then
    info "ANNODE_SKIP_IMPORT=yes -- skipping SQL import"
    CURRENT_PCT="$IMPORT_PCT_END"
    ok "database left empty (ready for the node to populate)"
else
    info "Importing $ANNODE_DB from annedb-latest.sql.zip"

    SQL_BYTES=$(unzip -l "$PAYLOAD/annedb-latest.sql.zip" 2>/dev/null | \
        awk '/\.sql$/ { sum += $1 } END { print sum+0 }')
    [ "$SQL_BYTES" -gt 0 ] || die "Cannot determine uncompressed SQL size in zip"
    SQL_MB=$(( SQL_BYTES / 1048576 ))
    info "  uncompressed SQL: ${SQL_MB} MB (${SQL_BYTES} bytes)"
    info "  this can take 5-15 minutes"

    AMOSFEED="$SELF_DIR/amosfeed"
    [ -x "$AMOSFEED" ] || die "Missing amosfeed binary at $AMOSFEED"

    STATUS_FILE="/tmp/annode-import.status"
    IMPORT_LOG="/tmp/annode-import.log"
    rm -f "$STATUS_FILE"
    : > "$IMPORT_LOG"

    import_start=$SECONDS

    (
        unzip -p "$PAYLOAD/annedb-latest.sql.zip" | \
          "$AMOSFEED" --total "$SQL_BYTES" --status "$STATUS_FILE" --interval 400 | \
          chroot "$TARGET_ROOT" /usr/bin/mariadb \
            --socket=/run/mysql/mysql.sock \
            -u root -p"$MYSQL_ROOT_PW" "$ANNODE_DB"
    ) > "$IMPORT_LOG" 2>&1 &
    IMPORT_PID=$!

    while kill -0 "$IMPORT_PID" 2>/dev/null; do
        DONE=0; TOT=$SQL_BYTES; ELAPSED_MS=0
        if [ -f "$STATUS_FILE" ]; then
            read -r DONE TOT ELAPSED_MS < "$STATUS_FILE" 2>/dev/null || true
            [ -n "${DONE:-}" ]       || DONE=0
            [ -n "${TOT:-}" ]        || TOT=$SQL_BYTES
            [ -n "${ELAPSED_MS:-}" ] || ELAPSED_MS=0
        fi
        draw_import_bar "$DONE" "$TOT" "$ELAPSED_MS"
        sleep 1
    done

    IMPORT_STATUS=0
    wait "$IMPORT_PID" || IMPORT_STATUS=$?

    if [ -n "$BAR_TTY" ]; then printf '\n' > "$BAR_TTY"; fi

    if [ "$IMPORT_STATUS" -ne 0 ]; then
        die "SQL import failed (exit $IMPORT_STATUS); see $IMPORT_LOG"
    fi

    DONE_FINAL=0
    if [ -f "$STATUS_FILE" ]; then
        read -r DONE_FINAL _TOT_FINAL _ELAPSED_FINAL < "$STATUS_FILE" 2>/dev/null || true
        [ -n "${DONE_FINAL:-}" ] || DONE_FINAL=0
    fi
    if [ "$DONE_FINAL" -ne "$SQL_BYTES" ]; then
        warn "Feeder pushed $DONE_FINAL of $SQL_BYTES bytes; import may be incomplete"
    else
        ok "Feeder pushed all $SQL_BYTES bytes"
    fi

    import_elapsed=$(( SECONDS - import_start ))
    CURRENT_PCT="$IMPORT_PCT_END"
    ok "import complete in ${import_elapsed}s"
fi

# -----------------------------------------------------------------------------
#  5. Extract the node application
# -----------------------------------------------------------------------------

CURRENT_PCT=91
info "Extracting anne-node.zip to $ANNODE_DIR"

chroot "$TARGET_ROOT" mkdir -p "$ANNODE_DIR"
chroot "$TARGET_ROOT" chown "$ANNODE_USER:$ANNODE_USER" "$ANNODE_DIR"
chroot "$TARGET_ROOT" chmod 750 "$ANNODE_HOME"

cp "$PAYLOAD/anne-node.zip" "$TARGET_ROOT/tmp/anne-node.zip"
chroot "$TARGET_ROOT" chown "$ANNODE_USER:$ANNODE_USER" /tmp/anne-node.zip
chroot "$TARGET_ROOT" su -s /bin/bash -c \
  "cd $ANNODE_DIR && unzip -q -o /tmp/anne-node.zip" "$ANNODE_USER"
chroot "$TARGET_ROOT" rm -f /tmp/anne-node.zip

CURRENT_PCT=93
ok "extracted"

JAR="$TARGET_ROOT$ANNODE_DIR/anne-node.jar"
DEFPROPS="$TARGET_ROOT$ANNODE_DIR/conf/node-default.properties"
NODEPROPS="$TARGET_ROOT$ANNODE_DIR/conf/node.properties"

[ -f "$JAR" ] || die "anne-node.jar not found at $ANNODE_DIR"
[ -f "$DEFPROPS" ] || die "conf/node-default.properties not found at $ANNODE_DIR"

# -----------------------------------------------------------------------------
#  6. Read peers file
# -----------------------------------------------------------------------------

CURRENT_PCT=94
info "Reading peers file"

PEERSLIST=$(tr -d '\n\r ' < "$SELF_DIR/peers")
PEERSLIST="${PEERSLIST%;}"

[ -n "$PEERSLIST" ] || die "peers file is empty"

PEERCOUNT=$(printf '%s\n' "$PEERSLIST" | tr ';' '\n' | awk '/^[0-9]/{n++} END{print n+0}')

[ "$PEERCOUNT" -gt 0 ] || die "peers file contains no valid NID entries: $PEERSLIST"

kv "Peers" "$PEERCOUNT"

# -----------------------------------------------------------------------------
#  7. Configure node.properties
# -----------------------------------------------------------------------------

CURRENT_PCT=95
info "Generating node identity"

KEYGEN_OUT=$(chroot "$TARGET_ROOT" \
  sh -c "cd $ANNODE_DIR && /usr/lib64/java/bin/java -cp anne-node.jar anne.debug.keygen" 2>&1) \
  || die "keygen failed: $KEYGEN_OUT"

NID=$(printf '%s\n' "$KEYGEN_OUT" | awk -F': ' '/^Nid:/ {print $2; exit}')
SECRET=$(printf '%s\n' "$KEYGEN_OUT" | awk -F': ' '/^Seed:/ {print $2; exit}')
PUBKEY=$(printf '%s\n' "$KEYGEN_OUT" | awk -F': ' '/^Pubkey:/ {print $2; exit}')
DBURL="jdbc:mariadb://10.200.2.1:3306/annedb"
PHP_FPM_HOST="10.200.2.1"
PHP_FPM_PORT=9000


[ -n "$NID" ]    || die "keygen produced no Nid (output: $KEYGEN_OUT)"
[ -n "$SECRET" ] || die "keygen produced no Seed (output: $KEYGEN_OUT)"
[ -n "$PUBKEY" ] || die "keygen produced no Pubkey (output: $KEYGEN_OUT)"

kv "NID" "$NID"

CURRENT_PCT=97
info "Writing conf/node.properties"

cp -a "$DEFPROPS" "$NODEPROPS"

sed -i "s/DB.Username.*/DB.Username=root/"                                       "$NODEPROPS"
sed -i "s/DB.Password.*/DB.Password=$MYSQL_ROOT_PW/"                             "$NODEPROPS"
sed -i "s/anne.nodeAccountId.*/anne.nodeAccountId=$NID/"                         "$NODEPROPS"
sed -i "s/anne.nodeSecret.*/anne.nodeSecret=$SECRET/"                            "$NODEPROPS"
sed -i "s/P2P.NumBootstrapConnections.*/P2P.NumBootstrapConnections=$PEERCOUNT/" "$NODEPROPS"
sed -i "s/P2P.BootstrapNidPeers.*/P2P.BootstrapNidPeers=$PEERSLIST/"             "$NODEPROPS"
sed -i "s/P2P.reBroadcastToNidPeers.*/P2P.reBroadcastToNidPeers=$PEERSLIST/"     "$NODEPROPS"

sed -i "s/P2P.UPnP.*/P2P.UPnP=no/"     "$NODEPROPS"
sed -i "s|DB.Url.*|DB.Url=$DBURL|" "$NODEPROPS"
if grep -q '^node\.PHP_FPM_HOST=' "$NODEPROPS"; then
  sed -i "s/^node\.PHP_FPM_HOST=.*/node.PHP_FPM_HOST=${PHP_FPM_HOST}/" "$NODEPROPS"
else
  printf '\nnode.PHP_FPM_HOST=%s\n' "$PHP_FPM_HOST" >> "$NODEPROPS"
fi

if grep -q '^node\.PHP_FPM_PORT=' "$NODEPROPS"; then
  sed -i "s/^node\.PHP_FPM_PORT=.*/node.PHP_FPM_PORT=${PHP_FPM_PORT}/" "$NODEPROPS"
else
  printf 'node.PHP_FPM_PORT=%s\n' "$PHP_FPM_PORT" >> "$NODEPROPS"
fi


sed -i "/^anne.nodeAccountId=/a # Pubkey: $PUBKEY" "$NODEPROPS"

ANNODE_UID=$(awk -F: -v u="$ANNODE_USER" '$1==u {print $3}' "$TARGET_ROOT/etc/passwd")
ANNODE_GID=$(awk -F: -v u="$ANNODE_USER" '$1==u {print $4}' "$TARGET_ROOT/etc/passwd")

[ -n "$ANNODE_UID" ] || die "cannot resolve UID for '$ANNODE_USER' in target passwd"
[ -n "$ANNODE_GID" ] || die "cannot resolve GID for '$ANNODE_USER' in target passwd"

chown "$ANNODE_UID:$ANNODE_GID" "$NODEPROPS"
chmod 600 "$NODEPROPS"

ok "node.properties written"


# -----------------------------------------------------------------------------
#  8. Shut down mariadbd
# -----------------------------------------------------------------------------

CURRENT_PCT=99
info "Shutting down mariadbd"

chroot "$TARGET_ROOT" /usr/bin/mariadb-admin --socket=/run/mysql/mysql.sock \
  -u root -p"$MYSQL_ROOT_PW" shutdown 2>/dev/null \
  || kill "$ANNODE_MARIADBD_PID" 2>/dev/null || true

for _ in $(seq 1 10); do
    kill -0 "$ANNODE_MARIADBD_PID" 2>/dev/null || break
    sleep 1
done
kill -0 "$ANNODE_MARIADBD_PID" 2>/dev/null && kill -9 "$ANNODE_MARIADBD_PID" 2>/dev/null || true
ANNODE_MARIADBD_PID=""

rm -f "$TARGET_ROOT/run/mysql/mysql.sock" "$TARGET_ROOT/run/mysql/mysql.pid"

CURRENT_PCT=100
ok "mariadbd stopped"

ok "Annode setup complete"
annode_log "setup-annode.sh finished at $(date '+%Y-%m-%d %H:%M:%S')"