Minecraft Server Deploy And Maintenance Linux

#!/bin/bash

# --- Configuration ---
# Set your desired Minecraft version here. E.g., "1.20.4", "1.19.2"
MINECRAFT_VERSION="1.20.4"
# The directory where your Minecraft server files will be stored.
# Using /opt/minecraft is recommended for system-wide servers.
SERVER_DIR="/opt/minecraft"
# Default Java memory allocation. Adjust based on your server's needs.
# Examples: "2G" (2 Gigabytes), "4096M" (4096 Megabytes)
JAVA_MEMORY="4G"

# Internal variable for the server JAR file name.
# This will be automatically detected or set during installation.
SERVER_JAR_NAME=""
# Internal variable for the server type.
# This will be automatically detected or set during installation.
SERVER_TYPE="unknown" # "vanilla", "paper", "forge", "fabric", "unknown"

# --- Colors for better readability ---
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
RED='\033[0;31m'
BLUE='\033[0;34m' # Added Blue for some options
CYAN='\033[0;36m' # Added Cyan for some options
NC='\033[0m' # No Color

# --- Helper Functions ---
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Function to get current server status (Running/Stopped)
get_server_status() {
    if screen -list | grep -q "minecraft"; then
        echo -e "${GREEN}RUNNING${NC}"
    else
        echo -e "${RED}STOPPED${NC}"
    fi
}

# --- Check and Install Prerequisites ---
check_prerequisites() {
    log_info "Checking system prerequisites..."

    # Check for Java (OpenJDK 17 or higher is recommended for MC 1.17+)
    if ! command -v java &> /dev/null; then
        log_warn "Java is not installed. Attempting to install OpenJDK 17 JRE..."
        sudo apt update
        sudo apt install -y openjdk-17-jre-headless
        if ! command -v java &> /dev/null; then
            log_error "Failed to install Java. Please install OpenJDK 17 (or higher) manually."
            exit 1
        fi
    else
        local java_version=$(java -version 2>&1 | awk -F '"' '/version/ {print $2}' | cut -d'.' -f1)
        if [[ "$java_version" -lt 17 ]]; then
            log_warn "Detected Java version ${java_version}. Minecraft ${MINECRAFT_VERSION} requires Java 17 or higher."
            log_warn "Attempting to install OpenJDK 17. If this fails, please upgrade Java manually."
            sudo apt update
            sudo apt install -y openjdk-17-jre-headless
            if ! command -v java &> /dev/null || [[ "$(java -version 2>&1 | awk -F '"' '/version/ {print $2}' | cut -d'.' -f1)" -lt 17 ]]; then
                log_error "Failed to install or upgrade Java to version 17. Please install Java 17 or higher manually."
                exit 1
            fi
        fi
    fi
    log_info "Java is installed and sufficient."

    # Check for 'screen' (for detached server sessions)
    if ! command -v screen &> /dev/null; then
        log_warn "Screen is not installed. Attempting to install 'screen'..."
        sudo apt update
        sudo apt install -y screen
        if ! command -v screen &> /dev/null; then
            log_error "Failed to install 'screen'. Please install it manually: sudo apt install screen."
            exit 1
        fi
    fi
    log_info "Screen is installed."

    # Check for 'curl' or 'wget' (for downloading server JARs)
    if ! command -v curl &> /dev/null && ! command -v wget &> /dev/null; then
        log_warn "Neither 'curl' nor 'wget' are installed. Attempting to install 'wget'..."
        sudo apt update
        sudo apt install -y wget
        if ! command -v wget &> /dev/null; then
            log_error "Failed to install 'wget'. Please install 'wget' or 'curl' manually."
            exit 1
        fi
    fi
    log_info "Download tools (curl/wget) are available."

    # Check for 'jq' (for parsing JSON APIs, especially PaperMC and Vanilla)
    if ! command -v jq &> /dev/null; then
        log_warn "'jq' is not installed. It's needed for downloading PaperMC/Vanilla servers. Attempting to install 'jq'..."
        sudo apt update
        sudo apt install -y jq
        if ! command -v jq &> /dev/null; then
            log_error "Failed to install 'jq'. Please install 'jq' manually: sudo apt install jq."
            exit 1
        fi
    fi
    log_info "jq is installed."

    log_info "All prerequisites met."
}

# --- Server Installation Functions ---

# Install Vanilla Minecraft Server
install_vanilla() {
    log_info "Attempting to install Vanilla Minecraft server version ${MINECRAFT_VERSION}..."
    local version_manifest_url="https://launchermeta.mojang.com/mc/game/version_manifest.json"
    local version_data_url=$(curl -s "$version_manifest_url" | jq -r ".versions[] | select(.id == \"${MINECRAFT_VERSION}\") | .url")

    if [ -z "$version_data_url" ] || [ "$version_data_url" = "null" ]; then
        log_error "Could not find Vanilla version data for Minecraft ${MINECRAFT_VERSION}. Please check the version number."
        return 1
    fi

    local server_jar_url=$(curl -s "$version_data_url" | jq -r ".downloads.server.url")

    if [ -z "$server_jar_url" ] || [ "$server_jar_url" = "null" ]; then
        log_error "Could not find server JAR download URL for Minecraft ${MINECRAFT_VERSION}. Aborting."
        return 1
    fi

    SERVER_JAR_NAME="server.jar"
    log_info "Downloading Vanilla server JAR from: ${server_jar_url}"
    wget -q --show-progress -O "${SERVER_DIR}/${SERVER_JAR_NAME}" "$server_jar_url"
    if [ $? -ne 0 ]; then
        log_error "Failed to download Vanilla server JAR."
        return 1
    fi
    log_info "Vanilla server JAR downloaded."
    return 0
}

# Install PaperMC Server
install_papermc() {
    log_info "Attempting to install PaperMC server version ${MINECRAFT_VERSION}..."
    local api_url="https://api.papermc.io/v2/projects/paper/versions/${MINECRAFT_VERSION}"
    local latest_build_number=$(curl -s "$api_url" | jq -r '.builds | last')

    if [ -z "$latest_build_number" ] || [ "$latest_build_number" = "null" ]; then
        log_error "Could not find latest PaperMC build for Minecraft ${MINECRAFT_VERSION}. Aborting."
        log_error "PaperMC might not support version ${MINECRAFT_VERSION} yet, or the API structure has changed."
        return 1
    fi

    local download_url="https://api.papermc.io/v2/projects/paper/versions/${MINECRAFT_VERSION}/builds/${latest_build_number}/downloads/paper-${MINECRAFT_VERSION}-${latest_build_number}.jar"
    SERVER_JAR_NAME="paper-${MINECRAFT_VERSION}-${latest_build_number}.jar"

    log_info "Downloading PaperMC server JAR from: ${download_url}"
    wget -q --show-progress -O "${SERVER_DIR}/${SERVER_JAR_NAME}" "$download_url"
    if [ $? -ne 0 ]; then
        log_error "Failed to download PaperMC server JAR."
        return 1
    fi
    log_info "PaperMC server JAR downloaded."
    return 0
}

# Install Forge Server (Manual steps involved)
install_forge() {
    log_info "Installing Forge server for Minecraft version ${MINECRAFT_VERSION}..."
    log_warn "Forge server installation is more involved and requires manual steps after download."
    log_warn "This script will NOT automatically run the Forge installer due to varying prompts and EULAs."

    echo ""
    echo -e "${YELLOW}Manual Steps for Forge Server Installation:${NC}"
    echo "1. Go to the official Forge download page: ${GREEN}https://files.minecraftforge.net/net/minecraftforge/forge/index.html${NC}"
    echo "2. Select Minecraft version ${MINECRAFT_VERSION} from the left sidebar."
    echo "3. Download the 'Installer' JAR file for the Recommended Build."
    echo "4. Place the downloaded Forge installer JAR (e.g., 'forge-*-installer.jar') into your server directory: ${SERVER_DIR}"
    echo "5. Navigate to your server directory: ${YELLOW}cd ${SERVER_DIR}${NC}"
    echo "6. Run the installer from the command line: ${YELLOW}java -jar <installer_name>.jar --installServer${NC}"
    echo "   (Replace <installer_name>.jar with the actual file name you downloaded)"
    echo "7. This will create a 'libraries' folder and a new server JAR (e.g., 'forge-<version>.jar' or 'minecraft_server.<version>.jar')."
    echo "8. The installer may also create a 'run.sh' or 'run.bat' script. You can use the generated server JAR directly with this script."
    echo "   The actual server JAR file is typically named something like 'forge-$(echo ${MINECRAFT_VERSION})-<forge_version>.jar'."
    echo "   You may want to rename it to 'server.jar' for simplicity, or update the SERVER_JAR_NAME variable in this script."
    echo ""

    read -p "Press Enter after you have manually downloaded and installed Forge (and placed the server JAR in ${SERVER_DIR})..."

    # Try to detect the generated server JAR
    local found_jar=$(find "${SERVER_DIR}" -maxdepth 1 -name "forge-*-${MINECRAFT_VERSION}-*.jar" -o -name "server.jar" -o -name "minecraft_server.*.jar" -print -quit)
    if [ -n "$found_jar" ]; then
        SERVER_JAR_NAME=$(basename "$found_jar")
        log_info "Detected server JAR: ${SERVER_JAR_NAME}. Please confirm this is correct for your Forge installation."
    else
        log_warn "Could not automatically detect Forge server JAR. Please verify it's in ${SERVER_DIR} and set SERVER_JAR_NAME manually in the script if issues arise."
        SERVER_JAR_NAME="forge-server.jar" # Placeholder, user needs to ensure correct name
    fi
    return 0
}

# Install Fabric Server (Manual steps involved)
install_fabric() {
    log_info "Installing Fabric server for Minecraft version ${MINECRAFT_VERSION}..."
    log_warn "Fabric server installation requires manual steps after downloading the installer."

    local fabric_installer_url="https://meta.fabricmc.net/v2/versions/installer"
    local latest_installer=$(curl -s "$fabric_installer_url" | jq -r '.[0].url')
    local installer_name="fabric-installer.jar"

    if [ -z "$latest_installer" ] || [ "$latest_installer" = "null" ]; then
        log_error "Failed to get latest Fabric installer URL from API."
        return 1
    fi

    log_info "Downloading Fabric installer from: ${latest_installer}"
    wget -q --show-progress -O "${SERVER_DIR}/${installer_name}" "$latest_installer"
    if [ $? -ne 0 ]; then
        log_error "Failed to download Fabric installer."
        return 1
    fi
    log_info "Fabric installer downloaded to ${SERVER_DIR}/${installer_name}."

    echo ""
    echo -e "${YELLOW}Manual Steps for Fabric Server Installation:${NC}"
    echo "1. Navigate to your server directory: ${YELLOW}cd ${SERVER_DIR}${NC}"
    echo "2. Run the Fabric installer to create the server JAR:"
    echo "   ${YELLOW}java -jar ${installer_name} server -mcversion ${MINECRAFT_VERSION}${NC}"
    echo "3. This will generate a Fabric server JAR (e.g., 'fabric-server-mc.${MINECRAFT_VERSION}-loader.<loader_version>.jar')."
    echo "   You may want to rename it to 'server.jar' for simplicity, or update the SERVER_JAR_NAME variable in this script."
    echo ""

    read -p "Press Enter after you have manually run the Fabric installer (and placed the server JAR in ${SERVER_DIR})..."

    # Try to detect the generated server JAR
    local found_jar=$(find "${SERVER_DIR}" -maxdepth 1 -name "fabric-server-mc*.jar" -o -name "server.jar" -print -quit)
    if [ -n "$found_jar" ]; then
        SERVER_JAR_NAME=$(basename "$found_jar")
        log_info "Detected server JAR: ${SERVER_JAR_NAME}. Please confirm this is correct for your Fabric installation."
    else
        log_warn "Could not automatically detect Fabric server JAR. Please verify it's in ${SERVER_DIR} and set SERVER_JAR_NAME manually in the script if issues arise."
        SERVER_JAR_NAME="fabric-server.jar" # Placeholder, user needs to ensure correct name
    fi
    return 0
}

# --- Main Server Installation Flow ---
install_minecraft_server() {
    log_info "Starting Minecraft server installation..."

    if [ -d "$SERVER_DIR" ]; then
        log_warn "Server directory $SERVER_DIR already exists."
        read -p "Do you want to reinstall/update the server? (y/N): " choice
        case "$choice" in
            y|Y)
                log_warn "Existing server files will be moved to a backup directory ($SERVER_DIR.bak) before proceeding."
                if [ -d "${SERVER_DIR}.bak" ]; then
                    rm -rf "${SERVER_DIR}.bak"
                fi
                mv "$SERVER_DIR" "${SERVER_DIR}.bak"
                log_info "Old server directory moved to ${SERVER_DIR}.bak"
                ;;
            *)
                log_info "Installation cancelled. Exiting to main menu."
                return 1
                ;;
        esac
    fi

    # Create server directory and set ownership
    sudo mkdir -p "$SERVER_DIR"
    sudo chown -R "$USER":"$USER" "$SERVER_DIR"
    log_info "Minecraft server directory created: $SERVER_DIR"

    echo ""
    echo "Choose your desired Minecraft server type:"
    echo "1) Vanilla (Official Minecraft Server - No mods or plugins)"
    echo "2) PaperMC (High-performance Spigot/Bukkit fork - Supports plugins)"
    echo "3) Forge (Modding API - Supports mods, often used for modpacks)"
    echo "4) Fabric (Lightweight Modding API - Supports mods, often for performance mods)"
    read -p "Enter your choice (1-4): " server_choice

    local install_success=1
    case "$server_choice" in
        1) SERVER_TYPE="vanilla"; install_vanilla && install_success=0 ;;
        2) SERVER_TYPE="paper"; install_papermc && install_success=0 ;;
        3) SERVER_TYPE="forge"; install_forge && install_success=0 ;;
        4) SERVER_TYPE="fabric"; install_fabric && install_success=0 ;;
        *) log_error "Invalid choice. Aborting installation."; return 1 ;;
    esac

    if [ "$install_success" -ne 0 ]; then
        log_error "Server type installation failed. Aborting."
        return 1
    fi

    # Accept EULA
    echo "eula=true" > "${SERVER_DIR}/eula.txt"
    log_info "Minecraft EULA accepted."

    # Initial server run to generate configuration files (server.properties, etc.)
    # This is crucial for Forge/Fabric too, as it sets up their environment.
    log_info "Performing initial server run to generate configuration files (this may take a moment)..."
    log_info "The server will start briefly and then stop automatically (or may require manual Ctrl+C if not shutting down on its own)."
    log_info "Please do NOT try to connect to the server during this step."

    cd "$SERVER_DIR" || { log_error "Failed to change to server directory: $SERVER_DIR."; return 1; }
    # Run in the foreground, wait a bit, then kill it.
    java -Xmx128M -Xms128M -jar "${SERVER_JAR_NAME}" nogui &
    SERVER_PID=$!
    sleep 30 # Give it time to generate files

    if kill -0 $SERVER_PID 2>/dev/null; then # Check if process is still running
        log_warn "Server process still active after initial run. Attempting graceful shutdown."
        kill $SERVER_PID # Send SIGTERM
        sleep 10
        if kill -0 $SERVER_PID 2>/dev/null; then # If still running, force kill
            log_error "Server did not shut down gracefully. Forcing termination."
            kill -9 $SERVER_PID
        fi
    fi
    log_info "Initial server file generation complete."

    log_info "Minecraft server installation complete."
    log_info "Remember to configure server.properties (and any other config files) in $SERVER_DIR before starting the server."
    log_info "You can adjust the allocated RAM using option 9 in the main menu."
    return 0
}

# --- Server Management Functions ---

# Start the Minecraft server in a screen session
start_server() {
    if [ ! -f "${SERVER_DIR}/${SERVER_JAR_NAME}" ]; then
        log_error "Server JAR not found at ${SERVER_DIR}/${SERVER_JAR_NAME}. Please install the server first (Option 1)."
        return 1
    fi

    if screen -list | grep -q "minecraft"; then
        log_warn "Minecraft server is already running."
        return 0
    fi

    log_info "Starting Minecraft server with ${JAVA_MEMORY} RAM..."
    cd "$SERVER_DIR" || { log_error "Failed to change to server directory: $SERVER_DIR."; return 1; }
    screen -dmS minecraft java -Xmx${JAVA_MEMORY} -Xms${JAVA_MEMORY} -jar "${SERVER_JAR_NAME}" nogui
    if [ $? -eq 0 ]; then
        log_info "Minecraft server started in a screen session named 'minecraft'."
        log_info "To attach to the server console, select Option 8 from the main menu."
        log_info "To detach from the console, press Ctrl+A then D."
    else
        log_error "Failed to start Minecraft server. Check Java and server JAR path."
    fi
}

# Stop the Minecraft server
stop_server() {
    if ! screen -list | grep -q "minecraft"; then
        log_warn "Minecraft server is not running."
        return 0
    fi

    log_info "Stopping Minecraft server gracefully..."
    # Send 'stop' command to the screen session
    screen -p 0 -S minecraft -X eval 'stuff "stop"\015'

    local wait_time=0
    local max_wait=60 # Wait up to 60 seconds
    while screen -list | grep -q "minecraft" && [ "$wait_time" -lt "$max_wait" ]; do
        echo -n "."
        sleep 5
        wait_time=$((wait_time+5))
    done
    echo "" # Newline after dots

    if screen -list | grep -q "minecraft"; then
        log_warn "Server did not shut down gracefully within ${max_wait} seconds. Forcibly terminating screen session."
        screen -X -S minecraft quit
    fi
    log_info "Minecraft server stopped."
}

# Restart the Minecraft server
restart_server() {
    log_info "Restarting Minecraft server..."
    stop_server
    sleep 5 # Give it a moment to fully shut down
    start_server
    log_info "Minecraft server restart sequence complete."
}

# Backup the Minecraft server directory
backup_server() {
    if [ ! -d "$SERVER_DIR" ]; then
        log_error "Server directory not found at $SERVER_DIR. Cannot perform backup."
        return 1
    fi

    log_info "Starting Minecraft server backup..."
    local backup_base_dir="/var/backups/minecraft_servers" # Central backup location
    sudo mkdir -p "$backup_base_dir"
    sudo chown -R "$USER":"$USER" "$backup_base_dir"

    local timestamp=$(date +%Y%m%d-%H%M%S)
    local backup_filename="minecraft-server-backup-${timestamp}.tar.gz"
    local full_backup_path="${backup_base_dir}/${backup_filename}"

    # Change to parent directory of SERVER_DIR for tar to work correctly
    # e.g., if SERVER_DIR is /opt/minecraft, tar from /opt
    log_info "Creating archive: ${full_backup_path}"
    tar -czvf "${full_backup_path}" -C "$(dirname "$SERVER_DIR")" "$(basename "$SERVER_DIR")"
    if [ $? -eq 0 ]; then
        log_info "Backup complete: ${full_backup_path}"
        log_info "You may want to move this backup to a safe off-site location."
    else
        log_error "Backup failed."
    fi
}

# Update the Minecraft server JAR
update_server() {
    if [ ! -f "${SERVER_DIR}/${SERVER_JAR_NAME}" ]; then
        log_error "Server JAR not found at ${SERVER_DIR}/${SERVER_JAR_NAME}. Please install the server first."
        return 1
    fi

    log_info "Attempting to update Minecraft server JAR to the latest for version ${MINECRAFT_VERSION}..."
    read -p "This will replace your current server JAR. Do you want to proceed? (y/N): " confirm_update
    if [[ ! "$confirm_update" =~ ^[Yy]$ ]]; then
        log_info "Server update cancelled."
        return 0
    fi

    # Stop server before update
    if screen -list | grep -q "minecraft"; then
        log_warn "Server is running. Stopping it before update..."
        stop_server
        sleep 5
    fi

    # Backup existing JAR before replacement
    mv "${SERVER_DIR}/${SERVER_JAR_NAME}" "${SERVER_DIR}/${SERVER_JAR_NAME}.old"
    log_info "Old server JAR backed up to ${SERVER_JAR_NAME}.old"

    local update_success=1
    case "$SERVER_TYPE" in
        "vanilla") install_vanilla && update_success=0 ;;
        "paper") install_papermc && update_success=0 ;;
        "forge")
            log_warn "Forge server updates typically involve downloading and running a new installer for your chosen Minecraft version."
            log_warn "This process is manual. Please download the new Forge installer for ${MINECRAFT_VERSION}."
            log_warn "Run it inside ${SERVER_DIR} to generate the updated server JAR."
            log_warn "Then, ensure the new server JAR is correctly named and located in ${SERVER_DIR}."
            read -p "Press Enter after you have manually updated Forge..."
            # Re-detect JAR name after manual update
            local found_jar=$(find "${SERVER_DIR}" -maxdepth 1 -name "forge-*-${MINECRAFT_VERSION}-*.jar" -o -name "server.jar" -o -name "minecraft_server.*.jar" -print -quit)
            if [ -n "$found_jar" ]; then
                SERVER_JAR_NAME=$(basename "$found_jar")
                log_info "Detected new server JAR: ${SERVER_JAR_NAME}. If this is incorrect, manually set SERVER_JAR_NAME in the script."
                update_success=0
            else
                log_error "Could not detect new Forge server JAR. Manual verification needed."
            fi
            ;;
        "fabric")
            log_warn "Fabric server updates typically involve downloading and running a new installer for your chosen Minecraft version."
            log_warn "This process is manual. Please download the new Fabric installer for ${MINECRAFT_VERSION}."
            log_warn "Run it inside ${SERVER_DIR} to generate the updated server JAR."
            log_warn "Then, ensure the new server JAR is correctly named and located in ${SERVER_DIR}."
            read -p "Press Enter after you have manually updated Fabric..."
            # Re-detect JAR name after manual update
            local found_jar=$(find "${SERVER_DIR}" -maxdepth 1 -name "fabric-server-mc*.jar" -o -name "server.jar" -print -quit)
            if [ -n "$found_jar" ]; then
                SERVER_JAR_NAME=$(basename "$found_jar")
                log_info "Detected new server JAR: ${SERVER_JAR_NAME}. If this is incorrect, manually set SERVER_JAR_NAME in the script."
                update_success=0
            else
                log_error "Could not detect new Fabric server JAR. Manual verification needed."
            fi
            ;;
        *) log_error "Unknown server type (${SERVER_TYPE}) for automated update. Manual update required."; return 1 ;;
    esac

    if [ "$update_success" -eq 0 ]; then
        log_info "Server update attempt complete. Please check the logs if you experience issues."
    else
        log_error "Server update failed. Reverting to old JAR..."
        mv "${SERVER_DIR}/${SERVER_JAR_NAME}.old" "${SERVER_DIR}/${SERVER_JAR_NAME}" # Revert
        # If the JAR name changed, revert it in the script too
        SERVER_JAR_NAME=$(basename "${SERVER_DIR}/${SERVER_JAR_NAME}")
    fi

    # Start server after update (if it was running before)
    if [[ "$(get_server_status)" != *RUNNING* ]]; then # Only restart if it was actually stopped
        start_server
    fi
}

# --- Mod/Plugin Management Guidance (Not automated installation) ---
manage_mods_plugins() {
    clear
    log_info "Minecraft Mod/Plugin Management Guidance"
    echo ""
    echo "Minecraft mods and plugins are highly dependent on your server type and Minecraft version."
    echo "This script does NOT automatically download or install specific mods/plugins due to:"
    echo "  - Their dynamic nature (versions, dependencies change constantly)."
    echo "  - Compatibility issues (mods/plugins must match exact Minecraft and loader versions)."
    echo "  - Legal/Terms of Service for downloading from third-party sites."
    echo ""

    echo "Based on your current detected server type (${YELLOW}${SERVER_TYPE}${NC}):"
    case "$SERVER_TYPE" in
        "vanilla")
            echo "  ${RED}Vanilla Minecraft servers do not natively support mods or plugins.${NC}"
            echo "  If you want to use mods/plugins, you must install a PaperMC, Forge, or Fabric server (Option 1)."
            ;;
        "paper")
            echo "  ${GREEN}PaperMC servers support Bukkit/Spigot/Paper plugins.${NC}"
            echo "  These are server-side only and do not require client modifications."
            echo "  To install plugins:"
            echo "  1. Download plugin JAR files from reputable sources."
            echo "     ${YELLOW}Recommended sites:${NC} https://www.spigotmc.org/resources/, https://modrinth.com/plugins"
            echo "     Always check if the plugin supports Minecraft version ${MINECRAFT_VERSION}."
            echo "  2. Place the downloaded plugin JAR files into the ${YELLOW}${SERVER_DIR}/plugins/${NC} directory."
            echo "     If this directory doesn't exist, start the server once to create it, then stop it."
            echo "  3. Restart your server for the plugins to load."
            echo ""
            echo "  ${YELLOW}Examples of popular PaperMC plugins (check compatibility for ${MINECRAFT_VERSION}):${NC}"
            echo "  - EssentialsX: Core commands, homes, warps, kits, etc."
            echo "  - LuckPerms: Advanced permissions management."
            echo "  - WorldEdit/WorldGuard: Powerful tools for building and region protection."
            echo "  - CoreProtect: Logging and rollback for grief prevention."
            echo "  - Dynmap: Live, interactive web map of your server."
            echo "  - Vault: API for plugins to hook into economic systems and permissions."
            echo "  - ClearLag: Reduces server lag by clearing entities."
            echo "  - MobStacker: Stacks mobs to reduce entity count and lag."
            echo "  - ProtocolLib: Required by many advanced plugins."
            echo "  - TAB: Customizes tab list, nametags, and prefixes."
            ;;
        "forge")
            echo "  ${GREEN}Forge servers support Forge mods.${NC}"
            echo "  Both your server AND players connecting must have the exact same Forge version and mods."
            echo "  To install mods:"
            echo "  1. Download mod JAR files from reputable sources."
            echo "     ${YELLOW}Recommended sites:${NC} https://www.curseforge.com/minecraft/mc-mods, https://modrinth.com/mods"
            echo "     Always check if the mod is for Minecraft version ${MINECRAFT_VERSION} AND your Forge version."
            echo "  2. Place the downloaded mod JAR files into the ${YELLOW}${SERVER_DIR}/mods/${NC} directory."
            echo "     If this directory doesn't exist, start the server once to create it, then stop it."
            echo "  3. Restart your server for the mods to load."
            echo ""
            echo "  ${YELLOW}Examples of popular Forge mods (check compatibility for ${MINECRAFT_VERSION}):${NC}"
            echo "  - Applied Energistics 2 / Refined Storage: Advanced item storage and automation."
            echo "  - Thermal Expansion / Mekanism: Tech mods for power generation, machinery, and automation."
            echo "  - Biomes O' Plenty / Oh The Biomes You'll Go: Adds many new biomes and world generation features."
            echo "  - Twilight Forest: A new, exploration-focused dimension."
            echo "  - Iron Chests: Upgraded chests with more storage space."
            echo "  - Waystones: Teleportation points for easier travel."
            echo "  - Botania: A magic-themed tech mod using natural flora."
            echo "  - Create: A unique mod focused on contraptions, automation, and moving parts."
            echo "  - Immersive Engineering: Adds realistic industrial machinery and power generation."
            echo "  - Pam's HarvestCraft 2: Adds a vast array of new crops, foods, and cooking mechanics."
            echo "  - Mystical Agriculture: Allows growing resources (ores, mob drops) from crops."
            echo "  - JourneyMap / Xaero's World Map (Client-side maps, but popular in modpacks)."
            echo "  - JEI (Just Enough Items): (Client-side, shows recipes and item info, essential for modpacks)."
            ;;
        "fabric")
            echo "  ${GREEN}Fabric servers support Fabric mods.${NC}"
            echo "  Both your server AND players connecting must have the exact same Fabric version and mods."
            echo "  To install mods:"
            echo "  1. Download mod JAR files from reputable sources."
            echo "     ${YELLOW}Recommended sites:${NC} https://www.curseforge.com/minecraft/mc-mods, https://modrinth.com/mods"
            echo "     Always check if the mod is for Minecraft version ${MINECRAFT_VERSION} AND your Fabric version."
            echo "  2. Place the downloaded mod JAR files into the ${YELLOW}${SERVER_DIR}/mods/${NC} directory."
            echo "     If this directory doesn't exist, start the server once to create it, then stop it."
            echo "  3. Restart your server for the mods to load."
            echo ""
            echo "  ${YELLOW}Examples of popular Fabric mods (check compatibility for ${MINECRAFT_VERSION}):${NC}"
            echo "  - Lithium: Server-side performance optimizations for game logic."
            echo "  - Phosphor: Server-side performance optimizations for lighting engine."
            echo "  - Carpet Mod: Technical utilities and bug fixes, often used by technical players."
            echo "  - Fabric API: A library required by many Fabric mods."
            echo "  - TerraLith / Tectonic / Incendium: Comprehensive world generation overhauls."
            echo "  - Applied Energistics 2 / Refined Storage (available on Fabric): Advanced storage."
            echo "  - Create (available on Fabric): Mechanical automation and contraptions."
            echo "  - Waystones (available on Fabric): Teleportation points."
            echo "  - BetterF3: (Client-side, improved debug screen)."
            echo "  - Mod Menu: (Client-side, in-game mod configuration list)."
            echo "  - Sodium / Iris / Indium: (Client-side performance & shaders, complement server)."
            echo "  - Litematica: (Client-side, schematic placements for building)."
            echo "  - Xaero's World Map / Minimap (Client-side maps, but popular)."
            ;;
        *)
            echo "  ${YELLOW}Server type ${SERVER_TYPE} is unknown or not yet configured.${NC}"
            echo "  Please install a server type (Option 1) to get specific mod/plugin guidance."
            ;;
    esac
    echo ""
    read -p "Press Enter to return to the main menu..."
}

# Attach to the server console via screen
attach_to_console() {
    if screen -list | grep -q "minecraft"; then
        log_info "Attaching to Minecraft server console. Press Ctrl+A then D to detach."
        screen -r minecraft
    else
        log_warn "Minecraft server screen session not found. Is the server running (Option 2)?"
        read -p "Press Enter to return to the main menu..."
    fi
}

# Change server configuration (RAM, Minecraft Version)
change_config() {
    clear
    log_info "Current Server Configuration:"
    echo "1) Minecraft Version: ${YELLOW}${MINECRAFT_VERSION}${NC}"
    echo "2) Allocated RAM: ${YELLOW}${JAVA_MEMORY}${NC}"
    echo "3) Server Directory: ${YELLOW}${SERVER_DIR}${NC} (Cannot be changed here without reinstall)"

    echo ""
    read -p "Enter number to change (1, 2) or 'b' to go back: " config_choice

    case "$config_choice" in
        1)
            read -p "Enter new Minecraft version (e.g., 1.20.4, 1.19.2): " new_version
            # Basic validation: check for X.Y.Z or X.Y format
            if [[ "$new_version" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]]; then
                MINECRAFT_VERSION="$new_version"
                log_info "Minecraft Version updated to ${MINECRAFT_VERSION}. Remember to run 'Install/Reinstall' (Option 1) or 'Update' (Option 6) for changes to take effect."
            else
                log_error "Invalid version format. Please use X.Y.Z or X.Y (e.g., 1.20.4)."
            fi
            ;;
        2)
            read -p "Enter new allocated RAM (e.g., 2G, 4G, 8G, 4096M): " new_ram
            if [[ "$new_ram" =~ ^[0-9]+[MG]$ ]]; then
                JAVA_MEMORY="$new_ram"
                log_info "Allocated RAM updated to ${JAVA_MEMORY}. Restart server (Option 4) for changes to take effect."
            else
                log_error "Invalid RAM format. Please use numbers followed by G (Gigabytes) or M (Megabytes)."
            fi
            ;;
        b|B)
            log_info "Returning to main menu."
            ;;
        *)
            log_error "Invalid choice."
            ;;
    esac
    read -p "Press Enter to continue..."
}

# --- Main Menu Display ---
display_menu() {
    clear
    echo -e "${GREEN}------------------------------------------------${NC}"
    echo -e "${CYAN}  Minecraft Server Management Script for Ubuntu ${NC}"
    echo -e "${GREEN}------------------------------------------------${NC}"
    echo -e "${BLUE}Server Information:${NC}"
    echo -e "${GREEN}  Server Directory: ${YELLOW}${SERVER_DIR}${NC}"
    echo -e "${GREEN}  Minecraft Version: ${YELLOW}${MINECRAFT_VERSION}${NC}"
    echo -e "${GREEN}  Server Type: ${YELLOW}${SERVER_TYPE}${NC}"
    echo -e "${GREEN}  Allocated RAM: ${YELLOW}${JAVA_MEMORY}${NC}"
    echo -e "${GREEN}  Server Status: $(get_server_status)${NC}"
    echo -e "${GREEN}------------------------------------------------${NC}"
    echo -e "${BLUE}Server Actions:${NC}"
    echo -e "${GREEN}1)${NC} ${YELLOW}Install/Reinstall Minecraft Server${NC}"
    echo -e "${GREEN}2)${NC} ${YELLOW}Start Minecraft Server${NC}"
    echo -e "${GREEN}3)${NC} ${YELLOW}Stop Minecraft Server${NC}"
    echo -e "${GREEN}4)${NC} ${YELLOW}Restart Minecraft Server${NC}"
    echo -e "${GREEN}5)${NC} ${YELLOW}Backup Minecraft Server${NC}"
    echo -e "${GREEN}6)${NC} ${YELLOW}Update Minecraft Server JAR${NC}"
    echo -e "${GREEN}7)${NC} ${YELLOW}Manage Mods/Plugins (Guidance Only)${NC}"
    echo -e "${GREEN}8)${NC} ${YELLOW}Attach to Server Console${NC}"
    echo -e "${GREEN}9)${NC} ${YELLOW}Change Server Configuration (RAM/Version)${NC}"
    echo -e "${GREEN}0)${NC} ${RED}Exit${NC}"
    echo -e "${GREEN}------------------------------------------------${NC}"
    read -p "Enter your choice: " choice
}

# --- Main Script Logic ---
main() {
    # Perform initial prerequisite checks
    check_prerequisites

    # Attempt to detect SERVER_JAR_NAME and SERVER_TYPE if server directory already exists
    if [ -d "$SERVER_DIR" ]; then
        local found_jar=$(find "${SERVER_DIR}" -maxdepth 1 -name "*.jar" -print -quit)
        if [ -n "$found_jar" ]; then
            SERVER_JAR_NAME=$(basename "$found_jar")
            log_info "Detected existing server JAR: ${SERVER_JAR_NAME}"

            # Infer server type from JAR name heuristics
            if [[ "$SERVER_JAR_NAME" == "server.jar" ]]; then
                SERVER_TYPE="vanilla"
            elif [[ "$SERVER_JAR_NAME" == paper-*-*.jar ]]; then
                SERVER_TYPE="paper"
            elif [[ "$SERVER_JAR_NAME" == forge-*.jar ]]; then
                SERVER_TYPE="forge"
            elif [[ "$SERVER_JAR_NAME" == fabric-server-mc*.jar ]]; then
                SERVER_TYPE="fabric"
            else
                SERVER_TYPE="unknown"
                log_warn "Could not determine server type from JAR name. Please manually set SERVER_TYPE if needed."
            fi
            log_info "Inferred server type: ${SERVER_TYPE}"
        else
            log_warn "No server JAR detected in ${SERVER_DIR}. Please run installation (Option 1)."
            SERVER_TYPE="unknown"
            SERVER_JAR_NAME="server.jar" # Set a default placeholder
        fi
    fi

    # Main menu loop
    while true; do
        display_menu
        case "$choice" in
            1) install_minecraft_server ;;
            2) start_server ;;
            3) stop_server ;;
            4) restart_server ;;
            5) backup_server ;;
            6) update_server ;;
            7) manage_mods_plugins ;;
            8) attach_to_console ;;
            9) change_config ;;
            0)
                log_info "Exiting. Goodbye!"
                exit 0
                ;;
            *) log_error "Invalid choice. Please enter a number from the menu." ;;
        esac
        # Pause after each action, unless it's attaching to console or exiting
        if [[ "$choice" != "8" && "$choice" != "0" ]]; then
            read -p "Press Enter to return to the menu..."
        fi
    done
}

# Execute the main function
main