#!/bin/bash
# ssd-test-suite.sh - USB-C SSD Test Suite
# Zweck: Umfassende Tests für gemountete SSDs

set -e

# Konfiguration
MOUNT_POINT="/mnt/ssd-storage"
TEST_DIR="$MOUNT_POINT/.ssd-tests"
LOG_FILE="/var/log/ssd-tests.log"

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

# Logging und Ausgabe
log_test() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - TEST: $1" >> "$LOG_FILE"
    echo -e "${BLUE}[TEST]${NC} $1"
}

log_success() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" >> "$LOG_FILE"
    echo -e "${GREEN}[✓]${NC} $1"
}

log_warning() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" >> "$LOG_FILE"
    echo -e "${YELLOW}[!]${NC} $1"
}

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" >> "$LOG_FILE"
    echo -e "${RED}[✗]${NC} $1"
}

# Test 1: Mount-Status prüfen
test_mount_status() {
    log_test "Prüfe Mount-Status..."
    
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        log_success "SSD ist gemountet: $mounted_device auf $MOUNT_POINT"
        return 0
    else
        log_error "Keine SSD auf $MOUNT_POINT gemountet"
        return 1
    fi
}

# Test 2: Dateisystem-Typ prüfen
test_filesystem_type() {
    log_test "Prüfe Dateisystem-Typ..."
    
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        fs_type=$(lsblk -o FSTYPE "$mounted_device" | tail -1 | xargs)
        
        if [ "$fs_type" = "ntfs" ]; then
            log_success "Dateisystem: NTFS ✓"
            return 0
        else
            log_warning "Dateisystem: $fs_type (erwartet: NTFS)"
            return 1
        fi
    else
        log_error "Kein gemountetes Device für Filesystem-Test"
        return 1
    fi
}

# Test 3: Lesezugriff prüfen
test_read_access() {
    log_test "Prüfe Lesezugriff..."
    
    if [ -r "$MOUNT_POINT" ]; then
        # Versuche Verzeichnis-Listing
        file_count=$(ls -1 "$MOUNT_POINT" 2>/dev/null | wc -l)
        log_success "Lesezugriff OK - $file_count Objekte gefunden"
        return 0
    else
        log_error "Kein Lesezugriff auf $MOUNT_POINT"
        return 1
    fi
}

# Test 4: Schreibzugriff prüfen
test_write_access() {
    log_test "Prüfe Schreibzugriff..."
    
    test_file="$MOUNT_POINT/.write_test_$(date +%s).tmp"
    
    if echo "Write test - $(date)" > "$test_file" 2>/dev/null; then
        if [ -f "$test_file" ]; then
            content=$(cat "$test_file")
            rm -f "$test_file"
            log_success "Schreibzugriff OK"
            return 0
        else
            log_error "Datei konnte nicht erstellt werden"
            return 1
        fi
    else
        log_error "Kein Schreibzugriff auf $MOUNT_POINT"
        return 1
    fi
}

# Test 5: Verzeichnis-Operationen
test_directory_operations() {
    log_test "Prüfe Verzeichnis-Operationen..."
    
    # Test-Verzeichnis erstellen
    if mkdir -p "$TEST_DIR" 2>/dev/null; then
        log_success "Verzeichnis erstellen: OK"
        
        # Test-Unterverzeichnis
        sub_dir="$TEST_DIR/subdir_$(date +%s)"
        if mkdir "$sub_dir" 2>/dev/null; then
            log_success "Unterverzeichnis erstellen: OK"
            
            # Verzeichnis löschen
            if rmdir "$sub_dir" 2>/dev/null; then
                log_success "Verzeichnis löschen: OK"
            else
                log_warning "Verzeichnis löschen: Fehler"
            fi
        else
            log_warning "Unterverzeichnis erstellen: Fehler"
        fi
        
        # Test-Verzeichnis aufräumen
        rmdir "$TEST_DIR" 2>/dev/null || log_warning "Test-Verzeichnis Cleanup: Fehler"
        return 0
    else
        log_error "Verzeichnis-Operationen: Fehler"
        return 1
    fi
}

# Test 6: Performance-Test (Schreibgeschwindigkeit)
test_write_performance() {
    log_test "Prüfe Schreibperformance..."
    
    test_file="$MOUNT_POINT/.performance_test_$(date +%s).tmp"
    
    # 100MB Test-Datei schreiben
    start_time=$(date +%s.%N)
    
    if dd if=/dev/zero of="$test_file" bs=1M count=100 2>/dev/null; then
        end_time=$(date +%s.%N)
        duration=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
        
        if [ -f "$test_file" ]; then
            file_size=$(stat -c%s "$test_file" 2>/dev/null || echo "0")
            rm -f "$test_file"
            
            if command -v bc >/dev/null && [ "$duration" != "0" ]; then
                speed=$(echo "scale=2; ($file_size / 1024 / 1024) / $duration" | bc -l)
                log_success "Schreibgeschwindigkeit: ${speed} MB/s"
            else
                log_success "Performance-Test abgeschlossen (Zeit: ${duration}s)"
            fi
        else
            log_warning "Performance-Test: Datei nicht erstellt"
        fi
        return 0
    else
        log_error "Performance-Test: Schreibfehler"
        return 1
    fi
}

# Test 7: Speicherplatz prüfen
test_disk_space() {
    log_test "Prüfe Speicherplatz..."
    
    if mountpoint -q "$MOUNT_POINT"; then
        space_info=$(df -h "$MOUNT_POINT" | tail -1)
        total=$(echo "$space_info" | awk '{print $2}')
        used=$(echo "$space_info" | awk '{print $3}')
        available=$(echo "$space_info" | awk '{print $4}')
        usage=$(echo "$space_info" | awk '{print $5}')
        
        log_success "Speicherplatz - Total: $total, Belegt: $used, Verfügbar: $available, Auslastung: $usage"
        
        # Warnung bei hoher Auslastung
        usage_percent=$(echo "$usage" | sed 's/%//')
        if [ "$usage_percent" -gt 90 ]; then
            log_warning "Hohe Speicherauslastung: $usage"
        fi
        
        return 0
    else
        log_error "Speicherplatz-Check: Kein gemountetes Device"
        return 1
    fi
}

# Test 8: NTFS-spezifische Eigenschaften
test_ntfs_features() {
    log_test "Prüfe NTFS-Features..."
    
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        
        # UUID prüfen
        uuid=$(sudo blkid -s UUID -o value "$mounted_device" 2>/dev/null)
        if [ -n "$uuid" ]; then
            log_success "NTFS UUID: $uuid"
        else
            log_warning "NTFS UUID nicht ermittelbar"
        fi
        
        # Label prüfen
        label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null)
        if [ -n "$label" ]; then
            log_success "NTFS Label: $label"
        else
            log_success "NTFS Label: (kein Label gesetzt)"
        fi
        
        # NTFS-spezifische Mount-Optionen prüfen
        mount_options=$(mount | grep "$MOUNT_POINT" | sed 's/.*(\(.*\)).*/\1/')
        log_success "Mount-Optionen: $mount_options"
        
        return 0
    else
        log_error "NTFS-Features: Kein gemountetes Device"
        return 1
    fi
}

# Test 9: SMB-Bereitschaft prüfen
test_smb_readiness() {
    log_test "Prüfe SMB-Bereitschaft..."
    
    # Benutzer-/Gruppen-Zugriff prüfen
    user_id=$(id -u)
    group_id=$(id -g)
    
    if [ -r "$MOUNT_POINT" ] && [ -w "$MOUNT_POINT" ]; then
        log_success "Benutzer-Zugriff (UID: $user_id, GID: $group_id): OK"
        
        # Test-Datei für SMB-Zugriff erstellen
        smb_test_file="$MOUNT_POINT/.smb_test_$(date +%s).txt"
        if echo "SMB Test - $(date)" > "$smb_test_file" 2>/dev/null; then
            if [ -f "$smb_test_file" ]; then
                rm -f "$smb_test_file"
                log_success "SMB-Test-Datei: OK"
            fi
        fi
        
        return 0
    else
        log_error "SMB-Bereitschaft: Unzureichende Zugriffsrechte"
        return 1
    fi
}

# Test 10: Safe-Eject Bereitschaft prüfen
test_safe_eject_readiness() {
    log_test "Prüfe Safe-Eject Bereitschaft..."
    
    if ! mountpoint -q "$MOUNT_POINT"; then
        log_warning "Safe-Eject: Kein Device gemountet"
        return 1
    fi
    
    mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
    device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
    
    # USB-Device prüfen
    if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
        log_success "USB-Device erkannt: Safe-Eject verfügbar"
        
        # eject Befehl prüfen
        if command -v eject >/dev/null; then
            log_success "eject Befehl: Verfügbar"
        else
            log_warning "eject Befehl: Nicht installiert (installierbar mit: sudo apt install eject)"
        fi
        
        # Aktive Prozesse prüfen
        active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
        if [ "$active_count" -eq 0 ]; then
            log_success "Aktive Prozesse: Keine (Safe-Eject bereit)"
        else
            log_warning "Aktive Prozesse: $active_count (Safe-Eject mit Vorsicht)"
        fi
        
        # Buffer-Status prüfen
        dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
        if [ "$dirty_pages" -le 100 ]; then
            log_success "System Buffer: Sauber (${dirty_pages}kB)"
        else
            log_warning "System Buffer: Dirty Pages vorhanden (${dirty_pages}kB)"
        fi
        
        return 0
    else
        log_warning "Kein USB-Device - Safe-Eject nicht erforderlich"
        return 1
    fi
}

# Test 11: Gesamtsystem-Status
test_system_status() {
    log_test "Prüfe Gesamtsystem-Status..."
    
    # NTFS-3G prüfen
    if command -v mount.ntfs-3g >/dev/null; then
        log_success "NTFS-3G: Installiert"
    else
        log_error "NTFS-3G: Nicht installiert"
    fi
    
    # Kernel-Module prüfen
    if lsmod | grep -q ntfs; then
        log_success "NTFS Kernel-Modul: Geladen"
    else
        log_warning "NTFS Kernel-Modul: Nicht erkannt"
    fi
    
    # System-Load prüfen
    load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    log_success "System Load: $load_avg"
    
    return 0
}

# Alle Tests ausführen
run_all_tests() {
    echo "=== USB-C SSD Test Suite ==="
    echo "Version: 1.0"
    echo "Zeitstempel: $(date)"
    echo "Mount-Point: $MOUNT_POINT"
    echo ""
    
    total_tests=11
    passed_tests=0
    
    # Test-Log initialisieren
    echo "=== Test-Session gestartet: $(date) ===" >> "$LOG_FILE"
    
    # Tests ausführen
    test_mount_status && ((passed_tests++))
    test_filesystem_type && ((passed_tests++))
    test_read_access && ((passed_tests++))
    test_write_access && ((passed_tests++))
    test_directory_operations && ((passed_tests++))
    test_write_performance && ((passed_tests++))
    test_disk_space && ((passed_tests++))
    test_ntfs_features && ((passed_tests++))
    test_smb_readiness && ((passed_tests++))
    test_safe_eject_readiness && ((passed_tests++))
    test_system_status && ((passed_tests++))
    
    echo ""
    echo "=== Test-Zusammenfassung ==="
    echo "Tests bestanden: $passed_tests/$total_tests"
    
    if [ $passed_tests -eq $total_tests ]; then
        log_success "Alle Tests bestanden - SSD ist bereit für SMB-Freigabe!"
        echo "=== ALLE TESTS BESTANDEN ===" >> "$LOG_FILE"
        return 0
    else
        failed_tests=$((total_tests - passed_tests))
        log_warning "$failed_tests Tests fehlgeschlagen - Überprüfung erforderlich"
        echo "=== $failed_tests TESTS FEHLGESCHLAGEN ===" >> "$LOG_FILE"
        return 1
    fi
}

# Hauptfunktion
main() {
    case "${1:-all}" in
        "all")
            run_all_tests
            ;;
        "quick")
            echo "=== Quick Test ==="
            test_mount_status && test_read_access && test_write_access
            ;;
        "mount")
            test_mount_status
            ;;
        "access")
            test_read_access && test_write_access
            ;;
        "performance")
            test_write_performance
            ;;
        "smb")
            test_smb_readiness
            ;;
        "safe-eject"|"eject")
            test_safe_eject_readiness
            ;;
        *)
            echo "Verwendung: $0 {all|quick|mount|access|performance|smb|safe-eject}"
            echo ""
            echo "Tests:"
            echo "  all         - Alle Tests ausführen (empfohlen)"
            echo "  quick       - Schnelle Basis-Tests"
            echo "  mount       - Nur Mount-Status prüfen"
            echo "  access      - Nur Zugriff prüfen"
            echo "  performance - Nur Performance-Test"
            echo "  smb         - Nur SMB-Bereitschaft prüfen"
            echo "  safe-eject  - Nur Safe-Eject Bereitschaft prüfen"
            ;;
    esac
}

# Script ausführen
main "$@"