#!/bin/bash
# ============================================================
# OpenClaw Doctor — диагностика и починка бота
# Для студентов практики ООО «МИТ», февраль 2026
#
# Использование:
#   curl -sL <URL> | sudo bash
#   или:
#   chmod +x openclaw-doctor.sh && sudo ./openclaw-doctor.sh
# ============================================================

set -euo pipefail

# ── Цвета ──────────────────────────────────────────────────
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m' # No Color

# ── Счётчики ───────────────────────────────────────────────
FOUND=0
FIXED=0

# ── Вспомогательные функции ────────────────────────────────
banner() {
    echo ""
    echo -e "${CYAN}╔══════════════════════════════════════════════╗${NC}"
    echo -e "${CYAN}║   ${BOLD}OpenClaw Doctor${NC}${CYAN} — диагностика бота        ║${NC}"
    echo -e "${CYAN}╚══════════════════════════════════════════════╝${NC}"
    echo ""
}

step() {
    echo ""
    echo -e "${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${BOLD}  УРОВЕНЬ $1: $2${NC}"
    echo -e "${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

ok()   { echo -e "  ${GREEN}✓${NC} $1"; }
warn() { echo -e "  ${YELLOW}⚠${NC} $1"; }
fail() { echo -e "  ${RED}✗${NC} $1"; }
info() { echo -e "  ${CYAN}ℹ${NC} $1"; }

ask_fix() {
    echo ""
    echo -e "  ${YELLOW}Починить? [Y/n]${NC} "
    read -r answer </dev/tty
    [[ -z "$answer" || "$answer" =~ ^[YyДд] ]]
}

# ── Проверка прав ──────────────────────────────────────────
if [[ $EUID -ne 0 ]]; then
    echo -e "${RED}Запустите с sudo:${NC}  sudo bash $0"
    exit 1
fi

banner

# ── Определяем пользователей и пути ────────────────────────
# Кто запускал onboard (обычно shoma или ubuntu)
LOGIN_USER="${SUDO_USER:-shoma}"
LOGIN_HOME=$(eval echo "~$LOGIN_USER")

# Под кем работает systemd-сервис
SERVICE_USER="openclaw"
SERVICE_HOME="/home/$SERVICE_USER"
SERVICE_CONFIG="$SERVICE_HOME/.openclaw/openclaw.json"
LOGIN_CONFIG="$LOGIN_HOME/.openclaw/openclaw.json"

info "Пользователь SSH:      ${BOLD}$LOGIN_USER${NC} ($LOGIN_HOME)"
info "Пользователь сервиса:  ${BOLD}$SERVICE_USER${NC} ($SERVICE_HOME)"

# Определяем публичный IP сервера
SERVER_IP=$(curl -s --max-time 5 ifconfig.me 2>/dev/null || hostname -I | awk '{print $1}')
info "IP этого сервера:      ${BOLD}$SERVER_IP${NC}"

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 0: Базовые проверки
# ════════════════════════════════════════════════════════════
step "0" "Базовые проверки"

# Проверяем что openclaw установлен
if command -v openclaw &>/dev/null; then
    OC_VERSION=$(openclaw --version 2>/dev/null || echo "неизвестна")
    ok "OpenClaw установлен: $OC_VERSION"
else
    fail "OpenClaw не установлен!"
    echo "  Установите: sudo npm i -g openclaw"
    exit 1
fi

# Проверяем systemd unit
if systemctl list-unit-files openclaw.service &>/dev/null; then
    ok "Systemd unit openclaw.service существует"
else
    fail "Systemd unit openclaw.service не найден"
    echo "  Запустите: openclaw onboard"
    exit 1
fi

# Проверяем статус сервиса
SERVICE_STATUS=$(systemctl is-active openclaw 2>/dev/null || true)
if [[ "$SERVICE_STATUS" == "active" ]]; then
    ok "Сервис openclaw: ${GREEN}active (running)${NC}"
else
    warn "Сервис openclaw: ${RED}$SERVICE_STATUS${NC}"
    info "Продолжаем диагностику — может заработать после починки"
fi

# Под каким пользователем работает процесс
PROC_USERS=$(ps aux | grep '[o]penclaw' | grep -v grep | awk '{print $1}' | sort -u)
PROC_COUNT=$(echo "$PROC_USERS" | wc -w)

if [[ $PROC_COUNT -gt 1 ]]; then
    fail "OpenClaw запущен от ${BOLD}НЕСКОЛЬКИХ${NC} пользователей: ${BOLD}$PROC_USERS${NC}"
    FOUND=$((FOUND + 1))
    echo ""
    info "Это конфликт — два gateway на одном порту мешают друг другу."
    info "Systemd-сервис работает от ${BOLD}openclaw${NC} — это правильный."
    info "Лишний процесс от ${BOLD}$LOGIN_USER${NC} нужно убить."
    echo ""
    info "Процессы:"
    ps aux | grep '[o]penclaw' | grep -v grep

    if ask_fix; then
        # Проверяем: есть ли user-level systemd сервис (причина респавна)
        USER_UNIT_ACTIVE=false
        if sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
            systemctl --user is-active openclaw-gateway 2>/dev/null | grep -q active; then
            USER_UNIT_ACTIVE=true
        fi

        if $USER_UNIT_ACTIVE; then
            info "Найден user-level systemd сервис openclaw-gateway от $LOGIN_USER"
            info "Это причина респавна — отключаем"
            sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
                systemctl --user stop openclaw-gateway 2>/dev/null || true
            sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
                systemctl --user disable openclaw-gateway 2>/dev/null || true
            ok "User-level сервис openclaw-gateway остановлен и отключён"
        else
            # Нет user-level сервиса — просто убиваем процессы
            for pid in $(ps aux | grep '[o]penclaw' | grep "^$LOGIN_USER" | awk '{print $2}'); do
                kill -9 "$pid" 2>/dev/null && ok "Убит процесс PID $pid (от $LOGIN_USER)" || true
            done
        fi

        sleep 1
        FIXED=$((FIXED + 1))

        # Перезапускаем systemd-сервис
        systemctl restart openclaw 2>/dev/null
        ok "Systemd-сервис openclaw перезапущен"
    fi
elif [[ $PROC_COUNT -eq 1 ]]; then
    # Один пользователь — но проверим нет ли отключённого user-level сервиса
    # который может случайно запуститься
    USER_UNIT_EXISTS=false
    if sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER" 2>/dev/null)" \
        systemctl --user list-unit-files openclaw-gateway.service 2>/dev/null | grep -q openclaw; then
        USER_UNIT_EXISTS=true
    fi

    if $USER_UNIT_EXISTS; then
        USER_UNIT_ENABLED=$(sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
            systemctl --user is-enabled openclaw-gateway 2>/dev/null || echo "unknown")
        if [[ "$USER_UNIT_ENABLED" == "enabled" ]]; then
            warn "User-level сервис openclaw-gateway ${BOLD}включён${NC} у $LOGIN_USER"
            info "Он может конфликтовать с system-level сервисом. Рекомендуется отключить."
            FOUND=$((FOUND + 1))
            if ask_fix; then
                sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
                    systemctl --user stop openclaw-gateway 2>/dev/null || true
                sudo -u "$LOGIN_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$LOGIN_USER")" \
                    systemctl --user disable openclaw-gateway 2>/dev/null || true
                ok "User-level сервис отключён"
                FIXED=$((FIXED + 1))
            fi
        else
            ok "User-level сервис openclaw-gateway: $USER_UNIT_ENABLED (не помешает)"
        fi
    fi
fi

PROC_USER=$(ps aux | grep '[o]penclaw gateway' | awk '{print $1}' | head -1 || true)
if [[ -n "$PROC_USER" ]]; then
    info "Процесс работает от пользователя: ${BOLD}$PROC_USER${NC}"
    SERVICE_USER="$PROC_USER"
    SERVICE_HOME=$(eval echo "~$SERVICE_USER" 2>/dev/null || echo "/home/$SERVICE_USER")
    SERVICE_CONFIG="$SERVICE_HOME/.openclaw/openclaw.json"
else
    info "Процесс openclaw не запущен, используем пользователя: $SERVICE_USER"
fi

# Проверяем AI API
echo ""
info "Проверяем AI API..."
API_RESPONSE=$(curl -s --max-time 10 \
    https://ai-labs.mitsrv.ru/v1/models \
    -H "Authorization: Bearer sk-student-2026" 2>/dev/null || echo "FAIL")

if [[ "$API_RESPONSE" != "FAIL" ]] && echo "$API_RESPONSE" | python3 -m json.tool &>/dev/null; then
    ok "AI API (ai-labs.mitsrv.ru) доступен"
else
    warn "AI API недоступен — бот не сможет отвечать"
fi

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 1: Два конфига
# ════════════════════════════════════════════════════════════
step "1" "Два конфига"

echo ""
info "Алгоритм: ${BOLD}ps aux | grep openclaw${NC} → узнаём пользователя"
info "Сервис работает от: ${BOLD}$SERVICE_USER${NC}"
info "Onboard настраивал:  ${BOLD}$LOGIN_USER${NC}"
echo ""

HAS_LOGIN_CONFIG=false
HAS_SERVICE_CONFIG=false
LOGIN_CONFIG_SIZE=0
SERVICE_CONFIG_SIZE=0

if [[ -f "$LOGIN_CONFIG" ]]; then
    HAS_LOGIN_CONFIG=true
    LOGIN_CONFIG_SIZE=$(wc -c < "$LOGIN_CONFIG")
    ok "Конфиг $LOGIN_USER: ${BOLD}$LOGIN_CONFIG${NC} ($LOGIN_CONFIG_SIZE байт)"
else
    warn "Конфиг $LOGIN_USER: НЕТ файла $LOGIN_CONFIG"
fi

if [[ -f "$SERVICE_CONFIG" ]]; then
    HAS_SERVICE_CONFIG=true
    SERVICE_CONFIG_SIZE=$(wc -c < "$SERVICE_CONFIG")
    ok "Конфиг $SERVICE_USER: ${BOLD}$SERVICE_CONFIG${NC} ($SERVICE_CONFIG_SIZE байт)"
else
    fail "Конфиг $SERVICE_USER: НЕТ файла $SERVICE_CONFIG"
fi

# Проверяем: есть ли telegram в конфиге сервиса
SERVICE_HAS_TELEGRAM=false
if $HAS_SERVICE_CONFIG; then
    if python3 -c "
import json, sys
cfg = json.load(open('$SERVICE_CONFIG'))
tg = cfg.get('channels', {}).get('telegram', {})
if tg.get('botToken') or tg.get('token'):
    sys.exit(0)
sys.exit(1)
" 2>/dev/null; then
        SERVICE_HAS_TELEGRAM=true
        ok "Конфиг сервиса содержит настройки Telegram"
    else
        fail "Конфиг сервиса НЕ содержит настройки Telegram"
    fi
fi

# Нужно ли копировать?
NEED_COPY=false
if $HAS_LOGIN_CONFIG && ! $HAS_SERVICE_CONFIG; then
    NEED_COPY=true
    fail "Проблема: конфиг есть только у $LOGIN_USER, а сервис работает от $SERVICE_USER"
    FOUND=$((FOUND + 1))
elif $HAS_LOGIN_CONFIG && $HAS_SERVICE_CONFIG && ! $SERVICE_HAS_TELEGRAM; then
    if [[ $LOGIN_CONFIG_SIZE -gt $SERVICE_CONFIG_SIZE ]]; then
        NEED_COPY=true
        fail "Проблема: конфиг сервиса пустой/минимальный ($SERVICE_CONFIG_SIZE байт), а полный конфиг у $LOGIN_USER ($LOGIN_CONFIG_SIZE байт)"
        FOUND=$((FOUND + 1))
    fi
elif $HAS_SERVICE_CONFIG && $SERVICE_HAS_TELEGRAM; then
    ok "Конфиг на месте и содержит Telegram — всё ОК"
fi

if $NEED_COPY; then
    echo ""
    info "${BOLD}Причина:${NC} вы запускали 'openclaw onboard' как $LOGIN_USER,"
    info "мастер записал конфиг в $LOGIN_CONFIG."
    info "Но systemd запускает сервис от $SERVICE_USER — он читает $SERVICE_CONFIG."
    info "Решение: скопировать конфиг."

    if ask_fix; then
        mkdir -p "$(dirname "$SERVICE_CONFIG")"
        cp "$LOGIN_CONFIG" "$SERVICE_CONFIG"
        chown -R "$SERVICE_USER:$SERVICE_USER" "$SERVICE_HOME/.openclaw"
        ok "Конфиг скопирован в $SERVICE_CONFIG"
        FIXED=$((FIXED + 1))
    fi
fi

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 2: contextWindow слишком маленький
# ════════════════════════════════════════════════════════════
step "2" "Окно контекста (contextWindow)"

# Перечитываем конфиг (мог быть скопирован на предыдущем шаге)
if [[ ! -f "$SERVICE_CONFIG" ]]; then
    fail "Конфиг $SERVICE_CONFIG не найден — пропускаем"
else
    CTX_WINDOW=$(python3 -c "
import json
cfg = json.load(open('$SERVICE_CONFIG'))
# Ищем contextWindow в разных местах конфига
for pname, prov in cfg.get('models', {}).get('providers', {}).items():
    for m in prov.get('models', []):
        if isinstance(m, dict) and 'contextWindow' in m:
            print(m['contextWindow'])
            exit()
print('NOT_FOUND')
" 2>/dev/null || echo "ERROR")

    MAX_TOKENS=$(python3 -c "
import json
cfg = json.load(open('$SERVICE_CONFIG'))
for pname, prov in cfg.get('models', {}).get('providers', {}).items():
    for m in prov.get('models', []):
        if isinstance(m, dict) and 'maxTokens' in m:
            print(m['maxTokens'])
            exit()
print('NOT_FOUND')
" 2>/dev/null || echo "ERROR")

    echo ""
    info "Алгоритм: смотрим конфиг → ищем contextWindow"

    NEED_CTX_FIX=false

    if [[ "$CTX_WINDOW" == "NOT_FOUND" ]]; then
        info "contextWindow не задан в конфиге (будет дефолт — обычно ОК)"
    elif [[ "$CTX_WINDOW" =~ ^[0-9]+$ ]] && [[ $CTX_WINDOW -lt 16000 ]]; then
        fail "contextWindow = ${BOLD}$CTX_WINDOW${NC} — слишком мало! Минимум 16 000"
        NEED_CTX_FIX=true
        FOUND=$((FOUND + 1))
    elif [[ "$CTX_WINDOW" =~ ^[0-9]+$ ]]; then
        ok "contextWindow = $CTX_WINDOW — ОК"
    fi

    if [[ "$MAX_TOKENS" =~ ^[0-9]+$ ]] && [[ $MAX_TOKENS -lt 8000 ]]; then
        warn "maxTokens = ${BOLD}$MAX_TOKENS${NC} — маловато, рекомендуется 8192"
        NEED_CTX_FIX=true
    elif [[ "$MAX_TOKENS" =~ ^[0-9]+$ ]]; then
        ok "maxTokens = $MAX_TOKENS — ОК"
    fi

    if $NEED_CTX_FIX; then
        echo ""
        info "${BOLD}Причина:${NC} мастер onboard записал contextWindow: 4096."
        info "OpenClaw требует минимум 16 000 токенов для работы."
        info "Исправим на 131072 (полное окно Gemini 3 Flash)."

        if ask_fix; then
            python3 -c "
import json

with open('$SERVICE_CONFIG', 'r') as f:
    cfg = json.load(f)

changed = False
for pname, prov in cfg.get('models', {}).get('providers', {}).items():
    new_models = []
    for m in prov.get('models', []):
        if isinstance(m, dict):
            if m.get('contextWindow', 999999) < 16000:
                m['contextWindow'] = 131072
                changed = True
            if m.get('maxTokens', 999999) < 8000:
                m['maxTokens'] = 8192
                changed = True
        new_models.append(m)
    prov['models'] = new_models

if changed:
    with open('$SERVICE_CONFIG', 'w') as f:
        json.dump(cfg, f, indent=2, ensure_ascii=False)
    print('FIXED')
else:
    print('NO_CHANGE')
"
            chown "$SERVICE_USER:$SERVICE_USER" "$SERVICE_CONFIG"
            ok "contextWindow → 131072, maxTokens → 8192"
            FIXED=$((FIXED + 1))
        fi
    fi
fi

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 3: dmPolicy (кто может писать боту)
# ════════════════════════════════════════════════════════════
step "3" "Политика доступа (dmPolicy)"

if [[ ! -f "$SERVICE_CONFIG" ]]; then
    fail "Конфиг не найден — пропускаем"
else
    DM_POLICY=$(python3 -c "
import json
cfg = json.load(open('$SERVICE_CONFIG'))
tg = cfg.get('channels', {}).get('telegram', {})
print(tg.get('dmPolicy', 'NOT_SET'))
" 2>/dev/null || echo "ERROR")

    ALLOW_FROM=$(python3 -c "
import json
cfg = json.load(open('$SERVICE_CONFIG'))
tg = cfg.get('channels', {}).get('telegram', {})
af = tg.get('allowFrom', [])
print(','.join(af) if af else 'NOT_SET')
" 2>/dev/null || echo "ERROR")

    echo ""
    info "dmPolicy = ${BOLD}$DM_POLICY${NC}"
    info "allowFrom = ${BOLD}$ALLOW_FROM${NC}"

    NEED_DM_FIX=false

    if [[ "$DM_POLICY" == "open" ]] && [[ "$ALLOW_FROM" == *"*"* ]]; then
        ok "Бот открыт для всех — ОК"
    elif [[ "$DM_POLICY" == "pairing" ]]; then
        fail "dmPolicy = pairing — бот требует код подтверждения от новых пользователей"
        NEED_DM_FIX=true
        FOUND=$((FOUND + 1))
    elif [[ "$DM_POLICY" == "open" ]] && [[ "$ALLOW_FROM" != *"*"* ]]; then
        fail "dmPolicy = open, но allowFrom не содержит '*' — бот упадёт!"
        NEED_DM_FIX=true
        FOUND=$((FOUND + 1))
    else
        warn "dmPolicy = $DM_POLICY — возможно нужна настройка"
        NEED_DM_FIX=true
        FOUND=$((FOUND + 1))
    fi

    if $NEED_DM_FIX; then
        echo ""
        info "${BOLD}Причина:${NC} в режиме 'pairing' каждый новый пользователь должен"
        info "получить код одобрения. Для учебного бота это лишнее."
        info "Исправим на 'open' + allowFrom: ['*'] — все могут писать."

        if ask_fix; then
            python3 -c "
import json

with open('$SERVICE_CONFIG', 'r') as f:
    cfg = json.load(f)

tg = cfg.setdefault('channels', {}).setdefault('telegram', {})
tg['dmPolicy'] = 'open'
tg['allowFrom'] = ['*']

with open('$SERVICE_CONFIG', 'w') as f:
    json.dump(cfg, f, indent=2, ensure_ascii=False)
"
            chown "$SERVICE_USER:$SERVICE_USER" "$SERVICE_CONFIG"
            ok "dmPolicy → open, allowFrom → ['*']"
            FIXED=$((FIXED + 1))
        fi
    fi
fi

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 4: Caddy (HTTPS для веб-морды)
# ════════════════════════════════════════════════════════════
step "4" "Caddy (HTTPS веб-морда)"

CADDYFILE="/etc/caddy/Caddyfile"

if [[ ! -f "$CADDYFILE" ]]; then
    warn "Caddyfile не найден ($CADDYFILE) — Caddy не установлен?"
    info "Веб-морда не будет работать по HTTPS, но Telegram-бот — будет"
else
    CADDY_CONTENT=$(cat "$CADDYFILE")

    if echo "$CADDY_CONTENT" | grep -q '<caddy_server_ip>'; then
        fail "В Caddyfile стоит плейсхолдер ${BOLD}<caddy_server_ip>${NC} вместо реального IP"
        FOUND=$((FOUND + 1))

        echo ""
        info "${BOLD}Причина:${NC} Caddy не знает IP сервера — не может получить"
        info "TLS-сертификат от Let's Encrypt и не проксирует запросы."
        info "Исправим: заменим <caddy_server_ip> на ${BOLD}$SERVER_IP${NC}"

        if ask_fix; then
            # Полностью перезаписываем Caddyfile — для IP нужен tls internal
            cat > "$CADDYFILE" << CADDYEOF
$SERVER_IP {
    tls internal
    reverse_proxy localhost:18789
}
CADDYEOF
            ok "Caddyfile перезаписан: IP=$SERVER_IP, tls internal"
            systemctl restart caddy 2>/dev/null && ok "Caddy перезапущен" || warn "Не удалось перезапустить Caddy"
            FIXED=$((FIXED + 1))
        fi
    elif echo "$CADDY_CONTENT" | grep -qE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'; then
        # IP есть — проверяем TLS конфиг
        if echo "$CADDY_CONTENT" | grep -q 'tls internal'; then
            ok "Caddyfile: IP-адрес + tls internal — ОК"
        elif echo "$CADDY_CONTENT" | grep -q 'issuer acme'; then
            fail "Caddyfile использует ACME (Let's Encrypt) — не работает для IP-адресов!"
            FOUND=$((FOUND + 1))
            info "Let's Encrypt не выдаёт сертификаты для IP. Нужен tls internal."
            if ask_fix; then
                cat > "$CADDYFILE" << CADDYEOF
$SERVER_IP {
    tls internal
    reverse_proxy localhost:18789
}
CADDYEOF
                ok "Caddyfile перезаписан: tls internal"
                systemctl restart caddy 2>/dev/null && ok "Caddy перезапущен" || warn "Не удалось перезапустить Caddy"
                FIXED=$((FIXED + 1))
            fi
        elif ! echo "$CADDY_CONTENT" | grep -q 'tls'; then
            fail "Caddyfile: нет TLS-конфигурации — HTTPS не будет работать"
            FOUND=$((FOUND + 1))
            info "Для IP-адреса нужен tls internal (самоподписанный сертификат)."
            if ask_fix; then
                cat > "$CADDYFILE" << CADDYEOF
$SERVER_IP {
    tls internal
    reverse_proxy localhost:18789
}
CADDYEOF
                ok "Caddyfile перезаписан: tls internal"
                systemctl restart caddy 2>/dev/null && ok "Caddy перезапущен" || warn "Не удалось перезапустить Caddy"
                FIXED=$((FIXED + 1))
            fi
        else
            ok "Caddyfile содержит IP-адрес и TLS — ОК"
        fi
    else
        warn "Caddyfile: не нашёл IP-адрес, проверьте вручную"
    fi

    echo ""
    info "Текущий Caddyfile:"
    echo -e "  ${CYAN}$(cat "$CADDYFILE" | head -10)${NC}"
fi

# ════════════════════════════════════════════════════════════
# УРОВЕНЬ 5: Пути workspace
# ════════════════════════════════════════════════════════════
step "5" "Пути workspace"

if [[ ! -f "$SERVICE_CONFIG" ]]; then
    fail "Конфиг не найден — пропускаем"
else
    # Проверяем: есть ли в конфиге пути, ведущие к login user вместо service user
    BAD_PATHS=$(grep -c "$LOGIN_HOME" "$SERVICE_CONFIG" 2>/dev/null || echo "0")

    if [[ "$BAD_PATHS" -gt 0 ]] && [[ "$LOGIN_USER" != "$SERVICE_USER" ]]; then
        fail "В конфиге найдено ${BOLD}$BAD_PATHS${NC} путей к $LOGIN_HOME"
        info "Сервис работает от $SERVICE_USER — он не имеет доступа к $LOGIN_HOME"
        FOUND=$((FOUND + 1))

        echo ""
        info "${BOLD}Причина:${NC} onboard записал пути к вашей домашней директории."
        info "Сервис работает от $SERVICE_USER и не может читать $LOGIN_HOME."
        info "Исправим: заменим $LOGIN_HOME → $SERVICE_HOME"

        if ask_fix; then
            sed -i "s|$LOGIN_HOME|$SERVICE_HOME|g" "$SERVICE_CONFIG"
            # Проверяем что JSON валидный после замены
            if python3 -m json.tool "$SERVICE_CONFIG" > /dev/null 2>&1; then
                ok "Пути исправлены: $LOGIN_HOME → $SERVICE_HOME"
            else
                fail "JSON сломался после замены! Восстанавливаю..."
                cp "$LOGIN_CONFIG" "$SERVICE_CONFIG" 2>/dev/null || true
            fi
            FIXED=$((FIXED + 1))
        fi
    elif [[ "$LOGIN_USER" == "$SERVICE_USER" ]]; then
        ok "Пользователь совпадает — проблемы с путями нет"
    else
        ok "Путей к $LOGIN_HOME в конфиге нет — ОК"
    fi

    # Создаём workspace директорию если нет
    WORKSPACE_DIR="$SERVICE_HOME/.openclaw/workspace"
    if [[ ! -d "$WORKSPACE_DIR" ]]; then
        warn "Директория workspace не существует: $WORKSPACE_DIR"
        mkdir -p "$WORKSPACE_DIR"
        chown -R "$SERVICE_USER:$SERVICE_USER" "$SERVICE_HOME/.openclaw"
        ok "Создана: $WORKSPACE_DIR"
    else
        ok "Директория workspace существует"
    fi
fi

# ════════════════════════════════════════════════════════════
# ФИНАЛ: Перезапуск и проверка
# ════════════════════════════════════════════════════════════
echo ""
echo -e "${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}  ФИНАЛ: Перезапуск и проверка${NC}"
echo -e "${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

if [[ $FIXED -gt 0 ]]; then
    echo ""
    info "Было исправлено: ${BOLD}$FIXED${NC} проблем. Перезапускаем OpenClaw..."
    echo ""

    # Финальная проверка JSON
    if python3 -m json.tool "$SERVICE_CONFIG" > /dev/null 2>&1; then
        ok "JSON конфиг валидный"
    else
        fail "JSON конфиг НЕВАЛИДНЫЙ! Проверьте вручную:"
        echo "  sudo cat $SERVICE_CONFIG | python3 -m json.tool"
        exit 1
    fi

    # Права на файлы
    chown -R "$SERVICE_USER:$SERVICE_USER" "$SERVICE_HOME/.openclaw"
    ok "Права на файлы установлены"

    # Перезапуск
    systemctl restart openclaw 2>/dev/null
    sleep 3

    # Проверяем статус
    NEW_STATUS=$(systemctl is-active openclaw 2>/dev/null || true)
    if [[ "$NEW_STATUS" == "active" ]]; then
        ok "OpenClaw: ${GREEN}active (running)${NC}"
    else
        fail "OpenClaw: ${RED}$NEW_STATUS${NC}"
        echo ""
        info "Последние логи:"
        journalctl -u openclaw --since "30 sec ago" --no-pager 2>/dev/null | tail -10
        echo ""
        info "Проверьте конфиг вручную: sudo cat $SERVICE_CONFIG | python3 -m json.tool"
        exit 1
    fi

    # Проверяем логи на ошибки
    sleep 2
    RECENT_ERRORS=$(journalctl -u openclaw --since "10 sec ago" --no-pager 2>/dev/null | grep -ci 'error\|fatal\|crash' || true)
    if [[ $RECENT_ERRORS -eq 0 ]]; then
        ok "Ошибок в логах нет"
    else
        warn "В логах есть ошибки — проверьте:"
        journalctl -u openclaw --since "10 sec ago" --no-pager 2>/dev/null | grep -i 'error\|fatal\|crash' | tail -5
    fi
else
    info "Ничего не менялось — перезапуск не нужен"
fi

# ════════════════════════════════════════════════════════════
# ИТОГОВЫЙ ОТЧЁТ
# ════════════════════════════════════════════════════════════
echo ""
echo -e "${CYAN}╔══════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║              ИТОГОВЫЙ ОТЧЁТ                 ║${NC}"
echo -e "${CYAN}╠══════════════════════════════════════════════╣${NC}"

if [[ $FOUND -eq 0 ]]; then
    echo -e "${CYAN}║${NC}  ${GREEN}Проблем не найдено — всё работает!${NC}          ${CYAN}║${NC}"
else
    echo -e "${CYAN}║${NC}  Найдено проблем:    ${BOLD}$FOUND${NC}                      ${CYAN}║${NC}"
    echo -e "${CYAN}║${NC}  Исправлено:         ${GREEN}$FIXED${NC}                      ${CYAN}║${NC}"
    SKIPPED=$((FOUND - FIXED))
    if [[ $SKIPPED -gt 0 ]]; then
        echo -e "${CYAN}║${NC}  Пропущено:          ${YELLOW}$SKIPPED${NC}                      ${CYAN}║${NC}"
    fi
fi

echo -e "${CYAN}╠══════════════════════════════════════════════╣${NC}"

# Показываем текущее состояние
FINAL_STATUS=$(systemctl is-active openclaw 2>/dev/null || echo "unknown")
if [[ "$FINAL_STATUS" == "active" ]]; then
    echo -e "${CYAN}║${NC}  Сервис:    ${GREEN}● active (running)${NC}               ${CYAN}║${NC}"
else
    echo -e "${CYAN}║${NC}  Сервис:    ${RED}● $FINAL_STATUS${NC}                     ${CYAN}║${NC}"
fi

# Извлекаем имя бота
BOT_NAME=$(python3 -c "
import json
try:
    cfg = json.load(open('$SERVICE_CONFIG'))
    tg = cfg.get('channels', {}).get('telegram', {})
    print(tg.get('botUsername', tg.get('username', '???')))
except:
    print('???')
" 2>/dev/null || echo "???")
echo -e "${CYAN}║${NC}  Telegram:  @${BOLD}$BOT_NAME${NC}                      ${CYAN}║${NC}"
echo -e "${CYAN}║${NC}  Web UI:    https://$SERVER_IP              ${CYAN}║${NC}"

echo -e "${CYAN}╚══════════════════════════════════════════════╝${NC}"

if [[ "$FINAL_STATUS" == "active" ]]; then
    echo ""
    echo -e "  ${GREEN}${BOLD}Напишите боту в Telegram — он должен ответить!${NC}"
    echo ""
fi

echo -e "  ${CYAN}Отчёт для чата практики:${NC}"
echo "  1. Скриншот этого экрана"
echo "  2. Скриншот ответа бота в Telegram"
echo "  3. Что было самым сложным?"
echo ""