#!/bin/sh
set -eu

umask 077

service_name=""
service_user="autochangeip-monitor"
install_path="/usr/local/bin/autochangeip-monitor-agent"
env_dir="/etc/autochangeip-monitor-agent"
env_path=""
service_path="/etc/systemd/system/autochangeip-monitor-agent@.service"
data_root="/var/lib/autochangeip-monitor-agent"

tmp_binary=""
tmp_env=""
tmp_service=""
terminal_echo_disabled=0

log() {
  printf '%s\n' "$*"
}

warn() {
  printf 'WARNING: %s\n' "$*" >&2
}

die() {
  printf 'ERROR: %s\n' "$*" >&2
  exit 1
}

cleanup() {
  if [ "$terminal_echo_disabled" -eq 1 ]; then
    stty echo 2>/dev/null || true
  fi
  [ -z "$tmp_binary" ] || rm -f "$tmp_binary"
  [ -z "$tmp_env" ] || rm -f "$tmp_env"
  [ -z "$tmp_service" ] || rm -f "$tmp_service"
}

trap cleanup EXIT
trap 'exit 1' HUP INT TERM

if [ "$(id -u)" != "0" ]; then
  die "please run this installer as root, for example: sudo sh install-monitor-agent.sh"
fi

if [ ! -r /etc/os-release ]; then
  die "/etc/os-release was not found; this installer supports Debian and Ubuntu"
fi

os_id=$(sed -n 's/^ID=//p' /etc/os-release | head -n 1 | tr -d '"')
os_version=$(sed -n 's/^VERSION_ID=//p' /etc/os-release | head -n 1 | tr -d '"')
if [ "$os_id" != "debian" ] && [ "$os_id" != "ubuntu" ]; then
  if [ "${MONITOR_ALLOW_UNSUPPORTED_OS:-0}" = "1" ]; then
    warn "detected $os_id $os_version; continuing because MONITOR_ALLOW_UNSUPPORTED_OS=1"
  else
    die "detected $os_id $os_version; this installer supports Debian and Ubuntu only"
  fi
fi

for required_command in systemctl install useradd id sed; do
  command -v "$required_command" >/dev/null 2>&1 || die "required command not found: $required_command"
done

case "$(uname -m)" in
  x86_64|amd64) machine_arch="amd64" ;;
  aarch64|arm64) machine_arch="arm64" ;;
  *) die "unsupported CPU architecture: $(uname -m); supported architectures are amd64 and arm64" ;;
esac

case "$0" in
  */*) script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" 2>/dev/null && pwd -P) || script_dir=$(pwd -P) ;;
  *) script_dir=$(pwd -P) ;;
esac

interactive=0
if [ -t 0 ] && [ "${MONITOR_NONINTERACTIVE:-0}" != "1" ]; then
  interactive=1
fi

prompt_required() {
  prompt_label=$1
  prompt_current=$2
  prompt_secret=${3:-0}

  if [ -n "$prompt_current" ]; then
    PROMPT_RESULT=$prompt_current
    return
  fi
  if [ "$interactive" -ne 1 ]; then
    die "$prompt_label is required"
  fi

  PROMPT_RESULT=""
  while [ -z "$PROMPT_RESULT" ]; do
    printf '%s: ' "$prompt_label"
    if [ "$prompt_secret" -eq 1 ]; then
      terminal_echo_disabled=1
      stty -echo
    fi
    if ! IFS= read -r PROMPT_RESULT; then
      if [ "$prompt_secret" -eq 1 ]; then
        stty echo
        terminal_echo_disabled=0
        printf '\n'
      fi
      die "unable to read $prompt_label"
    fi
    if [ "$prompt_secret" -eq 1 ]; then
      stty echo
      terminal_echo_disabled=0
      printf '\n'
    fi
    [ -n "$PROMPT_RESULT" ] || warn "$prompt_label cannot be empty"
  done
}

validate_single_line() {
  value_name=$1
  value=$2
  carriage_return=$(printf '\r')
  case "$value" in
    *"$carriage_return"*) die "$value_name must not contain a carriage return" ;;
  esac
  case "$value" in
    *"
"*) die "$value_name must not contain a newline" ;;
  esac
}

trim_value() {
  printf '%s' "$1" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//'
}

escape_env_value() {
  printf '%s' "$1" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
}

write_env() {
  env_key=$1
  env_value=$2
  validate_single_line "$env_key" "$env_value"
  printf '%s="%s"\n' "$env_key" "$(escape_env_value "$env_value")"
}

MONITOR_BINARY_URL=${MONITOR_BINARY_URL:-}
MONITOR_BINARY_PATH=${MONITOR_BINARY_PATH:-}
MONITOR_DOWNLOAD_BASE_URL=${MONITOR_DOWNLOAD_BASE_URL:-}
MONITOR_SERVER_URL=${MONITOR_SERVER_URL:-}
MONITOR_POINT_ID=${MONITOR_POINT_ID:-}
MONITOR_TOKEN=${MONITOR_TOKEN:-}
MONITOR_ENROLLMENT_TOKEN=${MONITOR_ENROLLMENT_TOKEN:-}
MONITOR_INSTANCE_ID=${MONITOR_INSTANCE_ID:-}
MONITOR_NAME=${MONITOR_NAME:-}
MONITOR_REGION=${MONITOR_REGION:-}
MONITOR_PROVIDER=${MONITOR_PROVIDER:-}
MONITOR_PROBE_PROVIDER=${MONITOR_PROBE_PROVIDER:-local}
MONITOR_PROVIDER_ENDPOINT=${MONITOR_PROVIDER_ENDPOINT:-${MONITOR_PROBE_PROVIDER_ENDPOINT:-}}
MONITOR_PROVIDER_TIMEOUT=${MONITOR_PROVIDER_TIMEOUT:-${MONITOR_PROBE_PROVIDER_TIMEOUT:-8s}}
MONITOR_PROVIDER_MAX_CONCURRENCY=${MONITOR_PROVIDER_MAX_CONCURRENCY:-${MONITOR_PROBE_PROVIDER_MAX_CONCURRENCY:-2}}
MONITOR_PROVIDER_ORIGIN=${MONITOR_PROVIDER_ORIGIN:-${MONITOR_PROBE_PROVIDER_ORIGIN:-}}
MONITOR_PROVIDER_REFERER=${MONITOR_PROVIDER_REFERER:-${MONITOR_PROBE_PROVIDER_REFERER:-}}
MONITOR_PROVIDER_USER_AGENT=${MONITOR_PROVIDER_USER_AGENT:-${MONITOR_PROBE_PROVIDER_USER_AGENT:-}}
MONITOR_PROVIDER_MAX_ATTEMPTS=${MONITOR_PROVIDER_MAX_ATTEMPTS:-${MONITOR_PROBE_PROVIDER_ATTEMPTS:-1}}
MONITOR_HEARTBEAT_INTERVAL=${MONITOR_HEARTBEAT_INTERVAL:-15s}
MONITOR_POLL_INTERVAL=${MONITOR_POLL_INTERVAL:-2s}
MONITOR_CONCURRENCY=${MONITOR_CONCURRENCY:-8}
MONITOR_BATCH_SIZE=${MONITOR_BATCH_SIZE:-32}
MONITOR_WORK_DIR=${MONITOR_WORK_DIR:-}
MONITOR_BINARY_SHA256=${MONITOR_BINARY_SHA256:-}
MONITOR_BINARY_SHA256_AMD64=${MONITOR_BINARY_SHA256_AMD64:-}
MONITOR_BINARY_SHA256_ARM64=${MONITOR_BINARY_SHA256_ARM64:-}

if [ -z "$MONITOR_BINARY_SHA256" ]; then
  case "$machine_arch" in
    amd64) MONITOR_BINARY_SHA256=$MONITOR_BINARY_SHA256_AMD64 ;;
    arm64) MONITOR_BINARY_SHA256=$MONITOR_BINARY_SHA256_ARM64 ;;
  esac
fi

if [ -n "$MONITOR_DOWNLOAD_BASE_URL" ]; then
  while [ "${MONITOR_DOWNLOAD_BASE_URL%/}" != "$MONITOR_DOWNLOAD_BASE_URL" ]; do
    MONITOR_DOWNLOAD_BASE_URL=${MONITOR_DOWNLOAD_BASE_URL%/}
  done
  if [ -z "$MONITOR_BINARY_URL" ]; then
    MONITOR_BINARY_URL="$MONITOR_DOWNLOAD_BASE_URL/autochangeip-monitor-agent-linux-$machine_arch"
  fi
fi

if [ -z "$MONITOR_BINARY_PATH" ] && [ -z "$MONITOR_BINARY_URL" ]; then
  bundled_binary="$script_dir/autochangeip-monitor-agent-linux-$machine_arch"
  current_binary="$(pwd -P)/autochangeip-monitor-agent-linux-$machine_arch"
  if [ -f "$bundled_binary" ]; then
    MONITOR_BINARY_PATH=$bundled_binary
    log "Using bundled monitor binary: $MONITOR_BINARY_PATH"
  elif [ -f "$current_binary" ]; then
    MONITOR_BINARY_PATH=$current_binary
    log "Using local monitor binary: $MONITOR_BINARY_PATH"
  elif [ -x "$install_path" ]; then
    MONITOR_BINARY_PATH=$install_path
    log "Reusing installed monitor binary: $MONITOR_BINARY_PATH"
  fi
fi

if [ -z "$MONITOR_BINARY_PATH" ] && [ -z "$MONITOR_BINARY_URL" ]; then
  prompt_required "Monitor binary download URL" "" 0
  MONITOR_BINARY_URL=$PROMPT_RESULT
fi

prompt_required "Panel URL (for example https://panel.example.com)" "$MONITOR_SERVER_URL" 0
MONITOR_SERVER_URL=$(trim_value "$PROMPT_RESULT")
prompt_required "Monitor Point ID" "$MONITOR_POINT_ID" 0
MONITOR_POINT_ID=$(trim_value "$PROMPT_RESULT")
if [ -z "$MONITOR_TOKEN" ] && [ -z "$MONITOR_ENROLLMENT_TOKEN" ]; then
  prompt_required "One-time Monitor Enrollment Token" "" 1
  MONITOR_ENROLLMENT_TOKEN=$(trim_value "$PROMPT_RESULT")
fi

if [ -z "$MONITOR_INSTANCE_ID" ]; then
  MONITOR_INSTANCE_ID=$MONITOR_POINT_ID
fi
MONITOR_INSTANCE_ID=$(trim_value "$MONITOR_INSTANCE_ID")
case "$MONITOR_INSTANCE_ID" in
  ''|.|..|*[!A-Za-z0-9_.-]*) die "MONITOR_INSTANCE_ID may only contain letters, numbers, dots, underscores, and hyphens" ;;
esac
if [ "${#MONITOR_INSTANCE_ID}" -gt 80 ]; then
  die "MONITOR_INSTANCE_ID must be at most 80 characters"
fi

service_name="autochangeip-monitor-agent@$MONITOR_INSTANCE_ID.service"
env_path="$env_dir/$MONITOR_INSTANCE_ID.env"
if [ -z "$MONITOR_WORK_DIR" ]; then
  MONITOR_WORK_DIR="$data_root/$MONITOR_INSTANCE_ID"
fi

case "$MONITOR_SERVER_URL" in
  http://*|https://*) ;;
  *) die "Panel URL must start with http:// or https://" ;;
esac
while [ "${MONITOR_SERVER_URL%/}" != "$MONITOR_SERVER_URL" ]; do
  MONITOR_SERVER_URL=${MONITOR_SERVER_URL%/}
done

if [ -n "$MONITOR_BINARY_URL" ]; then
  validate_single_line "MONITOR_BINARY_URL" "$MONITOR_BINARY_URL"
  case "$MONITOR_BINARY_URL" in
    http://*|https://*) ;;
    *) die "Monitor binary download URL must start with http:// or https://" ;;
  esac
fi

if [ -n "$MONITOR_DOWNLOAD_BASE_URL" ]; then
  validate_single_line "MONITOR_DOWNLOAD_BASE_URL" "$MONITOR_DOWNLOAD_BASE_URL"
  case "$MONITOR_DOWNLOAD_BASE_URL" in
    http://*|https://*) ;;
    *) die "Monitor download base URL must start with http:// or https://" ;;
  esac
fi

case "$MONITOR_WORK_DIR" in
  /*) ;;
  *) die "MONITOR_WORK_DIR must be an absolute path" ;;
esac
case "$MONITOR_WORK_DIR" in
  "$data_root"/*) ;;
  *) die "MONITOR_WORK_DIR must be inside $data_root for systemd instance isolation" ;;
esac
case "$MONITOR_WORK_DIR" in
  */../*|*/..|*/./*|*/.) die "MONITOR_WORK_DIR must not contain dot path segments" ;;
esac
case "$MONITOR_WORK_DIR" in
  */../*|*/..|*/./*|*/.) die "MONITOR_WORK_DIR must not contain dot path segments" ;;
esac
while [ "$MONITOR_WORK_DIR" != "/" ] && [ "${MONITOR_WORK_DIR%/}" != "$MONITOR_WORK_DIR" ]; do
  MONITOR_WORK_DIR=${MONITOR_WORK_DIR%/}
done
case "$MONITOR_WORK_DIR" in
  /|/bin|/boot|/dev|/etc|/home|/lib|/lib32|/lib64|/media|/mnt|/opt|/proc|/root|/run|/sbin|/srv|/sys|/tmp|/usr|/var|/var/lib|/var/log)
    die "MONITOR_WORK_DIR must be a dedicated Agent data directory"
    ;;
esac

case "$MONITOR_CONCURRENCY" in
  ''|*[!0-9]*) die "MONITOR_CONCURRENCY must be an integer between 1 and 64" ;;
esac
if [ "$MONITOR_CONCURRENCY" -lt 1 ] || [ "$MONITOR_CONCURRENCY" -gt 64 ]; then
  die "MONITOR_CONCURRENCY must be an integer between 1 and 64"
fi

case "$MONITOR_BATCH_SIZE" in
  ''|*[!0-9]*) die "MONITOR_BATCH_SIZE must be an integer between 1 and 128" ;;
esac
if [ "$MONITOR_BATCH_SIZE" -lt 1 ] || [ "$MONITOR_BATCH_SIZE" -gt 128 ]; then
  die "MONITOR_BATCH_SIZE must be an integer between 1 and 128"
fi

case "$MONITOR_PROVIDER_MAX_CONCURRENCY" in
  ''|*[!0-9]*) die "MONITOR_PROVIDER_MAX_CONCURRENCY must be an integer between 1 and 64" ;;
esac
if [ "$MONITOR_PROVIDER_MAX_CONCURRENCY" -lt 1 ] || [ "$MONITOR_PROVIDER_MAX_CONCURRENCY" -gt 64 ]; then
  die "MONITOR_PROVIDER_MAX_CONCURRENCY must be an integer between 1 and 64"
fi

case "$MONITOR_PROVIDER_MAX_ATTEMPTS" in
  ''|*[!0-9]*) die "MONITOR_PROVIDER_MAX_ATTEMPTS must be an integer between 1 and 5" ;;
esac
if [ "$MONITOR_PROVIDER_MAX_ATTEMPTS" -lt 1 ] || [ "$MONITOR_PROVIDER_MAX_ATTEMPTS" -gt 5 ]; then
  die "MONITOR_PROVIDER_MAX_ATTEMPTS must be an integer between 1 and 5"
fi

validate_single_line MONITOR_SERVER_URL "$MONITOR_SERVER_URL"
validate_single_line MONITOR_POINT_ID "$MONITOR_POINT_ID"
validate_single_line MONITOR_TOKEN "$MONITOR_TOKEN"
validate_single_line MONITOR_ENROLLMENT_TOKEN "$MONITOR_ENROLLMENT_TOKEN"
validate_single_line MONITOR_INSTANCE_ID "$MONITOR_INSTANCE_ID"
validate_single_line MONITOR_NAME "$MONITOR_NAME"
validate_single_line MONITOR_REGION "$MONITOR_REGION"
validate_single_line MONITOR_PROVIDER "$MONITOR_PROVIDER"
validate_single_line MONITOR_PROBE_PROVIDER "$MONITOR_PROBE_PROVIDER"
validate_single_line MONITOR_PROVIDER_ENDPOINT "$MONITOR_PROVIDER_ENDPOINT"
validate_single_line MONITOR_PROVIDER_TIMEOUT "$MONITOR_PROVIDER_TIMEOUT"
validate_single_line MONITOR_PROVIDER_MAX_CONCURRENCY "$MONITOR_PROVIDER_MAX_CONCURRENCY"
validate_single_line MONITOR_PROVIDER_ORIGIN "$MONITOR_PROVIDER_ORIGIN"
validate_single_line MONITOR_PROVIDER_REFERER "$MONITOR_PROVIDER_REFERER"
validate_single_line MONITOR_PROVIDER_USER_AGENT "$MONITOR_PROVIDER_USER_AGENT"
validate_single_line MONITOR_PROVIDER_MAX_ATTEMPTS "$MONITOR_PROVIDER_MAX_ATTEMPTS"
validate_single_line MONITOR_HEARTBEAT_INTERVAL "$MONITOR_HEARTBEAT_INTERVAL"
validate_single_line MONITOR_POLL_INTERVAL "$MONITOR_POLL_INTERVAL"
validate_single_line MONITOR_WORK_DIR "$MONITOR_WORK_DIR"
validate_single_line MONITOR_BINARY_PATH "$MONITOR_BINARY_PATH"
validate_single_line MONITOR_BINARY_SHA256 "$MONITOR_BINARY_SHA256"

if [ -z "$MONITOR_TOKEN" ] && [ -z "$MONITOR_ENROLLMENT_TOKEN" ]; then
  die "MONITOR_TOKEN or MONITOR_ENROLLMENT_TOKEN is required"
fi

if [ -n "$MONITOR_BINARY_URL" ] && [ -z "$MONITOR_BINARY_SHA256" ]; then
  die "a SHA256 digest for the $machine_arch monitor binary is required"
fi

install -d -o root -g root -m 0755 "$(dirname "$install_path")"
tmp_binary=$(mktemp "$install_path.tmp.XXXXXX")
if [ -n "$MONITOR_BINARY_PATH" ]; then
  [ -f "$MONITOR_BINARY_PATH" ] || die "monitor binary was not found: $MONITOR_BINARY_PATH"
  cp -- "$MONITOR_BINARY_PATH" "$tmp_binary"
else
  install_ca_certificates=0
  install_curl=0
  if ! command -v curl >/dev/null 2>&1 && ! command -v wget >/dev/null 2>&1; then
    install_curl=1
  fi
  case "$MONITOR_BINARY_URL" in
    https://*) [ -s /etc/ssl/certs/ca-certificates.crt ] || install_ca_certificates=1 ;;
  esac
  if [ "$install_curl" -eq 1 ] || [ "$install_ca_certificates" -eq 1 ]; then
    command -v apt-get >/dev/null 2>&1 || die "apt-get is required to install download dependencies"
    log "Installing download dependencies..."
    export DEBIAN_FRONTEND=noninteractive
    apt-get update
    if [ "$install_curl" -eq 1 ]; then
      apt-get install -y --no-install-recommends ca-certificates curl
    else
      apt-get install -y --no-install-recommends ca-certificates
    fi
  fi
  log "Downloading monitor binary..."
  if command -v curl >/dev/null 2>&1; then
    curl -fL --retry 3 --connect-timeout 15 --max-time 300 "$MONITOR_BINARY_URL" -o "$tmp_binary"
  else
    wget -O "$tmp_binary" "$MONITOR_BINARY_URL"
  fi
fi

[ -s "$tmp_binary" ] || die "the monitor binary is empty"

if [ -n "$MONITOR_BINARY_SHA256" ]; then
  command -v sha256sum >/dev/null 2>&1 || die "sha256sum is required when MONITOR_BINARY_SHA256 is set"
  actual_sha256=$(sha256sum "$tmp_binary" | awk '{print $1}')
  expected_sha256=$(printf '%s' "$MONITOR_BINARY_SHA256" | tr '[:upper:]' '[:lower:]')
  [ "$actual_sha256" = "$expected_sha256" ] || die "monitor binary SHA-256 mismatch"
fi

chmod 0700 "$tmp_binary"
if ! "$tmp_binary" -h >/dev/null 2>&1; then
  die "the downloaded binary cannot run on this $machine_arch server"
fi

if ! id "$service_user" >/dev/null 2>&1; then
  useradd --system --home-dir "$data_root" --shell /usr/sbin/nologin --user-group "$service_user"
fi
service_group=$(id -gn "$service_user")
install -d -o root -g root -m 0755 "$data_root"
install -d -o "$service_user" -g "$service_group" -m 0700 "$MONITOR_WORK_DIR"
install -o root -g root -m 0755 "$tmp_binary" "$install_path"

install -d -o root -g root -m 0755 "$env_dir"

tmp_env=$(mktemp)
{
  write_env MONITOR_SERVER_URL "$MONITOR_SERVER_URL"
  write_env MONITOR_POINT_ID "$MONITOR_POINT_ID"
  write_env MONITOR_TOKEN "$MONITOR_TOKEN"
  write_env MONITOR_ENROLLMENT_TOKEN "$MONITOR_ENROLLMENT_TOKEN"
  write_env MONITOR_NAME "$MONITOR_NAME"
  write_env MONITOR_REGION "$MONITOR_REGION"
  write_env MONITOR_PROVIDER "$MONITOR_PROVIDER"
  write_env MONITOR_PROBE_PROVIDER "$MONITOR_PROBE_PROVIDER"
  write_env MONITOR_PROVIDER_ENDPOINT "$MONITOR_PROVIDER_ENDPOINT"
  write_env MONITOR_PROVIDER_TIMEOUT "$MONITOR_PROVIDER_TIMEOUT"
  write_env MONITOR_PROVIDER_MAX_CONCURRENCY "$MONITOR_PROVIDER_MAX_CONCURRENCY"
  write_env MONITOR_PROVIDER_ORIGIN "$MONITOR_PROVIDER_ORIGIN"
  write_env MONITOR_PROVIDER_REFERER "$MONITOR_PROVIDER_REFERER"
  write_env MONITOR_PROVIDER_USER_AGENT "$MONITOR_PROVIDER_USER_AGENT"
  write_env MONITOR_PROVIDER_MAX_ATTEMPTS "$MONITOR_PROVIDER_MAX_ATTEMPTS"
  write_env MONITOR_HEARTBEAT_INTERVAL "$MONITOR_HEARTBEAT_INTERVAL"
  write_env MONITOR_POLL_INTERVAL "$MONITOR_POLL_INTERVAL"
  write_env MONITOR_CONCURRENCY "$MONITOR_CONCURRENCY"
  write_env MONITOR_BATCH_SIZE "$MONITOR_BATCH_SIZE"
  write_env MONITOR_WORK_DIR "$MONITOR_WORK_DIR"
} > "$tmp_env"
install -o root -g root -m 0600 "$tmp_env" "$env_path"

tmp_service=$(mktemp)
cat > "$tmp_service" <<SERVICE
[Unit]
Description=AutoChangeIP Monitor Agent (%i)
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=$service_user
Group=$service_group
EnvironmentFile=$env_dir/%i.env
ExecStart=$install_path
Restart=always
RestartSec=3s
UMask=0077
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectControlGroups=true
CapabilityBoundingSet=CAP_NET_RAW
AmbientCapabilities=CAP_NET_RAW
ReadWritePaths="$data_root"

[Install]
WantedBy=multi-user.target
SERVICE
install -o root -g root -m 0644 "$tmp_service" "$service_path"

systemctl daemon-reload
systemctl enable "$service_name" >/dev/null
if ! systemctl restart "$service_name"; then
  journalctl -u "$service_name" -n 30 --no-pager >&2 || true
  die "failed to start $service_name"
fi

sleep 2
if ! systemctl is-active --quiet "$service_name"; then
  journalctl -u "$service_name" -n 30 --no-pager >&2 || true
  die "$service_name is not active"
fi

log ""
log "AutoChangeIP monitor agent installed successfully."
log "Service: $service_name (active)"
log "Config:  $env_path"
log "Data:    $MONITOR_WORK_DIR"
log "Logs:    journalctl -u $service_name -f"
log "The monitor point should appear online in the panel after its first heartbeat."
