shell/plex/plex.sh

#!/bin/bash

################################################################################
# Plex Media Server Management Script
################################################################################
#
# Author: Peter Wood <peter@peterwood.dev>
# Description: Modern, user-friendly Plex Media Server management script with
#              styled output and comprehensive service control capabilities.
#              Provides an interactive interface for common Plex operations.
#
# Features:
#   - Service start/stop/restart/status operations
#   - Styled console output with Unicode symbols
#   - Service health monitoring
#   - Process management and monitoring
#   - Interactive menu system
#
# Related Scripts:
#   - backup-plex.sh: Comprehensive backup solution
#   - restore-plex.sh: Backup restoration utilities
#   - scan-plex-libraries.sh: Library scanning and metadata management
#   - monitor-plex-backup.sh: Backup system monitoring
#   - validate-plex-backups.sh: Backup validation tools
#   - test-plex-backup.sh: Testing framework
#
# Usage:
#   ./plex.sh start     # Start Plex service
#   ./plex.sh stop      # Stop Plex service
#   ./plex.sh restart   # Restart Plex service
#   ./plex.sh status    # Show service status
#   ./plex.sh scan      # Launch library scanner
#   ./plex.sh repair    # Repair Plex database issues
#   ./plex.sh nuclear   # Nuclear recovery mode
#   ./plex.sh help      # Show help menu
#   ./plex.sh logs      # Show recent logs
#   ./plex.sh           # Interactive menu
#
# Dependencies:
#   - systemctl (systemd service management)
#   - Plex Media Server package
#   - Web browser (for web interface launching)
#
# Exit Codes:
#   0 - Success
#   1 - General error
#   2 - Service operation failure
#   3 - Invalid command or option
#
################################################################################

# 🎬 Plex Media Server Management Script
# A modern script for managing Plex Media Server with style
# Author: acedanger
# Version: 2.0

set -euo pipefail

# 🎨 Color definitions for sexy output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly PURPLE='\033[0;35m'
readonly CYAN='\033[0;36m'
readonly WHITE='\033[1;37m'
readonly BOLD='\033[1m'
readonly DIM='\033[2m'
readonly RESET='\033[0m'

# 🔧 Configuration
readonly PLEX_SERVICE="plexmediaserver"
readonly PLEX_SQLITE="/usr/lib/plexmediaserver/Plex SQLite"
readonly PLEX_DB_DIR="/var/lib/plexmediaserver/Library/Application Support/Plex Media Server/Plug-in Support/Databases"
SCRIPT_NAME="$(basename "$0")"
readonly SCRIPT_NAME
SCRIPT_DIR="$(dirname "$(readlink -f "$0")")"
readonly SCRIPT_DIR

# DBRepair.sh location — searched in order: script dir, database dir, /usr/local/bin
find_dbrepair() {
    local candidates=(
        "${SCRIPT_DIR}/DBRepair.sh"
        "${PLEX_DB_DIR}/DBRepair.sh"
        "/usr/local/bin/DBRepair.sh"
    )
    for path in "${candidates[@]}"; do
        if [[ -x "$path" ]]; then
            echo "$path"
            return 0
        fi
    done
    return 1
}

# 🎭 ASCII symbols for compatible output
readonly CHECKMARK="[✓]"
readonly CROSS="[✗]"
readonly ROCKET="[>]"
readonly STOP_SIGN="[■]"
readonly RECYCLE="[~]"
readonly INFO="[i]"
readonly HOURGLASS="[*]"
readonly SPARKLES="[*]"

# 🎉 Function to print completion footer
print_footer() {
    echo -e "\n${DIM}${CYAN}--- Operation completed [*] ---${RESET}\n"
}

# 🎯 Function to print status with style
print_status() {
    local status="$1"
    local message="$2"
    local color="$3"
    echo -e "${color}${BOLD}[${status}]${RESET} ${message}"
}

# ⏱️ Function to show loading animation
show_loading() {
    local message="$1"
    local pid="$2"
    local spin='-\|/'
    local i=0

    echo -ne "${CYAN}${HOURGLASS} ${message}${RESET}"
    while kill -0 "$pid" 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r%s%s %s %s%s" "${CYAN}" "${HOURGLASS}" "${message}" "${spin:$i:1}" "${RESET}"
        sleep 0.1
    done
    printf "\r%s%s %s %s%s\n" "${CYAN}" "${HOURGLASS}" "${message}" "${CHECKMARK}" "${RESET}"
}

# 🔧 Repair database using ChuckPa/DBRepair when available, else manual steps
# DBRepair: https://github.com/ChuckPa/PlexDBRepair
repair_database() {
    print_status "${INFO}" "Attempting to repair Plex database..." "${BLUE}"

    local main_db="$PLEX_DB_DIR/com.plexapp.plugins.library.db"

    if [[ ! -f "$main_db" ]]; then
        print_status "${CROSS}" "Main database not found at: $main_db" "${RED}"
        return 1
    fi

    # ---------- Try DBRepair.sh (preferred) ----------
    local dbrepair_bin
    if dbrepair_bin=$(find_dbrepair); then
        print_status "${CHECKMARK}" "Found DBRepair.sh: $dbrepair_bin" "${GREEN}"
        print_status "${INFO}" "Running: stop → auto (check + repair + reindex + FTS rebuild) → start → exit" "${BLUE}"

        # DBRepair supports scripted mode — pass commands directly
        if sudo "$dbrepair_bin" stop auto start exit; then
            print_status "${CHECKMARK}" "DBRepair automatic repair completed successfully!" "${GREEN}"
            return 0
        else
            print_status "${CROSS}" "DBRepair automatic repair failed (exit code $?)" "${RED}"
            print_status "${INFO}" "Falling back to manual repair steps..." "${YELLOW}"
        fi
    else
        print_status "${INFO}" "DBRepair.sh not found — using manual repair" "${YELLOW}"
        echo -e "${DIM}${CYAN}   For better repairs, install DBRepair:${RESET}"
        echo -e "${DIM}${CYAN}   wget -O ${SCRIPT_DIR}/DBRepair.sh https://github.com/ChuckPa/PlexDBRepair/releases/latest/download/DBRepair.sh${RESET}"
        echo -e "${DIM}${CYAN}   chmod +x ${SCRIPT_DIR}/DBRepair.sh${RESET}"
    fi

    # ---------- Manual fallback (same approach DBRepair uses internally) ----------
    # Prefer Plex's bundled SQLite for ICU compatibility
    local sqlite_bin="sqlite3"
    if [[ -x "$PLEX_SQLITE" ]]; then
        sqlite_bin="$PLEX_SQLITE"
    fi

    # Stop Plex service first
    print_status "${INFO}" "Stopping Plex service..." "${BLUE}"
    sudo systemctl stop "$PLEX_SERVICE" 2>/dev/null || true
    sleep 3

    # Step 1: WAL checkpoint
    if [[ -f "${main_db}-wal" ]]; then
        print_status "${INFO}" "Checkpointing WAL journal..." "${BLUE}"
        sudo -u plex "$sqlite_bin" "$main_db" "PRAGMA wal_checkpoint(TRUNCATE);" 2>/dev/null || true
    fi

    # Step 2: Export → import (the core of DBRepair's repair/optimize)
    local ts
    ts=$(date +%Y%m%d_%H%M%S)
    local sql_dump="/tmp/plex_dump_${ts}.sql"
    local new_db="/tmp/plex_repaired_${ts}.db"
    local backup_db="$PLEX_DB_DIR/com.plexapp.plugins.library.db-BACKUP-${ts}"

    print_status "${INFO}" "Exporting database to SQL..." "${BLUE}"
    if sudo -u plex "$sqlite_bin" "$main_db" ".dump" | sudo -u plex tee "$sql_dump" >/dev/null 2>&1; then
        print_status "${CHECKMARK}" "SQL export completed ($(du -sh "$sql_dump" | cut -f1))" "${GREEN}"
    else
        print_status "${CROSS}" "SQL export failed — database may be too damaged for this method" "${RED}"
        rm -f "$sql_dump" 2>/dev/null
        print_status "${INFO}" "Install DBRepair.sh for more robust repair capabilities" "${YELLOW}"
        return 1
    fi

    print_status "${INFO}" "Importing into fresh database..." "${BLUE}"
    if sudo cat "$sql_dump" | sudo -u plex "$sqlite_bin" "$new_db" 2>/dev/null; then
        print_status "${CHECKMARK}" "Import into fresh database succeeded" "${GREEN}"
    else
        print_status "${CROSS}" "Import failed" "${RED}"
        rm -f "$sql_dump" "$new_db" 2>/dev/null
        return 1
    fi
    rm -f "$sql_dump" 2>/dev/null

    # Step 3: Verify repaired database (structural + FTS)
    print_status "${INFO}" "Verifying repaired database..." "${BLUE}"
    local verify_out
    verify_out=$(sudo -u plex "$sqlite_bin" "$new_db" "PRAGMA integrity_check;" 2>&1)
    if [[ "$verify_out" != "ok" ]]; then
        print_status "${CROSS}" "Repaired database failed integrity check" "${RED}"
        rm -f "$new_db" 2>/dev/null
        return 1
    fi

    # Step 4: Reindex (rebuilds all indexes INCLUDING FTS)
    print_status "${INFO}" "Rebuilding indexes (including FTS)..." "${BLUE}"
    sudo -u plex "$sqlite_bin" "$new_db" "REINDEX;" 2>/dev/null || true

    # Rebuild FTS index content explicitly
    local fts_tables
    fts_tables=$(sudo -u plex "$sqlite_bin" "$new_db" \
        "SELECT name FROM sqlite_master WHERE type='table' AND sql LIKE '%fts%';" 2>/dev/null) || true
    if [[ -n "$fts_tables" ]]; then
        while IFS= read -r table; do
            [[ -z "$table" ]] && continue
            print_status "${INFO}" "Rebuilding FTS index: $table" "${BLUE}"
            sudo -u plex "$sqlite_bin" "$new_db" \
                "INSERT INTO ${table}(${table}) VALUES('rebuild');" 2>/dev/null || true
        done <<< "$fts_tables"
    fi

    # Step 5: Swap databases
    print_status "${INFO}" "Backing up old database and activating repaired copy..." "${BLUE}"
    sudo cp "$main_db" "$backup_db"
    sudo mv "$new_db" "$main_db"
    sudo chown plex:plex "$main_db"
    sudo chmod 644 "$main_db"
    # Remove stale journals for the old database
    sudo rm -f "${main_db}-shm" "${main_db}-wal" 2>/dev/null || true

    print_status "${CHECKMARK}" "Database repaired and activated. Backup at: $(basename "$backup_db")" "${GREEN}"
    return 0
}

# 🔍 Function to check FTS (Full-Text Search) index integrity
# Standard PRAGMA integrity_check does NOT detect FTS corruption.
# This is the exact class of damage shown in the user's screenshot.
check_fts_integrity() {
    local db_file="$1"
    local sqlite_bin="${2:-sqlite3}"   # Use Plex SQLite if available
    local issues=0

    # Discover FTS tables dynamically from sqlite_master
    local fts_tables
    fts_tables=$(sudo -u plex "$sqlite_bin" "$db_file" \
        "SELECT name FROM sqlite_master WHERE type='table' AND sql LIKE '%fts%';" 2>/dev/null) || return 0

    if [[ -z "$fts_tables" ]]; then
        return 0   # No FTS tables — nothing to check
    fi

    print_status "${INFO}" "Checking FTS (Full-Text Search) indexes..." "${BLUE}"

    while IFS= read -r table; do
        [[ -z "$table" ]] && continue
        local result
        result=$(sudo -u plex "$sqlite_bin" "$db_file" \
            "INSERT INTO ${table}(${table}) VALUES('integrity-check');" 2>&1) || true
        if [[ -n "$result" ]]; then
            print_status "${CROSS}" "FTS index '${table}' — DAMAGED" "${RED}"
            echo -e "${DIM}${YELLOW}      $result${RESET}"
            ((issues++))
        else
            print_status "${CHECKMARK}" "FTS index '${table}' — OK" "${GREEN}"
        fi
    done <<< "$fts_tables"

    if (( issues > 0 )); then
        print_status "${CROSS}" "FTS integrity check complete. $issues index(es) damaged." "${RED}"
        print_status "${INFO}" "Run: ${SCRIPT_NAME} repair  (uses DBRepair reindex to rebuild FTS)" "${YELLOW}"
        return 1
    fi
    return 0
}

# 🔍 Function to check database integrity
check_database_integrity() {
    print_status "${INFO}" "Checking database integrity..." "${BLUE}"

    local main_db="$PLEX_DB_DIR/com.plexapp.plugins.library.db"

    if [[ ! -f "$main_db" ]]; then
        print_status "${CROSS}" "Main database not found at: $main_db" "${RED}"
        return 1
    fi

    # Prefer Plex's bundled SQLite for ICU compatibility
    local sqlite_bin="sqlite3"
    if [[ -x "$PLEX_SQLITE" ]]; then
        sqlite_bin="$PLEX_SQLITE"
    fi

    # Clean up stale WAL/SHM journals left by non-clean shutdowns.
    if [[ -f "${main_db}-wal" ]]; then
        print_status "${INFO}" "WAL journal found — attempting checkpoint before integrity check..." "${BLUE}"
        if ! sudo -u plex "$sqlite_bin" "$main_db" "PRAGMA wal_checkpoint(TRUNCATE);" 2>/dev/null; then
            print_status "${INFO}" "WAL checkpoint failed (non-critical, continuing check)" "${YELLOW}"
        fi
    fi

    # --- Standard structural integrity check ---
    local integrity_output
    local sqlite_exit_code=0
    integrity_output=$(sudo -u plex "$sqlite_bin" "$main_db" "PRAGMA integrity_check;" 2>&1) || sqlite_exit_code=$?

    local struct_ok=true

    if [[ "$integrity_output" == "ok" ]]; then
        print_status "${CHECKMARK}" "Database structural integrity check passed" "${GREEN}"
    elif [[ $sqlite_exit_code -ne 0 && -z "$integrity_output" ]]; then
        print_status "${CROSS}" "sqlite3 failed to open the database (exit code $sqlite_exit_code)" "${RED}"
        print_status "${INFO}" "Check file permissions and ensure Plex is fully stopped" "${YELLOW}"
        return 1
    else
        struct_ok=false
        print_status "${CROSS}" "Database structural integrity check reported issues:" "${RED}"
        echo "$integrity_output" | head -n 5 | while IFS= read -r line; do
            echo -e "${DIM}${YELLOW}   $line${RESET}"
        done
        local total_lines
        total_lines=$(echo "$integrity_output" | wc -l)
        if (( total_lines > 5 )); then
            echo -e "${DIM}${YELLOW}   ... and $((total_lines - 5)) more issue(s)${RESET}"
        fi
    fi

    # --- FTS index integrity (the most common unreported corruption) ---
    local fts_ok=true
    if ! check_fts_integrity "$main_db" "$sqlite_bin"; then
        fts_ok=false
    fi

    if [[ "$struct_ok" == true && "$fts_ok" == true ]]; then
        return 0
    fi

    print_status "${INFO}" "Consider running database repair: ${SCRIPT_NAME} repair" "${YELLOW}"
    return 1
}

# <20>🚀 Enhanced start function
start_plex() {
    print_status "${ROCKET}" "Starting Plex Media Server..." "${GREEN}"

    if systemctl is-active --quiet "$PLEX_SERVICE"; then
        print_status "${INFO}" "Plex is already running!" "${YELLOW}"
        show_detailed_status
        return 0
    fi

    # Reset any failed state first
    sudo systemctl reset-failed "$PLEX_SERVICE" 2>/dev/null || true

    # Check database integrity before starting (warn only — don't block startup).
    # Many "failures" are benign WAL journal leftovers that Plex resolves on its own.
    if ! check_database_integrity; then
        print_status "${INFO}" "Database integrity issues detected — starting Plex anyway (it may self-repair)." "${YELLOW}"
        echo -e "${DIM}${YELLOW}   If Plex fails to start, run: ${SCRIPT_NAME} repair${RESET}"
    fi

    print_status "${INFO}" "Attempting to start service..." "${BLUE}"

    if ! sudo systemctl start "$PLEX_SERVICE"; then
        print_status "${CROSS}" "Failed to start Plex Media Server!" "${RED}"
        print_status "${INFO}" "Checking service logs..." "${BLUE}"

        # Show recent error logs
        echo -e "\n${DIM}${RED}Recent error logs:${RESET}"
        sudo journalctl -u "$PLEX_SERVICE" --no-pager -n 5 --since "1 minute ago" | tail -5

        return 1
    fi

    # Wait and verify startup
    sleep 3
    local timeout=30
    local elapsed=0

    print_status "${HOURGLASS}" "Waiting for service to initialize..." "${CYAN}"

    while [[ $elapsed -lt $timeout ]]; do
        if systemctl is-active --quiet "$PLEX_SERVICE"; then
            print_status "${CHECKMARK}" "Plex Media Server started successfully!" "${GREEN}"
            print_footer
            return 0
        fi

        sleep 2
        elapsed=$((elapsed + 2))
        echo -ne "${DIM}${CYAN}   Waiting... ${elapsed}s/${timeout}s${RESET}\r"
    done

    echo ""
    print_status "${CROSS}" "Service startup timeout or failed!" "${RED}"

    # Show current status
    local status
    status=$(systemctl is-active "$PLEX_SERVICE" 2>/dev/null || echo "unknown")
    print_status "${INFO}" "Current status: $status" "${YELLOW}"

    if [[ "$status" == "failed" ]]; then
        echo -e "\n${DIM}${RED}Recent error logs:${RESET}"
        sudo journalctl -u "$PLEX_SERVICE" --no-pager -n 10 --since "2 minutes ago"
    fi

    return 1
}

# 🛑 Enhanced stop function
stop_plex() {
    print_status "${STOP_SIGN}" "Stopping Plex Media Server..." "${YELLOW}"

    if ! systemctl is-active --quiet "$PLEX_SERVICE"; then
        print_status "${INFO}" "Plex is already stopped!" "${YELLOW}"
        return 0
    fi

    sudo systemctl stop "$PLEX_SERVICE" &
    local pid=$!
    show_loading "Gracefully shutting down Plex" $pid
    wait $pid

    if ! systemctl is-active --quiet "$PLEX_SERVICE"; then
        print_status "${CHECKMARK}" "Plex Media Server stopped successfully!" "${GREEN}"
        print_footer
    else
        print_status "${CROSS}" "Failed to stop Plex Media Server!" "${RED}"
        return 1
    fi
}

# ♻️ Enhanced restart function
restart_plex() {
    print_status "${RECYCLE}" "Restarting Plex Media Server..." "${BLUE}"

    if systemctl is-active --quiet "$PLEX_SERVICE"; then
        stop_plex
        echo ""
    fi

    start_plex
}

# 📊 Enhanced status function with detailed info
show_detailed_status() {
    local service_status
    service_status=$(systemctl is-active "$PLEX_SERVICE" 2>/dev/null || echo "inactive")

    echo -e "\n${BOLD}${BLUE}+==============================================================+${RESET}"
    echo -e "${BOLD}${BLUE}                         SERVICE STATUS${RESET}"
    echo -e "${BOLD}${BLUE}+==============================================================+${RESET}"

    case "$service_status" in
        "active")
            print_status "${CHECKMARK}" "Service Status: ${GREEN}${BOLD}ACTIVE${RESET}" "${GREEN}"

            # Get additional info
            local uptime
            uptime=$(systemctl show "$PLEX_SERVICE" --property=ActiveEnterTimestamp --value | xargs -I {} date -d {} "+%Y-%m-%d %H:%M:%S" 2>/dev/null || echo "Unknown")

            local memory_usage
            memory_usage=$(systemctl show "$PLEX_SERVICE" --property=MemoryCurrent --value 2>/dev/null || echo "0")
            if [[ "$memory_usage" != "0" ]] && [[ "$memory_usage" =~ ^[0-9]+$ ]]; then
                memory_usage="$(( memory_usage / 1024 / 1024 )) MB"
            else
                memory_usage="Unknown"
            fi

            echo -e "${DIM}${CYAN}   Started: ${WHITE}${uptime}${RESET}"
            echo -e "${DIM}${CYAN}   Memory Usage: ${WHITE}${memory_usage}${RESET}"
            echo -e "${DIM}${CYAN}   Service Name: ${WHITE}${PLEX_SERVICE}${RESET}"
            ;;
        "inactive")
            print_status "${CROSS}" "Service Status: ${RED}${BOLD}INACTIVE${RESET}" "${RED}"
            echo -e "${DIM}${YELLOW}   Use '${SCRIPT_NAME} start' to start the service${RESET}"
            ;;
        "failed")
            print_status "${CROSS}" "Service Status: ${RED}${BOLD}FAILED${RESET}" "${RED}"
            echo -e "${DIM}${RED}   Check logs with: ${WHITE}journalctl -u ${PLEX_SERVICE}${RESET}"
            ;;
        *)
            print_status "${INFO}" "Service Status: ${YELLOW}${BOLD}${service_status^^}${RESET}" "${YELLOW}"
            ;;
    esac

    # Show recent logs
    echo -e "\n${DIM}${CYAN}+--- Recent Service Logs (24h) ---+${RESET}"

    # Try to get logs with sudo, fall back to user permissions
    local logs
    if logs=$(sudo journalctl -u "$PLEX_SERVICE" --no-pager -n 5 --since "24 hours ago" --output=short 2>/dev/null); then
        if [[ -n "$logs" && "$logs" != "-- No entries --" ]]; then
            echo -e "${DIM}${logs}${RESET}"
        else
            echo -e "${DIM}${YELLOW}No recent log entries found${RESET}"
        fi
    else
        # Fallback: try without sudo
        logs=$(journalctl -u "$PLEX_SERVICE" --no-pager -n 5 --since "24 hours ago" 2>/dev/null || echo "Unable to access logs")
        if [[ "$logs" == "Unable to access logs" || "$logs" == "-- No entries --" ]]; then
            echo -e "${DIM}${YELLOW}Unable to access recent logs (try: sudo journalctl -u ${PLEX_SERVICE})${RESET}"
        else
            echo -e "${DIM}${logs}${RESET}"
        fi
    fi

    echo -e "${DIM}${CYAN}+----------------------------------+${RESET}"
}

# 🔧 Show available commands
show_help() {
    echo -e "${BOLD}${WHITE}Usage:${RESET} ${CYAN}${SCRIPT_NAME}${RESET} ${YELLOW}<command>${RESET}"
    echo ""
    echo -e "${BOLD}${WHITE}Available Commands:${RESET}"
    echo -e "  ${GREEN}${BOLD}start${RESET}     ${ROCKET} Start Plex Media Server"
    echo -e "  ${YELLOW}${BOLD}stop${RESET}      ${STOP_SIGN} Stop Plex Media Server"
    echo -e "  ${BLUE}${BOLD}restart${RESET}   ${RECYCLE} Restart Plex Media Server"
    echo -e "  ${CYAN}${BOLD}status${RESET}    ${INFO} Show detailed service status"
    echo -e "  ${PURPLE}${BOLD}scan${RESET}      ${SPARKLES} Library scanner operations"
    echo -e "  ${RED}${BOLD}repair${RESET}    [!] Repair database corruption issues"
    echo -e "  ${RED}${BOLD}nuclear${RESET}   [!!] Nuclear database recovery (last resort)"
    echo -e "  ${PURPLE}${BOLD}help${RESET}      [*] Show this help message"
    echo ""
    echo -e "${DIM}${WHITE}Examples:${RESET}"
    echo -e "  ${DIM}${SCRIPT_NAME} start     # Start the Plex service${RESET}"
    echo -e "  ${DIM}${SCRIPT_NAME} status    # Show current status${RESET}"
    echo -e "  ${DIM}${SCRIPT_NAME} scan      # Launch library scanner interface${RESET}"
    echo -e "  ${DIM}${SCRIPT_NAME} repair    # Fix database issues${RESET}"
    echo -e "  ${DIM}${SCRIPT_NAME} nuclear   # Complete database replacement${RESET}"
    echo ""
}

# 📚 Function to launch library scanner
launch_scanner() {
    print_status "${SPARKLES}" "Launching Plex Library Scanner..." "${PURPLE}"

    local scanner_script="${SCRIPT_DIR}/scan-plex-libraries.sh"

    if [[ ! -f "$scanner_script" ]]; then
        print_status "${CROSS}" "Library scanner script not found: $scanner_script" "${RED}"
        print_status "${INFO}" "Expected location: ${SCRIPT_DIR}/scan-plex-libraries.sh" "${YELLOW}"
        return 1
    fi

    if [[ ! -x "$scanner_script" ]]; then
        print_status "${INFO}" "Making scanner script executable..." "${BLUE}"
        chmod +x "$scanner_script"
    fi

    # Check if additional arguments were passed
    if [[ $# -gt 1 ]]; then
        # Pass remaining arguments to the scanner script
        shift  # Remove 'scan' argument
        print_status "${INFO}" "Executing scanner with arguments: $*" "${BLUE}"
        exec "$scanner_script" "$@"
    else
        # No additional arguments, launch interactive mode
        print_status "${INFO}" "Launching scanner in interactive mode..." "${BLUE}"
        exec "$scanner_script" interactive
    fi
}

# Nuclear database recovery function
nuclear_recovery() {
    print_status "${INFO}" "Starting nuclear database recovery..." "${RED}"

    local nuclear_script="${SCRIPT_DIR}/nuclear-plex-recovery.sh"

    if [[ ! -f "$nuclear_script" ]]; then
        print_status "${CROSS}" "Nuclear recovery script not found: $nuclear_script" "${RED}"
        print_status "${INFO}" "This script should be in the same directory as plex.sh" "${YELLOW}"
        return 2
    fi

    # Warning message
    echo -e "\n${RED}${BOLD}⚠️  WARNING: NUCLEAR RECOVERY ⚠️${RESET}"
    echo -e "${RED}This will completely replace your Plex database with a backup!${RESET}"
    echo -e "${RED}All changes since the backup was created will be lost!${RESET}"
    echo -e "${YELLOW}This should only be used when standard repair methods have failed.${RESET}\n"

    # Get user confirmation
    echo -e "${CYAN}Do you want to proceed with nuclear recovery? ${RESET}"
    echo -e "${DIM}Type 'YES' (uppercase) to confirm: ${RESET}"
    read -r confirmation

    if [[ "$confirmation" != "YES" ]]; then
        print_status "${INFO}" "Nuclear recovery cancelled by user" "${YELLOW}"
        return 0
    fi

    print_status "${INFO}" "Executing nuclear recovery script..." "${BLUE}"

    # Execute the nuclear recovery script
    if sudo "$nuclear_script" --auto; then
        print_status "${CHECKMARK}" "Nuclear recovery completed successfully!" "${GREEN}"
        print_status "${INFO}" "Your Plex server should now be operational" "${GREEN}"
        print_footer
        return 0
    else
        local exit_code=$?
        print_status "${CROSS}" "Nuclear recovery failed!" "${RED}"

        case $exit_code in
            2) print_status "${INFO}" "Backup file issues - check backup integrity" "${YELLOW}" ;;
            3) print_status "${INFO}" "Database replacement failure - check permissions" "${YELLOW}" ;;
            4) print_status "${INFO}" "Service management failure - check systemctl" "${YELLOW}" ;;
            5) print_status "${INFO}" "Rollback performed due to failure" "${YELLOW}" ;;
            *) print_status "${INFO}" "Unknown error occurred during recovery" "${YELLOW}" ;;
        esac

        print_footer
        return $exit_code
    fi
}

# Database repair function
repair_plex() {
    print_status "${INFO}" "Starting Plex database repair..." "${YELLOW}"

    # Run the enhanced repair function
    if repair_database; then
        print_status "${CHECKMARK}" "Database repair completed successfully!" "${GREEN}"

        # Try to start the service
        print_status "${INFO}" "Starting Plex service..." "${BLUE}"
        if sudo systemctl start "$PLEX_SERVICE"; then
            # Wait for service to fully start
            sleep 5
            if systemctl is-active --quiet "$PLEX_SERVICE"; then
                print_status "${CHECKMARK}" "Plex service started successfully!" "${GREEN}"
                print_footer
                return 0
            else
                print_status "${CROSS}" "Service started but may not be fully operational!" "${YELLOW}"
                show_detailed_status
                return 1
            fi
        else
            print_status "${CROSS}" "Failed to start Plex service after repair!" "${RED}"
            return 1
        fi
    else
        local repair_exit_code=$?
        print_status "${CROSS}" "Database repair failed!" "${RED}"

        # Try to start the service anyway in case partial repair helped
        print_status "${INFO}" "Attempting to start Plex service anyway..." "${BLUE}"
        sudo systemctl start "$PLEX_SERVICE" 2>/dev/null || true

        if [[ $repair_exit_code -eq 2 ]]; then
            print_status "${INFO}" "Critical error - manual intervention required" "${YELLOW}"
        else
            print_status "${INFO}" "Repair failed but service may still work with corrupted database" "${YELLOW}"
        fi

        print_footer
        return $repair_exit_code
    fi
}

# 🎯 Main script logic
main() {
    # Check if running as root
    if [[ $EUID -eq 0 ]]; then
        print_status "${CROSS}" "Don't run this script as root! Use your regular user account." "${RED}"
        exit 1
    fi

    # Check if no arguments provided
    if [[ $# -eq 0 ]]; then
        show_help
        exit 1
    fi

    case "${1,,}" in  # Convert to lowercase
        "start")
            start_plex
            ;;
        "stop")
            stop_plex
            ;;
        "restart"|"reload")
            restart_plex
            ;;
        "status"|"info")
            show_detailed_status
            ;;
        "scan"|"scanner"|"library")
            launch_scanner "$@"
            ;;
        "repair"|"fix")
            repair_plex
            ;;
        "nuclear"|"nuke")
            nuclear_recovery
            ;;
        "help"|"--help"|"-h")
            show_help
            ;;
        *)
            print_status "${CROSS}" "Unknown command: ${RED}${BOLD}$1${RESET}" "${RED}"
            echo ""
            show_help
            exit 1
            ;;
    esac
}

# 🚀 Execute main function with all arguments
main "$@"