#!/bin/bash
# ssd-mount-manager.sh - USB-C SSD Mount Management
# Zweck: Flexibles Mounting verschiedener SSDs auf konstanten Mount-Point

set -e

# Konfiguration
MOUNT_POINT="/mnt/ssd-storage"
CONFIG_FILE="/etc/ssd-mount.conf"
LOG_FILE="/var/log/ssd-mount.log"

# Logging-Funktion
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | sudo tee -a "$LOG_FILE"
    echo "$1"
}

# Konfigurationsdatei erstellen
create_config() {
    log_message "Erstelle Konfigurationsdatei..."
    sudo tee "$CONFIG_FILE" > /dev/null << EOF
# SSD Mount Manager Konfiguration
# Erstellt: $(date)

# Standard Mount-Point
MOUNT_POINT="$MOUNT_POINT"

# Standard Mount-Optionen für NTFS
MOUNT_OPTIONS="defaults,uid=1000,gid=1000,umask=002,fmask=111,noatime"

# Automatisches Unmounting bei Shutdown
AUTO_UMOUNT=true

# Backup der letzten gemounteten SSD
LAST_DEVICE=""
LAST_UUID=""
EOF
    log_message "Konfiguration erstellt: $CONFIG_FILE"
}

# Konfiguration laden
load_config() {
    if [ -f "$CONFIG_FILE" ]; then
        source "$CONFIG_FILE"
    else
        create_config
        source "$CONFIG_FILE"
    fi
}

# Mount-Point vorbereiten
prepare_mount_point() {
    log_message "Bereite Mount-Point vor: $MOUNT_POINT"
    
    if [ ! -d "$MOUNT_POINT" ]; then
        sudo mkdir -p "$MOUNT_POINT"
        log_message "Mount-Point erstellt: $MOUNT_POINT"
    fi
    
    sudo chown root:root "$MOUNT_POINT"
    sudo chmod 755 "$MOUNT_POINT"
    log_message "Mount-Point Berechtigungen gesetzt"
}

# Aktuelle Mounts prüfen
check_current_mount() {
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        log_message "Aktuell gemountet: $mounted_device auf $MOUNT_POINT"
        return 0
    else
        log_message "Kein Device auf $MOUNT_POINT gemountet"
        return 1
    fi
}

# Device unmounten
unmount_device() {
    log_message "Unmounte Device von $MOUNT_POINT..."
    
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        log_message "Unmounte $mounted_device..."
        
        sudo umount "$MOUNT_POINT"
        log_message "Device erfolgreich unmountet"
        
        # Letztes Device in Config speichern
        update_last_device ""
    else
        log_message "Kein Device zum Unmounten gefunden"
    fi
}

# Safe-Eject Funktion
safe_eject_device() {
    log_message "Starte Safe-Eject Prozess..."
    
    # Externes Safe-Eject Script aufrufen
    if command -v ssd-safe-eject >/dev/null; then
        ssd-safe-eject eject
    else
        # Fallback: Integrierte Safe-Eject Funktionalität
        perform_integrated_safe_eject
    fi
}

# Integrierte Safe-Eject Funktionalität
perform_integrated_safe_eject() {
    if ! mountpoint -q "$MOUNT_POINT"; then
        log_message "Keine SSD gemountet - Safe-Eject nicht erforderlich"
        return 1
    fi
    
    mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
    device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
    
    log_message "Safe-Eject für $mounted_device..."
    
    # Vollständiger Sync
    log_message "Führe Sync durch..."
    sync
    sleep 2
    
    # Unmount
    log_message "Unmounte Device..."
    if sudo umount "$MOUNT_POINT"; then
        log_success "Unmount erfolgreich"
    else
        log_error "Unmount fehlgeschlagen"
        return 1
    fi
    
    # Hardware-Eject
    log_message "Hardware-Eject..."
    if command -v eject >/dev/null; then
        if sudo eject "$device_base" 2>/dev/null; then
            log_success "Hardware-Eject erfolgreich"
        else
            log_warning "Hardware-Eject fehlgeschlagen"
        fi
    else
        log_warning "eject Befehl nicht verfügbar"
    fi
    
    # Finaler Sync
    sync
    
    log_success "Safe-Eject abgeschlossen - SSD kann entfernt werden"
    update_last_device ""
}
# Device mounten
mount_device() {
    local device="$1"
    
    if [ -z "$device" ]; then
        log_message "Fehler: Kein Device angegeben"
        return 1
    fi
    
    if [ ! -b "$device" ]; then
        log_message "Fehler: Device $device existiert nicht"
        return 1
    fi
    
    log_message "Mounte Device: $device"
    
    # Prüfe ob bereits etwas gemountet ist
    if mountpoint -q "$MOUNT_POINT"; then
        log_message "Mount-Point bereits belegt - unmounte zuerst..."
        unmount_device
    fi
    
    # Device mounten
    log_message "Mounte $device auf $MOUNT_POINT mit Optionen: $MOUNT_OPTIONS"
    sudo mount -t ntfs-3g -o "$MOUNT_OPTIONS" "$device" "$MOUNT_POINT"
    
    if [ $? -eq 0 ]; then
        log_message "Mount erfolgreich: $device auf $MOUNT_POINT"
        
        # Device-Info speichern
        device_uuid=$(sudo blkid -s UUID -o value "$device")
        update_last_device "$device" "$device_uuid"
        
        # Mount-Status anzeigen
        show_mount_status
        return 0
    else
        log_message "Fehler beim Mounten von $device"
        return 1
    fi
}

# Letztes Device in Config updaten
update_last_device() {
    local device="$1"
    local uuid="$2"
    
    sudo sed -i "s|LAST_DEVICE=.*|LAST_DEVICE=\"$device\"|" "$CONFIG_FILE"
    sudo sed -i "s|LAST_UUID=.*|LAST_UUID=\"$uuid\"|" "$CONFIG_FILE"
}

# Mount-Status anzeigen
show_mount_status() {
    echo ""
    echo "=== Mount-Status ==="
    
    if mountpoint -q "$MOUNT_POINT"; then
        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
        echo "✓ Gemountet: $mounted_device"
        echo "✓ Mount-Point: $MOUNT_POINT"
        
        # Speicherplatz anzeigen
        df -h "$MOUNT_POINT"
        echo ""
        
        # Device-Details
        device_uuid=$(sudo blkid -s UUID -o value "$mounted_device")
        device_label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null || echo "Kein Label")
        echo "UUID: $device_uuid"
        echo "Label: $device_label"
        
        # Zugriffstest
        if [ -r "$MOUNT_POINT" ]; then
            echo "✓ Lesezugriff: OK"
        else
            echo "✗ Lesezugriff: Fehler"
        fi
        
        if [ -w "$MOUNT_POINT" ]; then
            echo "✓ Schreibzugriff: OK"
        else
            echo "✗ Schreibzugriff: Fehler"
        fi
        
    else
        echo "✗ Kein Device gemountet auf $MOUNT_POINT"
    fi
    echo ""
}

# Verfügbare NTFS-Devices auflisten
list_ntfs_devices() {
    echo "=== Verfügbare NTFS-Devices ==="
    lsblk -f | grep ntfs | while IFS= read -r line; do
        device=$(echo "$line" | awk '{print "/dev/" $1}')
        uuid=$(echo "$line" | awk '{print $3}')
        label=$(echo "$line" | awk '{print $4}')
        size=$(lsblk -o SIZE "$device" 2>/dev/null | tail -1)
        echo "$device | $size | UUID: $uuid | Label: $label"
    done
    echo ""
}

# Automatisches Device-Detection
auto_detect_device() {
    log_message "Automatische Device-Erkennung..."
    
    # Suche nach NTFS-Partitionen auf USB-Devices
    for device in /dev/sd[a-z][0-9]*; do
        if [ -b "$device" ]; then
            fstype=$(lsblk -o FSTYPE "$device" 2>/dev/null | tail -1 | xargs)
            if [ "$fstype" = "ntfs" ]; then
                size=$(lsblk -b -o SIZE "$device" 2>/dev/null | tail -1)
                size_gb=$((size / 1024 / 1024 / 1024))
                
                # Nur Devices > 100GB berücksichtigen (typisch für SSDs)
                if [ $size_gb -gt 100 ]; then
                    log_message "NTFS-SSD gefunden: $device (${size_gb}GB)"
                    echo "$device"
                    return 0
                fi
            fi
        fi
    done
    
    log_message "Keine geeignete NTFS-SSD gefunden"
    return 1
}

# Hauptfunktion
main() {
    echo "=== USB-C SSD Mount Manager ==="
    echo "Version: 1.0"
    echo ""
    
    load_config
    prepare_mount_point
    
    case "${1:-status}" in
        "mount")
            if [ -n "$2" ]; then
                mount_device "$2"
            else
                # Auto-Detection
                auto_device=$(auto_detect_device)
                if [ -n "$auto_device" ]; then
                    echo "Auto-erkanntes Device: $auto_device"
                    echo "Mounten? (y/n)"
                    read -r response
                    if [ "$response" = "y" ] || [ "$response" = "Y" ]; then
                        mount_device "$auto_device"
                    fi
                else
                    echo "Kein Device auto-erkannt. Verfügbare Devices:"
                    list_ntfs_devices
                fi
            fi
            ;;
        "unmount"|"umount")
            unmount_device
            ;;
        "safe-eject"|"eject")
            safe_eject_device
            ;;
        "status")
            show_mount_status
            ;;
        "list")
            list_ntfs_devices
            ;;
        "remount")
            if check_current_mount; then
                unmount_device
                sleep 2
            fi
            auto_device=$(auto_detect_device)
            if [ -n "$auto_device" ]; then
                mount_device "$auto_device"
            fi
            ;;
        *)
            echo "Verwendung: $0 {mount [device]|unmount|safe-eject|status|list|remount}"
            echo ""
            echo "Befehle:"
            echo "  mount [device]  - Device mounten (auto-detect wenn kein device)"
            echo "  unmount         - Device unmounten (einfach)"
            echo "  safe-eject      - Sichere USB-C SSD Entfernung mit Hardware-Eject"
            echo "  status          - Mount-Status anzeigen"
            echo "  list            - Verfügbare NTFS-Devices auflisten"
            echo "  remount         - Unmount + Auto-detect + Mount"
            ;;
    esac
}

# Script ausführen
main "$@"