#!/bin/bash

# 인페인팅 서버 의존성 설치 스크립트
# Jetson Xavier와 x86 시스템을 모두 지원합니다.
# Usage: ./install_deps.sh [options]

set -e

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

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

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

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

# 기본 설정 - 동적 경로 처리
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"

# 가상환경 경로 자동 감지
detect_venv_path() {
    local possible_paths=(
        "$PROJECT_ROOT/venv"           # 일반적인 venv 경로
        "$PROJECT_ROOT/.venv"          # 숨김 venv 경로
        "$PROJECT_ROOT/env"            # env 경로
        "$PROJECT_ROOT/.env"           # 숨김 env 경로
        "$PROJECT_ROOT"                # 프로젝트 루트 (Jetson 방식)
    )
    
    for path in "${possible_paths[@]}"; do
        if [ -f "$path/bin/python" ] || [ -f "$path/bin/python3" ]; then
            VENV_PATH="$path"
            log_info "가상환경 경로 감지: $VENV_PATH"
            return 0
        fi
    done
    
    # 현재 활성화된 가상환경 확인
    if [ -n "$VIRTUAL_ENV" ]; then
        VENV_PATH="$VIRTUAL_ENV"
        log_info "활성화된 가상환경 사용: $VENV_PATH"
        return 0
    fi
    
    # 가상환경을 찾지 못한 경우 시스템별 기본값 사용
    if [ "$(uname -m)" = "aarch64" ] && uname -a | grep -q "tegra"; then
        VENV_PATH="$PROJECT_ROOT"
        log_warning "가상환경을 찾을 수 없어 Jetson 기본값 사용: $VENV_PATH"
    else
        VENV_PATH="$PROJECT_ROOT/venv"
        log_warning "가상환경을 찾을 수 없어 x86 기본값 사용: $VENV_PATH"
    fi
}

# 시스템 감지
detect_system() {
    log_info "시스템 감지 중..."
    
    if [ "$(uname -m)" = "aarch64" ] && uname -a | grep -q "tegra"; then
        SYSTEM_TYPE="jetson"
        log_success "Jetson Xavier (ARM64) 감지됨"
        
        # Jetson 버전 확인
        if [ -f "/etc/nv_tegra_release" ]; then
            JETSON_VERSION=$(cat /etc/nv_tegra_release | head -1)
            log_info "Jetson 버전: $JETSON_VERSION"
        fi
        
        # CUDA 버전 확인
        if command -v nvcc &> /dev/null; then
            CUDA_VERSION=$(nvcc --version | grep "release" | awk '{print $6}' | cut -c2-)
            log_info "CUDA 버전: $CUDA_VERSION"
        fi
        
        # TensorRT 버전 확인
        if [ -f "/usr/lib/aarch64-linux-gnu/libnvinfer.so" ]; then
            TENSORRT_VERSION=$(strings /usr/lib/aarch64-linux-gnu/libnvinfer.so | grep "TensorRT" | head -1)
            log_info "TensorRT: $TENSORRT_VERSION"
        fi
        
    elif [ "$(uname -m)" = "x86_64" ]; then
        SYSTEM_TYPE="x86"
        log_success "x86_64 시스템 감지됨"
        
        # CUDA 버전 설정
        CUDA_VERSION="11.8"
        TENSORRT_VERSION="8.6.1"
        
    else
        log_error "지원되지 않는 시스템 아키텍처: $(uname -m)"
        exit 1
    fi
    
    # Python 버전 확인
    if command -v python3 &> /dev/null; then
        PYTHON_VERSION=$(python3 --version | awk '{print $2}')
        log_info "Python 버전: $PYTHON_VERSION"
        
        # Python 3.8 이상 필요
        if python3 -c "import sys; exit(0 if sys.version_info >= (3, 8) else 1)"; then
            log_success "Python 버전 확인 완료"
        else
            log_error "Python 3.8 이상이 필요합니다 (현재: $PYTHON_VERSION)"
            exit 1
        fi
    else
        log_error "Python3이 설치되어 있지 않습니다"
        exit 1
    fi
}

# 옵션 파싱
FORCE_REINSTALL=false
SKIP_CUDA_CHECK=false
INSTALL_TENSORRT=true
INSTALL_EXTRAS=false
JETSON_OPTIMIZE=false

while [[ $# -gt 0 ]]; do
    case $1 in
        -f|--force)
            FORCE_REINSTALL=true
            shift
            ;;
        --skip-cuda)
            SKIP_CUDA_CHECK=true
            shift
            ;;
        --no-tensorrt)
            INSTALL_TENSORRT=false
            shift
            ;;
        --extras)
            INSTALL_EXTRAS=true
            shift
            ;;
        --jetson-optimize)
            JETSON_OPTIMIZE=true
            shift
            ;;
        -h|--help)
            echo "Usage: $0 [options]"
            echo "Options:"
            echo "  -f, --force          기존 패키지 강제 재설치"
            echo "  --skip-cuda          CUDA 설치 확인 건너뛰기"
            echo "  --no-tensorrt        TensorRT 설치 건너뛰기"
            echo "  --extras             추가 패키지 설치 (개발 도구 등)"
            echo "  --jetson-optimize    Jetson 최적화 설정 (Jetson 전용)"
            echo "  -h, --help           이 도움말 표시"
            exit 0
            ;;
        *)
            log_error "알 수 없는 옵션: $1"
            exit 1
            ;;
    esac
done

# 시스템 요구사항 확인
check_system_requirements() {
    log_info "시스템 요구사항 확인 중..."
    
    # Ubuntu 버전 확인
    if [ -f /etc/os-release ]; then
        source /etc/os-release
        log_info "OS: $PRETTY_NAME"
        
        if [ "$SYSTEM_TYPE" = "jetson" ]; then
            # Jetson은 Ubuntu 18.04 이상 권장
            if [[ "$VERSION_ID" < "18.04" ]]; then
                log_warning "Ubuntu 18.04 이상을 권장합니다 (현재: $VERSION_ID)"
            fi
        else
            # x86은 Ubuntu 18.04 이상 권장
            if [[ "$VERSION_ID" < "18.04" ]]; then
                log_warning "Ubuntu 18.04 이상을 권장합니다 (현재: $VERSION_ID)"
            fi
        fi
    fi
    
    # 메모리 확인
    TOTAL_MEMORY=$(free -g | awk 'NR==2{print $2}')
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        if [ "$TOTAL_MEMORY" -lt 4 ]; then
            log_warning "4GB 이상의 RAM을 권장합니다 (현재: ${TOTAL_MEMORY}GB)"
        fi
    else
        if [ "$TOTAL_MEMORY" -lt 8 ]; then
            log_warning "8GB 이상의 RAM을 권장합니다 (현재: ${TOTAL_MEMORY}GB)"
        fi
    fi
    
    log_success "시스템 요구사항 확인 완료"
}

# CUDA 설치 확인
check_cuda_installation() {
    if [ "$SKIP_CUDA_CHECK" = true ]; then
        log_info "CUDA 확인을 건너뛰었습니다"
        return 0
    fi
    
    log_info "CUDA 설치 확인 중..."
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson Xavier CUDA 확인 중..."
        
        # Jetson 전용 확인 방법들
        jetson_checks_passed=0
        
        # 1. nvcc 확인
        if command -v nvcc &> /dev/null; then
            CUDA_VERSION_INSTALLED=$(nvcc --version | grep "release" | awk '{print $6}' | cut -c2-)
            log_info "CUDA 컴파일러 버전: $CUDA_VERSION_INSTALLED"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "nvcc를 찾을 수 없습니다"
        fi
        
        # 2. tegrastats 확인 (Jetson 전용)
        if command -v tegrastats &> /dev/null; then
            log_info "tegrastats 사용 가능 (Jetson 전용)"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "tegrastats를 찾을 수 없습니다"
        fi
        
        # 3. nvpmodel 확인 (전력 모드 관리)
        if command -v nvpmodel &> /dev/null; then
            log_info "nvpmodel 사용 가능 (전력 모드 관리)"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "nvpmodel을 찾을 수 없습니다"
        fi
        
        # 4. TensorRT 확인
        if [ -f "/usr/lib/aarch64-linux-gnu/libnvinfer.so" ]; then
            TENSORRT_VERSION=$(strings /usr/lib/aarch64-linux-gnu/libnvinfer.so | grep "TensorRT" | head -1)
            log_info "TensorRT: $TENSORRT_VERSION"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "TensorRT를 찾을 수 없습니다"
        fi
        
        # 5. Jetson 버전 확인
        if [ -f "/etc/nv_tegra_release" ]; then
            JETSON_VERSION=$(cat /etc/nv_tegra_release | head -1)
            log_info "Jetson 버전: $JETSON_VERSION"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "Jetson 버전 정보를 찾을 수 없습니다"
        fi
        
        # 6. GPU 디바이스 확인 (Jetson 전용 경로들)
        gpu_detected=false
        
        # Jetson GPU 클래스 확인
        if [ -d "/sys/class/nvidia-gpu" ]; then
            log_info "Jetson GPU 클래스 감지됨: /sys/class/nvidia-gpu"
            gpu_detected=true
        fi
        
        # Jetson GPU 디바이스 확인
        if [ -d "/sys/devices/platform/*/nvidia-gpu" ]; then
            log_info "Jetson GPU 디바이스 감지됨"
            gpu_detected=true
        fi
        
        # GV11B GPU 확인 (Jetson Xavier)
        if [ -d "/sys/firmware/devicetree/base/gv11b" ]; then
            log_info "GV11B GPU (Jetson Xavier) 감지됨"
            gpu_detected=true
        fi
        
        # 디버그 GPU 경로 확인 (권한이 있는 경우)
        if [ -r "/sys/kernel/debug/gpu" ]; then
            log_info "GPU 디버그 경로 접근 가능: /sys/kernel/debug/gpu"
            gpu_detected=true
        fi
        
        if [ "$gpu_detected" = true ]; then
            log_info "GPU 디바이스 감지됨"
            jetson_checks_passed=$((jetson_checks_passed + 1))
        else
            log_warning "GPU 디바이스를 찾을 수 없습니다 (권한 문제일 수 있음)"
            log_info "sudo 권한으로 실행하거나 시스템을 재부팅해보세요"
        fi
        
        if [ $jetson_checks_passed -ge 3 ]; then
            log_success "Jetson Xavier CUDA 확인 완료 ($jetson_checks_passed/6 체크 통과)"
        else
            log_warning "Jetson Xavier CUDA 확인 부분 실패 ($jetson_checks_passed/6 체크 통과)"
            log_info "Jetson SDK를 재설치하거나 시스템을 재부팅해보세요"
        fi
        
    else
        # x86 시스템용 기존 확인 방법
        if command -v nvidia-smi &> /dev/null; then
            log_info "NVIDIA 드라이버가 설치되어 있습니다"
            nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv,noheader
            
            # CUDA 런타임 확인
            if command -v nvcc &> /dev/null; then
                CUDA_VERSION_INSTALLED=$(nvcc --version | grep "release" | awk '{print $6}' | cut -c2-)
                log_info "CUDA 버전: $CUDA_VERSION_INSTALLED"
            else
                log_warning "CUDA 컴파일러(nvcc)를 찾을 수 없습니다"
                log_info "런타임만 설치된 상태일 수 있습니다"
            fi
            
            log_success "CUDA 확인 완료"
        else
            log_error "NVIDIA 드라이버가 설치되어 있지 않습니다"
            log_info "다음 명령어로 설치하세요:"
            log_info "sudo apt update && sudo apt install nvidia-driver-470"
            exit 1
        fi
    fi
}

# 가상환경 활성화
activate_venv() {
    log_info "가상환경 활성화 중..."
    
    if [ ! -f "$VENV_PATH/bin/activate" ]; then
        log_error "가상환경을 찾을 수 없습니다: $VENV_PATH"
        exit 1
    fi
    
    cd "$PROJECT_ROOT"
    source "$VENV_PATH/bin/activate"
    
    # pip 업그레이드
    log_info "pip 업그레이드 중..."
    pip install --upgrade pip setuptools wheel
    
    log_success "가상환경 활성화 완료"
}

# PyTorch 설치 (시스템별)
install_pytorch() {
    log_info "PyTorch 설치 중..."
    
    # 기존 PyTorch 확인
    if pip list | grep -q torch && [ "$FORCE_REINSTALL" = false ]; then
        log_info "PyTorch가 이미 설치되어 있습니다"
        python -c "import torch; print(f'PyTorch 버전: {torch.__version__}'); print(f'CUDA 사용 가능: {torch.cuda.is_available()}')"
        return 0
    fi
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson Xavier용 PyTorch 설치 중..."
        
        # Jetson 전용 PyTorch 설치
        pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
        
        # Jetson 최적화 패키지들
        pip install nvidia-ml-py3 pynvml
        
    else
        log_info "x86용 PyTorch 설치 중..."
        
        # x86용 PyTorch 설치
        case $CUDA_VERSION in
            "11.8")
                pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
                ;;
            "11.7")
                pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
                ;;
            "cpu")
                pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
                ;;
            *)
                log_warning "지원되지 않는 CUDA 버전: $CUDA_VERSION. 기본 버전을 설치합니다"
                pip install torch torchvision torchaudio
                ;;
        esac
    fi
    
    # 설치 확인
    python -c "import torch; print(f'PyTorch 설치 완료: {torch.__version__}'); print(f'CUDA 사용 가능: {torch.cuda.is_available()}')"
    
    log_success "PyTorch 설치 완료"
}

# TensorRT 설치
install_tensorrt() {
    if [ "$INSTALL_TENSORRT" = false ]; then
        log_info "TensorRT 설치를 건너뛰었습니다"
        return 0
    fi
    
    log_info "TensorRT 설치 중..."
    
    # 기존 TensorRT 확인
    if pip list | grep -q tensorrt && [ "$FORCE_REINSTALL" = false ]; then
        log_info "TensorRT가 이미 설치되어 있습니다"
        return 0
    fi
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson Xavier용 TensorRT 설치 중..."
        
        # Jetson에는 TensorRT가 기본적으로 포함되어 있음
        if [ -f "/usr/lib/aarch64-linux-gnu/libnvinfer.so" ]; then
            log_info "Jetson TensorRT가 이미 설치되어 있습니다"
            
            # Python 바인딩만 설치
            pip install nvidia-pyindex
            pip install nvidia-tensorrt
        else
            log_warning "Jetson TensorRT를 찾을 수 없습니다"
            log_info "Jetson SDK를 재설치하거나 수동으로 설치해주세요"
        fi
        
    else
        log_info "x86용 TensorRT 설치 중..."
        
        # x86용 TensorRT 설치 시도
        pip install tensorrt==$TENSORRT_VERSION || {
            log_warning "TensorRT 패키지 설치에 실패했습니다"
            log_info "수동으로 NVIDIA 웹사이트에서 다운로드가 필요할 수 있습니다"
            return 1
        }
    fi
    
    # pycuda 설치
    pip install pycuda
    
    log_success "TensorRT 설치 완료"
}

# 메인 패키지 설치
install_main_packages() {
    log_info "메인 패키지 설치 중..."
    
    # requirements.txt 확인
    if [ ! -f "$PROJECT_ROOT/requirements.txt" ]; then
        log_error "requirements.txt 파일을 찾을 수 없습니다"
        exit 1
    fi
    
    # Jetson 전용 requirements 처리
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson Xavier용 패키지 설치 중..."
        
        # Jetson에 맞는 패키지 버전으로 설치
        pip install fastapi uvicorn python-multipart pillow numpy
        
        # OpenCV - Jetson 최적화 버전
        pip install opencv-python-headless || pip install opencv-python
        
        # 나머지 패키지들
        pip install psutil asyncio-throttle aiofiles pydantic
        
    else
        # x86용 전체 패키지 설치
        if [ "$FORCE_REINSTALL" = true ]; then
            pip install --force-reinstall -r requirements.txt
        else
            pip install -r requirements.txt
        fi
    fi
    
    log_success "메인 패키지 설치 완료"
}

# 모델별 의존성 설치
install_model_dependencies() {
    log_info "모델별 의존성 설치 중..."
    
    # Simple LAMA 의존성
    log_info "Simple LAMA 의존성 설치 중..."
    pip install simple-lama-inpainting || {
        log_warning "simple-lama-inpainting 패키지 설치 실패"
        log_info "수동 설치가 필요할 수 있습니다"
    }
    
    # REMBG 의존성
    log_info "REMBG 의존성 설치 중..."
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        # Jetson용 REMBG (CPU 버전 권장)
        pip install rembg || pip install rembg[cpu]
    else
        pip install rembg[gpu] || pip install rembg
    fi
    
    # 추가 이미지 처리 라이브러리
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        # Jetson 최적화 버전 (pillow-simd는 ARM64에서 지원되지 않음)
        pip install opencv-python-headless pillow || pip install opencv-python pillow
    else
        # x86용 최적화 버전
        pip install opencv-python-headless pillow-simd || pip install opencv-python pillow
    fi
    
    log_success "모델별 의존성 설치 완료"
}

# GPU 라이브러리 설치
install_gpu_libraries() {
    log_info "GPU 라이브러리 설치 중..."
    
    # NVIDIA 관련 Python 패키지
    pip install nvidia-ml-py3 pynvml
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson 전용 GPU 라이브러리 설치 중..."
        
        # GCC 버전 확인 및 업그레이드 (ONNX Runtime GPU용)
        log_info "GCC 버전 확인 중..."
        if ! gcc-11 --version &> /dev/null; then
            log_warning "GCC-11이 설치되지 않았습니다. ONNX Runtime GPU 설치를 위해 설치 중..."
            
            # GCC 11 설치
            sudo apt install -y software-properties-common
            sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
            sudo apt update
            sudo apt install -y gcc-11 g++-11
            
            log_success "GCC-11 설치 완료"
        else
            log_info "GCC-11이 이미 설치되어 있습니다"
        fi
        
        # Jetson Xavier용 ONNX Runtime GPU 설치
        log_info "Jetson Xavier용 ONNX Runtime GPU 설치 중..."
        
        # 기존 onnxruntime 제거
        pip uninstall -y onnxruntime onnxruntime-gpu 2>/dev/null || true
        
        # ONNX Runtime GPU 휠 파일 다운로드
        ONNX_WHEEL_NAME="onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl"
        if [ ! -f "$PROJECT_ROOT/$ONNX_WHEEL_NAME" ]; then
            log_info "ONNX Runtime GPU 휠 파일 다운로드 중..."
            cd "$PROJECT_ROOT"
            wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl \
                -O "$ONNX_WHEEL_NAME"
        else
            log_info "ONNX Runtime GPU 휠 파일이 이미 존재합니다"
        fi
        
        # ONNX Runtime GPU 설치
        log_info "ONNX Runtime GPU 설치 중..."
        pip install --force-reinstall "$PROJECT_ROOT/$ONNX_WHEEL_NAME"
        
        # 설치 확인
        if python -c "import onnxruntime as ort; print('Available providers:', ort.get_available_providers())" 2>/dev/null; then
            log_success "ONNX Runtime GPU 설치 및 확인 완료"
            python -c "
import onnxruntime as ort
providers = ort.get_available_providers()
print('ONNX Runtime 버전:', ort.__version__)
print('사용 가능한 프로바이더:')
for provider in providers:
    print('  -', provider)
if 'TensorrtExecutionProvider' in providers:
    print('✅ TensorRT 프로바이더 사용 가능')
if 'CUDAExecutionProvider' in providers:
    print('✅ CUDA 프로바이더 사용 가능')
"
        else
            log_error "ONNX Runtime GPU 설치 실패"
            log_info "CPU 버전으로 폴백 설치 중..."
            pip install onnxruntime==1.19.2
        fi
        
        # Jetson 전용 패키지들
        pip install jetson-stats || log_warning "jetson-stats 설치 실패"
        
    else
        log_info "x86용 GPU 라이브러리 설치 중..."
        
        # x86용 ONNX Runtime GPU 설치
        log_info "x86용 ONNX Runtime GPU 설치 중..."
        pip install onnxruntime-gpu || {
            log_warning "ONNX Runtime GPU 설치 실패, CPU 버전으로 폴백"
            pip install onnxruntime==1.19.2
        }
        
        # 추가 GPU 가속 라이브러리
        if [ "$INSTALL_EXTRAS" = true ]; then
            pip install cupy-cuda118 || {
                log_warning "CuPy 설치 실패"
                log_info "CUDA 버전을 확인하고 수동 설치하세요"
            }
        fi
    fi
    
    log_success "GPU 라이브러리 설치 완료"
}

# Jetson 최적화 설정
setup_jetson_optimization() {
    if [ "$SYSTEM_TYPE" != "jetson" ] || [ "$JETSON_OPTIMIZE" != true ]; then
        return 0
    fi
    
    log_info "Jetson Xavier 최적화 설정 중..."
    
    # 전력 모드 설정
    if command -v nvpmodel &> /dev/null; then
        log_info "전력 모드를 MAXN으로 설정 중..."
        sudo nvpmodel -m 0  # MAXN 모드
        sudo nvpmodel -q
    else
        log_warning "nvpmodel을 찾을 수 없습니다"
    fi
    
    # 팬 제어 설정
    if [ -f "/sys/devices/pwm-fan/target_pwm" ]; then
        log_info "팬 제어 활성화 중..."
        echo 128 | sudo tee /sys/devices/pwm-fan/target_pwm > /dev/null
    fi
    
    # GPU 클럭 설정
    if [ -f "/sys/kernel/debug/clk/gpcclk/clk_rate" ]; then
        log_info "GPU 클럭 최적화 중..."
        # 최대 클럭으로 설정 (1200MHz)
        echo 1200000000 | sudo tee /sys/kernel/debug/clk/gpcclk/clk_rate > /dev/null
    fi
    
    # 메모리 클럭 설정
    if [ -f "/sys/kernel/debug/clk/emc/clk_rate" ]; then
        log_info "메모리 클럭 최적화 중..."
        # 최대 클럭으로 설정 (1600MHz)
        echo 1600000000 | sudo tee /sys/kernel/debug/clk/emc/clk_rate > /dev/null
    fi
    
    log_success "Jetson 최적화 설정 완료"
}

# 개발 도구 설치 (선택적)
install_dev_tools() {
    if [ "$INSTALL_EXTRAS" = false ]; then
        return 0
    fi
    
    log_info "개발 도구 설치 중..."
    
    # 코드 품질 도구
    pip install black flake8 isort mypy
    
    # 테스트 도구
    pip install pytest pytest-asyncio pytest-cov
    
    # 프로파일링 도구
    pip install line_profiler memory_profiler
    
    # Jupyter 노트북
    pip install jupyter ipykernel
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        # Jetson 전용 개발 도구
        pip install jetson-inference || log_warning "jetson-inference 설치 실패"
    fi
    
    log_success "개발 도구 설치 완료"
}

# 설치 확인
verify_installation() {
    log_info "설치 확인 중..."
    
    # Python 패키지 확인
    local packages=("fastapi" "uvicorn" "torch" "PIL" "cv2" "numpy")
    
    for package in "${packages[@]}"; do
        if python -c "import $package" 2>/dev/null; then
            log_success "$package 설치 확인"
        else
            log_error "$package 설치 실패"
        fi
    done
    
    # CUDA 사용 가능성 확인
    if python -c "import torch; exit(0 if torch.cuda.is_available() else 1)" 2>/dev/null; then
        log_success "CUDA 사용 가능"
        python -c "import torch; print(f'사용 가능한 GPU 수: {torch.cuda.device_count()}')"
        
        if [ "$SYSTEM_TYPE" = "jetson" ]; then
            python -c "
import torch
if torch.cuda.is_available():
    torch.cuda.empty_cache()
    print(f'Jetson GPU 메모리: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB')
    print(f'GPU 이름: {torch.cuda.get_device_properties(0).name}')
"
        fi
    else
        log_warning "CUDA를 사용할 수 없습니다"
    fi
    
    # Jetson 전용 확인
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        log_info "Jetson 전용 기능 확인 중..."
        
        # jetson-stats 확인
        if command -v jtop &> /dev/null; then
            log_success "jetson-stats (jtop) 사용 가능"
        fi
        
        # TensorRT 확인
        if python -c "import tensorrt" 2>/dev/null; then
            log_success "TensorRT Python 바인딩 확인"
        fi
    fi
    
    log_success "설치 확인 완료"
}

# 설치 후 정리
post_install_cleanup() {
    log_info "설치 후 정리 중..."
    
    # pip 캐시 정리
    pip cache purge
    
    # __pycache__ 정리
    find "$PROJECT_ROOT" -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
    find "$PROJECT_ROOT" -name "*.pyc" -delete 2>/dev/null || true
    
    log_success "정리 완료"
}

# 설치 요약 정보
print_installation_summary() {
    echo ""
    echo "=========================================="
    echo "📦 의존성 설치 완료!"
    echo "=========================================="
    echo "시스템 타입: $SYSTEM_TYPE"
    echo "Python 버전: $(python --version)"
    echo "PyTorch 버전: $(python -c 'import torch; print(torch.__version__)' 2>/dev/null || echo 'N/A')"
    echo "CUDA 사용 가능: $(python -c 'import torch; print(torch.cuda.is_available())' 2>/dev/null || echo 'N/A')"
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        echo ""
        echo "🚀 Jetson Xavier 최적화:"
        echo "  - 전력 모드: MAXN"
        echo "  - GPU 클럭: 1200MHz"
        echo "  - 메모리 클럭: 1600MHz"
        echo "  - 팬 제어: 활성화"
    fi
    
    echo ""
    echo "설치된 주요 패키지:"
    pip list | grep -E "(torch|fastapi|uvicorn|rembg|pillow|opencv)" | head -10
    
    echo ""
    echo "다음 단계:"
    echo "  1. 서버 시작: ./scripts/start_server.sh"
    echo "  2. 상태 확인: ./scripts/status.sh"
    echo "  3. API 문서: http://localhost:8008/docs"
    
    if [ "$SYSTEM_TYPE" = "jetson" ]; then
        echo "  4. Jetson 모니터링: jtop"
        echo "  5. 전력 모드 확인: nvpmodel -q"
    fi
    
    echo "=========================================="
}

# 메인 실행
main() {
    log_info "인페인팅 서버 의존성 설치 시작"
    
    detect_system
    detect_venv_path
    check_system_requirements
    check_cuda_installation
    activate_venv
    install_pytorch
    install_tensorrt
    install_main_packages
    install_model_dependencies
    install_gpu_libraries
    setup_jetson_optimization
    install_dev_tools
    verify_installation
    post_install_cleanup
    print_installation_summary
    
    log_success "의존성 설치가 완료되었습니다!"
}

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