#!/bin/bash

set -e
set -u

# Configuration
PROJECT_URL="https://donkeypay.ru/pitstop.tar.gz"
PROJECT_ARCHIVE="pitstop.tar.gz"
ZROK_API_KEY="ubDznPz2gxsx"
ZROK_SHARE_PREFIX="donkey"

# Determine service user (prefer the invoking sudo user, or current user)
if [ -n "${SUDO_USER-}" ] && [ "${SUDO_USER}" != "root" ]; then
	SERVICE_USER="${SUDO_USER}"
else
	SERVICE_USER="${USER}"
fi
# Primary group name for the resolved user (fallback to same name)
SERVICE_GROUP="$(id -gn "$SERVICE_USER" 2>/dev/null || echo "$SERVICE_USER")"

# User-based installation paths
SERVICE_USER_HOME=$(eval echo ~"$SERVICE_USER")
INSTALL_DIR="$SERVICE_USER_HOME/pitstop"
BACKUP_DIR="$SERVICE_USER_HOME/pitstop-backups"
SYSTEMD_USER_DIR="$SERVICE_USER_HOME/.config/systemd/user"
TEMP_DIR="/tmp/pitstop-install-$$"

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

# Debug mode (set via DEBUG=1 environment variable)
DEBUG="${DEBUG:-0}"

# Logging functions
log_info() { echo -e "${BLUE}[ИНФО]${NC} $1"; }
log_success() { echo -e "${GREEN}[УСПЕХ]${NC} $1"; }
log_warning() { echo -e "${YELLOW}[ВНИМАНИЕ]${NC} $1"; }
log_error() { echo -e "${RED}[ОШИБКА]${NC} $1"; }
log_debug() { 
    if [ "$DEBUG" = "1" ]; then
        echo -e "${YELLOW}[ОТЛАДКА]${NC} $1" >&2
    fi
}

error_exit() {
    log_error "$1"
    log_error "Установка не удалась. Откат изменений..."
    rollback
    exit 1
}

rollback() {
    log_warning "Выполняется откат..."
    systemctl --user stop pitstop.service zrok.service 2>/dev/null || true
    systemctl --user disable pitstop.service zrok.service 2>/dev/null || true
    rm -f "$SYSTEMD_USER_DIR"/{pitstop,zrok}.service 2>/dev/null || true
    systemctl --user daemon-reload 2>/dev/null || true
    [ -d "$TEMP_DIR" ] && rm -rf "$TEMP_DIR"
    log_warning "Откат завершен. Директория установки сохранена: $INSTALL_DIR"
}

# Helper function
get_share_name_from_unit() {
	local unit_path="$SYSTEMD_USER_DIR/zrok.service"
	if [ ! -f "$unit_path" ]; then
		return 1
	fi
	log_debug "Попытка извлечь share name из systemd user юнита: $unit_path"
	local result=$(python3 - "$unit_path" <<'PY'
import sys, shlex
path = sys.argv[1]
try:
	with open(path, 'r') as f:
		for line in f:
			line = line.strip()
			if not line.startswith('ExecStart='):
				continue
			cmd = line.split('=', 1)[1].strip()
			parts = shlex.split(cmd)
			for idx, token in enumerate(parts):
				if token == 'reserved' and idx + 1 < len(parts):
					print(parts[idx + 1])
					raise SystemExit
except Exception:
	pass
PY
)
	log_debug "Результат из юнита: '${result:-пусто}'"
	[ -n "$result" ] && echo "$result"
}

# Removed find_zrok_share - we only check the systemd unit file for existing shares

create_zrok_share() {
    log_debug "=== Начало создания zrok share ==="
    
    # Generate random suffix
    log_debug "Генерация случайного суффикса..."
    local suffix=$(cat /dev/urandom | tr -dc 'a-z' | fold -w 7 | head -n1 || echo "default")
    log_debug "Сгенерированный суффикс: $suffix"
    
    local name="${ZROK_SHARE_PREFIX}${suffix}"
    log_info "  Попытка создать share: $name"
    log_debug "Полное имя share: $name"
    log_debug "Пользователь: $SERVICE_USER"
    log_debug "Префикс: $ZROK_SHARE_PREFIX"
    log_debug "HOME пользователя: $(eval echo ~"$SERVICE_USER")"
    
    # Check if zrok is working first
    log_debug "=== Проверка доступности zrok ==="
    log_debug "Выполнение: sudo -u $SERVICE_USER zrok version"
    log_info "  Проверка zrok..."
    
    local version_output=""
    local version_exit_code=0
    if version_output=$(timeout 5 zrok version 2>&1); then
        version_exit_code=0
    else
        version_exit_code=$?
    fi
    
    log_debug "zrok version код выхода: $version_exit_code"
    log_debug "zrok version вывод: $version_output"
    
    if [ $version_exit_code -ne 0 ]; then
        log_error "  zrok не отвечает. Проверьте установку zrok."
        log_debug "zrok version завершился с ошибкой (код: $version_exit_code)"
        return 1
    fi
    log_debug "zrok доступен, версия: $version_output"
    
    # Check zrok environment
    log_debug "=== Проверка zrok environment ==="
    local env_file="/home/$SERVICE_USER/.zrok/environment.json"
    log_debug "Путь к environment файлу: $env_file"
    
    if [ -f "$env_file" ]; then
        log_debug "Файл environment найден"
        log_debug "Размер файла: $(stat -c%s "$env_file" 2>/dev/null || echo "неизвестно") байт"
        log_debug "Права доступа: $(ls -l "$env_file" 2>/dev/null || echo "не удалось прочитать")"
        log_debug "Содержимое environment (первые 500 символов):"
        log_debug "$(head -c 500 "$env_file" 2>/dev/null || echo "не удалось прочитать")"
        
        # Try to parse JSON to check if it's valid
        log_debug "Проверка валидности JSON..."
        if python3 -c "import json; json.load(open('$env_file'))" 2>/dev/null; then
            log_debug "JSON валиден"
        else
            log_warning "  JSON в environment файле может быть поврежден"
        fi
    else
        log_debug "Файл environment не найден: $env_file"
        log_debug "Список файлов в директории: $(ls -la /home/$SERVICE_USER/.zrok/ 2>/dev/null || echo "директория не существует")"
    fi
    
    # Check network connectivity
    log_debug "=== Проверка сетевого подключения ==="
    if command -v ping &>/dev/null; then
        log_debug "Проверка доступности 8.8.8.8..."
        if ping -c 1 -W 2 8.8.8.8 &>/dev/null; then
            log_debug "Интернет доступен"
        else
            log_warning "  Проблемы с интернет-подключением"
        fi
    fi
    
    # Test zrok connectivity
    log_debug "=== Тест подключения к zrok API ==="
    log_debug "Попытка выполнить простую команду zrok..."
    local test_output=$(timeout 10 zrok reserve 2>&1 || echo "TIMEOUT_OR_ERROR")
    log_debug "Тестовая команда 'zrok reserve' вывод: $test_output"
    
    # Build the command
    local cmd="zrok reserve private 127.0.0.1:22 --backend-mode tcpTunnel --unique-name $name"
    log_debug "=== Подготовка к выполнению команды ==="
    log_debug "Полная команда: $cmd"
    log_debug "Команда будет выполнена как: sudo -u $SERVICE_USER $cmd"
    
    # Use shorter timeout (10 seconds like in web_interface.py) to prevent long hangs
    if command -v timeout &>/dev/null; then
        log_info "  Выполнение команды (таймаут 10 сек)..."
        log_debug "Используется timeout 10 секунд (как в web_interface.py)"
        log_debug "Начало выполнения команды: $(date '+%Y-%m-%d %H:%M:%S')"
        log_debug "PID процесса: $$"
        
        # Create temp file for output
        local output_file="/tmp/zrok_reserve_$$.log"
        log_debug "Вывод команды будет сохранен в: $output_file"
        
        # Run command with timeout and capture output in real-time
        log_debug "Запуск команды..."
        log_info "  Ожидание ответа от zrok API..."
        
        # Use shorter timeout - if it hangs, we'll skip and let user create manually
        local cmd_output=""
        local cmd_exit_code=0
        
        # Try to run with timeout
        if cmd_output=$(timeout 10 $cmd 2>&1); then
            cmd_exit_code=0
        else
            cmd_exit_code=$?
        fi
        
        log_debug "Команда завершена: $(date '+%Y-%m-%d %H:%M:%S')"
        log_debug "Код выхода: $cmd_exit_code"
        log_debug "=== Полный вывод команды ==="
        log_debug "$cmd_output"
        log_debug "=== Конец вывода ==="
        
        if [ $cmd_exit_code -eq 0 ]; then
            log_success "  Share создан успешно: $name"
            echo "$name"
        elif [ $cmd_exit_code -eq 124 ]; then
            log_warning "  Таймаут при создании share (команда зависла > 10 сек)"
            log_warning "  Это может означать проблемы с подключением к zrok API"
            log_debug "Последний вывод перед таймаутом: $cmd_output"
            log_info "  Пропуск автоматического создания share"
            log_info "  Share можно создать позже через веб-интерфейс"
            return 2  # Special exit code for timeout - non-fatal
        else
            # Check if it's a conflict (share already exists)
            if echo "$cmd_output" | grep -qiE "(already|409|conflict|exists)"; then
                log_warning "  Share с именем $name уже существует"
                log_debug "Вывод: $cmd_output"
                # Try to use this name anyway
                echo "$name"
            else
                log_warning "  Не удалось создать share (код ошибки: $cmd_exit_code)"
                log_debug "Полный вывод ошибки: $cmd_output"
                return 1
            fi
        fi
    else
        # Fallback without timeout - show output in real-time
        log_info "  Выполнение команды (без таймаута)..."
        log_warning "  ВНИМАНИЕ: timeout не доступен, команда может зависнуть!"
        log_debug "Команда: sudo -u $SERVICE_USER $cmd"
        log_debug "Начало выполнения команды: $(date '+%Y-%m-%d %H:%M:%S')"
        
        log_info "  Выполняется команда zrok reserve..."
        log_info "  (вывод команды будет показан ниже)"
        
        # Execute and show output in real-time
        if $cmd 2>&1 | tee /tmp/zrok_output_$$.log; then
            local cmd_exit_code=0
        else
            local cmd_exit_code=$?
        fi
        
        log_debug "Команда завершена: $(date '+%Y-%m-%d %H:%M:%S')"
        log_debug "Код выхода: $cmd_exit_code"
        
        local cmd_output=$(cat /tmp/zrok_output_$$.log 2>/dev/null || echo "")
        rm -f /tmp/zrok_output_$$.log
        
        if [ $cmd_exit_code -eq 0 ]; then
            log_success "  Share создан успешно: $name"
            echo "$name"
        else
            log_error "  Не удалось создать share (код ошибки: $cmd_exit_code)"
            log_debug "Полный вывод ошибки: $cmd_output"
            return 1
        fi
    fi
    log_debug "=== Конец создания zrok share ==="
}

# Package installation is now handled outside the script
# Users must install required packages manually with:
# sudo apt install python3 curl tar wget

trap 'error_exit "Неожиданная ошибка на строке $LINENO"' ERR

# Header
echo ""
echo "========================================"
echo "  Установщик Donkey"
echo "========================================"
if [ "$DEBUG" = "1" ]; then
    echo ""
    log_warning "РЕЖИМ ОТЛАДКИ ВКЛЮЧЕН"
    log_warning "Для включения: DEBUG=1 ./install.sh"
    echo ""
fi
echo ""

# Pre-flight checks
log_debug "=== Начало проверок ==="
log_debug "EUID: $EUID"
log_debug "USER: $USER"
log_debug "HOME: $HOME"
log_debug "SERVICE_USER: $SERVICE_USER"
log_debug "INSTALL_DIR: $INSTALL_DIR"
log_debug "TEMP_DIR: $TEMP_DIR"

[ "$EUID" -eq 0 ] && error_exit "Не запускайте этот скрипт от root. Используйте обычного пользователя."
log_debug "Пользователь: $SERVICE_USER"
log_debug "Домашняя директория: $SERVICE_USER_HOME"

log_info "Проверка совместимости системы..."
[ ! -f /etc/os-release ] && error_exit "Невозможно определить ОС"
. /etc/os-release
log_debug "OS ID: $ID"
log_debug "OS VERSION: $VERSION_ID"
log_debug "OS PRETTY_NAME: $PRETTY_NAME"

if [[ "$ID" != "raspbian" ]] && [[ "$ID" != "debian" ]] && [[ "$ID_LIKE" != *"debian"* ]]; then
    log_warning "Этот скрипт разработан для Raspberry Pi (Debian)."
    log_warning "Обнаружено: $PRETTY_NAME"
	if [ -t 0 ]; then
		read -p "Хотите продолжить? (y/N): " -n 1 -r
		echo
	else
		log_info "Неинтерактивный режим: продолжаем установку на неподдерживаемой ОС"
		REPLY="y"
	fi
	[[ ! $REPLY =~ ^[Yy]$ ]] && exit 0
else
    log_success "Совместимая система: $PRETTY_NAME"
fi

command -v apt &>/dev/null || error_exit "Менеджер пакетов apt не найден"
id "$SERVICE_USER" &>/dev/null || error_exit "Пользователь '$SERVICE_USER' не существует"
log_success "Проверки системы пройдены"

# Check system packages (user must install them manually if missing)
log_info "Проверка системных зависимостей..."
MISSING_PKGS=()
for pkg in python3 curl tar wget; do
    if ! dpkg -l | grep -q "^ii  $pkg "; then
        MISSING_PKGS+=("$pkg")
    fi
done

if [ ${#MISSING_PKGS[@]} -gt 0 ]; then
    log_error "Отсутствующие пакеты: ${MISSING_PKGS[*]}"
    log_error "Установите их командой: sudo apt install ${MISSING_PKGS[*]}"
    error_exit "Системные зависимости не установлены"
fi
log_success "Системные зависимости установлены"

# Install uv
log_info "Проверка установки uv..."
UV_BIN="$HOME/.local/bin/uv"
if [ -f "$UV_BIN" ]; then
    log_success "uv уже установлен ($($UV_BIN --version))"
elif command -v uv &>/dev/null; then
    UV_BIN="uv"
    log_success "uv уже установлен ($(uv --version))"
else
    log_info "Установка uv..."
    curl -LsSf https://astral.sh/uv/install.sh | sh || error_exit "Не удалось установить uv"
    [ ! -f "$UV_BIN" ] && error_exit "Установка uv не удалась"
    log_success "uv установлен успешно ($($UV_BIN --version))"
fi

# Ensure PATH includes .local/bin for zrok
export PATH="$SERVICE_USER_HOME/.local/bin:$PATH"

# Install zrok (user installation)
log_info "Установка zrok..."
if ! command -v zrok &>/dev/null; then
    log_info "Загрузка и установка zrok в ~/.local/bin..."
    mkdir -p "$SERVICE_USER_HOME/.local/bin"
    curl -sSfL "https://github.com/openziti/zrok/releases/download/v1.1.10/zrok_1.1.10_linux_arm64.tar.gz" | tar -xz -C "$SERVICE_USER_HOME/.local/bin" zrok || error_exit "Не удалось установить zrok"
    chmod +x "$SERVICE_USER_HOME/.local/bin/zrok"
    log_success "zrok установлен в $SERVICE_USER_HOME/.local/bin"
else
    log_success "zrok уже установлен ($(command -v zrok))"
fi

# Activate zrok
log_info "Активация zrok с API ключом..."
if [ ! -f "$SERVICE_USER_HOME/.zrok/environment.json" ]; then
	enable_output=$(zrok enable "$ZROK_API_KEY" 2>&1) || true
	
	# Check if already enabled
	if echo "$enable_output" | grep -qi "already have an enabled environment"; then
		log_info "zrok уже активирован, переактивация..."
		zrok disable
		enable_output=$(zrok enable "$ZROK_API_KEY" 2>&1) || true
		if echo "$enable_output" | grep -qi "error"; then
			log_warning "Не удалось переактивировать zrok"
			log_warning "Активируйте вручную: zrok enable <ваш_api_ключ>"
		else
			log_success "zrok переактивирован"
		fi
	elif echo "$enable_output" | grep -qi "401.*unauthorized"; then
		log_warning "Неверный API ключ zrok (401 Unauthorized)"
		log_warning "Проверьте API ключ в скрипте: $ZROK_API_KEY"
		log_warning "zrok можно активировать позже вручную: zrok enable <api_ключ>"
	elif echo "$enable_output" | grep -qi "error"; then
		log_warning "Не удалось активировать zrok"
		log_warning "Вывод: $enable_output"
		log_warning "zrok можно активировать позже вручную: zrok enable <api_ключ>"
	else
		log_success "zrok активирован"
	fi
else
	log_success "zrok уже активирован"
fi

log_info "Создание временной директории..."
mkdir -p "$TEMP_DIR" || error_exit "Не удалось создать временную директорию"
cd "$TEMP_DIR"

log_info "Загрузка проекта из $PROJECT_URL..."
if command -v wget &>/dev/null; then
    wget -O "$PROJECT_ARCHIVE" "$PROJECT_URL" || error_exit "Не удалось загрузить проект"
else
    curl -L -o "$PROJECT_ARCHIVE" "$PROJECT_URL" || error_exit "Не удалось загрузить проект"
fi
log_success "Проект загружен"

# Handle update vs new install
IS_UPDATE=false
EXISTING_SHARE_NAME=""
if [ -d "$INSTALL_DIR" ] && [ -f "$INSTALL_DIR/main.py" ]; then
    IS_UPDATE=true
    log_info "Обнаружена существующая установка - режим обновления"
    
    if [ -f "$SYSTEMD_USER_DIR/zrok.service" ]; then
        EXISTING_SHARE_NAME=$(get_share_name_from_unit || true)
        [ -n "$EXISTING_SHARE_NAME" ] && log_success "Сохранен существующий share name из юнита: $EXISTING_SHARE_NAME"
    fi
    
    log_info "Остановка сервисов..."
    systemctl --user stop pitstop.service zrok.service 2>/dev/null || true
    log_success "Сервисы остановлены"
    
    log_info "Резервное копирование баз данных..."
    BACKUP_TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    DB_BACKUP_PATH="$BACKUP_DIR/pitstop_db_$BACKUP_TIMESTAMP"
    mkdir -p "$DB_BACKUP_PATH"
    if compgen -G "$INSTALL_DIR/*.db" >/dev/null; then
        cp -v "$INSTALL_DIR/"*.db "$DB_BACKUP_PATH/" || log_warning "Не удалось скопировать некоторые базы данных"
        log_success "Базы данных сохранены в: $DB_BACKUP_PATH"
    fi
    
    [ -f "$INSTALL_DIR/config.json" ] && cp "$INSTALL_DIR/config.json" "$TEMP_DIR/config.json.backup"
else
    log_info "Новая установка"
    mkdir -p "$INSTALL_DIR" || error_exit "Не удалось создать директорию установки"
fi

# Если уже существует systemd юнит, используем share имя из него 
UNIT_SHARE_NAME=$(get_share_name_from_unit || true)
if [ -n "$UNIT_SHARE_NAME" ]; then
	log_success "Обнаружен share name в systemd юните: $UNIT_SHARE_NAME"
	EXISTING_SHARE_NAME="$UNIT_SHARE_NAME"
fi

log_info "Определение имени zrok share..."
log_debug "=== Начало определения zrok share name ==="
ZROK_SHARE_NAME=""

if [ -n "${EXISTING_SHARE_NAME:-}" ]; then
	ZROK_SHARE_NAME="$EXISTING_SHARE_NAME"
	log_success "Используется существующий share: $ZROK_SHARE_NAME"
else
	log_info "Создание нового zrok share..."
	suffix="$(date +%s)$RANDOM"
	ZROK_SHARE_NAME="${ZROK_SHARE_PREFIX}${suffix: -7}"
	log_debug "Сгенерировано имя share: $ZROK_SHARE_NAME"
	log_debug "Выполнение: zrok reserve private 127.0.0.1:22 --backend-mode tcpTunnel --unique-name $ZROK_SHARE_NAME"
	
	reserve_output=""
	if reserve_output=$(zrok reserve private 127.0.0.1:22 --backend-mode tcpTunnel --unique-name "$ZROK_SHARE_NAME" 2>&1); then
		log_success "Share зарезервирован: $ZROK_SHARE_NAME"
		log_debug "Вывод zrok reserve: $reserve_output"
	else
		log_debug "Вывод zrok reserve: $reserve_output"
		
		# Check if it's 401 Unauthorized - means stale token
		if echo "$reserve_output" | grep -qi "401.*unauthorized"; then
			log_warning "Обнаружена устаревшая сессия zrok (401 Unauthorized)"
			log_info "Переактивация zrok..."
			
			# Disable and re-enable
			zrok disable 2>/dev/null || true
			sleep 1
			
			if ! enable_zrok; then
				log_error "Не удалось переактивировать zrok"
				error_exit "Переактивация zrok не удалась"
			fi
			
			# Retry share creation
			log_info "Повторная попытка создать share..."
			if reserve_output=$(zrok reserve private 127.0.0.1:22 --backend-mode tcpTunnel --unique-name "$ZROK_SHARE_NAME" 2>&1); then
				log_success "Share зарезервирован после переактивации: $ZROK_SHARE_NAME"
				log_debug "Вывод zrok reserve: $reserve_output"
			else
				log_error "Вывод zrok reserve: $reserve_output"
				error_exit "Не удалось создать zrok share после переактивации"
			fi
		else
			log_error "Вывод zrok reserve: $reserve_output"
			log_error "Не удалось зарезервировать share. Возможные причины:"
			log_error "  1. Имя share уже занято"
			log_error "  2. Проблемы с подключением к zrok API"
			log_error "  3. Неверный API ключ"
			error_exit "Не удалось создать zrok share"
		fi
	fi
fi

log_debug "Финальный ZROK_SHARE_NAME: $ZROK_SHARE_NAME"
log_debug "=== Конец определения zrok share name ==="

# Determine final share name to use for services/config
SHARE_NAME_TO_USE="$ZROK_SHARE_NAME"
log_debug "SHARE_NAME_TO_USE: '${SHARE_NAME_TO_USE:-пусто}'"

ZROK_BIN=$(command -v zrok || true)
if [ -z "$ZROK_BIN" ]; then
	error_exit "Команда zrok не найдена после установки"
fi
log_debug "Путь к zrok: $ZROK_BIN"

# Extract archive
log_info "Распаковка архива..."
mkdir -p "$INSTALL_DIR"
tar -xzf "$PROJECT_ARCHIVE" -C "$INSTALL_DIR" || error_exit "Не удалось распаковать архив"
log_success "Архив распакован"

# Restore config if update
[ "$IS_UPDATE" = true ] && [ -f "$TEMP_DIR/config.json.backup" ] && \
    cp "$TEMP_DIR/config.json.backup" "$INSTALL_DIR/config.json" && \
    log_success "config.json восстановлен"

# Files are already owned by the user running the script

# Remove old venv if updating
[ "$IS_UPDATE" = true ] && [ -d "$INSTALL_DIR/.venv" ] && \
    rm -rf "$INSTALL_DIR/.venv" && \
    log_success "Старое виртуальное окружение удалено"

# Create venv and install dependencies
log_info "Создание виртуального окружения Python с uv..."
cd "$INSTALL_DIR"
SERVICE_USER_HOME=$(eval echo ~"$SERVICE_USER")
SERVICE_UV_BIN="$SERVICE_USER_HOME/.local/bin/uv"
"$SERVICE_UV_BIN" venv || error_exit "Не удалось создать виртуальное окружение"
log_success "Виртуальное окружение создано"

log_info "Установка зависимостей Python с uv..."
if [ -f "$INSTALL_DIR/requirements.txt" ]; then
	log_info "Обнаружен requirements.txt — установка зависимостей из него"
	"$SERVICE_UV_BIN" pip install --no-cache -r "$INSTALL_DIR/requirements.txt" || error_exit "Не удалось установить зависимости из requirements.txt"
elif [ -f "$INSTALL_DIR/pyproject.toml" ]; then
	log_info "requirements.txt не найден — попытка установки через pyproject.toml (editable)"
	if "$SERVICE_UV_BIN" pip install --no-cache -e .; then
		log_success "Зависимости установлены через pyproject.toml"
	else
		log_error "Установка через pyproject.toml не удалась"
		error_exit "Не удалось установить зависимости (pyproject.toml). Добавьте requirements.txt или исправьте конфигурацию пакета."
	fi
else
	error_exit "Не найден ни requirements.txt, ни pyproject.toml"
fi
log_success "Зависимости Python установлены"

# All files are owned by the user since we're not using sudo

# Clean up Python cache files to save space
log_info "Очистка кэша Python..."
find "$INSTALL_DIR/.venv" -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null || true
find "$INSTALL_DIR" -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null || true
find "$INSTALL_DIR/.venv" -name "*.pyc" -delete 2>/dev/null || true
log_success "Кэш Python очищен"

# Remove non-production files to save space
log_info "Удаление ненужных файлов для production..."
rm -rf "$INSTALL_DIR/docs" "$INSTALL_DIR/tests" "$INSTALL_DIR/qrcodes" 2>/dev/null || true
log_success "Ненужные файлы удалены"

# Enable lingering for user (so services start at boot without login)
log_info "Включение user lingering для $SERVICE_USER..."
if loginctl show-user "$SERVICE_USER" -p Linger 2>/dev/null | grep -q "Linger=yes"; then
	log_success "User lingering уже включен"
else
	sudo loginctl enable-linger "$SERVICE_USER" || log_warning "Не удалось включить user lingering"
	log_success "User lingering включен"
fi

# Add user to gpio group if not already a member
if [ -n "$(groups "$SERVICE_USER" | grep -w gpio)" ]; then
	log_success "Пользователь $SERVICE_USER уже в группе gpio"
else
	log_info "Добавление $SERVICE_USER в группу gpio..."
	if getent group gpio &>/dev/null; then
		sudo usermod -a -G gpio "$SERVICE_USER" || log_warning "Не удалось добавить пользователя в группу gpio"
		log_success "Пользователь добавлен в группу gpio"
	else
		log_info "Группа gpio не существует, создаю..."
		if sudo groupadd gpio 2>/dev/null; then
			log_success "Группа gpio создана"
			sudo usermod -a -G gpio "$SERVICE_USER" || log_warning "Не удалось добавить пользователя в группу gpio"
			log_success "Пользователь добавлен в группу gpio"
		else
			log_warning "Не удалось создать группу gpio. Функциональность GPIO может быть ограничена."
		fi
	fi
fi

# Create systemd user directory
mkdir -p "$SYSTEMD_USER_DIR" || error_exit "Не удалось создать директорию $SYSTEMD_USER_DIR"

# Create systemd services
log_info "Установка systemd сервисов..."

tee "$SYSTEMD_USER_DIR/pitstop.service" >/dev/null <<EOF
[Unit]
Description=Donkey Pitstop Application
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=$INSTALL_DIR
Environment="PATH=$SERVICE_USER_HOME/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
ExecStart=$SERVICE_USER_HOME/.local/bin/uv run --python $INSTALL_DIR/.venv/bin/python $INSTALL_DIR/main.py
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
EOF
log_success "  pitstop.service создан"

tee "$SYSTEMD_USER_DIR/zrok.service" >/dev/null <<EOF
[Unit]
Description=Zrok Share - SSH Tunnel
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=$INSTALL_DIR
ExecStart=$ZROK_BIN share reserved $SHARE_NAME_TO_USE --headless
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
EOF
log_success "  zrok.service создан"

# Configure zrok mode in config.json (share name is managed by systemd unit only)
log_info "Настройка zrok mode в config.json..."
python3 <<EOF
import json
import os

config_path = "$INSTALL_DIR/config.json"

config = {}
if os.path.exists(config_path):
    with open(config_path) as f:
        config = json.load(f)

config.setdefault('zrok', {})
config['zrok']['mode'] = 'systemd'

with open(config_path, 'w') as f:
    json.dump(config, f, indent=4)
EOF
log_success "  Zrok mode установлен в config.json (share name управляется только юнитом)"

# Set permissions
[ -f "$INSTALL_DIR/zrok_wrapper.py" ] && chmod +x "$INSTALL_DIR/zrok_wrapper.py"

# Enable services
log_info "Перезагрузка демона systemd..."
systemctl --user daemon-reload || error_exit "Не удалось перезагрузить демон systemd"
log_success "systemd перезагружен"

log_info "Включение сервисов..."
systemctl --user enable pitstop.service || error_exit "Не удалось включить сервисы"
systemctl --user disable zrok.service 2>/dev/null || true
log_success "Сервисы настроены (zrok отключен по умолчанию)"

# Cleanup
log_info "Очистка временных файлов..."
rm -rf "$TEMP_DIR"
log_success "Временные файлы удалены"

# Start services
echo ""
if [ -t 0 ]; then
	read -p "Запустить сервисы сейчас? (Y/n): " -n 1 -r
	echo
else
	REPLY="y"
fi
if [[ ! $REPLY =~ ^[Nn]$ ]]; then
    log_info "Запуск сервисов..."
    systemctl --user start pitstop.service || log_error "Не удалось запустить pitstop.service"
    sleep 2
    systemctl is-active --quiet pitstop.service && log_success "pitstop.service запущен" || \
        log_error "pitstop.service не запустился. Проверьте логи: journalctl --user -u pitstop.service -n 50"
    log_info "zrok.service не запущен (отключен по умолчанию)"
else
    log_info "Сервисы не запущены. Запустите вручную:"
    log_info "  systemctl --user start pitstop.service"
fi

# Final message
echo ""
echo "========================================"
echo "  $([ "$IS_UPDATE" = true ] && echo "Обновление" || echo "Установка") завершено!"
echo "========================================"
echo ""
log_success "Donkey успешно $([ "$IS_UPDATE" = true ] && echo "обновлен" || echo "установлен")!"
[ -n "${DB_BACKUP_PATH:-}" ] && echo "" && echo "Резервные копии БД: $DB_BACKUP_PATH"
echo ""
echo "Директория установки: $INSTALL_DIR"
echo "Файл конфигурации: $INSTALL_DIR/config.json"
echo "Директория бэкапов: $BACKUP_DIR"
echo ""
echo "Управление сервисом:"
echo "  Запуск:    systemctl --user start pitstop.service"
echo "  Остановка: systemctl --user stop pitstop.service"
echo "  Перезапуск: systemctl --user restart pitstop.service"
echo "  Статус:    systemctl --user status pitstop.service"
echo "  Логи:      journalctl --user -u pitstop.service -f"
echo ""
echo "Zrok: $ZROK_SHARE_NAME"
echo ""

LOCAL_IP=$(ip -4 addr show | grep -oP '(?<=inet\s)\d+(\.\d+){3}' | grep -v '^127\.' | head -n1)

echo "Веб-интерфейс: http://$LOCAL_IP:8080"

echo ""
log_info "Установка завершена успешно!"