#!/bin/sh
# =============================================================================
# install-seafile.sh - install Seafile Server (Community Edition) on (almost)
# any Linux distribution and register it as a service that starts on boot.
# =============================================================================
# Seafile 13.x Community Edition is deployed with Docker, which is also the one
# method that behaves identically on every distribution. This script:
#
#   1. installs Docker Engine + the Compose v2 plugin if they are missing,
#      using whatever fits your distro (apt, dnf, yum, zypper, pacman, apk,
#      xbps; static-binary fallback for the Compose plugin),
#   2. downloads Seafile's official compose files for the chosen release and
#      generates <dir>/.env with random secrets,
#   3. installs a service called "seafile" (systemd unit, or OpenRC script)
#      so the stack starts at boot and is managed with systemctl/rc-service,
#   4. starts everything and waits until the web UI is up.
#
# Usage:   sudo sh install-seafile.sh [install|upgrade|uninstall] [options]
#          sudo sh install-seafile.sh --help
#
# POSIX sh only (works with dash, ash/busybox, bash) - no bashisms.
# =============================================================================

set -eu
umask 022

PROG=${0##*/}

# ------------------------------- defaults ------------------------------------
CMD=install
RELEASE=${SEAFILE_RELEASE:-13.0}
INSTALL_DIR=${SEAFILE_DIR:-/opt/seafile}
DATA_DIR=${SEAFILE_DATA_DIR:-/opt}
SF_HOST=${SEAFILE_HOSTNAME:-}
PROTOCOL=${SEAFILE_PROTOCOL:-}
ADMIN_EMAIL=${SEAFILE_ADMIN_EMAIL:-}
ADMIN_PASSWORD=${SEAFILE_ADMIN_PASSWORD:-}
TZ_NAME=${SEAFILE_TIMEZONE:-}
WAIT_TIMEOUT=${SEAFILE_WAIT_TIMEOUT:-900}
WITH_SEADOC=1
START_NOW=1
AUTO_DOCKER=1
ASSUME_YES=0
SKIP_CHECKS=0
SERVICE=seafile
UNIT_DIR=${SEAFILE_UNIT_DIR:-/etc/systemd/system}
INITD_DIR=${SEAFILE_INITD_DIR:-/etc/init.d}
NL='
'
PM=
INIT=none
ARCH=
OS_ID=unknown
OS_NAME=Linux
INTERACTIVE=0
FRESH=1
PASSWORD_GENERATED=0
ENV_FINAL=
ENV_FILE=
DOCKER_BIN=

# ------------------------------- helpers -------------------------------------
if [ -t 1 ]; then
  C_RED=$(printf '\033[31m'); C_YEL=$(printf '\033[33m')
  C_GRN=$(printf '\033[32m'); C_OFF=$(printf '\033[0m')
else
  C_RED=; C_YEL=; C_GRN=; C_OFF=
fi
log()  { printf '%s==>%s %s\n' "$C_GRN" "$C_OFF" "$*"; }
warn() { printf '%sWARNING:%s %s\n' "$C_YEL" "$C_OFF" "$*" >&2; }
die()  { printf '%sERROR:%s %s\n' "$C_RED" "$C_OFF" "$*" >&2; exit 1; }
have() { command -v "$1" >/dev/null 2>&1; }
try()  { "$@" >/dev/null 2>&1; }

usage() {
  cat <<EOF
Usage: sudo sh $PROG [command] [options]

Commands:
  install      Install Docker if needed, deploy Seafile, enable the service (default)
  upgrade      Pull the newest images of the installed release line and recreate containers
  uninstall    Stop Seafile and remove the service (your data is kept)

Options for install:
  --hostname HOST        Domain name or IP address users will connect to
                         (default: ask, else this machine's primary IP)
  --protocol http|https  Default: https for public-looking domain names, http otherwise.
                         With https, Caddy obtains a Let's Encrypt certificate
                         (DNS must point here; ports 80 and 443 must be reachable).
  --admin-email EMAIL    First admin account (default: admin@<domain> or admin@seafile.local)
  --admin-password PASS  First admin password (default: random). Prefer the
                         SEAFILE_ADMIN_PASSWORD variable - arguments show up in 'ps'.
  --release X.Y          Seafile release line to deploy (default: $RELEASE)
  --dir PATH             Where the compose files and .env live (default: $INSTALL_DIR)
  --data-dir PATH        Base directory for persistent data (default: $DATA_DIR);
                         creates seafile-data, seafile-mysql, seafile-caddy, seadoc-data
  --timezone TZ          e.g. Europe/Berlin (default: this machine's time zone)
  --no-seadoc            Do not deploy the SeaDoc collaborative editor
  --no-start             Prepare everything but do not start the stack
  --no-docker-install    Fail instead of installing Docker automatically
  --skip-checks          Skip the port / RAM / container-name preflight checks
  -y, --yes              Never prompt; use defaults for whatever is not given
  -h, --help             Show this help

Environment variables: SEAFILE_HOSTNAME, SEAFILE_PROTOCOL, SEAFILE_ADMIN_EMAIL,
SEAFILE_ADMIN_PASSWORD, SEAFILE_RELEASE, SEAFILE_DIR, SEAFILE_DATA_DIR,
SEAFILE_TIMEZONE (same meaning as the options above).
EOF
}

set_opt() { # option value
  case $1 in
    --hostname)       SF_HOST=$2 ;;
    --protocol)       PROTOCOL=$2 ;;
    --admin-email)    ADMIN_EMAIL=$2 ;;
    --admin-password) ADMIN_PASSWORD=$2 ;;
    --release)        RELEASE=$2 ;;
    --dir)            INSTALL_DIR=$2 ;;
    --data-dir)       DATA_DIR=$2 ;;
    --timezone)       TZ_NAME=$2 ;;
  esac
}

parse_args() {
  while [ $# -gt 0 ]; do
    case $1 in
      install|upgrade|uninstall) CMD=$1 ;;
      --hostname|--protocol|--admin-email|--admin-password|--release|--dir|--data-dir|--timezone)
        [ $# -ge 2 ] || die "Option $1 needs a value."
        set_opt "$1" "$2"
        shift ;;
      --hostname=*|--protocol=*|--admin-email=*|--admin-password=*|--release=*|--dir=*|--data-dir=*|--timezone=*)
        set_opt "${1%%=*}" "${1#*=}" ;;
      --no-seadoc)         WITH_SEADOC=0 ;;
      --no-start)          START_NOW=0 ;;
      --no-docker-install) AUTO_DOCKER=0 ;;
      --skip-checks)       SKIP_CHECKS=1 ;;
      -y|--yes)            ASSUME_YES=1 ;;
      -h|--help)           usage; exit 0 ;;
      *) die "Unknown argument: $1 (see --help)" ;;
    esac
    shift
  done
}

validate_inputs() {
  case $RELEASE in
    latest) ;;
    *) printf '%s' "$RELEASE" | grep -Eq '^[0-9]+\.[0-9]+$' \
         || die "--release must look like 13.0 (or be 'latest')." ;;
  esac
  case $PROTOCOL in
    ''|http|https) ;;
    *) die "--protocol must be http or https." ;;
  esac
  INSTALL_DIR=${INSTALL_DIR%/}
  DATA_DIR=${DATA_DIR%/}
  for _p in "$INSTALL_DIR" "$DATA_DIR"; do
    case $_p in
      /*) ;;
      *) die "Paths must be absolute: '$_p'" ;;
    esac
    case $_p in
      *[!A-Za-z0-9_./-]*) die "Unsupported characters in path '$_p' (allowed: letters, digits, _ . / -)." ;;
    esac
  done
  if [ -n "$SF_HOST" ]; then
    printf '%s' "$SF_HOST" | grep -Eq '^[A-Za-z0-9.:-]+$' || die "Invalid --hostname '$SF_HOST'."
  fi
  if [ -n "$ADMIN_EMAIL" ]; then
    printf '%s' "$ADMIN_EMAIL" | grep -Eq '^[^@[:space:]]+@[^@[:space:]]+\.[^@[:space:]]+$' \
      || die "Invalid --admin-email '$ADMIN_EMAIL'."
  fi
  case $ADMIN_PASSWORD in
    *"'"*|*"$NL"*) die "The admin password must not contain a single quote or a newline." ;;
  esac
  ENV_FINAL=$INSTALL_DIR/.env
  ENV_FILE=$ENV_FINAL
}

require_root() {
  if [ "$(id -u)" -eq 0 ]; then return 0; fi
  if have sudo && [ -f "$0" ]; then
    log "Not running as root - re-executing with sudo."
    exec sudo -E sh "$0" "$@"
  fi
  die "Run this script as root (for example: sudo sh $PROG)."
}

# ------------------------- small utility functions ---------------------------
fetch() { # url destination
  if have curl; then
    curl -fsSL --retry 3 --connect-timeout 20 -o "$2" "$1"
  elif have wget; then
    wget -q -O "$2" "$1"
  else
    return 1
  fi
}

rand() { # N random alphanumeric characters
  LC_ALL=C tr -dc 'A-Za-z0-9' </dev/urandom | head -c "$1"
}

is_ip() { printf '%s' "$1" | grep -Eq '^[0-9]{1,3}(\.[0-9]{1,3}){3}$|:'; }

wants_https() { # true if $1 looks like a public DNS name
  case $1 in
    localhost|*.local|*.lan|*.localdomain|*.internal|*.home.arpa|*.test|*.invalid) return 1 ;;
    *.*) if is_ip "$1"; then return 1; fi; return 0 ;;
    *) return 1 ;;
  esac
}

detect_ip() {
  _ip=
  if have ip; then
    _ip=$(ip -4 route get 1.1.1.1 2>/dev/null \
      | awk '{ for (i = 1; i < NF; i++) if ($i == "src") { print $(i + 1); exit } }')
  fi
  if [ -z "$_ip" ] && have hostname; then
    _ip=$(hostname -I 2>/dev/null | awk '{ print $1 }')
  fi
  printf '%s' "${_ip:-localhost}"
}

detect_tz() {
  _tz=
  if [ -r /etc/timezone ]; then
    _tz=$(head -n 1 /etc/timezone | tr -d '[:space:]')
  fi
  if [ -z "$_tz" ] && [ -L /etc/localtime ]; then
    _tz=$(readlink /etc/localtime | sed 's|.*/zoneinfo/||')
  fi
  if [ -z "$_tz" ] && have timedatectl; then
    _tz=$(timedatectl show -p Timezone --value 2>/dev/null || true)
  fi
  case $_tz in
    ''|*[!A-Za-z0-9_/+-]*) _tz=Etc/UTC ;;
  esac
  if [ -d /usr/share/zoneinfo ] && [ ! -e "/usr/share/zoneinfo/$_tz" ]; then
    _tz=Etc/UTC
  fi
  printf '%s' "$_tz"
}

ask() { # prompt default -> answer on stdout (prompt goes to stderr)
  printf '%s [%s]: ' "$1" "$2" >&2
  _a=
  read -r _a || _a=
  printf '%s' "${_a:-$2}"
}

confirm() {
  printf '%s [Y/n]: ' "$1" >&2
  _a=
  read -r _a || _a=
  case $_a in n|N|no|NO|No) return 1 ;; esac
  return 0
}

port_in_use() { # true if something listens on TCP port $1 (reads /proc: no ss/netstat needed)
  _hex=$(printf '%04X' "$1")
  for _f in /proc/net/tcp /proc/net/tcp6; do
    [ -r "$_f" ] || continue
    if awk -v h="$_hex" 'NR > 1 && $4 == "0A" { n = split($2, a, ":"); if (toupper(a[n]) == h) f = 1 } END { exit !f }' "$_f"; then
      return 0
    fi
  done
  return 1
}

# --- .env editing (values are single-quoted only when they need to be) ---
env_quote() {
  case $1 in
    *[!A-Za-z0-9_.,:@/+=-]*) printf "'%s'" "$1" ;;
    *) printf '%s' "$1" ;;
  esac
}

set_env() { # key value : replace KEY=... in $ENV_FILE, or append it
  _v=$(env_quote "$2")
  _tmp=$(mktemp "$ENV_FILE.XXXXXX")
  SE_KEY=$1 SE_VAL=$_v awk '
    BEGIN { k = ENVIRON["SE_KEY"]; v = ENVIRON["SE_VAL"]; done = 0 }
    {
      i = index($0, "=")
      if (!done && i > 1 && substr($0, 1, i - 1) == k) { print k "=" v; done = 1 }
      else print
    }
    END { if (!done) print k "=" v }
  ' "$ENV_FILE" > "$_tmp"
  cat "$_tmp" > "$ENV_FILE"
  rm -f "$_tmp"
}

get_env() { # key -> value (quotes stripped) from $ENV_FILE
  sed -n "s/^$1=//p" "$ENV_FILE" | head -n 1 | tr -d "'\""
}

# ------------------------- platform detection --------------------------------
osr() { sed -n "s/^$1=//p" /etc/os-release 2>/dev/null | head -n 1 | tr -d "\"'"; }

detect_init() {
  case ${SEAFILE_INIT_SYSTEM:-} in
    systemd|openrc|none) INIT=$SEAFILE_INIT_SYSTEM; return 0 ;;
  esac
  if [ -d /run/systemd/system ] && have systemctl; then
    INIT=systemd
  elif have rc-service && have rc-update; then
    INIT=openrc
  else
    INIT=none
  fi
}

detect_platform() {
  [ "$(uname -s)" = Linux ] || die "This installer supports Linux only."
  case $(uname -m) in
    x86_64|amd64)  ARCH=x86_64 ;;
    aarch64|arm64) ARCH=aarch64 ;;
    *) die "Unsupported CPU architecture '$(uname -m)': Seafile's images exist for x86_64 and arm64 only." ;;
  esac
  if [ -r /etc/os-release ]; then
    OS_ID=$(osr ID); OS_NAME=$(osr PRETTY_NAME)
  fi
  if [ -z "$OS_ID" ]; then OS_ID=unknown; fi
  if [ -z "$OS_NAME" ]; then OS_NAME=Linux; fi
  for _p in apt-get dnf yum zypper pacman apk xbps-install; do
    if have "$_p"; then PM=$_p; break; fi
  done
  detect_init
}

# --------------------------- package manager glue ----------------------------
pm_refresh() {
  case $PM in
    apt-get) apt-get update ;;
    zypper)  zypper --non-interactive refresh ;;
    *)       return 0 ;;
  esac
}

pm_install() { # packages...
  case $PM in
    apt-get)      DEBIAN_FRONTEND=noninteractive apt-get install -y "$@" ;;
    dnf)          dnf install -y "$@" ;;
    yum)          yum install -y "$@" ;;
    zypper)       zypper --non-interactive install --no-recommends "$@" ;;
    pacman)       pacman -S --needed --noconfirm "$@" ;;
    apk)          apk add --no-cache "$@" ;;
    xbps-install) xbps-install -Sy "$@" ;;
    *)            return 1 ;;
  esac
}

ensure_downloader() {
  if have curl || have wget; then return 0; fi
  [ -n "$PM" ] || die "Neither curl nor wget is installed, and no supported package manager was found."
  log "Installing curl..."
  pm_refresh || true
  pm_install curl ca-certificates || die "Could not install curl; please install curl or wget and re-run."
}

# ------------------------------- Docker --------------------------------------
docker_up()  { have docker && docker info >/dev/null 2>&1; }
compose_ok() { have docker && docker compose version >/dev/null 2>&1; }

docker_convenience_script() {
  log "Running Docker's official convenience script (https://get.docker.com)..."
  _s=$(mktemp)
  if fetch https://get.docker.com "$_s" && sh "$_s"; then
    rm -f "$_s"
    return 0
  fi
  rm -f "$_s"
  return 1
}

docker_distro_packages() {
  warn "Docker's own installer did not work on $OS_NAME; trying the distribution's Docker package instead."
  case $PM in
    apt-get) pm_refresh && pm_install docker.io ;;
    dnf|yum) pm_install docker || pm_install moby-engine ;;
    *)       return 1 ;;
  esac
}

install_docker_engine() {
  case $PM in
    pacman)       pm_install docker docker-compose || pm_install docker ;;
    apk)          pm_install docker docker-cli-compose || pm_install docker ;;
    xbps-install) pm_install docker docker-compose || pm_install docker ;;
    zypper)       pm_refresh || true
                  pm_install docker docker-compose || pm_install docker || docker_convenience_script ;;
    apt-get|dnf|yum)
      if [ "$OS_ID" = amzn ]; then
        pm_install docker
      else
        docker_convenience_script || docker_distro_packages
      fi ;;
    *) return 1 ;;
  esac
}

start_docker_service() {
  case $INIT in
    systemd)
      try systemctl enable --now docker || try systemctl start docker || true ;;
    openrc)
      try rc-update add docker default || true
      try rc-service docker start || true ;;
    *)
      if [ -d /etc/sv/docker ] && [ -d /var/service ]; then
        ln -sf /etc/sv/docker /var/service/docker
      elif have service; then
        try service docker start || true
      elif [ -x /etc/init.d/docker ]; then
        try /etc/init.d/docker start || true
      fi ;;
  esac
  _i=0
  while [ "$_i" -lt 60 ]; do
    if docker info >/dev/null 2>&1; then return 0; fi
    sleep 1
    _i=$((_i + 1))
  done
  return 1
}

install_compose_plugin() {
  log "Docker Compose v2 plugin not found - installing it..."
  case $PM in
    apt-get) try pm_install docker-compose-v2 || try pm_install docker-compose-plugin || true ;;
    dnf|yum) try pm_install docker-compose-plugin || true ;;
    zypper)  try pm_install docker-compose || true ;;
  esac
  if compose_ok; then return 0; fi

  # Fallback that works on every distro: the official static binary from GitHub.
  _dest=/usr/local/lib/docker/cli-plugins
  _url=https://github.com/docker/compose/releases/latest/download/docker-compose-linux-$ARCH
  _tmp=$(mktemp)
  mkdir -p "$_dest"
  if ! fetch "$_url" "$_tmp"; then
    rm -f "$_tmp"
    die "Could not download the Compose plugin from $_url"
  fi
  if have sha256sum && fetch "$_url.sha256" "$_tmp.sha256" 2>/dev/null; then
    _want=$(awk '{ print $1; exit }' "$_tmp.sha256")
    _got=$(sha256sum "$_tmp" | awk '{ print $1 }')
    if printf '%s' "$_want" | grep -Eq '^[0-9a-f]{64}$' && [ "$_want" != "$_got" ]; then
      rm -f "$_tmp" "$_tmp.sha256"
      die "Checksum mismatch for the downloaded Compose plugin - refusing to install it."
    fi
  fi
  rm -f "$_tmp.sha256"
  cp "$_tmp" "$_dest/docker-compose"
  chmod 755 "$_dest/docker-compose"
  rm -f "$_tmp"
}

ensure_docker() {
  if docker_up && compose_ok; then
    log "Docker and Compose are already available: $(docker --version)"
    return 0
  fi
  if ! have docker; then
    [ "$AUTO_DOCKER" -eq 1 ] || die "Docker is not installed (re-run without --no-docker-install to install it automatically)."
    [ -n "$PM" ] || die "No supported package manager found. Install Docker Engine + Compose v2 manually (https://docs.docker.com/engine/install/) and re-run."
    ensure_downloader
    log "Installing Docker Engine on $OS_NAME (package manager: $PM)..."
    install_docker_engine || die "Automatic Docker installation failed on $OS_NAME (on Arch, run 'pacman -Syu' and reboot first if packages are not found). Install Docker Engine + the Compose v2 plugin manually and re-run."
  fi
  start_docker_service || die "The Docker daemon is not running and could not be started."
  if ! compose_ok; then
    [ "$AUTO_DOCKER" -eq 1 ] || die "The Docker Compose v2 plugin is missing (re-run without --no-docker-install)."
    ensure_downloader
    install_compose_plugin
  fi
  compose_ok || die "'docker compose' still does not work. Please install the Docker Compose v2 plugin manually."
  log "Docker is ready: $(docker --version)"
}

# ------------------------- preflight checks ----------------------------------
preflight() {
  if [ "$SKIP_CHECKS" -eq 1 ]; then return 0; fi
  _mem=$(awk '/^MemTotal:/ { print int($2 / 1024) }' /proc/meminfo 2>/dev/null || true)
  if [ -n "$_mem" ] && [ "$_mem" -lt 1800 ]; then
    warn "Only ${_mem} MB of RAM detected. MariaDB, Redis, Seafile, Caddy and SeaDoc together may be slow or get OOM-killed. Consider more RAM/swap, or --no-seadoc."
  fi
  if [ "$FRESH" -eq 1 ]; then
    for _port in 80 443; do
      if port_in_use "$_port"; then
        die "TCP port $_port is already in use (Seafile's Caddy proxy needs ports 80 and 443). Stop the other service first, or use --skip-checks."
      fi
    done
  fi
  if [ "$ARCH" != x86_64 ]; then
    warn "Running on $ARCH: Seafile publishes arm64 images, but 'docker compose pull' will tell you if one is missing."
  fi
}

check_name_conflicts() {
  if [ "$SKIP_CHECKS" -eq 1 ] || [ "$FRESH" -eq 0 ]; then return 0; fi
  _existing=$(docker ps -a --format '{{.Names}}' 2>/dev/null || true)
  for _n in seafile seafile-mysql seafile-redis seafile-caddy seadoc; do
    if printf '%s\n' "$_existing" | grep -qx "$_n"; then
      die "A Docker container named '$_n' already exists. Remove/rename it first (docker rm -f $_n) or use --skip-checks."
    fi
  done
}

# ------------------------- settings & configuration --------------------------
resolve_settings() {
  if [ -z "$SF_HOST" ]; then
    _def=$(detect_ip)
    if [ "$INTERACTIVE" -eq 1 ]; then
      SF_HOST=$(ask "Domain name or IP address for Seafile" "$_def")
    else
      SF_HOST=$_def
    fi
  fi
  printf '%s' "$SF_HOST" | grep -Eq '^[A-Za-z0-9.:-]+$' || die "Invalid hostname '$SF_HOST'."
  if [ -z "$PROTOCOL" ]; then
    if wants_https "$SF_HOST"; then PROTOCOL=https; else PROTOCOL=http; fi
  fi
  if [ -z "$ADMIN_EMAIL" ]; then
    if [ "$PROTOCOL" = https ] && ! is_ip "$SF_HOST"; then
      _def=admin@$SF_HOST
    else
      _def=admin@seafile.local
    fi
    if [ "$INTERACTIVE" -eq 1 ]; then
      ADMIN_EMAIL=$(ask "Admin e-mail address (used as login name)" "$_def")
    else
      ADMIN_EMAIL=$_def
    fi
    printf '%s' "$ADMIN_EMAIL" | grep -Eq '^[^@[:space:]]+@[^@[:space:]]+\.[^@[:space:]]+$' \
      || die "Invalid admin e-mail '$ADMIN_EMAIL'."
  fi
  if [ -z "$ADMIN_PASSWORD" ]; then
    ADMIN_PASSWORD=$(rand 20)
    PASSWORD_GENERATED=1
  elif [ "${#ADMIN_PASSWORD}" -lt 8 ]; then
    warn "The admin password is shorter than 8 characters - please change it after the first login."
  fi
  if [ -z "$TZ_NAME" ]; then TZ_NAME=$(detect_tz); fi
}

DOC_BASE=
GH_BASE=
get_remote() { # path-relative-to-docker-dir destination
  fetch "$DOC_BASE/$1" "$2" 2>/dev/null && return 0
  fetch "$GH_BASE/$1" "$2" 2>/dev/null && return 0
  return 1
}

download_files() {
  _ref=$RELEASE
  if [ "$RELEASE" = latest ]; then _ref=master; fi
  DOC_BASE=https://manual.seafile.com/$RELEASE/repo/docker
  GH_BASE=https://raw.githubusercontent.com/haiwen/seafile-admin-docs/$_ref/manual/repo/docker
  log "Downloading Seafile $RELEASE compose files..."
  get_remote ce/env "$ENV_FILE" \
    || die "Could not download the .env template for Seafile $RELEASE (is --release valid? is the network up?)."
  get_remote ce/seafile-server.yml "$INSTALL_DIR/seafile-server.yml" \
    || die "Could not download seafile-server.yml for Seafile $RELEASE."
  get_remote caddy.yml "$INSTALL_DIR/caddy.yml" \
    || die "Could not download caddy.yml for Seafile $RELEASE."
  if [ "$WITH_SEADOC" -eq 1 ]; then
    get_remote seadoc.yml "$INSTALL_DIR/seadoc.yml" \
      || die "Could not download seadoc.yml for Seafile $RELEASE."
  fi
  grep -q '^JWT_PRIVATE_KEY=' "$ENV_FILE" || die "The downloaded .env template looks wrong (no JWT_PRIVATE_KEY)."
  grep -q '^services:' "$INSTALL_DIR/seafile-server.yml" || die "The downloaded seafile-server.yml looks wrong."
}

write_env() {
  chmod 600 "$ENV_FILE"
  set_env SEAFILE_SERVER_HOSTNAME "$SF_HOST"
  set_env SEAFILE_SERVER_PROTOCOL "$PROTOCOL"
  set_env TIME_ZONE "$TZ_NAME"
  set_env BASIC_STORAGE_PATH "$DATA_DIR"
  set_env JWT_PRIVATE_KEY "$(rand 48)"
  set_env SEAFILE_MYSQL_DB_PASSWORD "$(rand 24)"
  set_env INIT_SEAFILE_MYSQL_ROOT_PASSWORD "$(rand 24)"
  set_env INIT_SEAFILE_ADMIN_EMAIL "$ADMIN_EMAIL"
  set_env INIT_SEAFILE_ADMIN_PASSWORD "$ADMIN_PASSWORD"
  if [ "$WITH_SEADOC" -eq 0 ]; then
    set_env COMPOSE_FILE "seafile-server.yml,caddy.yml"
    set_env ENABLE_SEADOC false
  fi
}

make_dirs() {
  mkdir -p "$INSTALL_DIR" "$DATA_DIR/seafile-data" "$DATA_DIR/seafile-mysql/db" "$DATA_DIR/seafile-caddy"
  if [ "$WITH_SEADOC" -eq 1 ]; then mkdir -p "$DATA_DIR/seadoc-data"; fi
}

# ------------------------- the service (the "daemon") ------------------------
install_service() {
  DOCKER_BIN=$(command -v docker) || die "Cannot locate the docker binary."
  case $INIT in
    systemd)
      mkdir -p "$UNIT_DIR"
      _dep=
      if try systemctl cat docker.service; then _dep="Requires=docker.service"; fi
      cat > "$UNIT_DIR/$SERVICE.service" <<EOF
[Unit]
Description=Seafile server (Docker Compose stack in $INSTALL_DIR)
Documentation=https://manual.seafile.com/
$_dep
After=docker.service network-online.target
Wants=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=$INSTALL_DIR
Environment=HOME=/root
ExecStart=$DOCKER_BIN compose up -d --remove-orphans
ExecStop=$DOCKER_BIN compose stop --timeout 120
TimeoutStartSec=0
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target
EOF
      systemctl daemon-reload
      try systemctl enable "$SERVICE" || warn "Could not enable the $SERVICE service at boot."
      log "Installed systemd unit $UNIT_DIR/$SERVICE.service (enabled at boot)."
      ;;
    openrc)
      mkdir -p "$INITD_DIR"
      cat > "$INITD_DIR/$SERVICE" <<EOF
#!/sbin/openrc-run
# Generated by $PROG
description="Seafile server (Docker Compose stack in $INSTALL_DIR)"

depend() {
	need docker
	after net
}

start() {
	ebegin "Starting Seafile"
	cd "$INSTALL_DIR" && "$DOCKER_BIN" compose up -d --remove-orphans
	eend \$?
}

stop() {
	ebegin "Stopping Seafile"
	cd "$INSTALL_DIR" && "$DOCKER_BIN" compose stop --timeout 120
	eend \$?
}

status() {
	cd "$INSTALL_DIR" && "$DOCKER_BIN" compose ps
}
EOF
      chmod 755 "$INITD_DIR/$SERVICE"
      try rc-update add "$SERVICE" default || warn "Could not add $SERVICE to the default runlevel."
      log "Installed OpenRC service $INITD_DIR/$SERVICE (added to the default runlevel)."
      ;;
    *)
      warn "No systemd or OpenRC detected, so no service file was created."
      warn "The containers use 'restart: unless-stopped', so they come back by themselves whenever the Docker daemon starts at boot - make sure Docker is enabled at boot on this system."
      return 1 ;;
  esac
}

compose_in_dir() { (cd "$INSTALL_DIR" && docker compose "$@"); }

start_stack() {
  log "Pulling container images (this can take a few minutes)..."
  compose_in_dir pull || die "Pulling the images failed. Check the network connection (and Docker Hub rate limits)."
  log "Starting Seafile..."
  case $INIT in
    systemd)
      if ! systemctl start "$SERVICE"; then
        systemctl status "$SERVICE" --no-pager -l || true
        die "The $SERVICE service failed to start (see: journalctl -u $SERVICE)."
      fi ;;
    openrc)
      rc-service "$SERVICE" start || die "The $SERVICE service failed to start." ;;
    *)
      compose_in_dir up -d --remove-orphans || die "'docker compose up' failed." ;;
  esac
}

wait_ready() {
  log "Waiting for Seafile to finish its first-time setup (can take several minutes)..."
  _t=0
  while [ "$_t" -lt "$WAIT_TIMEOUT" ]; do
    _h=$(docker inspect -f '{{.State.Health.Status}}' seafile 2>/dev/null || true)
    if [ "$_h" = healthy ]; then return 0; fi
    if docker logs --tail 300 seafile 2>&1 | grep -q 'Seahub is started'; then return 0; fi
    sleep 5
    _t=$((_t + 5))
    if [ $((_t % 30)) -eq 0 ]; then log "  ...still starting (${_t}s)"; fi
  done
  return 1
}

row() { printf '  %-46s %s\n' "$1" "$2"; }

print_manage_help() {
  printf '\nUseful commands:\n'
  case $INIT in
    systemd)
      row "systemctl status|start|stop|restart $SERVICE" "(control the stack)"
      row "journalctl -u $SERVICE" "(service log)" ;;
    openrc)
      row "rc-service $SERVICE status|start|stop|restart" "(control the stack)" ;;
    *)
      row "cd $INSTALL_DIR && docker compose ps|stop|up -d" "(control the stack)" ;;
  esac
  row "docker logs -f seafile" "(Seafile application log)"
  row "sudo sh $PROG upgrade" "(pull newer images of this release line)"
}

print_summary() {
  _url=$(get_env SEAFILE_SERVER_PROTOCOL)://$(get_env SEAFILE_SERVER_HOSTNAME)
  _data=$(get_env BASIC_STORAGE_PATH)
  printf '\n  URL        %s\n' "$_url"
  printf '  Admin      %s\n' "$(get_env INIT_SEAFILE_ADMIN_EMAIL)"
  if [ "$PASSWORD_GENERATED" -eq 1 ]; then
    printf '  Password   %s   (generated - change it after logging in)\n' "$ADMIN_PASSWORD"
  elif [ "$FRESH" -eq 1 ]; then
    printf '  Password   (the one you supplied)\n'
  else
    printf '  Password   see INIT_SEAFILE_ADMIN_PASSWORD in %s (valid only until you change it in the web UI)\n' "$ENV_FINAL"
  fi
  printf '  Settings   %s   (contains secrets, mode 600)\n' "$ENV_FINAL"
  printf '  Data       %s/seafile-data, %s/seafile-mysql\n' "${_data:-$DATA_DIR}" "${_data:-$DATA_DIR}"
  if [ "$(get_env SEAFILE_SERVER_PROTOCOL)" = https ]; then
    printf '\nHTTPS: Caddy requests a Let'"'"'s Encrypt certificate on first start, so the DNS record\nfor %s must point to this machine and ports 80/443 must be reachable.\n' "$(get_env SEAFILE_SERVER_HOSTNAME)"
  fi
  print_manage_help
}

# ------------------------------ commands -------------------------------------
do_install() {
  if [ -f "$ENV_FINAL" ]; then FRESH=0; fi
  if [ "$FRESH" -eq 1 ]; then resolve_settings; fi
  log "System: $OS_NAME ($ARCH) | package manager: ${PM:-none} | init system: $INIT"

  if [ "$FRESH" -eq 1 ] && [ "$INTERACTIVE" -eq 1 ]; then
    printf '\nSeafile %s will be installed with:\n  address   %s://%s\n  admin     %s\n  files     %s (compose + .env) and %s (data)\n  SeaDoc    %s\n\n' \
      "$RELEASE" "$PROTOCOL" "$SF_HOST" "$ADMIN_EMAIL" "$INSTALL_DIR" "$DATA_DIR" \
      "$(if [ "$WITH_SEADOC" -eq 1 ]; then echo yes; else echo no; fi)"
    confirm "Continue?" || die "Aborted by user."
  fi

  preflight
  ensure_docker
  check_name_conflicts

  if [ "$FRESH" -eq 1 ]; then
    make_dirs
    ENV_FILE=$INSTALL_DIR/.env.new
    download_files
    write_env
    mv -f "$ENV_FILE" "$ENV_FINAL"
    ENV_FILE=$ENV_FINAL
  else
    log "Existing configuration found in $INSTALL_DIR - keeping it (secrets are not regenerated)."
    if [ -n "$SF_HOST$PROTOCOL$ADMIN_EMAIL$ADMIN_PASSWORD$TZ_NAME" ]; then
      warn "Settings given on the command line are ignored for an existing installation - edit $ENV_FINAL and restart the service instead."
    fi
  fi

  compose_in_dir config -q \
    || die "The compose configuration is invalid. Fix $ENV_FINAL (or delete it and re-run to regenerate it)."

  _have_service=1
  install_service || _have_service=0

  if [ "$START_NOW" -eq 0 ]; then
    if [ "$_have_service" -eq 0 ]; then
      _how="cd $INSTALL_DIR && docker compose up -d"
    elif [ "$INIT" = openrc ]; then
      _how="rc-service $SERVICE start"
    else
      _how="systemctl start $SERVICE"
    fi
    log "Prepared but not started (--no-start). Start it with: $_how"
    print_summary
    return 0
  fi

  start_stack
  if wait_ready; then
    log "Seafile is up and running."
    print_summary
  else
    warn "Seafile did not report 'ready' within ${WAIT_TIMEOUT}s. The first start can be slow on small machines."
    warn "Check progress with: docker logs -f seafile"
    print_summary
    exit 2
  fi
}

do_upgrade() {
  [ -f "$ENV_FINAL" ] || die "No Seafile installation found in $INSTALL_DIR (nothing to upgrade)."
  if ! docker_up || ! compose_ok; then
    die "Docker (with the Compose plugin) is not available or not running."
  fi
  log "Pulling the newest images for the installed release line..."
  compose_in_dir pull || die "Pulling the images failed."
  compose_in_dir up -d --remove-orphans || die "Recreating the containers failed."
  if wait_ready; then
    log "Upgrade finished and Seafile is healthy."
  else
    warn "Seafile did not report 'ready' in time - check: docker logs -f seafile"
    exit 2
  fi
  log "Note: this follows the pinned tag (e.g. 13.0-latest). For a new major/minor line such as 14.0, read Seafile's upgrade notes first and back up your data."
}

do_uninstall() {
  log "Removing the $SERVICE service and containers (your data is NOT deleted)..."
  case $INIT in
    systemd)
      try systemctl disable --now "$SERVICE" || true
      rm -f "$UNIT_DIR/$SERVICE.service"
      try systemctl daemon-reload || true ;;
    openrc)
      try rc-service "$SERVICE" stop || true
      try rc-update del "$SERVICE" default || true
      rm -f "$INITD_DIR/$SERVICE" ;;
  esac
  if [ -f "$ENV_FINAL" ] && docker_up && compose_ok; then
    compose_in_dir down || warn "'docker compose down' reported a problem."
  fi
  _data=$DATA_DIR
  if [ -f "$ENV_FINAL" ]; then _data=$(get_env BASIC_STORAGE_PATH); fi
  log "Done. Kept: $INSTALL_DIR (compose files + .env) and the data under ${_data:-$DATA_DIR}/ (seafile-data, seafile-mysql, seafile-caddy, seadoc-data)."
  log "Delete those directories yourself only if you really want to erase everything."
}

# -------------------------------- main ---------------------------------------
main() {
  for _a in "$@"; do
    case $_a in -h|--help) usage; exit 0 ;; esac
  done
  require_root "$@"
  parse_args "$@"
  validate_inputs
  if [ "$ASSUME_YES" -eq 0 ] && [ -t 0 ]; then INTERACTIVE=1; fi
  detect_platform
  case $CMD in
    install)   do_install ;;
    upgrade)   do_upgrade ;;
    uninstall) do_uninstall ;;
  esac
}

main "$@"