#!/usr/bin/env bash
###############################################################################
#                       GEEKCADE ASSETS SYNC
#                  USB Drive -> Cabinet Asset Copier
#                       Version: v2.0 (build 38)
#
# Copies a Pleasuredome-format MAME assets bundle from a USB drive to
# the cabinet, then updates ~/mame/mame.ini with the right paths.
#
# Usage:
#   geekcade_assets.sh                    Auto-detect USB, run all sections
#   geekcade_assets.sh --source PATH      Use specific path as USB source
#   geekcade_assets.sh --check            Only check if USB is detected, exit
#   geekcade_assets.sh --help             Show this help
#
# Exit codes for --check:
#   0  USB detected and looks valid
#   1  USB not found or not valid
###############################################################################

set -u

# ==============================
# [0] CONFIG
# ==============================
USB_LABEL="GEEKCADE"

# Cabinet destination directories. These were created by the installer.
MAME_DIR="$HOME/mame"
MAME_INI="$MAME_DIR/mame.ini"
ATTRACT_DIR="$HOME/attractplus"

# Paths where USB drives typically auto-mount on Ubuntu. udisks2 uses
# /media/<user>/<label>/ on modern systems. /run/media/<user>/<label>/ is
# the older pattern. /mnt/usb is for manual mounts.
#
# /media/GEEKCADE (no user folder) is what our installer's systemd
# automount unit uses - that's the canonical location.
USB_SEARCH_PATHS=(
  "/media/$USB_LABEL"
  "/media/geekcade/$USB_LABEL"
  "/run/media/geekcade/$USB_LABEL"
  "/run/media/$USB_LABEL"
  "/mnt/$USB_LABEL"
  "/mnt/usb"
  "/mnt/geekcade"
)

# Folders we expect to find at the USB root. Detection requires at least
# one of these to confirm "this is a GeekCade asset USB."
USB_EXPECTED_FOLDERS=("extras" "multimedia" "roms" "support")

# Extras zip files get UNZIPPED into matching subfolders of ~/mame/.
# This way MAME finds them as folders (faster, no in-archive decompress on
# every game launch) AND AttractMode Plus can read the same folders for
# artwork (AM+ does not crawl into zips).
#
# Format: each entry is "<basename>" -- the .zip extension is implied.
# Source: extras/<basename>.zip on USB
# Dest:   ~/mame/<basename>/  on cabinet
EXTRAS_ZIP_NAMES=(
  "artpreview"
  "bosses"
  "cabinets"
  "cpanel"
  "devices"
  "ends"
  "flyers"
  "gameover"
  "howto"
  "icons"
  "logo"
  "manuals"
  "marquees"
  "pcb"
  "scores"
  "select"
  "snap"
  "titles"
  "versus"
  "warning"
)

# cheat.7z is special: it stays as a 7-zip archive (MAME reads it natively
# as a folder) and is just copied, not extracted. AM+ doesn't use cheats.
EXTRAS_KEEP_AS_FILE=(
  "cheat.7z"
)

# Already-extracted folders inside extras/ that get merged into matching
# folders under ~/mame/. These are NOT zips - they're directory trees with
# many small files (dats, ini filters, history.xml, sample zips, artwork
# zips). We use rsync to merge: USB files win, but local additions survive.
#
# Format: each entry is "<src_subfolder>:<dest_subfolder>" relative to
# extras/ and ~/mame/ respectively.
EXTRAS_SUBFOLDERS=(
  "artwork:artwork"     # per-game bezel/overlay zips (~/mame/artwork/<rom>.zip)
  "dats:dats"           # history.dat, mameinfo.dat, command.dat, etc.
  "folders:folders"     # catver.ini, nplayers.ini, genre.ini etc filter files
  "history:history"     # history.xml for the MAME history plugin
  "samples:samples"     # per-game sample zips (~/mame/samples/<rom>.zip)
)

# Multimedia folders. These are not extras - they're separate Pleasuredome
# torrents (MAME Multimedia). Land under ~/mame/ for cleanliness, get
# wired into AttractMode Plus as snap/video/music sources. Not referenced
# by mame.ini (MAME itself doesn't use these).
#
# Format: "<src_subfolder>:<dest_subfolder>" same as EXTRAS_SUBFOLDERS.
MULTIMEDIA_SUBFOLDERS=(
  "soundtrack:soundtrack"   # mp3 per game (in-game music tracks)
  "videosnaps:videosnaps"   # mp4 per game (gameplay video previews)
)

# Support files (AntoPISA's MAME_SupportFiles project). These are .ini
# filter files and .dat info files that MAME's plugins and AM+ display
# filters consume. The source layout has self-routing structure: each
# support folder has dats/ and folders/ subfolders matching MAME's
# expected destinations.
#
# Format: "<src_path>:<dest_subfolder>:<filename_pattern>"
# Run AFTER extras subfolders sync so AntoPISA versions win on filename
# collisions (typically newer/more authoritative than Pleasuredome).
SUPPORT_RULES=(
  # bestgames/bestgames.ini → ~/mame/folders/
  "bestgames:folders:*.ini"

  # catver/catver.ini → ~/mame/folders/
  "catver:folders:catver.ini"

  # catver/UI_files/* → ~/mame/folders/  (catlist, genre, genre_ows,
  #                                       mature, not_mature)
  "catver/UI_files:folders:*.ini"

  # command/dats/command.dat → ~/mame/dats/
  "command/dats:dats:*.dat"

  # command/folders/command.ini → ~/mame/folders/
  "command/folders:folders:*.ini"

  # gameinit/dats/gameinit.dat → ~/mame/dats/
  "gameinit/dats:dats:*.dat"

  # gameinit/folders/gameinit.ini → ~/mame/folders/
  "gameinit/folders:folders:*.ini"
)

# ==============================
# [1] COLORS
# ==============================
GREEN=$'\033[0;32m'
RED=$'\033[0;31m'
YELLOW=$'\033[1;33m'
CYAN=$'\033[0;36m'
NC=$'\033[0m'

# ==============================
# [2] HELP
# ==============================
show_help() {
  sed -n '2,/^####/p' "$0" | sed 's/^#//' | head -n -1
}

# ==============================
# [3] USB DETECTION
# ==============================

# Sets global USB_SOURCE to the detected path. Returns 0 on success, 1
# on failure. If USB_SOURCE is already set externally (e.g. via
# --source arg), validates that path instead of searching.
detect_usb() {
  local path

  # If --source was passed, just validate it
  if [ -n "${USB_SOURCE_OVERRIDE:-}" ]; then
    if validate_usb_path "$USB_SOURCE_OVERRIDE"; then
      USB_SOURCE="$USB_SOURCE_OVERRIDE"
      return 0
    else
      echo -e "${RED}--source path is not a valid GeekCade USB:${NC} $USB_SOURCE_OVERRIDE" >&2
      return 1
    fi
  fi

  # Fast path: if there's no GEEKCADE-labeled device attached, skip the
  # filesystem search entirely. This avoids triggering systemd automount
  # units (which can hang waiting for absent devices) and is a O(1) check.
  if [ ! -e "/dev/disk/by-label/$USB_LABEL" ] \
     && [ ! -e "/dev/disk/by-partlabel/$USB_LABEL" ]; then
    # No labeled device. Still allow manual mounts at /mnt/* to work.
    for path in "/mnt/$USB_LABEL" "/mnt/usb" "/mnt/geekcade"; do
      if validate_usb_path "$path"; then
        USB_SOURCE="$path"
        return 0
      fi
    done
    return 1
  fi

  # Labeled device exists. Search the conventional paths for where it's
  # mounted (or where automount will mount it on access).
  for path in "${USB_SEARCH_PATHS[@]}"; do
    if validate_usb_path "$path"; then
      USB_SOURCE="$path"
      return 0
    fi
  done

  return 1
}

# Returns 0 if path looks like a valid GeekCade USB, 1 otherwise.
# We require it to exist, be readable, and contain at least one of the
# expected top-level folders.
validate_usb_path() {
  local path="$1"
  local folder

  [ -z "$path" ] && return 1
  [ ! -d "$path" ] && return 1
  [ ! -r "$path" ] && return 1

  for folder in "${USB_EXPECTED_FOLDERS[@]}"; do
    if [ -d "$path/$folder" ]; then
      return 0
    fi
  done

  return 1
}

# Prints a manual-mount help message to stderr.
print_mount_help() {
  cat >&2 <<EOF

${YELLOW}USB drive not detected.${NC}

If you have a USB drive plugged in but it didn't auto-mount, you may
need to mount it manually:

  ${CYAN}lsblk${NC}                              # find the USB device (usually sdb1 or sdc1)
  ${CYAN}sudo mkdir -p /mnt/usb${NC}
  ${CYAN}sudo mount /dev/sdX1 /mnt/usb${NC}      # replace sdX1 with your device

Then re-run with:

  ${CYAN}$0 --source /mnt/usb${NC}

If your USB is mounted somewhere else, point at it directly:

  ${CYAN}$0 --source /path/to/your/usb${NC}

The USB should contain at least one of these folders at its root:
  ${USB_EXPECTED_FOLDERS[*]}

EOF
}

# ==============================
# [4] SYNC HELPERS
# ==============================

# Pretty-print a boxed section header
section_header() {
  local title="$1"
  echo
  echo -e "${CYAN}========================================================${NC}"
  echo -e "${CYAN}  $title${NC}"
  echo -e "${CYAN}========================================================${NC}"
}

# Get human-readable size of a single file (e.g., "7.8G", "32K")
file_size_h() {
  du -h "$1" 2>/dev/null | awk '{print $1}'
}

# Copy a single file from USB to destination using rsync.
# Uses --size-only to avoid timezone-related mtime mismatches between
# macOS-formatted exFAT and the cabinet's view of it.
# Args: <src_file> <dest_dir> <label_for_display>
# Returns 0 on success/skip, 1 on actual failure.
rsync_one_file() {
  local src="$1"
  local dest_dir="$2"
  local label="$3"
  local size t0 t1 dur rc

  if [ ! -f "$src" ]; then
    return 2  # not on USB, distinct from failure
  fi

  size="$(file_size_h "$src")"
  printf "${YELLOW}  → %-20s${NC} (%s)  " "$label" "$size"

  t0=$SECONDS

  # --size-only: skip the file if the destination has the same size.
  #   Avoids re-copying every time due to mtime drift across exFAT.
  # --info=progress2,stats0: progress bar that overwrites in place; we
  #   pipe it to a filter that erases the line when rsync finishes,
  #   so we end up with one neat status line per file.
  # --partial: if interrupted, keep the partial file so resume is fast.
  # -a: archive mode (preserves perms etc.)
  # -h: human-readable sizes
  if ! command -v rsync >/dev/null 2>&1; then
    printf "${RED}✗ rsync not installed${NC}\n"
    return 1
  fi

  rsync -ah --size-only --partial --info=progress2,stats0 \
       "$src" "$dest_dir/" 2>&1 | \
       awk 'BEGIN{ORS=""} /xfr/ {print "\r\033[K"; next} {print}' >/dev/null
  rc="${PIPESTATUS[0]}"

  if [ "$rc" -eq 0 ]; then
    t1=$SECONDS
    dur=$((t1 - t0))
    if [ "$dur" -lt 1 ]; then
      printf "${GREEN}✓${NC} (skipped, already current)\n"
    elif [ "$dur" -lt 60 ]; then
      printf "${GREEN}✓${NC} (%ds)\n" "$dur"
    else
      printf "${GREEN}✓${NC} (%dm%ds)\n" "$((dur/60))" "$((dur%60))"
    fi
    return 0
  else
    printf "${RED}✗ FAILED (rsync exit %d)${NC}\n" "$rc"
    return 1
  fi
}

# Extract one zip from USB into a matching folder under ~/mame/.
# Uses rsync to first stage the zip into a temp location (resumable
# across re-runs), then unzip into the destination folder. Both MAME
# and AttractMode Plus read these as folders — much faster at runtime
# than letting MAME decompress on every game launch, and AM+ can't read
# zips at all.
#
# If the destination folder already exists with files, we only re-extract
# if the zip on USB is different from the one we previously extracted.
# We track this with a small marker file containing the source size.
#
# Args: <name> (e.g. "flyers" → flyers.zip → ~/mame/flyers/)
# Returns: 0 success, 1 failure, 2 not on USB
extract_one_zip() {
  local name="$1"
  local src_zip="$USB_SOURCE/extras/$name.zip"
  local dest_dir="$MAME_DIR/$name"
  local marker="$dest_dir/.geekcade_synced_size"
  local src_size existing_size t0 t1 dur sz_h

  if [ ! -f "$src_zip" ]; then
    return 2
  fi

  src_size="$(stat -c%s "$src_zip" 2>/dev/null || stat -f%z "$src_zip")"
  sz_h="$(file_size_h "$src_zip")"

  printf "${YELLOW}  → %-20s${NC} (%s)  " "$name.zip" "$sz_h"

  # If destination exists and our marker says it was extracted from a zip
  # of the same size, skip. This is our "size-only" idempotency check
  # (avoids the FAT/exFAT mtime trap).
  if [ -d "$dest_dir" ] && [ -f "$marker" ]; then
    existing_size="$(cat "$marker" 2>/dev/null)"
    if [ "$existing_size" = "$src_size" ]; then
      printf "${GREEN}✓${NC} (already extracted)\n"
      return 0
    fi
  fi

  t0=$SECONDS

  # Make the destination folder (or empty it if size differs from marker)
  mkdir -p "$dest_dir"

  # Extract directly from USB - faster than staging the zip first, since
  # we'd need to copy 7+GB of zip just to throw it away after extracting.
  # -q quiet; -o overwrite without prompting (so re-runs cleanly update).
  if unzip -q -o "$src_zip" -d "$dest_dir" 2>/dev/null; then
    # Record the source size so future runs can skip this zip
    echo "$src_size" > "$marker"

    t1=$SECONDS
    dur=$((t1 - t0))
    if [ "$dur" -lt 60 ]; then
      printf "${GREEN}✓${NC} extracted (%ds)\n" "$dur"
    else
      printf "${GREEN}✓${NC} extracted (%dm%ds)\n" "$((dur/60))" "$((dur%60))"
    fi
    return 0
  else
    printf "${RED}✗ unzip failed${NC}\n"
    return 1
  fi
}

# Copy a single file as-is from USB to ~/mame/ (used for cheat.7z which
# stays archived — MAME reads .7z natively as a folder).
copy_one_extras_file() {
  local file="$1"
  local src="$USB_SOURCE/extras/$file"

  if [ ! -f "$src" ]; then
    return 2
  fi

  rsync_one_file "$src" "$MAME_DIR" "$file"
  return $?
}

# Process the extras top-level files: extract zips into matching folders,
# copy cheat.7z as-is. Then update mame.ini with the resulting paths.
sync_extras_zips() {
  local src_dir="$USB_SOURCE/extras"
  local extracted=0 copied=0 failed=0 missing=0
  local name file rc

  if [ ! -d "$src_dir" ]; then
    echo -e "${YELLOW}No extras/ folder on USB - skipping extras zips.${NC}"
    return 0
  fi

  section_header "Syncing extras (top-level files)"
  echo "Source: $src_dir"
  echo "Dest:   $MAME_DIR"
  echo "Note:   .zip files are extracted into named folders;"
  echo "        cheat.7z is kept as a single archive."
  echo

  mkdir -p "$MAME_DIR"

  # Extract each .zip into its own folder
  for name in "${EXTRAS_ZIP_NAMES[@]}"; do
    extract_one_zip "$name"
    rc=$?
    case "$rc" in
      0) extracted=$((extracted + 1)) ;;
      1) failed=$((failed + 1)) ;;
      2)
        printf "${YELLOW}  → %-20s${NC} (not on USB)\n" "$name.zip"
        missing=$((missing + 1))
        ;;
    esac
  done

  # Copy any keep-as-file extras (cheat.7z)
  for file in "${EXTRAS_KEEP_AS_FILE[@]}"; do
    copy_one_extras_file "$file"
    rc=$?
    case "$rc" in
      0) copied=$((copied + 1)) ;;
      1) failed=$((failed + 1)) ;;
      2)
        printf "${YELLOW}  → %-20s${NC} (not on USB)\n" "$file"
        missing=$((missing + 1))
        ;;
    esac
  done

  echo
  echo -e "${GREEN}Extras:${NC} $extracted extracted, $copied copied as-is, $missing missing, $failed failed"

  # Update mame.ini if at least one asset was processed
  if [ $((extracted + copied)) -gt 0 ]; then
    update_extras_mame_ini
    update_attractplus_artwork
  fi

  return 0
}

# Sync one folder from USB to cabinet using rsync merge.
# Args: <src_dir> <dest_dir> <label_for_display>
# Returns: 0 success, 1 failure, 2 src not present
# Uses --size-only to avoid FAT/exFAT mtime drift; no --delete so
# cabinet-only files are preserved.
rsync_one_folder() {
  local src="$1"
  local dest="$2"
  local label="$3"
  local rc t0 t1 dur sz_h count_h

  if [ ! -d "$src" ]; then
    return 2
  fi

  if ! command -v rsync >/dev/null 2>&1; then
    printf "${RED}✗ rsync not installed${NC}\n"
    return 1
  fi

  sz_h="$(du -sh "$src" 2>/dev/null | awk '{print $1}')"
  count_h="$(find "$src" -maxdepth 2 -type f 2>/dev/null | wc -l | awk '{print $1}')"

  # Header line on its own (newline at end). Live progress writes on the
  # NEXT line and overwrites itself with \r as rsync emits updates.
  printf "${YELLOW}  → %-15s${NC} (%s, %s files)\n" "$label" "$sz_h" "$count_h"

  mkdir -p "$dest"
  t0=$SECONDS

  # Trailing slashes on src are important - they tell rsync to copy
  # CONTENTS of the source folder, not the folder itself, so we get
  # a merge into dest rather than dest/src_name nested inside.
  #
  # rsync emits progress2 lines separated by \r (carriage return) so they
  # overwrite in place on a terminal. But awk reads line-by-line on \n,
  # so we use `tr` to convert \r to \n first. Then awk can filter to just
  # the progress lines, and we re-add \r ourselves for in-place display.
  #
  # stdbuf -oL forces line buffering on tr's output, otherwise the pipe
  # buffers up the whole output and we don't see anything until rsync
  # is done.
  #
  # rsync's progress2 line looks like:
  #   47.31G  31%  14.32MB/s  1:53:21 (xfr#12456, to-chk=31362/43818)
  rsync -ah --size-only --partial --info=progress2,stats0 \
       "$src/" "$dest/" 2>&1 | \
       stdbuf -oL tr '\r' '\n' | \
       while IFS= read -r line; do
         # Skip empty lines and file names; only show progress lines
         case "$line" in
           *%*) printf "\r\033[K      %s" "$line" ;;
         esac
       done
  rc="${PIPESTATUS[0]}"

  # Newline + clear so the final summary prints cleanly
  printf "\n"

  if [ "$rc" -eq 0 ]; then
    t1=$SECONDS
    dur=$((t1 - t0))
    if [ "$dur" -lt 1 ]; then
      printf "      ${GREEN}✓${NC} (already current)\n"
    elif [ "$dur" -lt 60 ]; then
      printf "      ${GREEN}✓${NC} synced (%ds)\n" "$dur"
    else
      printf "      ${GREEN}✓${NC} synced (%dh%dm%ds)\n" "$((dur/3600))" "$(((dur%3600)/60))" "$((dur%60))"
    fi
    return 0
  else
    printf "      ${RED}✗ FAILED (rsync exit %d)${NC}\n" "$rc"
    return 1
  fi
}

# Sync the already-extracted subfolders inside extras/ (artwork, dats,
# folders, history, samples) into matching folders under ~/mame/.
#
# These are merged with rsync: files on USB overwrite cabinet copies,
# but cabinet-only files survive (so user customizations in e.g.
# ~/mame/folders/ aren't wiped out).
#
# After sync, mame.ini gets historypath, categorypath, samplepath, and
# artpath set to absolute paths so MAME finds everything.
sync_extras_subfolders() {
  local src_dir="$USB_SOURCE/extras"
  local synced=0 missing=0 failed=0
  local entry src_name dest_name rc

  if [ ! -d "$src_dir" ]; then
    echo -e "${YELLOW}No extras/ folder on USB - skipping subfolders.${NC}"
    return 0
  fi

  section_header "Syncing extras (subfolders)"
  echo "Source: $src_dir/<folder>"
  echo "Dest:   $MAME_DIR/<folder>"
  echo "Note:   merged with rsync; cabinet-only files are preserved."
  echo

  for entry in "${EXTRAS_SUBFOLDERS[@]}"; do
    src_name="${entry%%:*}"
    dest_name="${entry##*:}"

    rsync_one_folder "$src_dir/$src_name" "$MAME_DIR/$dest_name" "$src_name/"
    rc=$?
    case "$rc" in
      0) synced=$((synced + 1)) ;;
      1) failed=$((failed + 1)) ;;
      2)
        printf "${YELLOW}  → %-15s${NC} (not on USB)\n" "$src_name/"
        missing=$((missing + 1))
        ;;
    esac
  done

  echo
  echo -e "${GREEN}Subfolders:${NC} $synced synced, $missing missing, $failed failed"

  if [ "$synced" -gt 0 ]; then
    update_subfolders_mame_ini
  fi

  return 0
}

# Sync multimedia folders (soundtrack, videosnaps) from USB into
# matching folders under ~/mame/. Wires them into AM+ as snap, video,
# and music artwork sources. MAME itself doesn't use these, so no
# mame.ini update.
sync_multimedia() {
  local src_dir="$USB_SOURCE/multimedia"
  local synced=0 missing=0 failed=0
  local entry src_name dest_name rc

  if [ ! -d "$src_dir" ]; then
    echo -e "${YELLOW}No multimedia/ folder on USB - skipping.${NC}"
    return 0
  fi

  section_header "Syncing multimedia"
  echo "Source: $src_dir/<folder>"
  echo "Dest:   $MAME_DIR/<folder>"
  echo "Note:   merged with rsync; for AttractMode Plus snap/video/music."
  echo

  for entry in "${MULTIMEDIA_SUBFOLDERS[@]}"; do
    src_name="${entry%%:*}"
    dest_name="${entry##*:}"

    rsync_one_folder "$src_dir/$src_name" "$MAME_DIR/$dest_name" "$src_name/"
    rc=$?
    case "$rc" in
      0) synced=$((synced + 1)) ;;
      1) failed=$((failed + 1)) ;;
      2)
        printf "${YELLOW}  → %-15s${NC} (not on USB)\n" "$src_name/"
        missing=$((missing + 1))
        ;;
    esac
  done

  echo
  echo -e "${GREEN}Multimedia:${NC} $synced synced, $missing missing, $failed failed"

  if [ "$synced" -gt 0 ]; then
    update_attractplus_multimedia
  fi

  return 0
}

# Wire multimedia folders into AM+ mame.cfg.
# - videosnaps becomes the source for both 'snap' and 'video' artwork
#   (videos play during attract mode, but also serve as snap fallback).
# - soundtrack becomes a 'music' artwork type for layouts that play audio.
update_attractplus_multimedia() {
  local emu_cfg="$ATTRACT_DIR/emulators/mame.cfg"

  if [ ! -f "$emu_cfg" ]; then
    echo -e "${YELLOW}WARNING:${NC} $emu_cfg not found - skipping AM+ multimedia update."
    return 0
  fi

  echo
  echo -e "${YELLOW}Updating $emu_cfg with multimedia paths...${NC}"

  # videosnaps drives both 'snap' (which already exists with snap.zip
  # extracted folder) and 'video' (motion preview during attract mode)
  set_attract_artwork "snap"  "videosnaps"
  set_attract_artwork "video" "videosnaps"

  # music is a custom artwork type some layouts read for in-game audio
  # preview during attract mode
  set_attract_artwork "music" "soundtrack"

  echo -e "${GREEN}AM+ mame.cfg updated.${NC}"
}

# Sync ROMs from USB to ~/mame/roms/. Roms are flat .zip files (one per
# game/clone). After sync, rebuild the AM+ romlist so newly-added games
# show up in the frontend.
#
# Note: we sync ALL roms including clones. AM+ filters them at display
# time via the "Working/!Clone" filter in attract.cfg. This way MAME has
# access to clones (needed for parent/clone dependencies) but the user
# sees a clean parents-only menu.
sync_roms() {
  local src_dir="$USB_SOURCE/roms"
  local dest_dir="$MAME_DIR/roms"
  local src_count dest_count_before dest_count_after rc

  if [ ! -d "$src_dir" ]; then
    echo -e "${YELLOW}No roms/ folder on USB - skipping.${NC}"
    return 0
  fi

  section_header "Syncing roms"
  echo "Source: $src_dir"
  echo "Dest:   $dest_dir"
  echo

  # Count what we have on each side BEFORE sync
  src_count="$(find "$src_dir" -maxdepth 1 -type f -name '*.zip' 2>/dev/null | wc -l | awk '{print $1}')"
  dest_count_before=0
  if [ -d "$dest_dir" ]; then
    dest_count_before="$(find "$dest_dir" -maxdepth 1 -type f -name '*.zip' 2>/dev/null | wc -l | awk '{print $1}')"
  fi

  echo "ROM zip files on USB:    $src_count"
  echo "ROM zip files on cabinet: $dest_count_before (before sync)"
  echo

  if [ "$src_count" -eq 0 ]; then
    echo -e "${YELLOW}No .zip files found in $src_dir - nothing to sync.${NC}"
    return 0
  fi

  rsync_one_folder "$src_dir" "$dest_dir" "roms/"
  rc=$?

  if [ "$rc" -ne 0 ] && [ "$rc" -ne 2 ]; then
    echo -e "${RED}roms sync failed.${NC}"
    return 1
  fi

  # Count after sync to give a real "added N roms" summary
  dest_count_after="$(find "$dest_dir" -maxdepth 1 -type f -name '*.zip' 2>/dev/null | wc -l | awk '{print $1}')"
  echo
  echo -e "${GREEN}ROMs:${NC} $dest_count_after total on cabinet"
  echo "       (added $((dest_count_after - dest_count_before)) since last sync)"

  # Rebuild AM+ romlist so new roms appear in the frontend
  rebuild_attract_romlist
  _romlist_rebuilt=1

  # Make sure the display filter is in place (idempotent, so safe to call
  # every sync).
  ensure_attract_display_filter

  return 0
}

# Ensure the AttractMode Plus display has a "Working Parents Only" filter
# so the cabinet shows a curated list, not the full 40K+ rom dump including
# clones, preliminary/broken games, mahjong sets, etc.
#
# The filter hides items at display time — MAME still has access to all
# roms (needed for parent/clone dependencies). This is much better than
# deleting clone roms from disk.
#
# Idempotent: only adds the filter if it isn't already present.
ensure_attract_display_filter() {
  local cfg="$ATTRACT_DIR/config/attract.cfg"

  if [ ! -f "$cfg" ]; then
    echo -e "${YELLOW}WARNING:${NC} $cfg not found - skipping display filter."
    return 0
  fi

  # Already has our filter? Skip.
  if grep -q "GeekCade Working Parents" "$cfg"; then
    return 0
  fi

  echo
  echo -e "${YELLOW}Adding display filter (Working Parents Only) to attract.cfg...${NC}"

  # Append the filter inside the Arcade display block. We expect the
  # installer-created display block to look like:
  #   display Arcade
  #    layout               Attrac-Man
  #    romlist              mame
  #    in_cycle             yes
  #    in_menu              yes
  #
  # We append filter lines AFTER the in_menu line (the last property of
  # the block that the installer wrote).
  #
  # AM+ filter rules. Each "rule" line is an AND condition; for OR logic
  # AM+ also supports "exception" rules. We use a positive-match approach:
  # require Category to start with "Arcade" (the catver.ini category prefix
  # for actual arcade games) and exclude common non-game subcategories.
  #
  # Categories from catver.ini look like:
  #   Maze / Driving        → Pac-Man          (Arcade-prefixed in newer catver)
  #   Computer / Atari 400  → home computer    (filter out)
  #   Console / Atari 2600  → home console     (filter out)
  #   Mechanical / *        → pinball etc      (filter out)
  #   Slot Machine / *      → slots            (filter out)
  #   Casino / *            → casino           (filter out)
  #   Tabletop / *          → handhelds        (filter out)
  #
  # NOTE: catver.ini format varies by version. Some prefix arcade games
  # with "Arcade:" while others use bare category names. Our filter
  # excludes the non-arcade prefixes which works for both formats.
  if grep -q "^display Arcade" "$cfg"; then
    awk '
      /^display Arcade/ { in_arcade = 1 }
      { print }
      in_arcade && /^[[:space:]]+in_menu/ {
        print " filter               GeekCade Working Parents"
        print "  rule                 Status not_equals preliminary"
        print "  rule                 CloneOf equals"
        print "  rule                 Category not_contains Mahjong"
        print "  rule                 Category not_contains Casino"
        print "  rule                 Category not_contains Casino /"
        print "  rule                 Category not_contains Computer"
        print "  rule                 Category not_contains Console"
        print "  rule                 Category not_contains Handheld"
        print "  rule                 Category not_contains Tabletop"
        print "  rule                 Category not_contains Mechanical"
        print "  rule                 Category not_contains Slot Machine"
        print "  rule                 Category not_contains Calculator"
        print "  rule                 Category not_contains Electromechanical"
        print "  rule                 Category not_contains Misc."
        print "  rule                 Category not_contains Utilities"
        print "  rule                 Category not_contains System"
        print "  rule                 Category not_contains BIOS"
        in_arcade = 0
      }
    ' "$cfg" > "$cfg.tmp" && mv "$cfg.tmp" "$cfg"
    echo -e "${GREEN}Display filter added.${NC}"
  else
    echo -e "${YELLOW}No 'display Arcade' block in attract.cfg - skipping filter add.${NC}"
  fi
}

# Rebuild the AttractMode Plus MAME romlist. Called after roms sync so
# new games show up. Uses --build-romlist on the launcher script (which
# applies our SDL_VIDEODRIVER env vars). Output goes to ~/attractplus/romlists/mame.txt.
rebuild_attract_romlist() {
  local launcher="$HOME/attractplus.sh"
  local romlist="$ATTRACT_DIR/romlists/mame.txt"
  local count_before=0 count_after=0 t0 t1 dur

  if [ ! -x "$launcher" ]; then
    echo -e "${YELLOW}WARNING:${NC} $launcher not found - skipping romlist rebuild."
    echo "       Run option 3 ('Rebuild Romlist') from the menu later."
    return 0
  fi

  if [ -f "$romlist" ]; then
    count_before="$(grep -c '^[^#]' "$romlist" 2>/dev/null || echo 0)"
  fi

  echo
  echo -e "${YELLOW}Rebuilding AttractMode Plus romlist...${NC}"

  mkdir -p "$ATTRACT_DIR/romlists"
  rm -f "$romlist"

  t0=$SECONDS

  # AM+ writes the romlist to the file path matching the romlist name.
  # Output is verbose (one line per rom checked); suppress to one summary.
  if "$launcher" --build-romlist mame 2>&1 | tail -5; then
    t1=$SECONDS
    dur=$((t1 - t0))

    if [ -f "$romlist" ]; then
      count_after="$(grep -c '^[^#]' "$romlist" 2>/dev/null || echo 0)"
      if [ "$dur" -lt 60 ]; then
        echo -e "${GREEN}Romlist rebuilt:${NC} $count_after entries (${dur}s)"
      else
        echo -e "${GREEN}Romlist rebuilt:${NC} $count_after entries ($((dur/60))m$((dur%60))s)"
      fi
    else
      echo -e "${YELLOW}Romlist command finished but mame.txt was not created.${NC}"
    fi
  else
    echo -e "${RED}Romlist rebuild failed.${NC}"
    return 1
  fi

  return 0
}

# Sync AntoPISA's MAME_SupportFiles content from USB to ~/mame/.
# The source layout is self-routing: each support category has dats/
# and folders/ subfolders matching MAME's expected destinations.
#
# Run order matters: this comes AFTER sync_extras_subfolders so AntoPISA
# files (typically newer/more authoritative) win on filename collisions
# (e.g. command.dat exists in both extras/dats/ and support/command/dats/).
#
# Files are tiny (KB-MB), so we cp instead of rsync — easier to show
# per-file progress and the speed difference is irrelevant at these sizes.
#
# After sync we also call update_subfolders_mame_ini defensively in case
# the user ran support without extras subfolders earlier.
sync_support() {
  local src_dir="$USB_SOURCE/support"
  local rule src_rel dest_rel pattern src dest
  local total_copied=0 total_missing=0 total_failed=0
  local rule_copied f basename

  if [ ! -d "$src_dir" ]; then
    echo -e "${YELLOW}No support/ folder on USB - skipping.${NC}"
    return 0
  fi

  section_header "Syncing support files (AntoPISA)"
  echo "Source: $src_dir/<category>"
  echo "Dest:   $MAME_DIR/<dats|folders>/"
  echo "Note:   AntoPISA versions win over extras/ on filename collisions."
  echo

  for rule in "${SUPPORT_RULES[@]}"; do
    src_rel="${rule%%:*}"
    rule="${rule#*:}"
    dest_rel="${rule%%:*}"
    pattern="${rule##*:}"

    src="$src_dir/$src_rel"
    dest="$MAME_DIR/$dest_rel"

    if [ ! -d "$src" ]; then
      printf "${YELLOW}  → %-30s${NC} (not on USB)\n" "$src_rel/$pattern"
      total_missing=$((total_missing + 1))
      continue
    fi

    mkdir -p "$dest"
    rule_copied=0

    # Glob match in src for the pattern, copy each matching file
    shopt -s nullglob
    for f in "$src"/$pattern; do
      [ -f "$f" ] || continue
      basename="${f##*/}"
      if cp -f "$f" "$dest/" 2>/dev/null; then
        rule_copied=$((rule_copied + 1))
      else
        printf "${RED}    ✗ failed:${NC} %s\n" "$basename"
        total_failed=$((total_failed + 1))
      fi
    done
    shopt -u nullglob

    if [ "$rule_copied" -gt 0 ]; then
      printf "${YELLOW}  → %-30s${NC} ${GREEN}✓${NC} %d file(s) → %s\n" \
        "$src_rel/$pattern" "$rule_copied" "$dest_rel/"
      total_copied=$((total_copied + rule_copied))
    else
      printf "${YELLOW}  → %-30s${NC} (no matching files)\n" "$src_rel/$pattern"
      total_missing=$((total_missing + 1))
    fi
  done

  echo
  echo -e "${GREEN}Support files:${NC} $total_copied copied, $total_missing missing/empty, $total_failed failed"

  # Defensive mame.ini update - in case user ran support without extras
  # subfolders earlier, this ensures historypath/categorypath are set.
  if [ "$total_copied" -gt 0 ]; then
    update_subfolders_mame_ini

    # ALWAYS rebuild romlist after support sync, even if roms already
    # triggered one earlier this run. The reason: catver.ini, genre.ini,
    # and bestgames.ini land here, and AM+ reads category data from them
    # at romlist BUILD time. A romlist built before catver was in place
    # has no category data, so filters like "Category not_contains
    # Mahjong" silently match everything. Rebuilding now picks up
    # the categories.
    rebuild_attract_romlist
    _romlist_rebuilt=1
  fi

  return 0
}

# Update mame.ini with paths for the subfolder-based extras. These paths
# don't depend on the AM+ side (those are still pointed at ~/attractplus
# locations or the extras zip folders for artwork). MAME-only.
update_subfolders_mame_ini() {
  if [ ! -f "$MAME_INI" ]; then
    echo -e "${YELLOW}WARNING:${NC} $MAME_INI not found - skipping mame.ini update."
    return 0
  fi

  echo
  echo -e "${YELLOW}Updating $MAME_INI with subfolder paths...${NC}"

  # samplepath and artpath were already set by the installer, but we
  # rewrite them anyway in case they got changed.
  set_ini_path "samplepath"   "$MAME_DIR/samples"
  set_ini_path "artpath"      "$MAME_DIR/artwork"

  # historypath and categorypath are new - let's write them now.
  # historypath is multi-path: history/ contains history.xml (modern
  # plugin format), dats/ contains history.dat (older format). MAME
  # will find whichever is present.
  set_ini_path "historypath"  "$MAME_DIR/history;$MAME_DIR/dats"
  set_ini_path "categorypath" "$MAME_DIR/folders"

  echo -e "${GREEN}mame.ini updated.${NC}"
}

# set_ini_path KEY VALUE
# Writes a single-value mame.ini key. Replaces existing line (matches
# tab or space sep) or appends if absent. Only writes if at least one
# of the path components in VALUE is a real directory on disk (avoids
# pointing MAME at folders that don't exist).
set_ini_path() {
  local key="$1"
  local value="$2"
  local p any_exists=0

  # VALUE may be a semicolon-separated list. Verify at least one part exists.
  IFS=';' read -ra _parts <<< "$value"
  for p in "${_parts[@]}"; do
    [ -z "$p" ] && continue
    if [ -d "$p" ] || [ -f "$p" ]; then
      any_exists=1
      break
    fi
  done

  if [ "$any_exists" -eq 0 ]; then
    return 0
  fi

  if grep -qE "^${key}[[:space:]]" "$MAME_INI"; then
    sed -i "s!^${key}[[:space:]].*!${key}                 ${value}!" "$MAME_INI"
  else
    echo "${key}                 ${value}" >> "$MAME_INI"
  fi
}

# ============================================================
# (continuing helpers below)
# ============================================================

# Update AttractMode Plus mame.cfg to point its artwork settings at the
# extras folders we just extracted. AM+ supports multi-path artwork
# (semicolon separated), so we keep its existing ~/attractplus/<art>
# folder (where users can drop custom art) AND add ~/mame/<art>.
# Custom art in ~/attractplus/<art>/ takes precedence on per-rom lookup.
#
# Maps AM+ artwork name → list of ~/mame/ folders to add:
#   flyer    → flyers
#   marquee  → marquees
#   snap     → snap
#   cabinet  → cabinets, devices  (custom artwork name; we add it)
#   title    → titles             (custom)
#   pcb      → pcb                (custom)
update_attractplus_artwork() {
  local emu_cfg="$ATTRACT_DIR/emulators/mame.cfg"

  if [ ! -f "$emu_cfg" ]; then
    echo -e "${YELLOW}WARNING:${NC} $emu_cfg not found - skipping AM+ artwork update."
    echo "    Did the cabinet installer run yet?"
    return 0
  fi

  echo
  echo -e "${YELLOW}Updating $emu_cfg with extras paths...${NC}"

  set_attract_artwork "flyer"   "flyers"
  set_attract_artwork "marquee" "marquees"
  set_attract_artwork "snap"    "snap"
  set_attract_artwork "cabinet" "cabinets" "devices"
  set_attract_artwork "title"   "titles"
  set_attract_artwork "pcb"     "pcb"
  set_attract_artwork "bosses"  "bosses"
  set_attract_artwork "scores"  "scores"
  set_attract_artwork "select"  "select"
  set_attract_artwork "versus"  "versus"
  set_attract_artwork "gameover" "gameover"
  set_attract_artwork "howto"   "howto"

  echo -e "${GREEN}AM+ mame.cfg updated.${NC}"
}

# set_attract_artwork ART_NAME ASSET [ASSET...]
# Updates an "artwork ART_NAME ..." line in AM+ mame.cfg. Preserves the
# existing path (so user customizations survive), appends ~/mame/<asset>
# folders that exist locally, separated by semicolons.
#
# Lines look like:
#   artwork    flyer     /home/geekcade/attractplus/flyers;/home/geekcade/mame/flyers
set_attract_artwork() {
  local art="$1"; shift
  local emu_cfg="$ATTRACT_DIR/emulators/mame.cfg"
  local existing="" candidate paths="" a final="" p

  # Build the list of new paths to add
  for a in "$@"; do
    candidate="$MAME_DIR/$a"
    [ -d "$candidate" ] || continue
    if [ -z "$paths" ]; then
      paths="$candidate"
    else
      paths="$paths;$candidate"
    fi
  done

  # If no folders for this art type are present locally, skip.
  [ -z "$paths" ] && return 0

  # Get the existing path (if any) for this artwork type, so we keep it.
  # AM+ artwork lines are like: "artwork    flyer     /path/to/flyers"
  existing="$(awk -v art="$art" '
    $1 == "artwork" && $2 == art {
      $1=""; $2="";
      sub(/^[ \t]+/, "");
      print;
      exit
    }' "$emu_cfg")"

  # Build deduplicated list: existing paths first (in order), then new
  # paths, skipping any that are already in the list. Splits on ';'.
  final=""
  if [ -n "$existing" ]; then
    IFS=';' read -ra _existing_arr <<< "$existing"
    for p in "${_existing_arr[@]}"; do
      [ -z "$p" ] && continue
      if [ -z "$final" ]; then
        final="$p"
      else
        final="$final;$p"
      fi
    done
  fi
  IFS=';' read -ra _new_arr <<< "$paths"
  for p in "${_new_arr[@]}"; do
    [ -z "$p" ] && continue
    case ";${final};" in
      *";${p};"*) ;;  # already in list, skip
      *)
        if [ -z "$final" ]; then
          final="$p"
        else
          final="$final;$p"
        fi
        ;;
    esac
  done

  # Replace existing line, or append if absent.
  if grep -qE "^artwork[[:space:]]+${art}[[:space:]]" "$emu_cfg"; then
    sed -i "s!^artwork[[:space:]]\+${art}[[:space:]].*!artwork    ${art}     ${final}!" "$emu_cfg"
  else
    echo "artwork    ${art}     ${final}" >> "$emu_cfg"
  fi
}

# Update mame.ini with directory paths for the extras assets that were
# successfully processed. Uses explicit absolute folder paths (much more
# readable than the Pleasuredome "name;root" syntax) so it's easy to
# eyeball mame.ini and see exactly what each setting points at.
#
# Multi-source keys (cabinets+devices, snap+warning) get a semicolon-
# separated list of absolute paths.
update_extras_mame_ini() {
  if [ ! -f "$MAME_INI" ]; then
    echo -e "${YELLOW}WARNING:${NC} $MAME_INI not found - skipping mame.ini update."
    echo "    Did the cabinet installer run yet?"
    return 0
  fi

  echo
  echo -e "${YELLOW}Updating $MAME_INI with extras paths...${NC}"

  # Each call: KEY  ASSET [ASSET...]
  # ASSET is the basename of a folder under ~/mame/ (or "cheat.7z" file).
  # Keys whose assets aren't present locally are skipped.
  set_ini_for "artwork_preview_directory" "artpreview"
  set_ini_for "bosses_directory"          "bosses"
  set_ini_for "cabinets_directory"        "cabinets" "devices"
  set_ini_for "cheatpath"                 "cheat.7z"
  set_ini_for "cpanels_directory"         "cpanel"
  set_ini_for "ends_directory"            "ends"
  set_ini_for "flyers_directory"          "flyers"
  set_ini_for "gameover_directory"        "gameover"
  set_ini_for "howto_directory"           "howto"
  set_ini_for "icons_directory"           "icons"
  set_ini_for "logos_directory"           "logo"
  set_ini_for "manuals_directory"         "manuals"
  set_ini_for "marquees_directory"        "marquees"
  set_ini_for "pcbs_directory"            "pcb"
  set_ini_for "scores_directory"          "scores"
  set_ini_for "select_directory"          "select"
  set_ini_for "snapshot_directory"        "snap" "warning"
  set_ini_for "titles_directory"          "titles"
  set_ini_for "versus_directory"          "versus"

  echo -e "${GREEN}mame.ini updated.${NC}"
}

# set_ini_for KEY ASSET [ASSET...]
# Sets a mame.ini key to a semicolon-separated list of absolute paths,
# one per asset that exists locally. ASSET can be:
#   - a folder name (e.g. "flyers" → /home/geekcade/mame/flyers)
#   - a filename with extension (e.g. "cheat.7z" → /home/geekcade/mame/cheat.7z)
# Uses explicit absolute paths for readability and easy troubleshooting.
set_ini_for() {
  local key="$1"; shift
  local paths="" a candidate

  for a in "$@"; do
    # Determine if this is a file or folder asset
    if [[ "$a" == *.* ]]; then
      # Has an extension - treat as a file
      candidate="$MAME_DIR/$a"
      [ -f "$candidate" ] || continue
    else
      # No extension - treat as a folder
      candidate="$MAME_DIR/$a"
      [ -d "$candidate" ] || continue
    fi

    if [ -z "$paths" ]; then
      paths="$candidate"
    else
      paths="$paths;$candidate"
    fi
  done

  # If none of the assets for this key are present, skip.
  [ -z "$paths" ] && return 0

  # Replace existing line (matches tab or space sep) or append if absent.
  # Use ! as sed delimiter since paths contain /.
  if grep -qE "^${key}[[:space:]]" "$MAME_INI"; then
    sed -i "s!^${key}[[:space:]].*!${key}                 ${paths}!" "$MAME_INI"
  else
    echo "${key}                 ${paths}" >> "$MAME_INI"
  fi
}

# ==============================
# [5] ARGUMENT PARSING
# ==============================
USB_SOURCE_OVERRIDE=""
MODE="sync"

while [ "$#" -gt 0 ]; do
  case "$1" in
    --source)
      shift
      USB_SOURCE_OVERRIDE="${1:-}"
      [ -z "$USB_SOURCE_OVERRIDE" ] && {
        echo -e "${RED}--source requires a path argument${NC}" >&2
        exit 2
      }
      ;;
    --check)
      MODE="check"
      ;;
    --help|-h)
      show_help
      exit 0
      ;;
    *)
      echo -e "${RED}Unknown option: $1${NC}" >&2
      echo "Run with --help for usage." >&2
      exit 2
      ;;
  esac
  shift
done

# ==============================
# [6] MAIN
# ==============================

case "$MODE" in
  check)
    if detect_usb; then
      echo "$USB_SOURCE"
      exit 0
    else
      exit 1
    fi
    ;;

  sync)
    echo -e "${YELLOW}======> Detecting GeekCade USB drive...${NC}"

    if ! detect_usb; then
      echo -e "${RED}No GeekCade USB drive found.${NC}" >&2
      print_mount_help
      exit 1
    fi

    echo -e "${GREEN}USB detected:${NC} $USB_SOURCE"
    echo

    # Show what was found
    echo "Contents at USB root:"
    for folder in "${USB_EXPECTED_FOLDERS[@]}"; do
      if [ -d "$USB_SOURCE/$folder" ]; then
        size="$(du -sh "$USB_SOURCE/$folder" 2>/dev/null | awk '{print $1}')"
        echo -e "  ${GREEN}+${NC} $folder/  ($size)"
      else
        echo -e "  ${YELLOW}-${NC} $folder/  (not present)"
      fi
    done

    # Run each section. Order matters:
    # - extras zips/subfolders before multimedia (mame.ini setup)
    # - roms before support (so romlist exists for filter rebuild)
    # - support last so AntoPISA versions win on filename collisions
    _romlist_rebuilt=0
    sync_extras_zips
    sync_extras_subfolders
    sync_multimedia
    sync_roms
    sync_support

    section_header "Sync complete"
    echo
    exit 0
    ;;
esac