#!/bin/bash

# AutoNAS Media Importer

# Advanced media import engine that processes, organizes and imports media files from cameras

# Usage: autonas-media-importer.sh <source_mount> <destination_path>

# Global configuration

LOG_TAG="autonas-import"

# Function to log messages

log_message() {

    local message="$1"

    local priority="${2:-info}"  # Default priority is info

    # Log to syslog with facility local0 and specified priority

    logger -p "local0.$priority" -t "$LOG_TAG" "$message"

    # Also echo to stdout/stderr for interactive use

    if [ -t 1 ]; then

        echo "$(date '+%Y-%m-%d %H:%M:%S') - $message"

    fi

}

# Usage function

usage() {

    echo "Usage: $0 <source_mount> <destination_path> [options]"

    echo ""

    echo "Arguments:"

    echo "  source_mount     - Mount point of the camera (e.g., /mnt/autonas/camera)"

    echo "  destination_path - Destination directory for imported files"

    echo ""

    echo "Options:"

    echo "  --dry-run        - Show what would be done without actually doing it"

    echo "  --keep-originals - Keep original files on camera after import"

    echo "  --verbose        - Enable verbose output"

    echo "  --limit N        - Process only N files (useful for testing)"

    echo "  --help           - Show this help"

    echo ""

    echo "Examples:"

    echo "  $0 /mnt/autonas/camera /mnt/autonas/photos/imported"

    echo "  $0 /mnt/autonas/camera /mnt/autonas/photos/imported --dry-run --verbose"

}

# Parse command line arguments

SOURCE_MOUNT=""

DESTINATION=""

DRY_RUN=0

KEEP_ORIGINALS=0

VERBOSE=0

FILE_LIMIT=0

while [[ $# -gt 0 ]]; do

    case $1 in

        --dry-run)

            DRY_RUN=1

            shift

            ;;

        --keep-originals)

            KEEP_ORIGINALS=1

            shift

            ;;

        --verbose)

            VERBOSE=1

            shift

            ;;

        --limit)

            FILE_LIMIT="$2"

            if ! [[ "$FILE_LIMIT" =~ ^[0-9]+$ ]]; then

                echo "Error: --limit requires a number"

                usage

                exit 1

            fi

            shift 2

            ;;

        --help)

            usage

            exit 0

            ;;

        -*)

            echo "Unknown option: $1"

            usage

            exit 1

            ;;

        *)

            if [[ -z "$SOURCE_MOUNT" ]]; then

                SOURCE_MOUNT="$1"

            elif [[ -z "$DESTINATION" ]]; then

                DESTINATION="$1"

            else

                echo "Too many arguments"

                usage

                exit 1

            fi

            shift

            ;;

    esac

done

# Validate arguments

if [[ -z "$SOURCE_MOUNT" || -z "$DESTINATION" ]]; then

    echo "Error: Both source_mount and destination_path are required"

    usage

    exit 1

fi

# Check if source exists and is mounted

if [[ ! -d "$SOURCE_MOUNT" ]]; then

    log_message "Error: Source mount point does not exist: $SOURCE_MOUNT" "err"

    exit 1

fi

# Check if source is actually mounted

if ! mountpoint -q "$SOURCE_MOUNT" 2>/dev/null; then

    log_message "Warning: Source path is not a mount point: $SOURCE_MOUNT" "warning"

fi

# Create destination directory if it doesn't exist

if [[ $DRY_RUN -eq 0 ]]; then

    mkdir -p "$DESTINATION"

    if [[ ! -d "$DESTINATION" ]]; then

        log_message "Error: Cannot create destination directory: $DESTINATION" "err"

        exit 1

    fi

fi

# Check for required tools

if ! command -v exiftool &> /dev/null; then

    log_message "Error: exiftool is required but not installed" "err"

    exit 1

fi

# Function to process a single file

process_file() {

    local file="$1"

    local relative_path="${file#$SOURCE_MOUNT/}"

    # Check if source mount is still available

    if ! mountpoint -q "$SOURCE_MOUNT" 2>/dev/null; then

        log_message "Error: Source mount point is no longer available: $SOURCE_MOUNT" "err"

        return 1

    fi

    # Check if file still exists

    if [[ ! -f "$file" ]]; then

        log_message "Error: File no longer exists: $relative_path" "err"

        log_message "Camera appears to be disconnected, stopping import" "warning"

        exit 1

    fi

    if [[ $VERBOSE -eq 1 ]]; then

        log_message "Processing: $relative_path" "info"

    fi

    # Check which group CreateDate comes from to determine correct handling

    create_date_info=$(exiftool -G1 -s -CreateDate "$file" 2>/dev/null | grep CreateDate | head -1)

    # Check if exiftool failed (possible if device disconnected)

    local exiftool_exit_code=$?

    if [[ $exiftool_exit_code -ne 0 ]] && [[ $exiftool_exit_code -ne 1 ]]; then

        log_message "Error: Cannot read file (device may be disconnected): $relative_path" "err"

        log_message "Camera appears to be disconnected, stopping import" "warning"

        exit 1

    fi

    if [[ -z "$create_date_info" ]]; then

        log_message "Warning: No CreateDate found in $relative_path, using file modification time" "warning"

        # Fallback to file modification time

        local file_date=$(date -r "$file" "+%Y-%m-%d %H:%M:%S" 2>/dev/null)

        if [[ -n "$file_date" ]]; then

            create_date_value="$file_date"

            create_date_group="FileSystem"

        else

            log_message "Error: Cannot determine date for $relative_path" "err"

            return 1

        fi

    else

        create_date_group=$(echo "$create_date_info" | cut -d']' -f1 | cut -d'[' -f2)

        create_date_value=$(echo "$create_date_info" | cut -d':' -f2- | xargs)

        # Convert EXIF date format (YYYY:MM:DD HH:MM:SS) to standard format (YYYY-MM-DD HH:MM:SS)

        create_date_value=$(echo "$create_date_value" | sed 's/^\([0-9]\{4\}\):\([0-9]\{2\}\):\([0-9]\{2\}\)/\1-\2-\3/')

    fi

    if [[ $VERBOSE -eq 1 ]]; then

        echo -n "  Date: [$create_date_value] from $create_date_group "

    fi

    # Extract file extension

    local filename=$(basename "$file")

    local extension="${filename##*.}"

    # For QuickTime files, the CreateDate is in UTC and needs conversion to local time

    if [[ "$create_date_group" == "QuickTime" ]]; then

        # Convert UTC time to local time

        local utc_timestamp=$(date -d "$create_date_value UTC" "+%s" 2>/dev/null)

        if [[ -n "$utc_timestamp" ]]; then

            create_date_value=$(date -d "@$utc_timestamp" "+%Y-%m-%d %H:%M:%S" 2>/dev/null)

            if [[ $VERBOSE -eq 1 ]]; then

                echo -n "(converted from UTC) "

            fi

        fi

    fi

    # Create output directory structure

    local date_dir=$(date -d "$create_date_value" "+%Y-%m-%d" 2>/dev/null)

    if [[ -z "$date_dir" ]]; then

        log_message "Error: Invalid date format for $relative_path: $create_date_value" "err"

        return 1

    fi

    local output_dir="$DESTINATION/$date_dir"

    if [[ $DRY_RUN -eq 0 ]]; then

        mkdir -p "$output_dir"

    fi

    # Generate output filename with timestamp

    local timestamp=$(date -d "$create_date_value" "+%Y-%m-%d_%H-%M-%S" 2>/dev/null)

    local output_filename="${timestamp}.${extension,,}"  # Convert extension to lowercase

    local output_path="$output_dir/$output_filename"

    # Handle filename conflicts

    local counter=1

    local base_output_path="$output_path"

    while [[ -f "$output_path" ]] && [[ $DRY_RUN -eq 0 ]]; do

        local name_without_ext="${timestamp}_${counter}"

        output_path="$output_dir/${name_without_ext}.${extension,,}"

        counter=$((counter + 1))

    done

    if [[ $DRY_RUN -eq 1 ]]; then

        if [[ $KEEP_ORIGINALS -eq 1 ]]; then

            echo "Would copy: $relative_path -> ${output_path#$DESTINATION/}"

        else

            echo "Would move: $relative_path -> ${output_path#$DESTINATION/}"

        fi

    else

        # Perform the actual file operation

        if [[ $KEEP_ORIGINALS -eq 1 ]]; then

            if cp "$file" "$output_path"; then

                if [[ $VERBOSE -eq 1 ]]; then

                    echo "✓ Copied"

                fi

                log_message "Copied: $relative_path -> ${output_path#$DESTINATION/}" "info"

                return 0

            else

                if [[ $VERBOSE -eq 1 ]]; then

                    echo "✗ Copy failed"

                fi

                log_message "Error: Failed to copy $relative_path" "err"

                return 1

            fi

        else

            if mv "$file" "$output_path"; then

                if [[ $VERBOSE -eq 1 ]]; then

                    echo "✓ Moved"

                fi

                log_message "Moved: $relative_path -> ${output_path#$DESTINATION/}" "info"

                return 0

            else

                if [[ $VERBOSE -eq 1 ]]; then

                    echo "✗ Move failed"

                fi

                log_message "Error: Failed to move $relative_path" "err"

                return 1

            fi

        fi

    fi

}

# Function to find camera directories

find_camera_directories() {

    local search_patterns=("DCIM" "PRIVATE" "MP_ROOT" "AVCHD" "Photos" "Videos")

    local found_dirs=()

    # Test if the mount point is accessible with a timeout

    if ! timeout 3 ls "$SOURCE_MOUNT" >/dev/null 2>&1; then

        log_message "Error: Mount point is not accessible (device likely disconnected): $SOURCE_MOUNT" "err"

        exit 1

    fi

    for pattern in "${search_patterns[@]}"; do

        while IFS= read -r -d '' dir; do

            found_dirs+=("$dir")

        done < <(timeout 5 find "$SOURCE_MOUNT" -maxdepth 3 -type d -iname "$pattern" -print0 2>/dev/null)

    done

    # If no camera directories found, search for common media file extensions

    if [[ ${#found_dirs[@]} -eq 0 ]]; then

        log_message "No camera directories found, searching for media files..." "info"

        local media_extensions=("*.jpg" "*.jpeg" "*.png" "*.tiff" "*.cr2" "*.nef" "*.arw" "*.mp4" "*.mov" "*.avi" "*.mts" "*.m2ts")

        for ext in "${media_extensions[@]}"; do

            while IFS= read -r -d '' file; do

                local dir=$(dirname "$file")

                if [[ ! " ${found_dirs[@]} " =~ " ${dir} " ]]; then

                    found_dirs+=("$dir")

                fi

            done < <(timeout 5 find "$SOURCE_MOUNT" -maxdepth 3 -type f -iname "$ext" -print0 2>/dev/null)

        done

    fi

    printf '%s\n' "${found_dirs[@]}" | sort -u

}

# Main execution

log_message "Starting camera import from $SOURCE_MOUNT to $DESTINATION" "info"

if [[ $DRY_RUN -eq 1 ]]; then

    log_message "DRY RUN MODE - No files will be actually moved/copied" "info"

fi

if [[ $KEEP_ORIGINALS -eq 1 ]]; then

    log_message "KEEP ORIGINALS MODE - Files will be copied instead of moved" "info"

fi

# Find camera directories

log_message "Scanning for camera directories..." "info"

camera_dirs=$(find_camera_directories)

if [[ -z "$camera_dirs" ]]; then

    log_message "No camera directories or media files found in $SOURCE_MOUNT" "warning"

    exit 0

fi

echo "Found camera directories:"

echo "$camera_dirs" | while IFS= read -r dir; do

    echo "  $dir"

done

# Process files

total_files=0

processed_files=0

error_files=0

# Delete GLV files (Garmin video preview files) - they're usually not needed

log_message "Cleaning up GLV preview files..." "info"

glv_count=0

while IFS= read -r dir; do

    if [[ $DRY_RUN -eq 1 ]]; then

        glv_files=$(find "$dir" -type f -iname "*.glv" 2>/dev/null | wc -l)

        if [[ $glv_files -gt 0 ]]; then

            echo "Would delete $glv_files GLV files from $dir"

            glv_count=$((glv_count + glv_files))

        fi

    else

        while IFS= read -r -d '' glv_file; do

            if rm "$glv_file" 2>/dev/null; then

                glv_count=$((glv_count + 1))

            fi

        done < <(find "$dir" -type f -iname "*.glv" -print0 2>/dev/null)

    fi

done <<< "$camera_dirs"

if [[ $glv_count -gt 0 ]]; then

    if [[ $DRY_RUN -eq 1 ]]; then

        log_message "Would delete $glv_count GLV preview files" "info"

    else

        log_message "Deleted $glv_count GLV preview files" "info"

    fi

fi

# Process media files

log_message "Processing media files..." "info"

media_extensions=("*.jpg" "*.jpeg" "*.png" "*.tiff" "*.tif" "*.cr2" "*.nef" "*.arw" "*.dng" "*.mp4" "*.mov" "*.avi" "*.mts" "*.m2ts" "*.mkv" "*.wmv")

# In dry-run mode, limit output to avoid overwhelming logs

max_files_to_show=20

files_shown=0

files_processed_count=0

while IFS= read -r dir; do

    # Check if mount point is still available before processing each directory

    if ! mountpoint -q "$SOURCE_MOUNT" 2>/dev/null; then

        log_message "Camera disconnected, stopping import process" "warning"

        break

    fi

    for ext in "${media_extensions[@]}"; do

        while IFS= read -r -d '' file; do

            total_files=$((total_files + 1))

            files_processed_count=$((files_processed_count + 1))

            # Check if camera is still connected before processing each file

            if ! mountpoint -q "$SOURCE_MOUNT" 2>/dev/null; then

                log_message "Camera disconnected during processing, stopping import" "warning"

                exit 1

            fi

            # Check file limit

            if [[ $FILE_LIMIT -gt 0 && $files_processed_count -gt $FILE_LIMIT ]]; then

                echo "Reached file limit of $FILE_LIMIT files, stopping processing..."

                break 3

            fi

            # In dry-run mode, limit verbose output

            if [[ $DRY_RUN -eq 1 && $files_shown -ge $max_files_to_show ]]; then

                if [[ $files_shown -eq $max_files_to_show ]]; then

                    echo "... (limiting output in dry-run mode, processing continues)"

                    files_shown=$((files_shown + 1))

                fi

                # Still process but don't show details

                processed_files=$((processed_files + 1))

            else

                if [[ $DRY_RUN -eq 1 ]]; then

                    files_shown=$((files_shown + 1))

                fi

                if process_file "$file"; then

                    processed_files=$((processed_files + 1))

                else

                    error_files=$((error_files + 1))

                fi

            fi

        done < <(find "$dir" -type f -iname "$ext" -print0 2>/dev/null)

    done

done <<< "$camera_dirs"

# Summary

log_message "Import completed: $processed_files/$total_files files processed successfully" "info"

if [[ $error_files -gt 0 ]]; then

    log_message "Import had errors: $error_files files failed to process" "warning"

fi

echo ""

echo "=== Import Summary ==="

echo "Total files found: $total_files"

echo "Successfully processed: $processed_files"

echo "Errors: $error_files"

if [[ $glv_count -gt 0 ]]; then

    echo "GLV files cleaned up: $glv_count"

fi

# Exit with error code if there were errors

if [[ $error_files -gt 0 ]]; then

    exit 1

else

    exit 0

fi