run

#!/bin/bash

PG_PORT=5332
GIT_PULL=true
PEER_LIST_FILE="demos_peerlist.json"
VERBOSE=false

# Detect platform for cross-platform compatibility
PLATFORM=$(uname -s)
case $PLATFORM in
    "Darwin")
        PLATFORM_NAME="macOS"
        ;;
    "Linux")
        PLATFORM_NAME="Linux"
        ;;
    *)
        PLATFORM_NAME="Unknown"
        ;;
esac

# trap ctrl-c and call ctrl_c()
trap ctrl_c INT

HAS_BEEN_INTERRUPTED=false

# Verbose logging function
log_verbose() {
    if [ "$VERBOSE" = true ]; then
        echo "[VERBOSE] $1"
    fi
}

# Help documentation function
show_help() {
    cat << EOF
🚀 Demos Network Node Runner

USAGE:
    ./run [OPTIONS]

Welcome to Demos Network! This script helps you run your blockchain node easily.

OPTIONS:
    -p <port>                      Node port (default: 53550)
    -d <port>                      PostgreSQL port (default: 5332)
    -i <path>                      Identity file path (default: .demos_identity)
    -c <true/false>                Clean database on startup
    -n <true/false>                Skip git pull (useful for custom branches)
    -u <url>                       Override EXPOSED_URL
    -l <path>                      Peer list file (default: demos_peerlist.json)
    -r <runtime>                   Force runtime (bun only - node deprecated)
    -b <true/false>                Restore from backup
    -v                             Verbose logging
    -h                             Show this help message

EXAMPLES:
    ./run                          # Start with default settings
    ./run -p 53551 -d 5333         # Run on custom ports
    ./run -c                       # Clean start (fresh database)
    ./run -v                       # Verbose output for troubleshooting
    ./run -n                       # Skip git update (for development)

SYSTEM REQUIREMENTS:
    - 8GB RAM minimum (12GB recommended)
    - 4+ CPU cores
    - Docker and Docker Compose
    - Bun runtime
    - Network: <200ms ping to 1.1.1.1 (<100ms recommended)
    - Free ports: 5332 (PostgreSQL) and 53550 (Node)

For support and documentation: https://demos.network
EOF
}

# System requirements validation
check_system_requirements() {
    echo "🔍 Checking system requirements..."
    log_verbose "Platform detected: $PLATFORM_NAME"
    
    local failed_requirements=0
    local warnings=0
    
    # Check RAM
    log_verbose "Checking RAM requirements"
    if [ "$PLATFORM_NAME" = "macOS" ]; then
        # macOS: Get RAM in bytes, convert to GB
        ram_bytes=$(sysctl -n hw.memsize)
        ram_gb=$((ram_bytes / 1024 / 1024 / 1024))
    elif [ "$PLATFORM_NAME" = "Linux" ]; then
        # Linux: Get RAM from /proc/meminfo in kB, convert to GB
        ram_kb=$(grep MemTotal /proc/meminfo | awk '{print $2}')
        ram_gb=$((ram_kb / 1024 / 1024))
    else
        echo "⚠️  Unknown platform - cannot check RAM"
        ram_gb=0
        warnings=$((warnings + 1))
    fi
    
    if [ $ram_gb -lt 8 ]; then
        echo "❌ Insufficient RAM: ${ram_gb}GB (minimum: 8GB)"
        failed_requirements=$((failed_requirements + 1))
    elif [ $ram_gb -lt 12 ]; then
        echo "⚠️  RAM below recommended: ${ram_gb}GB (recommended: 12GB)"
        warnings=$((warnings + 1))
    else
        echo "✅ RAM: ${ram_gb}GB"
    fi
    
    # Check CPU cores
    log_verbose "Checking CPU requirements"
    if [ "$PLATFORM_NAME" = "macOS" ]; then
        cpu_cores=$(sysctl -n hw.ncpu)
    elif [ "$PLATFORM_NAME" = "Linux" ]; then
        cpu_cores=$(nproc)
    else
        echo "⚠️  Unknown platform - cannot check CPU"
        cpu_cores=0
        warnings=$((warnings + 1))
    fi
    
    if [ $cpu_cores -lt 4 ]; then
        echo "❌ Insufficient CPU cores: ${cpu_cores} (minimum: 4)"
        failed_requirements=$((failed_requirements + 1))
    else
        echo "✅ CPU cores: ${cpu_cores}"
    fi
    
    # Check network connectivity (ping 1.1.1.1)
    log_verbose "Checking network connectivity"
    if command -v ping > /dev/null; then
        if [ "$PLATFORM_NAME" = "macOS" ]; then
            # macOS ping syntax
            ping_result=$(ping -c 3 -t 5 1.1.1.1 2>/dev/null | tail -1 | awk -F'/' '{print $5}' | cut -d'.' -f1)
        elif [ "$PLATFORM_NAME" = "Linux" ]; then
            # Linux ping syntax
            ping_result=$(ping -c 3 -W 5 1.1.1.1 2>/dev/null | tail -1 | awk -F'/' '{print $5}' | cut -d'.' -f1)
        fi
        
        if [ -z "$ping_result" ]; then
            echo "❌ Network connectivity failed - cannot reach 1.1.1.1"
            failed_requirements=$((failed_requirements + 1))
        elif [ "$ping_result" -gt 200 ]; then
            echo "❌ Network latency too high: ${ping_result}ms (maximum: 200ms)"
            failed_requirements=$((failed_requirements + 1))
        elif [ "$ping_result" -gt 100 ]; then
            echo "⚠️  Network latency above recommended: ${ping_result}ms (recommended: <100ms)"
            warnings=$((warnings + 1))
        else
            echo "✅ Network latency: ${ping_result}ms"
        fi
    else
        echo "⚠️  Cannot test network - ping command not available"
        warnings=$((warnings + 1))
    fi
    
    # Check port availability
    log_verbose "Checking port availability"
    if command -v lsof > /dev/null; then
        if lsof -i :$PG_PORT > /dev/null 2>&1; then
            echo "❌ PostgreSQL port $PG_PORT is already in use"
            failed_requirements=$((failed_requirements + 1))
        else
            echo "✅ PostgreSQL port $PG_PORT is available"
        fi
        
        if lsof -i :$PORT > /dev/null 2>&1; then
            echo "❌ Node port $PORT is already in use"
            failed_requirements=$((failed_requirements + 1))
        else
            echo "✅ Node port $PORT is available"
        fi
    elif command -v netstat > /dev/null; then
        # Fallback to netstat if lsof is not available
        if netstat -an | grep ":$PG_PORT " > /dev/null 2>&1; then
            echo "❌ PostgreSQL port $PG_PORT is already in use"
            failed_requirements=$((failed_requirements + 1))
        else
            echo "✅ PostgreSQL port $PG_PORT is available"
        fi
        
        if netstat -an | grep ":$PORT " > /dev/null 2>&1; then
            echo "❌ Node port $PORT is already in use"
            failed_requirements=$((failed_requirements + 1))
        else
            echo "✅ Node port $PORT is available"
        fi
    else
        echo "⚠️  Cannot check port availability - lsof and netstat not available"
        warnings=$((warnings + 1))
    fi
    
    # Summary
    if [ $failed_requirements -gt 0 ]; then
        echo ""
        echo "❌ System requirements check FAILED!"
        echo "   Failed requirements: $failed_requirements"
        echo "   Please resolve the above issues before running the node."
        echo ""
        echo "💡 Need help? Visit: https://demos.network/support"
        exit 1
    elif [ $warnings -gt 0 ]; then
        echo ""
        echo "⚠️  System requirements check passed with $warnings warning(s)"
        echo "   The node will run but performance may be limited."
        echo ""
    else
        echo ""
        echo "✅ All system requirements met!"
        echo ""
    fi
}

function ctrl_c() {
    HAS_BEEN_INTERRUPTED=true
    cd postgres
    docker compose down
    cd ..
}

# Function to check if we are on the first run with the .RUN file
function is_first_run() {
    if [ ! -f ".RUN" ]; then
        return 0
    else
        return 1
    fi
}


# If we are on the first run, we need to install the dependencies
if is_first_run; then
    echo "Installing node dependencies"
    if ! bun install; then
        echo "Error: Dependencies failed to install"
        exit 1
    fi
    echo "Ok, dependencies installed"
    # We need docker and docker compose to be installed
    echo "🔍 Checking Docker..."
    if ! command -v docker &> /dev/null; then
        echo "❌ Docker is not installed"
        echo "💡 Install Docker from: https://docs.docker.com/get-docker/"
        if [ "$PLATFORM_NAME" = "macOS" ]; then
            echo "🍎 On macOS: Download Docker Desktop from https://docker.com/products/docker-desktop"
        elif [ "$PLATFORM_NAME" = "Linux" ]; then
            echo "🐧 On Linux: Use your package manager or install script"
        fi
        exit 1
    fi
    
    if ! docker compose version &> /dev/null; then
        echo "❌ Docker Compose is not available"
        echo "💡 Make sure Docker Desktop is running or install docker-compose-plugin"
        exit 1
    fi
    
    # Check if Docker daemon is running
    if ! docker info &> /dev/null; then
        echo "❌ Docker daemon is not running"
        echo "💡 Start Docker Desktop or run: sudo systemctl start docker"
        exit 1
    fi
    
    echo "✅ Docker and Docker Compose are ready"
    # Check if Bun is installed
    if ! command -v bun &> /dev/null; then
        echo "Error: Bun is not installed and is required to run the node (since 0.9.5)"
        echo "Install bun following: https://bun.sh/docs/installation."
        exit 1
    else
        echo "Ok, Bun is installed"
    fi
    # This file is used to check if we are on the first run

    # This file is used to check if we are on the first run
    touch .RUN
fi

CLEAN="false"
PORT=53550

# Getting arguments
while getopts "p:d:c:i:n:u:l:r:b:vh" opt; do
    case $opt in
        p) PORT=$OPTARG;;
        d) PG_PORT=$OPTARG;;
        c) CLEAN=$OPTARG;;
        i) IDENTITY_FILE=$OPTARG;;
        l) PEER_LIST_FILE=$OPTARG;;
        n) GIT_PULL=false;;
        u) EXPOSED_URL=$OPTARG;;
        r) RUNTIME=$OPTARG;;
        b) RESTORE=$OPTARG;;
        v) VERBOSE=true;;
        h) show_help; exit 0;;
        *) echo "Invalid option. Use -h for help."; exit 1;;
    esac
done
shift $((OPTIND -1))

# if RESTORE is true, make clean false
if [ "$RESTORE" == "true" ]; then
    CLEAN="false"
fi

# Run system requirements check
check_system_requirements

# Perform git pull if GIT_PULL is true
if [ "$GIT_PULL" = true ]; then
    echo "🔄 Updating repository..."
    log_verbose "Running git pull to get latest changes"
    if ! git pull; then
        echo "⚠️  Warning: Git pull failed, continuing with current version"
        log_verbose "Git pull failed but continuing - might be in development mode"
    else
        echo "✅ Repository updated successfully"
    fi
fi


echo ""
echo "🚀 Welcome to Demos Network!"
echo "⚙️  Node Configuration:"
echo "   🌐 Node Port: $PORT"
echo "   🗄️  Database Port: $PG_PORT"
if [ ! -z "$IDENTITY_FILE" ]; then
    echo "   🔑 Identity File: $IDENTITY_FILE"
fi
if [ ! -z "$EXPOSED_URL" ]; then
    echo "   📡 Exposed URL: $EXPOSED_URL"
fi
echo "   👥 Peer List: $PEER_LIST_FILE"
if [ "$RESTORE" = "true" ]; then
    echo "   📦 Mode: Restore from backup"
elif [ "$CLEAN" = "true" ]; then
    echo "   🧹 Mode: Clean start (fresh database)"
else
    echo "   ▶️  Mode: Normal start"
fi
log_verbose "Platform: $PLATFORM_NAME"
log_verbose "Verbose logging enabled"
echo ""

# Check if runtime is forced via CLI argument
if [ ! -z "$RUNTIME" ]; then
    case $RUNTIME in
        "node")
            echo "❌ Error: Node runtime requested but Bun is required to run the node (since 0.9.5)"
            exit 1
            ;;
        "bun")
            if ! command -v bun &> /dev/null; then
                echo "❌ Error: Bun runtime requested but Bun is not installed"
                exit 1
            fi
            START_COMMAND="bun run start:bun"
            ;;
        *)
            echo "❌ Error: Invalid runtime specified. Use 'bun' only (node deprecated)"
            exit 1
            ;;
    esac
else
    # Default behavior: Check if Bun is available and set the start command
    if command -v bun &> /dev/null; then
        START_COMMAND="bun run start:bun"
        log_verbose "Using Bun runtime with command: $START_COMMAND"
    else
        echo "❌ Error: Bun is not installed and is required to run the node (since 0.9.5)"
        echo "💡 Install Bun from: https://bun.sh/docs/installation"
        if [ "$PLATFORM_NAME" = "macOS" ]; then
            echo "🍎 On macOS: brew install oven-sh/bun/bun"
        elif [ "$PLATFORM_NAME" = "Linux" ]; then
            echo "🐧 On Linux: curl -fsSL https://bun.sh/install | bash"
        fi
        exit 1
    fi
    # Temporary overriding
    START_COMMAND="bun start:bun"  # REVIEW Consider using bun directly
fi


echo "🚀 Starting your Demos Network node..."
log_verbose "Using command: $START_COMMAND"
echo "💡 This may take a moment to initialize all services..."
sleep 1


# PG_PORT and IDENTITY_FILE are exported for both docker and bun
export PG_PORT=$PG_PORT
export IDENTITY_FILE=$IDENTITY_FILE
export EXPOSED_URL=$EXPOSED_URL
export PEER_LIST_FILE=$PEER_LIST_FILE
export RESTORE=$RESTORE

# Database management with proper folder based on the port
# Create a unique postgres folder for this instance based on the port number
PG_FOLDER="postgres_${PG_PORT}" 

# If the folder doesn't exist yet, create it by copying the base postgres folder
# This allows multiple instances to run simultaneously with different ports
if [ ! -d "$PG_FOLDER" ]; then
    cp -r postgres $PG_FOLDER
fi
cd $PG_FOLDER

# If we are cleaning, we need to remove the database
if [ "$CLEAN" == "true" ]; then
    echo "🧹 Cleaning the database..."
    log_verbose "Removing existing database data for clean start"
    sleep 1
    rm -rf data_*
    mkdir data_${PG_PORT}
    echo "✅ Database cleaned"
fi

# Suppressing errors if the database is not running
docker compose down > /dev/null 2>&1
if [ "$CLEAN" == "true" ]; then
    rm -rf data_${PG_PORT} || rm -rf data_${PG_PORT}
    mkdir data_${PG_PORT}
fi

# Finally starting the database
echo "🗄️  Starting PostgreSQL database..."
log_verbose "Running docker compose up -d in $PG_FOLDER"
if ! docker compose up -d; then
    echo "❌ Failed to start PostgreSQL database"
    echo "💡 Check Docker Desktop is running and try again"
    exit 1
fi
echo "✅ PostgreSQL container started"
cd ..

function is_db_ready() {
    docker exec postgres_${PG_PORT} pg_isready -U demosuser -d demos > /dev/null 2>&1
    return $?
}

# Function to wait for database availability
function wait_for_database() {
    local port=$1
    local timeout=${2:-30}  # Increased timeout to 30 seconds
    
    echo "⏳ Waiting for PostgreSQL to be available on port $port..."
    log_verbose "Checking database connectivity with timeout of ${timeout}s"
    local count=0
    while ! nc -z localhost $port; do
        if [ $((count % 5)) -eq 0 ]; then
            echo "   Still waiting... (${count}s elapsed)"
        fi
        count=$((count+1))
        if [ $count -gt $timeout ]; then
            echo "❌ Timeout waiting for PostgreSQL to be available after ${timeout}s"
            echo "💡 Try increasing resources or check Docker logs"
            return 1
        fi
        sleep 1
    done
    echo "✅ PostgreSQL is accepting connections"
    return 0
}

function wait_for_database_ready() {
    local port=$1
    local timeout=${2:-20}  # Increased timeout to 20 seconds
    
    echo "⏳ Waiting for PostgreSQL to be ready for connections..."
    log_verbose "Checking database readiness with pg_isready, timeout ${timeout}s"
    local count=0
    while ! is_db_ready; do   
        if [ $((count % 3)) -eq 0 ] && [ $count -gt 0 ]; then
            echo "   Database initializing... (${count}s elapsed)"
        fi
        count=$((count+1))
        if [ $count -gt $timeout ]; then
            echo "❌ Timeout waiting for PostgreSQL to be ready after ${timeout}s"
            echo "💡 Database may be still initializing - check Docker logs"
            return 1
        fi
        sleep 1
    done
    echo "✅ PostgreSQL is ready for operations"
    return 0
}

# Replace the original wait code with function call
if ! wait_for_database $PG_PORT; then
    echo "❌ Failed to connect to PostgreSQL database"
    echo "💡 Try restarting Docker or check system resources"
    exit 1
fi

if [ "$RESTORE" == "true" ]; then
    if ! wait_for_database_ready $PG_PORT; then
        echo "❌ Failed to connect to PostgreSQL database"
        echo "💡 Database may need more time to initialize"
        exit 1
    fi

    echo "🔄 Restoring the node"
    if ! bun run restore; then
        echo "❌ Error: Failed to restore the node"
        exit 1
    fi
    # sleep 20
    # exit 0

    # Stop the database
    echo "Stopping the database"
    cd postgres_${PG_PORT}
    docker compose down

    # Remove the database folder
    echo "Removing the database folder"
    rm -rf data_* || sudo rm -rf data_*
    mkdir data_${PG_PORT}

    # Start the database
    echo "Starting the database"
    docker compose up -d
    cd ..

    # Wait for the database to be available
    echo "Restarting database"
    wait_for_database $PG_PORT
# else
#     echo "Cleaning the output/ folder"
#     rm -rf output/*
fi

# Ensuring the logs folder exists
mkdir -p logs

echo ""
echo "🎉 All systems ready! Starting your Demos Network node..."
echo "📝 Logs will be saved to: logs/"
echo "🌐 Your node will be available on: http://localhost:$PORT"
if [ ! -z "$EXPOSED_URL" ]; then
    echo "🌍 External URL: $EXPOSED_URL"
fi
echo ""
echo "💡 Press Ctrl+C to stop the node safely"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

# Starting the node managing errors
log_verbose "Starting node with environment: RPC_PORT=$PORT PG_PORT=$PG_PORT IDENTITY_FILE=$IDENTITY_FILE"
if ! RPC_PORT=$PORT PG_PORT=$PG_PORT IDENTITY_FILE=$IDENTITY_FILE $START_COMMAND; then
    if [ "$HAS_BEEN_INTERRUPTED" == "true" ]; then
        echo ""
        echo "✅ Demos Network node stopped successfully"
    else
        echo "❌ Error: RPC failed to start or crashed"
        exit_code=$?
        # Logging memory usage (cross-platform)
        echo "💾 Memory usage at crash:"
        if [ "$PLATFORM_NAME" = "macOS" ]; then
            vm_stat | head -10
            vm_stat | head -10 > last_crash_memory_usage.txt
        elif [ "$PLATFORM_NAME" = "Linux" ]; then
            free -m
            free -m > last_crash_memory_usage.txt
        else
            echo "Unknown platform - cannot collect memory info"
            echo "Platform: $PLATFORM_NAME" > last_crash_memory_usage.txt
        fi
    fi
else
    echo ""
    echo "✅ Demos Network node exited successfully"
    exit_code=0
fi

# Once exiting, stopping the database
echo "🛑 Stopping PostgreSQL database..."
cd postgres_${PG_PORT}
if docker compose down; then
    echo "✅ PostgreSQL stopped successfully"
else
    echo "⚠️  Warning: Failed to stop PostgreSQL gracefully"
fi
cd ..

echo ""
echo "🏁 Demos Network node session completed"
echo "💡 Thank you for running a Demos Network node!"
echo "📚 For support: https://demos.network/support"
echo ""

log_verbose "Final exit code: $exit_code"