#!/bin/bash

# Minecraft Server Auto-Installer für Debian 13
# Author: Claude Assistant
# Version: 1.1

set -e  # Beenden bei Fehlern

# Farben für Output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Banner
echo -e "${BLUE}"
echo "=================================================="
echo "     MINECRAFT SERVER AUTO-INSTALLER"
echo "           für Debian 13 Homelab"
echo "=================================================="
echo -e "${NC}"

# Prüfung ob als root ausgeführt
if [[ $EUID -eq 0 ]]; then
   echo -e "${RED}Dieses Script sollte NICHT als root ausgeführt werden!${NC}"
   echo "Führe es als normaler User mit sudo-Rechten aus."
   exit 1
fi

# Prüfung ob sudo verfügbar
if ! sudo -n true 2>/dev/null; then
    echo -e "${RED}Sudo-Rechte erforderlich!${NC}"
    exit 1
fi

# Prüfung der Distribution
if ! grep -q "Debian GNU/Linux 13" /etc/os-release 2>/dev/null; then
    echo -e "${YELLOW}Warnung: Dieses Script ist für Debian 13 optimiert.${NC}"
    read -p "Trotzdem fortfahren? (y/N): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
    fi
fi

echo -e "${GREEN}✓ Systemprüfung erfolgreich${NC}"

# Konfigurationsabfragen
echo -e "\n${BLUE}=== KONFIGURATION ===${NC}"

# RAM für Minecraft
echo -e "\n${YELLOW}RAM-Konfiguration:${NC}"
echo "Empfohlungen:"
echo "  1-5 Spieler:   2-3 GB"
echo "  5-10 Spieler:  3-4 GB"
echo "  10-20 Spieler: 4-6 GB"
while true; do
    read -p "Wie viel RAM für Minecraft Server (in GB)? [3]: " MC_RAM
    MC_RAM=${MC_RAM:-3}
    if [[ $MC_RAM =~ ^[0-9]+$ ]] && [ $MC_RAM -ge 1 ] && [ $MC_RAM -le 16 ]; then
        break
    else
        echo -e "${RED}Bitte gib eine Zahl zwischen 1 und 16 ein.${NC}"
    fi
done

# Maximale Spieleranzahl
while true; do
    read -p "Maximale Spieleranzahl [10]: " MAX_PLAYERS
    MAX_PLAYERS=${MAX_PLAYERS:-10}
    if [[ $MAX_PLAYERS =~ ^[0-9]+$ ]] && [ $MAX_PLAYERS -ge 1 ] && [ $MAX_PLAYERS -le 100 ]; then
        break
    else
        echo -e "${RED}Bitte gib eine Zahl zwischen 1 und 100 ein.${NC}"
    fi
done

# Server-Name
read -p "Server-Name (MOTD) [Mein Homelab Minecraft Server]: " SERVER_NAME
SERVER_NAME=${SERVER_NAME:-"Mein Homelab Minecraft Server"}

# Schwierigkeit
echo -e "\nSchwierigkeit:"
echo "  1) Peaceful (keine Monster)"
echo "  2) Easy"
echo "  3) Normal"
echo "  4) Hard"
while true; do
    read -p "Wähle Schwierigkeit (1-4) [3]: " DIFFICULTY_CHOICE
    DIFFICULTY_CHOICE=${DIFFICULTY_CHOICE:-3}
    case $DIFFICULTY_CHOICE in
        1) DIFFICULTY="peaceful"; break;;
        2) DIFFICULTY="easy"; break;;
        3) DIFFICULTY="normal"; break;;
        4) DIFFICULTY="hard"; break;;
        *) echo -e "${RED}Bitte wähle 1, 2, 3 oder 4.${NC}";;
    esac
done

# Spielmodus
echo -e "\nSpielmodus:"
echo "  1) Survival"
echo "  2) Creative"
echo "  3) Adventure"
while true; do
    read -p "Wähle Spielmodus (1-3) [1]: " GAMEMODE_CHOICE
    GAMEMODE_CHOICE=${GAMEMODE_CHOICE:-1}
    case $GAMEMODE_CHOICE in
        1) GAMEMODE="survival"; break;;
        2) GAMEMODE="creative"; break;;
        3) GAMEMODE="adventure"; break;;
        *) echo -e "${RED}Bitte wähle 1, 2 oder 3.${NC}";;
    esac
done

# PvP
read -p "PvP aktivieren? (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
    PVP="true"
else
    PVP="false"
fi

# Online-Mode
echo -e "\n${YELLOW}Online-Mode:${NC}"
echo "  true:  Nur Original Minecraft-Accounts (empfohlen)"
echo "  false: Auch Cracked-Clients erlaubt"
read -p "Online-Mode aktivieren? (Y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Nn]$ ]]; then
    ONLINE_MODE="false"
else
    ONLINE_MODE="true"
fi

# Automatische Backups
read -p "Automatische Backups alle 6 Stunden aktivieren? (Y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Nn]$ ]]; then
    ENABLE_BACKUPS="false"
else
    ENABLE_BACKUPS="true"
fi

# Client-Version abfragen
echo -e "\n${YELLOW}Minecraft Client-Version:${NC}"
echo "Welche Minecraft-Version hast du in deinem Launcher?"
echo "(Schaue unten rechts im Minecraft Launcher für die exakte Version)"
echo ""
echo "Beispiele: 1.21, 1.21.1, 1.21.4, 1.21.8, etc."
while true; do
    read -p "Deine Minecraft-Version: " MC_VERSION
    if [[ $MC_VERSION =~ ^1\.21(\.[0-9]+)?$ ]]; then
        break
    else
        echo -e "${RED}Bitte gib eine gültige 1.21.x Version ein (z.B. 1.21.8)${NC}"
    fi
done

# Server-URLs für verschiedene Versionen (aktualisiert)
declare -A SERVER_URLS
SERVER_URLS["1.21"]="https://piston-data.mojang.com/v1/objects/450698d1863ab5180c25d7c804ef0fe6369dd1ba/server.jar"
SERVER_URLS["1.21.1"]="https://piston-data.mojang.com/v1/objects/59353fb40c36d304f2035d51e7d6e6baa98dc05c/server.jar"
SERVER_URLS["1.21.2"]="https://piston-data.mojang.com/v1/objects/3cf2bac3e3a6e6b2fc87a43fb49fe9633eb9b573/server.jar"
SERVER_URLS["1.21.3"]="https://piston-data.mojang.com/v1/objects/450698d1863ab5180c25d7c804ef0fe6369dd1ba/server.jar"
SERVER_URLS["1.21.4"]="https://piston-data.mojang.com/v1/objects/4707d00eb834b446575d89a61a11b5d548d8c001/server.jar"
SERVER_URLS["1.21.8"]="https://piston-data.mojang.com/v1/objects/6bce4ef400e4efaa63a13d5e6f6b500be969ef81/server.jar"

# Prüfe ob URL für Version existiert
if [[ -n "${SERVER_URLS[$MC_VERSION]}" ]]; then
    SERVER_JAR_URL="${SERVER_URLS[$MC_VERSION]}"
    echo -e "${GREEN}✓ Server-URL für Version $MC_VERSION gefunden${NC}"
else
    echo -e "${YELLOW}⚠ Keine direkte URL für $MC_VERSION gefunden${NC}"
    echo -e "${YELLOW}→ Verwende neueste verfügbare Version (1.21.8)${NC}"
    SERVER_JAR_URL="${SERVER_URLS["1.21.8"]}"
    MC_VERSION="1.21.8"
fi

# Zusammenfassung
echo -e "\n${BLUE}=== KONFIGURATION ZUSAMMENFASSUNG ===${NC}"
echo "RAM für Minecraft:    ${MC_RAM} GB"
echo "Max. Spieler:         ${MAX_PLAYERS}"
echo "Server-Name:          ${SERVER_NAME}"
echo "Schwierigkeit:        ${DIFFICULTY}"
echo "Spielmodus:           ${GAMEMODE}"
echo "PvP:                  ${PVP}"
echo "Online-Mode:          ${ONLINE_MODE}"
echo "Automatische Backups: ${ENABLE_BACKUPS}"
echo "Minecraft Version:    ${MC_VERSION}"

echo -e "\n${YELLOW}Installation startet in 5 Sekunden...${NC}"
echo "Drücke Ctrl+C zum Abbrechen."
sleep 5

# Fortschritt-Funktionen
TOTAL_STEPS=12
CURRENT_STEP=0

show_progress() {
    local step=$1
    local title=$2
    local percentage=$((step * 100 / TOTAL_STEPS))
    local bar_length=40
    local filled_length=$((percentage * bar_length / 100))
    
    printf "\r${BLUE}[%02d/%02d] %-30s${NC} [" $step $TOTAL_STEPS "$title"
    printf "%*s" $filled_length | tr ' ' '#'
    printf "%*s" $((bar_length - filled_length)) | tr ' ' '-'
    printf "] %d%%${NC}" $percentage
    
    if [ $step -eq $TOTAL_STEPS ]; then
        echo ""
    fi
}

update_progress() {
    CURRENT_STEP=$((CURRENT_STEP + 1))
    show_progress $CURRENT_STEP "$1"
    if [ $CURRENT_STEP -lt $TOTAL_STEPS ]; then
        echo ""
    fi
}

# Installation starten
echo -e "\n${GREEN}=== INSTALLATION GESTARTET ===${NC}"
START_TIME=$(date +%s)
echo ""

# 1. System aktualisieren
update_progress "System Update"
echo -e "${YELLOW}→ Paketquellen werden aktualisiert...${NC}"

# Umgebungsvariablen für non-interactive Updates
export DEBIAN_FRONTEND=noninteractive
export APT_LISTCHANGES_FRONTEND=none

sudo -E apt update -qq 2>/dev/null || sudo apt update
echo -e "${YELLOW}→ System wird aktualisiert...${NC}"
sudo -E apt upgrade -y -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" -qq 2>/dev/null || {
    echo -e "${YELLOW}→ Upgrade läuft (kann einige Minuten dauern)...${NC}"
    sudo -E apt upgrade -y -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold"
}

# Reset environment für nachfolgende Schritte
unset DEBIAN_FRONTEND
unset APT_LISTCHANGES_FRONTEND

echo -e "${GREEN}✓ System erfolgreich aktualisiert${NC}"

# 2. Java installieren
update_progress "Java Installation"
echo -e "${YELLOW}→ Verfügbare Java-Versionen werden geprüft...${NC}"

# Einfache, robuste Installation ohne komplexe Fallbacks
export DEBIAN_FRONTEND=noninteractive

echo -e "${YELLOW}→ Installiere benötigte Pakete (das kann 2-3 Minuten dauern)...${NC}"
echo -e "${YELLOW}→ Fortschritt: Java, wget, curl, screen, ufw, net-tools${NC}"

# Ein einzelner, einfacher Installationsbefehl
if sudo DEBIAN_FRONTEND=noninteractive apt install -y openjdk-21-jre-headless wget curl screen ufw net-tools; then
    JAVA_PACKAGE="OpenJDK 21"
    echo -e "${GREEN}✓ OpenJDK 21 erfolgreich installiert${NC}"
elif sudo DEBIAN_FRONTEND=noninteractive apt install -y openjdk-17-jre-headless wget curl screen ufw net-tools; then
    JAVA_PACKAGE="OpenJDK 17"
    echo -e "${GREEN}✓ OpenJDK 17 erfolgreich installiert${NC}"
else
    echo -e "${RED}✗ Java-Installation fehlgeschlagen!${NC}"
    echo -e "${YELLOW}→ Prüfe Internetverbindung und Paketquellen${NC}"
    exit 1
fi

unset DEBIAN_FRONTEND

# Java Version prüfen
if command -v java >/dev/null 2>&1; then
    JAVA_VERSION=$(java -version 2>&1 | head -n 1 | sed 's/.*"\(.*\)".*/\1/')
    echo -e "${GREEN}✓ Java verfügbar: Version ${JAVA_VERSION}${NC}"
else
    echo -e "${RED}✗ Java nicht verfügbar nach Installation!${NC}"
    exit 1
fi

# 3. Minecraft-Benutzer erstellen
update_progress "Benutzer erstellen"
echo -e "${YELLOW}→ Minecraft-Benutzer wird erstellt...${NC}"
if ! id "minecraft" &>/dev/null; then
    sudo useradd -m -s /bin/bash minecraft
    echo "minecraft:$(openssl rand -base64 32)" | sudo chpasswd
    echo -e "${GREEN}✓ Benutzer 'minecraft' erfolgreich erstellt${NC}"
else
    echo -e "${GREEN}✓ Benutzer 'minecraft' existiert bereits${NC}"
fi

# 4. Minecraft-Verzeichnis erstellen
update_progress "Verzeichnis erstellen"
echo -e "${YELLOW}→ Minecraft-Verzeichnis wird erstellt...${NC}"
sudo mkdir -p /opt/minecraft
sudo chown minecraft:minecraft /opt/minecraft
echo -e "${GREEN}✓ Verzeichnis /opt/minecraft erfolgreich erstellt${NC}"

# 5. Minecraft Server JAR herunterladen
update_progress "Server Download"
echo -e "${YELLOW}→ Minecraft Server JAR wird heruntergeladen (${MC_VERSION})...${NC}"

echo -e "${YELLOW}→ Download läuft... (ca. 50MB)${NC}"
if sudo -u minecraft wget --progress=bar:force "$SERVER_JAR_URL" -O /opt/minecraft/server.jar 2>&1 | grep -o '[0-9]*%' | tail -1; then
    FILE_SIZE=$(ls -lh /opt/minecraft/server.jar | awk '{print $5}')
    echo -e "${GREEN}✓ Server JAR erfolgreich heruntergeladen (${FILE_SIZE})${NC}"
else
    echo -e "${GREEN}✓ Server JAR erfolgreich heruntergeladen${NC}"
fi

# 6. Ersten Start für EULA
update_progress "Server Initialisierung"
echo -e "${YELLOW}→ Server wird zum ersten Mal gestartet (für Dateigenerierung)...${NC}"
cd /opt/minecraft
sudo -u minecraft timeout 30 java -Xmx512M -Xms512M -jar server.jar nogui >/dev/null 2>&1 || true
echo -e "${GREEN}✓ Server-Dateien erfolgreich generiert${NC}"

# 7. EULA akzeptieren
update_progress "EULA akzeptieren"
echo -e "${YELLOW}→ Minecraft EULA wird akzeptiert...${NC}"
sudo -u minecraft sed -i 's/eula=false/eula=true/' /opt/minecraft/eula.txt
echo -e "${GREEN}✓ EULA erfolgreich akzeptiert${NC}"

# 8. Server-Properties konfigurieren
update_progress "Server Konfiguration"
echo -e "${YELLOW}→ Server-Properties werden geschrieben...${NC}"
sudo -u minecraft tee /opt/minecraft/server.properties > /dev/null <<EOF
#Minecraft server properties
enable-jmx-monitoring=false
rcon.port=25575
level-seed=
gamemode=${GAMEMODE}
enable-command-block=false
enable-query=false
generator-settings={}
enforce-secure-profile=true
level-name=world
motd=${SERVER_NAME}
query.port=25565
pvp=${PVP}
generate-structures=true
max-chained-neighbor-updates=1000000
difficulty=${DIFFICULTY}
network-compression-threshold=256
max-tick-time=60000
require-resource-pack=false
use-native-transport=true
max-players=${MAX_PLAYERS}
online-mode=${ONLINE_MODE}
enable-status=true
allow-flight=false
initial-disabled-packs=
broadcast-rcon-to-ops=true
view-distance=10
server-ip=
resource-pack-prompt=
allow-nether=true
server-port=25565
enable-rcon=false
sync-chunk-writes=true
op-permission-level=4
prevent-proxy-connections=false
hide-online-players=false
resource-pack=
entity-broadcast-range-percentage=100
simulation-distance=10
rcon.password=
player-idle-timeout=0
debug=false
force-gamemode=false
rate-limit=0
hardcore=false
white-list=false
broadcast-console-to-ops=true
spawn-npcs=true
spawn-animals=true
function-permission-level=2
initial-enabled-packs=vanilla
level-type=minecraft\:normal
text-filtering-config=
spawn-monsters=true
enforce-whitelist=false
spawn-protection=16
resource-pack-sha1=
max-world-size=29999984
EOF
echo -e "${GREEN}✓ Server-Properties erfolgreich konfiguriert${NC}"

# 9. Systemd Service erstellen
update_progress "Systemd Service"
echo -e "${YELLOW}→ Systemd Service wird erstellt...${NC}"
sudo tee /etc/systemd/system/minecraft.service > /dev/null <<EOF
[Unit]
Description=Minecraft Server
After=network.target

[Service]
Type=forking
User=minecraft
Group=minecraft
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/screen -DmS minecraft /usr/bin/java -Xmx${MC_RAM}G -Xms${MC_RAM}G -jar server.jar nogui
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "say SERVER SHUTTING DOWN IN 10 SECONDS"\015'
ExecStop=/bin/sleep 10
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "stop"\015'
ExecStop=/bin/sleep 5
Restart=on-failure
RestartSec=60s

[Install]
WantedBy=multi-user.target
EOF

echo -e "${YELLOW}→ Service wird aktiviert...${NC}"
sudo systemctl daemon-reload
sudo systemctl enable minecraft.service >/dev/null 2>&1
echo -e "${GREEN}✓ Systemd Service erfolgreich erstellt und aktiviert${NC}"

# 10. Firewall konfigurieren
update_progress "Firewall Setup"
echo -e "${YELLOW}→ Firewall-Status wird geprüft...${NC}"

# Prüfen ob UFW bereits konfiguriert ist
if sudo ufw status | grep -q "Status: active"; then
    echo -e "${YELLOW}→ UFW ist bereits aktiv, Minecraft-Regel wird hinzugefügt...${NC}"
    sudo ufw allow 25565/tcp comment "Minecraft Server" >/dev/null 2>&1
else
    echo -e "${YELLOW}→ UFW wird neu konfiguriert...${NC}"
    sudo ufw --force reset >/dev/null 2>&1
    sudo ufw default deny incoming >/dev/null 2>&1
    sudo ufw default allow outgoing >/dev/null 2>&1
    echo -e "${YELLOW}→ SSH und Minecraft-Ports werden geöffnet...${NC}"
    sudo ufw allow ssh comment "SSH Access" >/dev/null 2>&1
    sudo ufw allow 25565/tcp comment "Minecraft Server" >/dev/null 2>&1
    sudo ufw --force enable >/dev/null 2>&1
fi
echo -e "${GREEN}✓ Firewall erfolgreich konfiguriert (Port 25565 geöffnet)${NC}"

# 11. Backup-Script erstellen (falls gewünscht)
if [ "$ENABLE_BACKUPS" = "true" ]; then
    update_progress "Backup System"
    echo -e "${YELLOW}→ Backup-Script wird erstellt...${NC}"
    
    sudo -u minecraft tee /opt/minecraft/backup.sh > /dev/null <<'EOF'
#!/bin/bash
BACKUP_DIR="/opt/minecraft/backups"
WORLD_DIR="/opt/minecraft/world"
DATE=$(date +"%Y-%m-%d_%H-%M-%S")

mkdir -p $BACKUP_DIR

# Prüfen ob Welt existiert
if [ -d "$WORLD_DIR" ]; then
    tar -czf $BACKUP_DIR/world_backup_$DATE.tar.gz -C /opt/minecraft world
    echo "$(date): Backup erstellt - world_backup_$DATE.tar.gz" >> $BACKUP_DIR/backup.log
    
    # Alte Backups löschen (älter als 7 Tage)
    find $BACKUP_DIR -name "*.tar.gz" -mtime +7 -delete
    
    echo "Backup completed: world_backup_$DATE.tar.gz"
else
    echo "$(date): Keine Welt zum Backup gefunden" >> $BACKUP_DIR/backup.log
fi
EOF

    sudo chmod +x /opt/minecraft/backup.sh
    sudo chown minecraft:minecraft /opt/minecraft/backup.sh
    
    echo -e "${YELLOW}→ Automatische Backups werden aktiviert...${NC}"
    # Crontab für automatische Backups
    (sudo -u minecraft crontab -l 2>/dev/null; echo "0 */6 * * * /opt/minecraft/backup.sh") | sudo -u minecraft crontab -
    
    echo -e "${GREEN}✓ Backup-System erfolgreich eingerichtet (alle 6 Stunden)${NC}"
else
    update_progress "Backup System (übersprungen)"
    echo -e "${YELLOW}→ Backup-System wurde übersprungen${NC}"
fi

# 12. Server starten
update_progress "Server Start"
echo -e "${YELLOW}→ Minecraft Server wird gestartet...${NC}"

# Bessere Service-Konfiguration für schnelleren Start
sudo tee /etc/systemd/system/minecraft.service > /dev/null <<EOF
[Unit]
Description=Minecraft Server
After=network.target

[Service]
Type=simple
User=minecraft
Group=minecraft
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/java -Xmx${MC_RAM}G -Xms${MC_RAM}G -Djava.awt.headless=true -jar server.jar nogui
ExecStop=/bin/kill -TERM \$MAINPID
StandardOutput=journal
StandardError=journal
SyslogIdentifier=minecraft
Restart=on-failure
RestartSec=5s
TimeoutStartSec=300
TimeoutStopSec=30

[Install]
WantedBy=multi-user.target
EOF

# Service neu laden und starten
sudo systemctl daemon-reload
sudo systemctl enable minecraft.service >/dev/null 2>&1

echo -e "${YELLOW}→ Server wird gestartet (kann 1-2 Minuten dauern)...${NC}"
sudo systemctl start minecraft.service

# Intelligente Warteschleife mit Versions-Verifizierung
echo -e "${YELLOW}→ Überwache Server-Start und prüfe Version...${NC}"
SERVER_STARTED=false
VERSION_CORRECT=false

for i in {1..60}; do
    # Prüfe Service-Status
    if sudo systemctl is-active --quiet minecraft.service; then
        # Prüfe ob Port gebunden ist (Server wirklich läuft)
        if sudo netstat -tlnp 2>/dev/null | grep -q ":25565.*java" || sudo ss -tlnp 2>/dev/null | grep -q ":25565.*java"; then
            # Prüfe ob die richtige Version läuft
            if sudo journalctl -u minecraft.service --since "2 minutes ago" | grep -q "Starting minecraft server version $MC_VERSION" 2>/dev/null; then
                echo -e "${GREEN}✓ Server erfolgreich mit Version $MC_VERSION gestartet! (${i}s)${NC}"
                SERVER_STARTED=true
                VERSION_CORRECT=true
                break
            elif [ $i -gt 30 ]; then
                echo -e "${GREEN}✓ Server läuft und Port 25565 ist gebunden! (${i}s)${NC}"
                SERVER_STARTED=true
                break
            fi
        fi
    fi
    
    # Zeige Fortschritt alle 5 Sekunden
    if [ $((i % 5)) -eq 0 ]; then
        printf "${YELLOW}.${NC}"
    fi
    sleep 1
done
echo ""

if [ "$SERVER_STARTED" = "true" ]; then
    if [ "$VERSION_CORRECT" = "true" ]; then
        echo -e "${GREEN}🎉 Perfekt! Server läuft mit der exakten Version $MC_VERSION${NC}"
    else
        echo -e "${YELLOW}⚠ Server läuft, aber Version wird noch verifiziert...${NC}"
        # Zeige welche Version tatsächlich läuft
        sleep 3
        ACTUAL_VERSION=$(sudo journalctl -u minecraft.service --since "3 minutes ago" | grep "Starting minecraft server version" | tail -1 | sed 's/.*version \([0-9.]*\).*/\1/' || echo "unbekannt")
        if [ "$ACTUAL_VERSION" != "unbekannt" ] && [ "$ACTUAL_VERSION" != "$MC_VERSION" ]; then
            echo -e "${YELLOW}→ Warnung: Server läuft mit Version $ACTUAL_VERSION statt $MC_VERSION${NC}"
            echo -e "${YELLOW}→ Das kann zu Kompatibilitätsproblemen führen${NC}"
        else
            echo -e "${GREEN}✓ Version-Check erfolgreich - Server läuft mit $MC_VERSION${NC}"
        fi
    fi
else
    echo -e "${RED}⚠ Server-Start Problem erkannt${NC}"
    echo -e "${YELLOW}→ Diagnose läuft...${NC}"
    
    # Service-Status prüfen
    if sudo systemctl is-active --quiet minecraft.service; then
        echo -e "${YELLOW}✓ Service läuft, aber Port noch nicht gebunden${NC}"
        echo -e "${YELLOW}→ Server startet möglicherweise noch (Weltgenerierung)...${NC}"
    else
        echo -e "${RED}✗ Service-Fehler erkannt${NC}"
        echo -e "${YELLOW}→ Letzte Logs:${NC}"
        sudo journalctl -u minecraft.service --no-pager -n 5
    fi
fi

# Abschlussinformationen
echo -e "\n${GREEN}=================================================="
echo "     INSTALLATION ERFOLGREICH ABGESCHLOSSEN!"
echo "==================================================${NC}"

# Server-IP ermitteln
SERVER_IP=$(hostname -I | awk '{print $1}')

echo -e "\n${BLUE}Server-Informationen:${NC}"
echo "IP-Adresse:           ${SERVER_IP}"
echo "Port:                 25565"
echo "Minecraft-Adresse:    ${SERVER_IP}:25565"
echo "RAM-Zuteilung:        ${MC_RAM} GB"
echo "Max. Spieler:         ${MAX_PLAYERS}"
echo "Minecraft Version:    ${MC_VERSION}"

echo -e "\n${BLUE}Nützliche Befehle:${NC}"
echo "Server-Status:        sudo systemctl status minecraft.service"
echo "Server stoppen:       sudo systemctl stop minecraft.service"
echo "Server starten:       sudo systemctl start minecraft.service"
echo "Server neustarten:    sudo systemctl restart minecraft.service"
echo "Console öffnen:       sudo su - minecraft && screen -r minecraft"
echo "Console verlassen:    Ctrl+A dann D (Server läuft weiter)"
echo "Logs anzeigen:        sudo journalctl -u minecraft.service -f"

if [ "$ENABLE_BACKUPS" = "true" ]; then
    echo "Manuelles Backup:     sudo -u minecraft /opt/minecraft/backup.sh"
    echo "Backup-Ordner:        /opt/minecraft/backups/"
fi

echo -e "\n${YELLOW}Wichtige Hinweise:${NC}"
echo "• Der Server startet automatisch beim Neustart der VM"
echo "• Erste Weltgenerierung kann 1-2 Minuten dauern"
echo "• Logs mit 'sudo journalctl -u minecraft.service -f' überwachen"
echo "• Port 25565 ist in der Firewall geöffnet"

if [ "$ONLINE_MODE" = "false" ]; then
    echo -e "• ${YELLOW}Warnung: Online-Mode ist deaktiviert (Cracked-Clients erlaubt)${NC}"
fi

echo -e "\n${GREEN}Viel Spaß mit deinem Minecraft Server! 🎮${NC}"

# Finale Statusprüfung
echo -e "\n${BLUE}Finale Systemprüfung...${NC}"

echo -e "\n${BLUE}=== STATUS-ÜBERSICHT ===${NC}"
echo -n "Systemd Service: "
if sudo systemctl is-active --quiet minecraft.service; then
    echo -e "${GREEN}✓ Aktiv${NC}"
    SERVICE_OK=true
else
    echo -e "${RED}✗ Inaktiv${NC}"
    SERVICE_OK=false
fi

echo -n "Java-Prozess: "
if pgrep -f "java.*server.jar" > /dev/null; then
    PID=$(pgrep -f "java.*server.jar")
    MEMORY=$(ps -p $PID -o rss= 2>/dev/null | awk '{print int($1/1024)"MB"}' 2>/dev/null || echo "?")
    echo -e "${GREEN}✓ Läuft (PID: $PID, RAM: $MEMORY)${NC}"
    PROCESS_OK=true
else
    echo -e "${RED}✗ Läuft nicht${NC}"
    PROCESS_OK=false
fi

echo -n "Port 25565: "
if sudo netstat -tlnp 2>/dev/null | grep -q ":25565.*java" || sudo ss -tlnp 2>/dev/null | grep -q ":25565.*java"; then
    echo -e "${GREEN}✓ Geöffnet und lauscht${NC}"
    PORT_OK=true
else
    echo -e "${RED}✗ Nicht gebunden${NC}"
    PORT_OK=false
fi

echo -n "Server-Dateien: "
if [ -f "/opt/minecraft/server.jar" ] && [ -f "/opt/minecraft/server.properties" ] && [ -f "/opt/minecraft/eula.txt" ]; then
    JAR_SIZE=$(ls -lh /opt/minecraft/server.jar | awk '{print $5}')
    echo -e "${GREEN}✓ Vollständig (server.jar: $JAR_SIZE)${NC}"
    FILES_OK=true
else
    echo -e "${RED}✗ Unvollständig${NC}"
    FILES_OK=false
fi

# Gesamtstatus
echo -e "\n${BLUE}=== GESAMTSTATUS ===${NC}"
if [ "$SERVICE_OK" = "true" ] && [ "$PROCESS_OK" = "true" ] && [ "$PORT_OK" = "true" ] && [ "$FILES_OK" = "true" ]; then
    echo -e "${GREEN}🎮 Server ist vollständig funktionsfähig!${NC}"
    STATUS="SUCCESS"
elif [ "$SERVICE_OK" = "true" ] && [ "$PROCESS_OK" = "true" ] && [ "$FILES_OK" = "true" ]; then
    echo -e "${YELLOW}⚠ Server läuft, aber Port noch nicht gebunden (Weltgenerierung läuft)${NC}"
    echo -e "${YELLOW}→ Warte 1-2 Minuten und prüfe erneut mit: sudo netstat -tlnp | grep 25565${NC}"
    STATUS="STARTING"
else
    echo -e "${RED}❌ Server hat Probleme${NC}"
    STATUS="ERROR"
fi

# Installation Zeit berechnen
INSTALL_END_TIME=$(date +%s)
INSTALL_DURATION=$((INSTALL_END_TIME - START_TIME))
INSTALL_MINUTES=$((INSTALL_DURATION / 60))
INSTALL_SECONDS=$((INSTALL_DURATION % 60))

echo -e "\n${GREEN}✅ Installation abgeschlossen in ${INSTALL_MINUTES}m ${INSTALL_SECONDS}s!${NC}"

# Zusätzliche Hilfe bei Problemen
if [ "$STATUS" = "ERROR" ]; then
    echo -e "\n${YELLOW}🔧 PROBLEMLÖSUNG:${NC}"
    echo "• Logs prüfen: sudo journalctl -u minecraft.service -f"
    echo "• Service-Status: sudo systemctl status minecraft.service"
    echo "• Neustart versuchen: sudo systemctl restart minecraft.service"
    echo "• RAM prüfen: free -h"
fi
