pve9-repo-fix/RDP/proxmox-auto-rdp-setup.sh

#!/bin/bash

# Proxmox Auto RDP Setup Script
# 자동으로 Proxmox 호스트를 RDP VM에 연결하는 설정을 수행합니다
# 사용법: bash -c "$(curl -fsSL [스크립트 URL])"

set -euo pipefail

# 색상 코드 정의
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# 로그 함수들
msg_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

msg_ok() {
    echo -e "${GREEN}[OK]${NC} $1"
}

msg_error() {
    echo -e "${RED}[ERROR]${NC} $1"
    exit 1
}

msg_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

# 헤더 출력
print_header() {
    clear
    echo -e "${PURPLE}"
    echo "═══════════════════════════════════════════════════════════════════"
    echo "           Proxmox Auto RDP Setup Script v1.0"
    echo "═══════════════════════════════════════════════════════════════════"
    echo -e "${NC}"
    echo "이 스크립트는 Proxmox VE 호스트가 부팅 시 자동으로 RDP 연결하도록 설정합니다."
    echo ""
}

# Proxmox 버전 확인
check_proxmox_version() {
    msg_info "Proxmox VE 버전 확인 중..."

    # pveversion 명령어 확인
    if ! command -v pveversion > /dev/null 2>&1; then
        msg_warn "pveversion 명령을 찾을 수 없습니다. 버전 확인을 건너뜁니다."
        return 0
    fi

    # 버전 추출 (여러 형식 지원)
    local pve_version=$(pveversion 2>/dev/null | head -n1 | grep -oP '\d+\.\d+' | head -n1 | cut -d'.' -f1)

    # 버전 번호를 추출할 수 없으면 경고만 하고 계속 진행
    if [ -z "$pve_version" ]; then
        msg_warn "Proxmox VE 버전을 확인할 수 없습니다. 계속 진행합니다."
        return 0
    fi

    # 숫자인지 확인
    if ! [[ "$pve_version" =~ ^[0-9]+$ ]]; then
        msg_warn "Proxmox VE 버전 형식이 올바르지 않습니다 ($pve_version). 계속 진행합니다."
        return 0
    fi

    msg_ok "Proxmox VE $pve_version.x 버전 확인됨"
}

# IP 주소 가져오기 (Headscale 우선, 없으면 로컬 IP)
get_primary_ip() {
    # Headscale VPN IP 확인 (100.64.x.x 대역)
    local headscale_ip=$(hostname -I | tr ' ' '\n' | grep '^100\.64\.' | head -n1)

    if [ -n "$headscale_ip" ]; then
        echo "$headscale_ip"
        return 0
    fi

    # Headscale IP가 없으면 로컬 IP (첫 번째)
    local local_ip=$(hostname -I | awk '{print $1}')

    if [ -n "$local_ip" ]; then
        echo "$local_ip"
        return 0
    fi

    # 그것도 없으면 localhost
    echo "127.0.0.1"
}

# 루트 권한 확인
check_root() {
    if [ "$EUID" -ne 0 ]; then
        msg_error "이 스크립트는 root 권한으로 실행해야 합니다. sudo를 사용하세요."
    fi
}

# 입력 검증 함수
validate_rdp_server() {
    local server="$1"
    
    # 기본적인 형식 검증 (호스트:포트 또는 호스트만)
    if [[ ! "$server" =~ ^[a-zA-Z0-9.-]+(:([0-9]{1,5}))?$ ]]; then
        return 1
    fi
    
    # 포트 범위 검증
    if [[ "$server" =~ :([0-9]+)$ ]]; then
        local port="${BASH_REMATCH[1]}"
        if [ "$port" -lt 1 ] || [ "$port" -gt 65535 ]; then
            return 1
        fi
    fi
    
    return 0
}

validate_username() {
    local username="$1"
    
    # 사용자명 길이 및 문자 검증
    if [ ${#username} -lt 1 ] || [ ${#username} -gt 32 ]; then
        return 1
    fi
    
    # 허용된 문자만 포함 확인
    if [[ ! "$username" =~ ^[a-zA-Z0-9._-]+$ ]]; then
        return 1
    fi
    
    return 0
}

# 사용자 입력 받기
get_user_input() {
    echo -e "${CYAN}RDP 연결 정보를 입력해주세요:${NC}"
    echo ""
    
    # RDP 서버 정보 (검증 포함)
    while true; do
        read -p "RDP 서버 주소 (예: example.com:3389): " RDP_SERVER </dev/tty
        if [ -z "$RDP_SERVER" ]; then
            msg_error "RDP 서버 주소는 필수입니다."
        elif ! validate_rdp_server "$RDP_SERVER"; then
            msg_warn "잘못된 서버 주소 형식입니다. 다시 입력해주세요."
            echo "  예시: example.com 또는 example.com:3389"
            continue
        else
            break
        fi
    done

    # 사용자명 (검증 포함)
    while true; do
        read -p "RDP 사용자명: " RDP_USERNAME </dev/tty
        if [ -z "$RDP_USERNAME" ]; then
            msg_error "RDP 사용자명은 필수입니다."
        elif ! validate_username "$RDP_USERNAME"; then
            msg_warn "잘못된 사용자명 형식입니다. 영문, 숫자, ., _, - 만 사용 가능합니다."
            continue
        else
            break
        fi
    done

    # 패스워드 (재확인 포함)
    while true; do
        echo -n "RDP 패스워드: "
        read -s RDP_PASSWORD </dev/tty
        echo ""
        if [ -z "$RDP_PASSWORD" ]; then
            msg_error "RDP 패스워드는 필수입니다."
        fi

        echo -n "패스워드 확인: "
        read -s password_confirm </dev/tty
        echo ""

        if [ "$RDP_PASSWORD" != "$password_confirm" ]; then
            msg_warn "패스워드가 일치하지 않습니다. 다시 입력해주세요."
            continue
        else
            break
        fi
    done

    # 로컬 사용자명 (선택사항, 검증 포함)
    while true; do
        read -p "로컬 사용자명 [rdpuser]: " LOCAL_USER </dev/tty
        LOCAL_USER=${LOCAL_USER:-rdpuser}

        if ! validate_username "$LOCAL_USER"; then
            msg_warn "잘못된 로컬 사용자명 형식입니다. 영문, 숫자, ., _, - 만 사용 가능합니다."
            continue
        else
            break
        fi
    done
    
    echo ""
    echo -e "${YELLOW}입력된 정보:${NC}"
    echo "  RDP 서버: $RDP_SERVER"
    echo "  RDP 사용자: $RDP_USERNAME"
    echo "  로컬 사용자: $LOCAL_USER"
    echo ""
    
    # 최종 확인
    local attempts=0
    while [ $attempts -lt 3 ]; do
        read -p "설정을 계속하시겠습니까? [y/N]: " confirm </dev/tty
        case $confirm in
            [yY]|[yY][eE][sS])
                return 0
                ;;
            [nN]|[nN][oO]|"")
                msg_error "설정이 취소되었습니다."
                ;;
            *)
                msg_warn "y 또는 n으로 답해주세요."
                ((attempts++))
                ;;
        esac
    done

    msg_error "너무 많은 잘못된 입력으로 설정이 취소되었습니다."
}

# 백업 생성
create_backup() {
    msg_info "기존 설정 백업 중..."
    
    local backup_dir="/root/proxmox-rdp-backup-$(date +%Y%m%d-%H%M%S)"
    mkdir -p "$backup_dir"
    
    # 기존 설정 백업
    if [ -f /etc/systemd/system/getty@tty1.service.d/override.conf ]; then
        cp -r /etc/systemd/system/getty@tty1.service.d "$backup_dir/" 2>/dev/null || true
    fi
    
    if id "$LOCAL_USER" &>/dev/null; then
        cp -r "/home/$LOCAL_USER" "$backup_dir/home-$LOCAL_USER" 2>/dev/null || true
    fi
    
    msg_ok "백업 완료: $backup_dir"
}

# 네트워크 연결 확인
check_network() {
    msg_info "네트워크 연결 확인 중..."
    
    # 인터넷 연결 확인
    if ! ping -c 1 -W 5 8.8.8.8 > /dev/null 2>&1; then
        msg_error "인터넷 연결을 확인할 수 없습니다. 네트워크 설정을 확인해주세요."
    fi
    
    # RDP 서버 연결 확인
    local server_host="${RDP_SERVER%:*}"
    local server_port="${RDP_SERVER#*:}"
    
    # 포트가 지정되지 않았으면 기본값 3389 사용
    if [ "$server_port" = "$server_host" ]; then
        server_port="3389"
    fi
    
    msg_info "RDP 서버 연결 확인 중... ($server_host:$server_port)"
    
    if command -v timeout > /dev/null; then
        if ! timeout 10 bash -c "</dev/tcp/$server_host/$server_port" > /dev/null 2>&1; then
            msg_warn "RDP 서버에 연결할 수 없습니다. 서버 주소와 포트를 확인해주세요."
            read -p "계속 진행하시겠습니까? [y/N]: " continue_anyway </dev/tty
            case $continue_anyway in
                [yY]|[yY][eE][sS]) ;;
                *) msg_error "설정이 취소되었습니다." ;;
            esac
        else
            msg_ok "RDP 서버 연결 확인됨"
        fi
    else
        msg_warn "연결 테스트를 건너뜁니다 (timeout 명령어 없음)"
    fi
}

# 필수 패키지 설치
install_packages() {
    msg_info "필수 패키지 설치 중..."
    
    # 패키지 목록 업데이트
    msg_info "  - 패키지 목록 업데이트 중..."
    if ! apt update > /dev/null 2>&1; then
        msg_error "패키지 목록 업데이트에 실패했습니다."
    fi
    
    # 필수 패키지들
    local packages="xorg openbox unclutter freerdp3-x11"
    
    for package in $packages; do
        msg_info "  - $package 설치 중..."
        
        # 패키지가 이미 설치되어 있는지 확인
        if dpkg -l | grep -q "^ii  $package "; then
            msg_ok "    $package 이미 설치됨"
            continue
        fi
        
        # 패키지 설치 시도
        local retry_count=0
        while [ $retry_count -lt 3 ]; do
            if apt install -y "$package" > /dev/null 2>&1; then
                msg_ok "    $package 설치 완료"
                break
            else
                ((retry_count++))
                if [ $retry_count -lt 3 ]; then
                    msg_warn "    $package 설치 실패, 재시도 중... ($retry_count/3)"
                    sleep 2
                else
                    msg_error "$package 설치에 실패했습니다. 네트워크 연결이나 패키지 저장소를 확인해주세요."
                fi
            fi
        done
    done
    
    # 설치 확인 (실제 명령어 존재 여부로 확인)
    msg_info "설치된 패키지 확인 중..."

    # 각 패키지의 주요 실행 파일 확인
    local check_commands="startx openbox xfreerdp3 unclutter"
    local all_ok=true

    for cmd in $check_commands; do
        if command -v "$cmd" > /dev/null 2>&1; then
            msg_ok "  $cmd 설치 확인됨"
        else
            msg_warn "  $cmd를 찾을 수 없습니다"
            all_ok=false
        fi
    done

    if [ "$all_ok" = false ]; then
        msg_warn "일부 패키지가 정상적으로 설치되지 않았을 수 있습니다. 계속 진행합니다."
    else
        msg_ok "모든 패키지 설치 완료"
    fi
}

# 사용자 계정 생성
setup_user() {
    msg_info "사용자 계정 설정 중..."
    
    if ! id "$LOCAL_USER" &>/dev/null; then
        useradd -m -s /bin/bash "$LOCAL_USER"
        msg_ok "사용자 '$LOCAL_USER' 생성됨"
    else
        msg_warn "사용자 '$LOCAL_USER'가 이미 존재합니다."
    fi
    
    # 홈 디렉토리 권한 설정
    chown -R "$LOCAL_USER:$LOCAL_USER" "/home/$LOCAL_USER"
}

# 자동 로그인 설정
setup_autologin() {
    msg_info "자동 로그인 설정 중..."
    
    # getty@tty1 서비스 override 디렉토리 생성
    mkdir -p /etc/systemd/system/getty@tty1.service.d
    
    # override.conf 파일 생성
    cat > /etc/systemd/system/getty@tty1.service.d/override.conf << EOF
[Service]
ExecStart=
ExecStart=-/sbin/agetty --autologin $LOCAL_USER --noclear %I \$TERM
Type=idle
EOF
    
    # systemd 리로드
    systemctl daemon-reload
    
    msg_ok "자동 로그인 설정 완료"
}

# X 자동 시작 설정
setup_x_autostart() {
    msg_info "X Window 자동 시작 설정 중..."
    
    # .bash_profile 생성
    cat > "/home/$LOCAL_USER/.bash_profile" << 'EOF'
# tty1에서만 X 자동 시작
if [[ -z $DISPLAY ]] && [[ $(tty) == /dev/tty1 ]]; then
    startx
    logout
fi
EOF
    
    chown "$LOCAL_USER:$LOCAL_USER" "/home/$LOCAL_USER/.bash_profile"
    
    msg_ok "X Window 자동 시작 설정 완료"
}

# RDP 연결 설정
setup_rdp_connection() {
    msg_info "RDP 연결 설정 중..."
    
    # .xinitrc 파일 생성
    cat > "/home/$LOCAL_USER/.xinitrc" << EOF
#!/bin/bash

# 화면 절전 모드 비활성화
xset -dpms
xset s off
xset s noblank

# 마우스 커서 숨기기
unclutter -idle 0.1 -root &

# Openbox 윈도우 매니저 시작
openbox-session &

# 잠시 대기 (X 완전 초기화)
sleep 2

# FreeRDP3를 사용한 직접 RDP 연결 (풀스크린)
xfreerdp3 \\
    /v:$RDP_SERVER \\
    /u:$RDP_USERNAME \\
    /p:"$RDP_PASSWORD" \\
    +f \\
    /cert:ignore \\
    +dynamic-resolution \\
    /sound:sys:alsa \\
    +clipboard

# RDP 종료 시 X 세션도 종료
pkill -SIGTERM Xorg
EOF
    
    # 실행 권한 및 소유권 설정
    chmod +x "/home/$LOCAL_USER/.xinitrc"
    chown "$LOCAL_USER:$LOCAL_USER" "/home/$LOCAL_USER/.xinitrc"
    
    msg_ok "RDP 연결 설정 완료"
}

# Openbox 설정
setup_openbox() {
    msg_info "Openbox 윈도우 매니저 설정 중..."
    
    # Openbox 설정 디렉토리 생성
    mkdir -p "/home/$LOCAL_USER/.config/openbox"
    
    # rc.xml 설정 파일 생성
    cat > "/home/$LOCAL_USER/.config/openbox/rc.xml" << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<openbox_config xmlns="http://openbox.org/3.4/rc">
  <applications>
    <application class="*">
      <decor>no</decor>
      <maximized>yes</maximized>
    </application>
  </applications>
</openbox_config>
EOF
    
    # 소유권 설정
    chown -R "$LOCAL_USER:$LOCAL_USER" "/home/$LOCAL_USER/.config"
    
    msg_ok "Openbox 설정 완료"
}

# RDP Toggle API 설치
install_rdp_api() {
    msg_info "RDP Toggle API 설치 중..."

    local INSTALL_DIR="/opt/rdp-toggle-api"
    local VENV_DIR="$INSTALL_DIR/venv"
    local GITEA_BASE_URL="https://git.0bin.in/thug0bin/pve9-repo-fix/raw/branch/main/RDP"

    # Python 및 venv 설치
    msg_info "Python 및 필수 패키지 설치 중..."
    apt install -y python3 python3-venv python3-pip curl > /dev/null 2>&1

    # 설치 디렉토리 생성
    mkdir -p "$INSTALL_DIR"

    # 가상환경 생성
    msg_info "Python 가상환경 생성 중..."
    python3 -m venv "$VENV_DIR"

    # 가상환경에서 패키지 설치
    msg_info "FastAPI 패키지 설치 중..."
    "$VENV_DIR/bin/pip" install --upgrade pip > /dev/null 2>&1
    "$VENV_DIR/bin/pip" install fastapi==0.115.5 uvicorn==0.32.1 python-multipart==0.0.20 pydantic==2.10.3 > /dev/null 2>&1

    # API 파일 다운로드
    msg_info "API 서버 파일 다운로드 중..."
    curl -fsSL "$GITEA_BASE_URL/rdp-toggle-api.py" -o "$INSTALL_DIR/rdp-toggle-api.py"
    chmod +x "$INSTALL_DIR/rdp-toggle-api.py"

    # systemd 서비스 생성
    msg_info "systemd 서비스 생성 중..."
    cat > /etc/systemd/system/rdp-toggle-api.service << EOF
[Unit]
Description=RDP Toggle API Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=$INSTALL_DIR
ExecStart=$VENV_DIR/bin/python $INSTALL_DIR/rdp-toggle-api.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

    # RDP 설정을 API에 저장
    msg_info "RDP 설정 저장 중..."
    mkdir -p /var/lib/rdp-toggle
    cat > /var/lib/rdp-toggle/config.json << EOF
{
    "rdp_server": "$RDP_SERVER",
    "rdp_username": "$RDP_USERNAME",
    "rdp_password": "$RDP_PASSWORD",
    "local_user": "$LOCAL_USER"
}
EOF

    # 서비스 활성화 및 시작
    msg_info "API 서비스 활성화 및 시작 중..."
    systemctl daemon-reload
    systemctl enable rdp-toggle-api.service > /dev/null 2>&1
    systemctl start rdp-toggle-api.service

    # API 서비스 시작 대기
    sleep 3

    # API 서비스 확인
    if systemctl is-active rdp-toggle-api.service > /dev/null 2>&1; then
        msg_ok "RDP Toggle API 설치 완료 (포트 8090)"
        return 0
    else
        msg_warn "API 서비스가 정상적으로 시작되지 않았습니다."
        return 1
    fi
}

# 설정 테스트
test_configuration() {
    msg_info "설정 테스트 중..."

    # systemd 서비스 상태 확인
    if systemctl is-enabled getty@tty1.service > /dev/null 2>&1; then
        msg_ok "getty@tty1 서비스가 활성화되어 있습니다."
    else
        msg_warn "getty@tty1 서비스가 비활성화되어 있습니다."
    fi

    # 필수 파일들 존재 확인
    local files=(
        "/etc/systemd/system/getty@tty1.service.d/override.conf"
        "/home/$LOCAL_USER/.bash_profile"
        "/home/$LOCAL_USER/.xinitrc"
        "/home/$LOCAL_USER/.config/openbox/rc.xml"
    )

    for file in "${files[@]}"; do
        if [ -f "$file" ]; then
            msg_ok "설정 파일 존재: $file"
        else
            msg_error "설정 파일 누락: $file"
        fi
    done

    # FreeRDP3 설치 확인
    if command -v xfreerdp3 > /dev/null 2>&1; then
        msg_ok "FreeRDP3 설치 확인됨"
    else
        msg_error "FreeRDP3가 설치되어 있지 않습니다."
    fi
}

# 완료 메시지
print_completion() {
    echo ""
    echo -e "${GREEN}═══════════════════════════════════════════════════════════════════${NC}"
    echo -e "${GREEN}                    설정이 완료되었습니다!${NC}"
    echo -e "${GREEN}═══════════════════════════════════════════════════════════════════${NC}"
    echo ""
    echo -e "${CYAN}설정 요약:${NC}"
    echo "  - RDP 서버: $RDP_SERVER"
    echo "  - RDP 사용자: $RDP_USERNAME"
    echo "  - 로컬 사용자: $LOCAL_USER"
    echo "  - 자동 로그인: 활성화됨 (tty1)"
    echo "  - 풀스크린 RDP: 활성화됨"
    echo "  - RDP Toggle API: 설치됨 (포트 8090)"
    echo ""
    echo -e "${YELLOW}다음 단계:${NC}"
    echo "  1. RDP 연결을 활성화하세요 (즉시 적용 또는 재부팅)"
    echo "  2. 자동으로 RDP 연결이 시작됩니다"
    echo "  3. 문제 발생 시 Ctrl+Alt+F2로 다른 터미널에 접근 가능합니다"
    echo ""
    echo -e "${CYAN}RDP 연결을 어떻게 활성화하시겠습니까?${NC}"
    echo "  1) 즉시 적용 (getty@tty1 서비스 재시작, 권장)"
    echo "  2) 시스템 재부팅"
    echo "  3) 나중에 수동으로 적용"
    echo ""
    echo -n "선택 [1/2/3]: "
    read -r apply_choice </dev/tty

    case $apply_choice in
        1)
            msg_info "API를 통해 RDP 모드로 전환합니다..."
            systemctl daemon-reload
            sleep 1

            # API를 통해 RDP 모드 활성화
            local api_response=$(curl -s -X POST http://localhost:8090/toggle \
                -H 'Content-Type: application/json' \
                -d '{"mode":"rdp"}' 2>/dev/null)

            if echo "$api_response" | grep -q '"status":"success"'; then
                echo ""
                echo -e "${GREEN}✅ RDP 모드가 API를 통해 활성화되었습니다!${NC}"
                echo ""
                echo -e "${YELLOW}참고:${NC}"
                echo "  - 물리 모니터(tty1)에서 RDP 연결이 시작됩니다"
                echo "  - SSH 세션은 계속 사용 가능합니다"
                echo "  - RDP Toggle API: http://$(get_primary_ip):8090"
                echo ""
                echo -e "${CYAN}API 사용 예시:${NC}"
                echo "  Shell 모드로 전환: curl -X POST http://localhost:8090/toggle -H 'Content-Type: application/json' -d '{\"mode\":\"shell\"}'"
                echo "  상태 확인: curl http://localhost:8090/status"
                echo ""
            else
                msg_warn "API를 통한 RDP 활성화에 실패했습니다. 수동으로 활성화합니다..."
                systemctl restart getty@tty1.service
                sleep 1
                echo ""
                echo -e "${GREEN}✅ RDP 연결이 tty1에서 활성화되었습니다!${NC}"
                echo ""
            fi
            ;;
        2)
            msg_info "시스템을 재부팅합니다..."
            sleep 2
            reboot
            ;;
        *)
            echo ""
            echo -e "${GREEN}설정이 완료되었습니다.${NC}"
            echo ""
            echo -e "${YELLOW}수동 적용 방법:${NC}"
            echo "  API로 RDP 활성화: curl -X POST http://localhost:8090/toggle -H 'Content-Type: application/json' -d '{\"mode\":\"rdp\"}'"
            echo "  또는 직접 활성화: systemctl daemon-reload && systemctl restart getty@tty1"
            echo "  또는 재부팅: reboot"
            echo ""
            ;;
    esac
}

# RDP 토글 테스트 메뉴
show_rdp_toggle_menu() {
    while true; do
        echo ""
        echo "=========================================="
        echo "RDP 제어 메뉴"
        echo "  1) RDP 모드로 전환"
        echo "  2) Shell 모드로 전환"
        echo "  3) 현재 상태 확인"
        echo "  4) 종료"
        echo ""
        echo -n "선택 [1/2/3/4]: "
        read -r choice </dev/tty

        case "$choice" in
            1)
                echo ""
                msg_info "RDP 모드로 전환 중..."
                if curl -s -X POST http://localhost:8090/toggle \
                    -H 'Content-Type: application/json' \
                    -d '{"mode":"rdp"}' > /dev/null 2>&1; then
                    msg_ok "RDP 모드로 전환 완료!"
                    echo ""
                    echo "현재 상태:"
                    curl -s http://localhost:8090/status | python3 -m json.tool 2>/dev/null || curl -s http://localhost:8090/status
                else
                    msg_error "RDP 모드 전환 실패. 서비스 상태를 확인하세요: systemctl status rdp-toggle-api"
                fi
                ;;
            2)
                echo ""
                msg_info "Shell 모드로 전환 중..."
                if curl -s -X POST http://localhost:8090/toggle \
                    -H 'Content-Type: application/json' \
                    -d '{"mode":"shell"}' > /dev/null 2>&1; then
                    msg_ok "Shell 모드로 전환 완료!"
                    echo ""
                    echo "현재 상태:"
                    curl -s http://localhost:8090/status | python3 -m json.tool 2>/dev/null || curl -s http://localhost:8090/status
                else
                    msg_error "Shell 모드 전환 실패. 서비스 상태를 확인하세요: systemctl status rdp-toggle-api"
                fi
                ;;
            3)
                echo ""
                msg_info "현재 상태 확인 중..."
                curl -s http://localhost:8090/status | python3 -m json.tool 2>/dev/null || curl -s http://localhost:8090/status
                ;;
            4)
                echo ""
                msg_ok "종료합니다."
                return 0
                ;;
            *)
                echo ""
                msg_warn "잘못된 선택입니다."
                ;;
        esac
        echo ""
    done
}

# 메인 함수
main() {
    print_header

    # 사전 검사
    check_root
    check_proxmox_version

    # 이미 설치되어 있는지 확인
    if systemctl is-active --quiet rdp-toggle-api.service && \
       [ -f "/opt/rdp-toggle-api/rdp-toggle-api.py" ] && \
       [ -f "/etc/systemd/system/getty@tty1.service.d/override.conf" ]; then

        # 현재 설정 로드
        if [ -f "/var/lib/rdp-toggle/config.json" ]; then
            CURRENT_RDP_SERVER=$(python3 -c "import json; print(json.load(open('/var/lib/rdp-toggle/config.json'))['rdp_server'])" 2>/dev/null || echo "")
            CURRENT_RDP_USERNAME=$(python3 -c "import json; print(json.load(open('/var/lib/rdp-toggle/config.json'))['rdp_username'])" 2>/dev/null || echo "")
            CURRENT_LOCAL_USER=$(python3 -c "import json; print(json.load(open('/var/lib/rdp-toggle/config.json'))['local_user'])" 2>/dev/null || echo "rdpuser")
        else
            CURRENT_RDP_SERVER=""
            CURRENT_RDP_USERNAME=""
            CURRENT_LOCAL_USER="rdpuser"
        fi

        echo ""
        echo -e "${GREEN}=========================================="
        echo "✅ RDP 자동화 시스템이 이미 설치되어 있습니다!"
        echo -e "==========================================${NC}"
        echo ""
        echo -e "${CYAN}📍 API 서버: http://$(get_primary_ip):8090${NC}"
        echo ""
        echo -e "${CYAN}현재 설정:${NC}"
        echo "  RDP 서버: ${CURRENT_RDP_SERVER:-'설정되지 않음'}"
        echo "  RDP 사용자: ${CURRENT_RDP_USERNAME:-'설정되지 않음'}"
        echo "  로컬 사용자: $CURRENT_LOCAL_USER"
        echo ""
        echo "다음 중 선택하세요:"
        echo "  1) RDP 토글 메뉴 (RDP ↔ Shell 전환)"
        echo "  2) RDP 설정 수정"
        echo "  3) 재설치 (기존 설정 삭제 후 새로 설치)"
        echo "  4) 종료"
        echo ""
        echo -n "선택 [1/2/3/4]: "
        read -r reinstall_choice </dev/tty

        case "$reinstall_choice" in
            1)
                # RDP 토글 메뉴 실행
                show_rdp_toggle_menu
                exit 0
                ;;
            2)
                # RDP 설정 수정
                echo ""
                echo -e "${CYAN}=========================================="
                echo "RDP 설정 수정"
                echo -e "==========================================${NC}"
                echo ""

                # 새로운 RDP 정보 입력
                if [ -n "$CURRENT_RDP_SERVER" ]; then
                    echo -n "RDP 서버 주소 (현재: $CURRENT_RDP_SERVER, Enter=유지): "
                else
                    echo -n "RDP 서버 주소 (예: 192.168.0.201:3389): "
                fi
                read -r NEW_RDP_SERVER </dev/tty
                [ -z "$NEW_RDP_SERVER" ] && NEW_RDP_SERVER="$CURRENT_RDP_SERVER"

                if [ -n "$CURRENT_RDP_USERNAME" ]; then
                    echo -n "RDP 사용자명 (현재: $CURRENT_RDP_USERNAME, Enter=유지): "
                else
                    echo -n "RDP 사용자명: "
                fi
                read -r NEW_RDP_USERNAME </dev/tty
                [ -z "$NEW_RDP_USERNAME" ] && NEW_RDP_USERNAME="$CURRENT_RDP_USERNAME"

                echo -n "RDP 비밀번호: "
                read -s NEW_RDP_PASSWORD </dev/tty
                echo ""

                # 로컬 사용자는 기본 rdpuser로 자동 설정
                NEW_LOCAL_USER="${CURRENT_LOCAL_USER:-rdpuser}"

                echo ""
                echo "새로운 설정:"
                echo "  RDP 서버: $NEW_RDP_SERVER"
                echo "  RDP 사용자: $NEW_RDP_USERNAME"
                echo "  로컬 사용자: $NEW_LOCAL_USER (자동 설정)"
                echo ""
                echo -n "이 설정으로 업데이트하시겠습니까? [y/N]: "
                read -r confirm </dev/tty

                if [[ "$confirm" =~ ^[Yy]$ ]]; then
                    # 설정 파일 업데이트
                    cat > /var/lib/rdp-toggle/config.json << EOF
{
    "rdp_server": "$NEW_RDP_SERVER",
    "rdp_username": "$NEW_RDP_USERNAME",
    "rdp_password": "$NEW_RDP_PASSWORD",
    "local_user": "$NEW_LOCAL_USER"
}
EOF

                    # RDP 설정 파일도 업데이트
                    RDP_SERVER="$NEW_RDP_SERVER"
                    RDP_USERNAME="$NEW_RDP_USERNAME"
                    RDP_PASSWORD="$NEW_RDP_PASSWORD"
                    LOCAL_USER="$NEW_LOCAL_USER"

                    # .xinitrc 업데이트
                    user_home="/home/$LOCAL_USER"
                    if [ -f "$user_home/.xinitrc" ]; then
                        cat > "$user_home/.xinitrc" << EOF
#!/bin/bash
xset -dpms
xset s off
xset s noblank
unclutter -idle 0.1 -root &
openbox-session &
sleep 2
xfreerdp3 /v:$RDP_SERVER /u:$RDP_USERNAME /p:"$RDP_PASSWORD" +f /cert:ignore +dynamic-resolution /sound:sys:alsa +clipboard
pkill -SIGTERM Xorg
EOF
                        chmod +x "$user_home/.xinitrc"
                        chown "$LOCAL_USER:$LOCAL_USER" "$user_home/.xinitrc"
                    fi

                    msg_ok "RDP 설정이 업데이트되었습니다!"
                    echo ""
                    echo "변경사항을 적용하려면 RDP 모드를 다시 활성화하세요."
                    echo ""

                    # 토글 메뉴로 이동
                    show_rdp_toggle_menu
                else
                    msg_warn "설정 변경이 취소되었습니다."
                fi
                exit 0
                ;;
            3)
                echo ""
                msg_warn "기존 설정을 삭제하고 재설치를 시작합니다..."
                # 기존 설정 삭제는 하지 않고 덮어쓰기로 진행
                echo ""
                ;;
            4)
                echo ""
                msg_ok "종료합니다."
                exit 0
                ;;
            *)
                echo ""
                msg_warn "잘못된 선택입니다. 종료합니다."
                exit 1
                ;;
        esac
    fi

    # 사용자 입력
    get_user_input
    
    # 네트워크 확인
    check_network
    
    # 백업 생성
    create_backup
    
    # 설정 수행
    install_packages
    setup_user
    setup_autologin
    setup_x_autostart
    setup_rdp_connection
    setup_openbox

    # RDP Toggle API 설치
    install_rdp_api

    # 테스트 및 완료
    test_configuration
    print_completion
}

# 에러 핸들링
trap 'msg_error "스크립트 실행 중 오류가 발생했습니다."' ERR

# 스크립트 실행
main "$@"