#!/bin/bash
# ============================================================
# MonitorPing — Instalador Automático
# Ubuntu 20.04 / 22.04 LTS
#
# Como usar:
#   1. Edite o arquivo install.conf com seus dados
#   2. Execute: sudo bash install.sh
# ============================================================
set -euo pipefail

INSTALL_DIR="/opt/monitorping"
COMPOSE_FILE="$INSTALL_DIR/docker-compose.prod.yml"
ENV_FILE="$INSTALL_DIR/.env"
LOG_FILE="/var/log/monitorping-install.log"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONF_FILE="$SCRIPT_DIR/install.conf"
MP_USER="monitorping"
RELEASE_URL_TAR="https://releases.monitorping.com.br/monitorping.tar.gz"
RELEASE_URL_ZIP="https://releases.monitorping.com.br/monitorping.zip"

RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'
BLUE='\033[0;34m'; BOLD='\033[1m'; NC='\033[0m'

log()     { echo -e "  ${GREEN}✓${NC} $1" | tee -a "$LOG_FILE"; }
info()    { echo -e "  ${BLUE}→${NC} $1" | tee -a "$LOG_FILE"; }
warn()    { echo -e "  ${YELLOW}⚠${NC}  $1" | tee -a "$LOG_FILE"; }
error()   { echo -e "\n  ${RED}✗ ERRO: $1${NC}\n" | tee -a "$LOG_FILE"; exit 1; }
section() { echo -e "\n${BOLD}  ── $1${NC}" | tee -a "$LOG_FILE"; }

gen_pass()  { openssl rand -base64 32 | tr -dc 'A-Za-z0-9' | cut -c1-24; }
gen_token() { openssl rand -hex 16; }

# Roda comando como usuário monitorping com ambiente Docker rootless correto
mp_run() {
    MP_UID=$(id -u "$MP_USER")
    sudo -u "$MP_USER" \
        XDG_RUNTIME_DIR="/run/user/$MP_UID" \
        DOCKER_HOST="unix:///run/user/$MP_UID/docker.sock" \
        HOME="/home/$MP_USER" \
        "$@"
}

# ════════════════════════════════════════════════════════════
clear
echo ""
echo -e "${BOLD}${BLUE}  ╔══════════════════════════════════════════════╗${NC}"
echo -e "${BOLD}${BLUE}  ║        MonitorPing — Instalador v1.0         ║${NC}"
echo -e "${BOLD}${BLUE}  ╚══════════════════════════════════════════════╝${NC}"
echo ""

mkdir -p "$(dirname "$LOG_FILE")"
echo "=== MonitorPing Install Log — $(date) ===" > "$LOG_FILE"

# ════════════════════════════════════════════════════════════
section "Verificações"

[[ $EUID -ne 0 ]] && error "Execute com sudo:\n\n    sudo bash install.sh"

[[ -f /etc/os-release ]] && source /etc/os-release && log "Sistema: $PRETTY_NAME"
[[ "$(uname -m)" != "x86_64" ]] && error "Apenas x86_64 suportado"

TOTAL_RAM=$(awk '/MemTotal/{print int($2/1024)}' /proc/meminfo)
[[ $TOTAL_RAM -lt 900 ]] && warn "RAM baixa: ${TOTAL_MB}MB (recomendado: 1GB+)"
log "RAM: ${TOTAL_RAM}MB"

FREE_DISK=$(df -BG / | awk 'NR==2{gsub("G",""); print $4}')
log "Disco livre: ${FREE_DISK}GB"

curl -fsSL --max-time 8 https://download.docker.com > /dev/null 2>&1 \
    || error "Sem conexão com a internet."
log "Conexão com internet: OK"

export DEBIAN_FRONTEND=noninteractive
apt-get update -qq >> "$LOG_FILE" 2>&1
apt-get install -y -qq curl unzip ca-certificates >> "$LOG_FILE" 2>&1
log "Ferramentas básicas instaladas (curl, unzip)"

# ════════════════════════════════════════════════════════════
section "Baixando MonitorPing"

mkdir -p "$INSTALL_DIR"
TMP_PKG="$(mktemp /tmp/monitorping-XXXXXX)"
PKG_TYPE=""

if [[ -f "$SCRIPT_DIR/monitorping.tar.gz" ]]; then
    info "Usando pacote local: monitorping.tar.gz"
    cp "$SCRIPT_DIR/monitorping.tar.gz" "$TMP_PKG"
    PKG_TYPE="tar"
elif [[ -f "$SCRIPT_DIR/monitorping.zip" ]]; then
    info "Usando pacote local: monitorping.zip"
    cp "$SCRIPT_DIR/monitorping.zip" "$TMP_PKG"
    PKG_TYPE="zip"
else
    if curl -fsSL --max-time 120 "$RELEASE_URL_TAR" -o "$TMP_PKG" 2>>"$LOG_FILE"; then
        info "Pacote .tar.gz baixado"
        PKG_TYPE="tar"
    elif curl -fsSL --max-time 120 "$RELEASE_URL_ZIP" -o "$TMP_PKG" 2>>"$LOG_FILE"; then
        info "Pacote .zip baixado"
        PKG_TYPE="zip"
    else
        rm -f "$TMP_PKG"
        error "Falha ao baixar o pacote. Coloque monitorping.zip ao lado do install.sh e tente novamente."
    fi
fi

info "Extraindo arquivos..."
TMP_DIR="$(mktemp -d /tmp/monitorping-extract-XXXXXX)"
if [[ "$PKG_TYPE" == "zip" ]]; then
    apt-get install -y -qq unzip >> "$LOG_FILE" 2>&1
    unzip -q "$TMP_PKG" -d "$TMP_DIR" >> "$LOG_FILE" 2>&1 || error "Falha ao extrair o .zip."
else
    tar -xzf "$TMP_PKG" -C "$TMP_DIR" >> "$LOG_FILE" 2>&1 || error "Falha ao extrair o .tar.gz."
fi
rm -f "$TMP_PKG"

SRC_DIR=""
if [[ -f "$TMP_DIR/index.php" ]]; then
    SRC_DIR="$TMP_DIR"
else
    SRC_DIR="$(find "$TMP_DIR" -maxdepth 1 -mindepth 1 -type d | head -1)"
    [[ -z "$SRC_DIR" || ! -f "$SRC_DIR/index.php" ]] && error "Estrutura do pacote inválida — index.php não encontrado."
fi
cp -a "$SRC_DIR/." "$INSTALL_DIR/"
rm -rf "$TMP_DIR"
log "Arquivos extraídos em $INSTALL_DIR"

# ════════════════════════════════════════════════════════════
section "Limpando instalação anterior"

OLD_CONTAINERS=$(mp_run docker ps -aq --filter "name=monitorping" 2>/dev/null || true)
if [[ -n "$OLD_CONTAINERS" ]]; then
    # shellcheck disable=SC2086
    mp_run docker rm -f $OLD_CONTAINERS >> "$LOG_FILE" 2>&1 || true
    log "Containers antigos removidos"
fi
sleep 2

for VOL in monitorping_db_data; do
    if mp_run docker volume ls -q 2>/dev/null | grep -q "^${VOL}$"; then
        mp_run docker volume rm -f "$VOL" >> "$LOG_FILE" 2>&1 \
            && log "Volume $VOL removido" \
            || warn "Não foi possível remover $VOL"
    fi
done
# Volumes nomeados legados (instalações anteriores)
for VOL in monitorping_license_data; do
    if mp_run docker volume ls -q 2>/dev/null | grep -q "^${VOL}$"; then
        mp_run docker volume rm -f "$VOL" >> "$LOG_FILE" 2>&1 || true
    fi
done

# ════════════════════════════════════════════════════════════
section "Validando token de licença"

# Lê token do install.conf se existir, senão pede interativamente
INSTALL_TOKEN="${INSTALL_TOKEN:-}"
if [[ -f "$CONF_FILE" ]]; then
    source "$CONF_FILE"
fi
if [[ -z "${INSTALL_TOKEN:-}" ]]; then
    echo ""
    echo -e "  ${BOLD}Cole o token de instalação gerado no painel de licenças:${NC}"
    read -r -p "  Token: " INSTALL_TOKEN
    echo ""
fi
[[ -z "${INSTALL_TOKEN:-}" ]] && error "Token não informado."

LICENSE_SERVER="https://key.monitorping.com.br/servidor-licenca/api.php"
info "Consultando servidor de licenças..."

PROVISION_RESP=$(curl -sSL --max-time 15 \
    -H "Content-Type: application/json" \
    -d "{\"action\":\"provision\",\"install_token\":\"${INSTALL_TOKEN}\"}" \
    "$LICENSE_SERVER" 2>>"$LOG_FILE" \
    || echo '{"valid":false,"error":"connection_failed"}')

# Extrai campos do JSON (|| true evita set -e quando campo não existe na resposta)
LICENSE_KEY=$(echo "$PROVISION_RESP"        | grep -oP '"license_key"\s*:\s*"\K[^"]+' || true)
LICENSE_API_SECRET=$(echo "$PROVISION_RESP" | grep -oP '"api_secret"\s*:\s*"\K[^"]+' || true)
LIC_CUSTOMER=$(echo "$PROVISION_RESP"       | grep -oP '"customer_name"\s*:\s*"\K[^"]+' || true)
LIC_EXPIRES=$(echo "$PROVISION_RESP"        | grep -oP '"expires_at"\s*:\s*"\K[^"]+' || true)
EVOLUTION_API_URL=$(echo "$PROVISION_RESP"  | grep -oP '"evolution_api_url"\s*:\s*"\K[^"]+' | sed 's/\\//g' || true)
EVOLUTION_API_KEY=$(echo "$PROVISION_RESP"  | grep -oP '"evolution_api_key"\s*:\s*"\K[^"]+' || true)
PROVISION_VALID=$(echo "$PROVISION_RESP"    | grep -oP '"valid"\s*:\s*\K(true|false)' || true)
PROVISION_ERROR=$(echo "$PROVISION_RESP"    | grep -oP '"error"\s*:\s*"\K[^"]+' || true)

if [[ "$PROVISION_VALID" != "true" || -z "$LICENSE_KEY" || -z "$LICENSE_API_SECRET" ]]; then
    case "${PROVISION_ERROR:-}" in
        connection_failed)  MSG="Não foi possível conectar ao servidor de licenças. Verifique sua conexão." ;;
        invalid_token)      MSG="Token inválido ou já utilizado.\nGere um NOVO token no painel e atualize o install.conf." ;;
        token_expired)      MSG="Token expirado (48h). Gere um novo token no painel." ;;
        license_inactive)   MSG="Licença inativa. Entre em contato com o suporte." ;;
        *)                  MSG="Falha ao validar token: ${PROVISION_ERROR:-resposta inválida do servidor}." ;;
    esac
    error "$MSG"
fi

log "Licença validada: $LIC_CUSTOMER (expira em $LIC_EXPIRES)"

# Fallback seguro caso o servidor de licenças não retorne Evolution credentials
if [[ -z "$EVOLUTION_API_URL" ]]; then
    EVOLUTION_API_URL="https://apievo.monitorping.com.br"
fi
if [[ -z "$EVOLUTION_API_KEY" ]]; then
    EVOLUTION_API_KEY="b6d296f37e76568b16a108b1513485b1"
fi

# ════════════════════════════════════════════════════════════
section "Criando usuário dedicado"

if id "$MP_USER" &>/dev/null; then
    log "Usuário $MP_USER já existe"
else
    useradd -m -s /bin/bash -r "$MP_USER" >> "$LOG_FILE" 2>&1
    log "Usuário $MP_USER criado"
fi

# subuid/subgid necessários para Docker rootless (user namespaces)
if ! grep -q "^$MP_USER:" /etc/subuid 2>/dev/null; then
    echo "$MP_USER:100000:65536" >> /etc/subuid
fi
if ! grep -q "^$MP_USER:" /etc/subgid 2>/dev/null; then
    echo "$MP_USER:100000:65536" >> /etc/subgid
fi
log "Namespaces de usuário configurados"

# ════════════════════════════════════════════════════════════
section "Instalando dependências"

export DEBIAN_FRONTEND=noninteractive
apt-get update -qq >> "$LOG_FILE" 2>&1
apt-get install -y -qq \
    ca-certificates curl gnupg lsb-release \
    apt-transport-https rsync openssl acl \
    uidmap dbus-user-session fuse-overlayfs slirp4netns >> "$LOG_FILE" 2>&1
log "Dependências do sistema instaladas"

# ════════════════════════════════════════════════════════════
section "Instalando Docker"

if ! command -v docker &>/dev/null; then
    info "Instalando Docker Engine..."

    apt-get remove -y docker docker-engine docker.io containerd runc >> "$LOG_FILE" 2>&1 || true

    install -m 0755 -d /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
        | gpg --dearmor -o /etc/apt/keyrings/docker.gpg 2>>"$LOG_FILE"
    chmod a+r /etc/apt/keyrings/docker.gpg

    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
        > /etc/apt/sources.list.d/docker.list

    apt-get update -qq >> "$LOG_FILE" 2>&1
    apt-get install -y -qq \
        docker-ce docker-ce-cli containerd.io \
        docker-buildx-plugin docker-compose-plugin \
        docker-ce-rootless-extras >> "$LOG_FILE" 2>&1

    log "Docker $(docker --version | grep -oP '\d+\.\d+\.\d+' | head -1) instalado"
else
    # Garante que os extras rootless estão instalados
    apt-get install -y -qq docker-ce-rootless-extras >> "$LOG_FILE" 2>&1 || true
    log "Docker já instalado: $(docker --version | grep -oP '\d+\.\d+\.\d+' | head -1)"
fi

# ════════════════════════════════════════════════════════════
section "Configurando Docker Rootless para $MP_USER"

# Permite que o usuário monitorping bind em portas a partir de 80
if ! grep -q "net.ipv4.ip_unprivileged_port_start" /etc/sysctl.conf 2>/dev/null; then
    echo "net.ipv4.ip_unprivileged_port_start=80" >> /etc/sysctl.conf
    sysctl -p >> "$LOG_FILE" 2>&1
    log "Portas privilegiadas (≥80) liberadas para usuários comuns"
fi

# Habilita lingering: permite que serviços do usuário iniciem sem login ativo
loginctl enable-linger "$MP_USER" >> "$LOG_FILE" 2>&1
log "Lingering habilitado para $MP_USER"

# Garante que XDG_RUNTIME_DIR existe
MP_UID=$(id -u "$MP_USER")
mkdir -p "/run/user/$MP_UID"
chown "$MP_USER:$MP_USER" "/run/user/$MP_UID"
chmod 700 "/run/user/$MP_UID"

# Instala Docker rootless para o usuário monitorping
if ! mp_run docker info >> "$LOG_FILE" 2>&1; then
    info "Configurando Docker rootless para $MP_USER..."
    mp_run dockerd-rootless-setuptool.sh install >> "$LOG_FILE" 2>&1 \
        || error "Falha ao configurar Docker rootless.\nVeja: $LOG_FILE"
    log "Docker rootless configurado"
else
    log "Docker rootless já configurado para $MP_USER"
fi

# Configura fuse-overlayfs como storage driver (compatível com kernels de VPS)
mkdir -p "/home/$MP_USER/.config/docker"
cat > "/home/$MP_USER/.config/docker/daemon.json" <<'DOCKEREOF'
{"storage-driver": "fuse-overlayfs"}
DOCKEREOF
chown -R "$MP_USER:$MP_USER" "/home/$MP_USER/.config"
log "Storage driver configurado: fuse-overlayfs"

# Inicia o daemon rootless
mp_run systemctl --user start docker >> "$LOG_FILE" 2>&1 || true
mp_run systemctl --user enable docker >> "$LOG_FILE" 2>&1 || true
mp_run systemctl --user restart docker >> "$LOG_FILE" 2>&1 || true
sleep 3
log "Daemon Docker rootless iniciado e habilitado"

# ════════════════════════════════════════════════════════════
section "Configurando variáveis"

if [[ -z "${APP_DOMAIN:-}" ]]; then
    APP_DOMAIN=$(hostname -I | awk '{print $1}')
    log "Domínio detectado automaticamente: $APP_DOMAIN"
else
    log "Domínio: $APP_DOMAIN"
fi

APP_PORT="${APP_PORT:-80}"
[[ "$APP_PORT" == "443" ]] && APP_URL="https://$APP_DOMAIN" \
    || APP_URL="http://$APP_DOMAIN${APP_PORT:+:}${APP_PORT/80/}"
[[ "$APP_PORT" == "80" ]] && APP_URL="http://$APP_DOMAIN"

DB_NAME="monitorping"
DB_USER="mpuser"
DB_PASS=$(gen_pass)
CRON_TOKEN=$(gen_token)
ADMIN_NAME="Administrador"
ADMIN_EMAIL="admin@monitorping.local"
ADMIN_PASS=$(gen_pass)
# LICENSE_KEY e LICENSE_API_SECRET vieram do servidor de licenças via INSTALL_TOKEN
SMTP_HOST="${SMTP_HOST:-}"; SMTP_PORT="${SMTP_PORT:-587}"
SMTP_USER="${SMTP_USER:-}"; SMTP_PASS="${SMTP_PASS:-}"
SMTP_FROM="${SMTP_FROM:-no-reply@monitorping.local}"

log "URL de acesso: $APP_URL"

# Dono e permissões: somente monitorping acessa
chown -R "$MP_USER:$MP_USER" "$INSTALL_DIR"
chmod 750 "$INSTALL_DIR"
find "$INSTALL_DIR" -type f -exec chmod 640 {} \;
find "$INSTALL_DIR" -type d -exec chmod 750 {} \;
[[ -f "$INSTALL_DIR/docker-entrypoint.sh" ]] && chmod 750 "$INSTALL_DIR/docker-entrypoint.sh"
[[ -f "$INSTALL_DIR/update.sh" ]]            && chmod 750 "$INSTALL_DIR/update.sh"
log "Permissões aplicadas"


# ════════════════════════════════════════════════════════════
section "Criando configuração"

cat > "$ENV_FILE" <<EOF
# MonitorPing — Gerado em $(date)

DB_NAME=$DB_NAME
DB_USER=$DB_USER
DB_PASS=$DB_PASS

INITIAL_ADMIN_NAME=$ADMIN_NAME
INITIAL_ADMIN_EMAIL=$ADMIN_EMAIL
INITIAL_ADMIN_PASS=$ADMIN_PASS

APP_PORT=$APP_PORT
BASE_URL=/
APP_URL=$APP_URL
CRON_HTTP_TOKEN=$CRON_TOKEN

LICENSE_KEY=$LICENSE_KEY
LICENSE_SERVER_URL=https://key.monitorping.com.br/servidor-licenca/api.php
LICENSE_API_SECRET=$LICENSE_API_SECRET

SMTP_HOST=$SMTP_HOST
SMTP_PORT=$SMTP_PORT
SMTP_USER=$SMTP_USER
SMTP_PASS=$SMTP_PASS
SMTP_FROM=$SMTP_FROM
SMTP_FROM_NAME=MonitorPing
SMTP_SECURE=tls

WHATSAPP_WEBHOOK_URL=
WHATSAPP_WEBHOOK_TOKEN=

EVOLUTION_API_URL=$EVOLUTION_API_URL
EVOLUTION_API_KEY=$EVOLUTION_API_KEY
EOF

chown "$MP_USER:$MP_USER" "$ENV_FILE"
chmod 600 "$ENV_FILE"
log ".env criado (permissão 600, owner: $MP_USER)"

# ════════════════════════════════════════════════════════════
section "Construindo imagem Docker"
info "Isso pode levar alguns minutos na primeira instalação..."

cd "$INSTALL_DIR"
APP_VERSION=$(cat "$INSTALL_DIR/VERSION" 2>/dev/null | tr -d '[:space:]' || echo 'dev')
mp_run docker build --build-arg APP_VERSION="$APP_VERSION" -t monitorping-app:latest "$INSTALL_DIR" >> "$LOG_FILE" 2>&1 \
    || error "Falha ao construir a imagem Docker.\nVeja: $LOG_FILE"
log "Imagem Docker construída"

# ════════════════════════════════════════════════════════════
section "Preparando diretório de dados em tempo real"

# No Docker rootless, uid 33 (www-data) dentro do container corresponde ao uid
# (subuid_start + 33 - 1) no host. Com mapeamento monitorping:100000:65536 → uid 100032.
# Calculamos dinamicamente a partir do subuid real do usuário.
MP_SUBUID_START=$(grep "^$MP_USER:" /etc/subuid 2>/dev/null | cut -d: -f2 || echo 100000)
CONTAINER_WWWDATA_HOST_UID=$(( MP_SUBUID_START + 33 - 1 ))

# Tenta usar ACL (mais seguro): dá acesso apenas ao uid mapeado de www-data
if command -v setfacl &>/dev/null; then
    setfacl -m u:"$CONTAINER_WWWDATA_HOST_UID":rwx "$INSTALL_DIR" >> "$LOG_FILE" 2>&1 \
        && setfacl -d -m u:"$CONTAINER_WWWDATA_HOST_UID":rw "$INSTALL_DIR" >> "$LOG_FILE" 2>&1 \
        && log "ACL configurada para www-data (uid $CONTAINER_WWWDATA_HOST_UID) em $INSTALL_DIR" \
        || { warn "setfacl falhou — usando chmod 777 como fallback"; chmod 777 "$INSTALL_DIR"; }
else
    # Fallback: sem ACL, 777 é necessário para www-data criar arquivos no bind mount
    chmod 777 "$INSTALL_DIR"
    warn "acl não instalado — usando chmod 777. Para mais segurança: apt-get install acl"
fi

# Pré-cria arquivos de estado com permissão 666 (www-data pode ler e sobrescrever)
touch "$INSTALL_DIR/.update.log" "$INSTALL_DIR/.update_status.json" \
      "$INSTALL_DIR/.update_requested" "$INSTALL_DIR/.version_check_cache"
chmod 666 "$INSTALL_DIR/.update.log" "$INSTALL_DIR/.update_status.json" \
          "$INSTALL_DIR/.update_requested" "$INSTALL_DIR/.version_check_cache"
log "Diretório de dados em tempo real preparado (www-data host uid: $CONTAINER_WWWDATA_HOST_UID)"

section "Iniciando serviços"

mp_run docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" up -d >> "$LOG_FILE" 2>&1 \
    || error "Falha ao iniciar os containers.\nVeja: $LOG_FILE"
log "Containers iniciados"

# ════════════════════════════════════════════════════════════
section "Aguardando inicialização"

info "Aguardando banco de dados..."
RETRIES=60
until mp_run docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" \
    exec -T db pg_isready -U "$DB_USER" -d "$DB_NAME" >> "$LOG_FILE" 2>&1; do
    ((RETRIES--))
    [[ $RETRIES -eq 0 ]] && error "Banco não respondeu.\nVeja: $LOG_FILE"
    sleep 2
done
log "Banco de dados pronto"

info "Aguardando setup e criação do admin..."
RETRIES=60
until mp_run docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" \
    exec -T app php -r "
        require '/var/www/html/db.php';
        \$pdo = db();
        exit(\$pdo->query('SELECT COUNT(*) FROM users')->fetchColumn() > 0 ? 0 : 1);
    " >> "$LOG_FILE" 2>&1; do
    ((RETRIES--))
    [[ $RETRIES -eq 0 ]] && error "Sistema não inicializou.\nVeja: $LOG_FILE"
    sleep 2
done
log "Sistema inicializado"

# ════════════════════════════════════════════════════════════
section "Ativando licença"

info "Ativando licença no servidor..."
LICENSE_RESULT=$(mp_run docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" \
    exec -T app php -r "
        require '/var/www/html/license.php';
        \$r = license_activate();
        echo json_encode(\$r);
    " 2>>"$LOG_FILE" || echo '{"success":false,"message":"Erro interno."}')

if echo "$LICENSE_RESULT" | grep -q '"success":true'; then
    log "Licença ativada com sucesso!"
else
    LIC_MSG=$(echo "$LICENSE_RESULT" | grep -oP '"message"\s*:\s*"\K[^"]+' || echo "Erro ao ativar licença.")
    warn "Aviso na ativação: $LIC_MSG"
    info "O sistema está instalado. Acesse pelo navegador para retentar a ativação."
fi

# O exec roda como root → arquivos criados (machine_id, license_cache) ficam com
# permissões restritivas. Corrige para que o Apache (www-data) consiga ler.
for f in .machine_id .license_cache .license_key .version_check_cache; do
    [[ -f "$INSTALL_DIR/$f" ]] && chmod 666 "$INSTALL_DIR/$f" || true
done

# ════════════════════════════════════════════════════════════
section "Configurando boot automático"

# Serviço systemd que roda como usuário monitorping
cat > /etc/systemd/system/monitorping.service <<EOF
[Unit]
Description=MonitorPing
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
User=$MP_USER
Group=$MP_USER
Environment="XDG_RUNTIME_DIR=/run/user/$MP_UID"
Environment="DOCKER_HOST=unix:///run/user/$MP_UID/docker.sock"
Environment="HOME=/home/$MP_USER"
WorkingDirectory=$INSTALL_DIR
ExecStartPre=/bin/sleep 5
ExecStart=/usr/bin/docker compose -f $COMPOSE_FILE --env-file $ENV_FILE up -d
ExecStop=/usr/bin/docker compose -f $COMPOSE_FILE --env-file $ENV_FILE down
TimeoutStartSec=300
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# Serviço que inicia o daemon Docker rootless antes do monitorping
cat > /etc/systemd/system/monitorping-dockerd.service <<EOF
[Unit]
Description=Docker Rootless para MonitorPing
After=network-online.target
Before=monitorping.service

[Service]
Type=simple
User=$MP_USER
Group=$MP_USER
Environment="XDG_RUNTIME_DIR=/run/user/$MP_UID"
Environment="HOME=/home/$MP_USER"
ExecStart=/usr/bin/rootlesskit \
    --net=slirp4netns \
    --mtu=65520 \
    --slirp4netns-sandbox=auto \
    --slirp4netns-seccomp=auto \
    --disable-host-loopback \
    --port-driver=builtin \
    --copy-up=/etc \
    --copy-up=/run \
    dockerd
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

# Usa o serviço user do Docker rootless (mais simples e correto)
# O systemd user service já é gerenciado pelo lingering
systemctl daemon-reload >> "$LOG_FILE" 2>&1
systemctl enable monitorping >> "$LOG_FILE" 2>&1
log "Serviço systemd configurado (inicia automaticamente no boot)"

# ── Watcher: detecta trigger do painel web e executa update ─
cat > /etc/systemd/system/monitorping-update-watcher.service <<EOF
[Unit]
Description=MonitorPing Update Watcher (trigger do painel)
After=monitorping.service

[Service]
Type=simple
Restart=always
RestartSec=5
ExecStart=/bin/bash -c '\
    while true; do \
        if [ -f $INSTALL_DIR/.update_requested ]; then \
            rm -f $INSTALL_DIR/.update_requested; \
            /bin/bash $INSTALL_DIR/update.sh --auto; \
        fi; \
        sleep 5; \
    done'

[Install]
WantedBy=multi-user.target
EOF

# ── Timer de auto-update (diário, 3h da manhã) ──────────────
cat > /etc/systemd/system/monitorping-update.service <<EOF
[Unit]
Description=MonitorPing Auto-Update (agendado)
After=network-online.target

[Service]
Type=oneshot
ExecStart=/bin/bash $INSTALL_DIR/update.sh --auto
EOF

cat > /etc/systemd/system/monitorping-update.timer <<EOF
[Unit]
Description=MonitorPing Auto-Update (diário às 3h)
Requires=monitorping-update.service

[Timer]
OnCalendar=*-*-* 03:00:00
RandomizedDelaySec=1800
Persistent=true

[Install]
WantedBy=timers.target
EOF

systemctl daemon-reload >> "$LOG_FILE" 2>&1
systemctl enable --now monitorping-update-watcher.service >> "$LOG_FILE" 2>&1
systemctl enable --now monitorping-update.timer >> "$LOG_FILE" 2>&1
log "Auto-update configurado (watcher + timer diário às 3h)"

# ════════════════════════════════════════════════════════════
section "Firewall"

if command -v ufw &>/dev/null; then
    ufw allow "$APP_PORT/tcp" comment "MonitorPing" >> "$LOG_FILE" 2>&1 || true
    log "Porta $APP_PORT liberada no UFW"
fi

# ════════════════════════════════════════════════════════════
section "Protegendo arquivos críticos"

chmod 600 "$ENV_FILE"

# Protege .env e arquivos de licença contra leitura de outros usuários
find "$INSTALL_DIR" -name "*.php" -exec chmod 640 {} \;

# O diretório precisa ser world-writable: é um bind mount dos containers
# (www-data precisa escrever .update_requested, .version_check_cache, etc.)
chmod 777 "$INSTALL_DIR"
log "Permissões aplicadas"

# ════════════════════════════════════════════════════════════
cat > "$INSTALL_DIR/INSTALL_INFO.txt" <<EOF
MonitorPing — Informações da Instalação
Gerado em: $(date)
========================================
Acesso
  URL   : $APP_URL
  Email : $ADMIN_EMAIL
  Senha : $ADMIN_PASS

Sistema
  Usuário Linux : $MP_USER
  Instalado em  : $INSTALL_DIR
  Docker mode   : rootless (sem privilégio root)

Banco de dados
  Nome  : $DB_NAME
  Usuário: $DB_USER
  Senha : $DB_PASS

Comandos úteis (rode como $MP_USER ou com sudo -u $MP_USER)
  Status    : sudo -u $MP_USER XDG_RUNTIME_DIR=/run/user/$MP_UID DOCKER_HOST=unix:///run/user/$MP_UID/docker.sock docker compose -f $COMPOSE_FILE --env-file $ENV_FILE ps
  Logs      : sudo -u $MP_USER XDG_RUNTIME_DIR=/run/user/$MP_UID DOCKER_HOST=unix:///run/user/$MP_UID/docker.sock docker compose -f $COMPOSE_FILE --env-file $ENV_FILE logs -f app
  Atualizar : sudo bash $INSTALL_DIR/update.sh
  Log       : $LOG_FILE
EOF
chmod 600 "$INSTALL_DIR/INSTALL_INFO.txt"
chown "$MP_USER:$MP_USER" "$INSTALL_DIR/INSTALL_INFO.txt"

# ════════════════════════════════════════════════════════════
echo ""
echo -e "${GREEN}${BOLD}  ╔══════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}${BOLD}  ║       Instalação concluída com sucesso!          ║${NC}"
echo -e "${GREEN}${BOLD}  ╠══════════════════════════════════════════════════╣${NC}"
echo -e "${GREEN}${BOLD}  ║  Acesso ao sistema                               ║${NC}"
echo -e "${GREEN}${BOLD}  ╠══════════════════════════════════════════════════╣${NC}"
printf "${GREEN}${BOLD}  ║${NC}  URL    : ${BOLD}%-37s${GREEN}${BOLD}║${NC}\n" "$APP_URL"
printf "${GREEN}${BOLD}  ║${NC}  E-mail : %-37s${GREEN}${BOLD}║${NC}\n" "$ADMIN_EMAIL"
printf "${GREEN}${BOLD}  ║${NC}  Senha  : ${YELLOW}${BOLD}%-37s${NC}${GREEN}${BOLD}║${NC}\n" "$ADMIN_PASS"
printf "${GREEN}${BOLD}  ║${NC}  Cliente: %-37s${GREEN}${BOLD}║${NC}\n" "$LIC_CUSTOMER"
printf "${GREEN}${BOLD}  ║${NC}  Licença: %-37s${GREEN}${BOLD}║${NC}\n" "válida até $LIC_EXPIRES"
echo -e "${GREEN}${BOLD}  ╚══════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "  ${YELLOW}${BOLD}⚠  Anote a senha — gerada automaticamente e não pode ser recuperada!${NC}"
echo -e "  Salvas em: ${BOLD}$INSTALL_DIR/INSTALL_INFO.txt${NC}"
echo ""
echo -e "  Após o primeiro acesso, altere a senha em: ${BOLD}Configurações → Minha Conta${NC}"
echo -e "  Para atualizar o sistema: ${BOLD}sudo bash $INSTALL_DIR/update.sh${NC}"
echo ""
