#!/bin/bash
# -----------------------------------------------------------------------------------------------
# --------------------------------- Lidarr Cleanup Script --------------------------------------
# -----------------------------------------------------------------------------------------------
# Removes orphaned music files from the library that Lidarr no longer tracks.
# Uses the Lidarr API to build a complete list of tracked file paths then compares
# against what exists on disk — anything not tracked and older than LIDARR_ORPHAN_AGE
# days is considered an orphan and deleted.
#
# File classification:
#   TRACKED   — Lidarr API knows about this exact file path → leave it alone
#   PROTECTED — matches LIDARR_PROTECTED_PATTERNS → never delete (cover art, .nfo etc.)
#   ORPHAN    — music file, not tracked, older than LIDARR_ORPHAN_AGE days → delete
#   JUNK      — not a music extension, not protected → delete regardless of age
#   RECENT    — not tracked, under LIDARR_ORPHAN_AGE days old → skip (may be mid-import)
#
# Why protected patterns matter:
#   Lidarr generates cover art (*.jpg), metadata (*.nfo) and lyrics (*.lrc) but does
#   not include these in its tracked file API response. Without protection these would
#   be classified as orphans and deleted — breaking Lidarr and Emby metadata display.
#
# Safety layers — all must pass before any file is touched:
#   1. Container must be running and healthy
#   2. API must be reachable
#   3. Artist count must be > 0
#   4. Tracked file count must be > 0
#   5. Tracked count must be >= LIDARR_MIN_TRACKED_PCT% of last known count
#   6. Deletion size must be < LIDARR_MAX_DELETE_GB — or --i-know-what-im-doing required
#
# --i-know-what-im-doing flag:
#   Required when deletion would exceed LIDARR_MAX_DELETE_GB
#   Long and annoying by design — cannot be added accidentally
#
# --skip-strike-list flag:
#   Bypasses the LIDARR_ORPHAN_AGE age check — deletes recent files too
#   Combined with --i-know-what-im-doing activates NUCLEAR MODE:
#     Age check bypassed, size threshold bypassed, deletes on first pass
#     Use when Soularr/other tool has filled the gaps — clean one-pass wipe
#     ⚠️  The script author takes NO responsibility for data loss with both flags active
#         The user accepts full responsibility — this is 100% intentional by design
#
# Lidarr runs on HOST1 only — music library is HOST1's source of truth.
# If run on HOST2 this script exits cleanly with no action.
# All configuration in Master.conf under Arr Cleanup section.
# Supports --dry-run to preview what would be deleted without making changes.
# -----------------------------------------------------------------------------------------------

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "$SCRIPT_DIR/../Master.conf"
source "$SCRIPT_DIR/../common.sh"

# Check for --i-know-what-im-doing and --skip-strike-list flags before parse_args
# These flags are filtered out before parse_args sees them to avoid unknown flag errors
I_KNOW=false
SKIP_STRIKES=false
FILTERED_ARGS=()
for arg in "$@"; do
    if [[ "$arg" == "--i-know-what-im-doing" ]]; then
        I_KNOW=true
    elif [[ "$arg" == "--skip-strike-list" ]]; then
        SKIP_STRIKES=true
    else
        FILTERED_ARGS+=("$arg")
    fi
done

parse_args "${FILTERED_ARGS[@]}"

# Nuclear mode — both override flags active
# Strike system AND size threshold bypassed — deletes on first pass
# Script author takes no responsibility for data loss when both flags are used.
# This combination is 100% intentional and the user accepts full responsibility.
if [[ "$I_KNOW" == true ]] && [[ "$SKIP_STRIKES" == true ]] && [[ "$DRY_RUN" != true ]]; then
    echo ""
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo "⚠️  WARNING — NUCLEAR MODE ACTIVE"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo "  Flags:            --i-know-what-im-doing --skip-strike-list"
    echo "  Strike system:    BYPASSED — deletes on first pass"
    echo "  Size threshold:   BYPASSED — no GB limit"
    echo "  Data recovery:    NOT POSSIBLE after deletion"
    echo ""
    echo "  The script author takes no responsibility for data"
    echo "  loss when both flags are used together. This is a"
    echo "  100% intentional action by the user."
    echo ""
    echo "  Review the dry run output before proceeding."
    echo "  You have 10 seconds to cancel (Ctrl+C)..."
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    sleep 10
    echo "  Proceeding..."
    echo ""
fi

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_GEAR Setup ━━━
# -----------------------------------------------------------------------------------------------
echo ""
echo "━━━ $ICON_GEAR Setup ━━━"

if [[ "$EUID" -ne 0 ]]; then
    error "Must be run as root"
    exit 1
fi

success "Running as root"

if ! command -v curl >/dev/null 2>&1; then
    error "curl not found — required for Lidarr API calls"
    exit 1
fi

if ! command -v jq >/dev/null 2>&1; then
    error "jq not found — required for JSON parsing"
    notify "Lidarr cleanup failed on $(hostname) — jq not installed" "Lidarr Cleanup" "warning"
    exit 1
fi

# Lidarr runs on HOST1 only — exit cleanly if running on HOST2
detect_hosts

if [[ "$LOCAL_SERVER_NAME" != "$HOST1" ]]; then
    info "Lidarr runs on $HOST1 only — skipping on $LOCAL_SERVER_NAME"
    exit 0
fi

LIDARR_URL="$HOST1_LIDARR_URL"
LIDARR_API_KEY="$HOST1_LIDARR_API_KEY"
LIDARR_MUSIC_ROOT="$HOST1_LIDARR_MUSIC_ROOT"
LIDARR_CONTAINER="Lidarr"

# Load path map — translates container paths from API to host paths on disk
declare -A ARR_PATH_MAP
if [[ "$LOCAL_SERVER_NAME" == "$HOST1" ]]; then
    for key in "${!HOST1_LIDARR_PATH_MAP[@]}"; do
        ARR_PATH_MAP["$key"]="${HOST1_LIDARR_PATH_MAP[$key]}"
    done
else
    for key in "${!HOST2_LIDARR_PATH_MAP[@]}"; do
        ARR_PATH_MAP["$key"]="${HOST2_LIDARR_PATH_MAP[$key]}"
    done
fi

info "Lidarr instance: $LOCAL_SERVER_NAME → $LIDARR_URL"
info "Music root: $LIDARR_MUSIC_ROOT"

require_var LIDARR_URL
require_var LIDARR_API_KEY
require_var LIDARR_MUSIC_ROOT

if [[ ! -d "$LIDARR_MUSIC_ROOT" ]]; then
    error "Music root not found: $LIDARR_MUSIC_ROOT"
    notify "Lidarr cleanup failed on $(hostname) — music root not found: $LIDARR_MUSIC_ROOT" "Lidarr Cleanup" "warning"
    exit 1
fi

# Large library scans take time — override default lock warn age
[[ -n "${LIDARR_LOCK_WARN_AGE:-}" ]] && LOCK_WARN_AGE="$LIDARR_LOCK_WARN_AGE"

acquire_lock "wait"

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_SHIELD Safety Layer 1 — Container Health ━━━
# -----------------------------------------------------------------------------------------------
echo ""
echo "━━━ $ICON_SHIELD Safety Checks ━━━"

# Check container is running
CONTAINER_RUNNING=$(docker inspect -f '{{.State.Running}}' "$LIDARR_CONTAINER" 2>/dev/null)
if [[ "$CONTAINER_RUNNING" != "true" ]]; then
    error "$LIDARR_CONTAINER container is not running — aborting"
    notify "Lidarr cleanup aborted on $(hostname) — Lidarr container not running" "Lidarr Cleanup" "warning"
    exit 1
fi
success "$LIDARR_CONTAINER is running"

# Check container health — only fail if explicitly unhealthy
CONTAINER_HEALTH=$(docker inspect -f '{{.State.Health.Status}}' "$LIDARR_CONTAINER" 2>/dev/null)
case "$CONTAINER_HEALTH" in
    healthy)
        success "$LIDARR_CONTAINER is healthy" ;;
    "")
        info "$LIDARR_CONTAINER has no health check configured — proceeding" ;;
    starting)
        error "$LIDARR_CONTAINER is still starting — aborting"
        notify "Lidarr cleanup aborted on $(hostname) — Lidarr container still starting" "Lidarr Cleanup" "warning"
        exit 1 ;;
    unhealthy)
        error "$LIDARR_CONTAINER is unhealthy — aborting"
        notify "Lidarr cleanup aborted on $(hostname) — Lidarr container unhealthy" "Lidarr Cleanup" "warning"
        exit 1 ;;
    *)
        warn "$LIDARR_CONTAINER health status: $CONTAINER_HEALTH — proceeding with caution" ;;
esac

success "All safety checks passed"
[[ "$DRY_RUN" == true ]] && warn "DRY RUN — no files will be deleted"
[[ "$I_KNOW" == true ]] && warn "OVERRIDE — --i-know-what-im-doing flag active"
[[ "$SKIP_STRIKES" == true ]] && warn "OVERRIDE — --skip-strike-list flag active — strike system bypassed"

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_SUMMARY Status ━━━
# -----------------------------------------------------------------------------------------------
if [[ "$SHOW_STATUS" == true ]]; then
    echo ""
    echo "━━━━━ $ICON_SUMMARY STATUS ━━━━━"
    echo "$ICON_GEAR  Lidarr URL:         $LIDARR_URL"
    echo "$ICON_GEAR  Music root:         $LIDARR_MUSIC_ROOT"
    echo "$ICON_TIME  Orphan age:         ${LIDARR_ORPHAN_AGE} days"
    echo "$ICON_GEAR  Max delete:         ${LIDARR_MAX_DELETE_GB}GB (requires --i-know-what-im-doing)"
    echo "$ICON_GEAR  Min tracked %:      ${LIDARR_MIN_TRACKED_PCT}% of last run"
    echo "$ICON_GEAR  Extensions:         ${LIDARR_EXTENSIONS[*]}"
    echo "$ICON_GEAR  Protected patterns: ${LIDARR_PROTECTED_PATTERNS[*]}"
    echo "$ICON_GEAR  Dry Run:            $DRY_RUN"
    echo "━━━━━━━━━━━━━━━━━━━━━━━"
    exit 0
fi

# -----------------------------------------------------------------------------------------------
# HELPERS
# -----------------------------------------------------------------------------------------------

lidarr_api() {
    local endpoint="$1"
    local response http_code body

    response=$(curl -sf \
        --max-time 30 \
        -H "X-Api-Key: $LIDARR_API_KEY" \
        -w "\n%{http_code}" \
        "${LIDARR_URL}/api/v1/${endpoint}" 2>/dev/null)

    http_code=$(echo "$response" | tail -1)
    body=$(echo "$response" | head -n -1)

    if [[ "$http_code" != "200" ]]; then
        error "Lidarr API returned HTTP $http_code for endpoint: $endpoint"
        return 1
    fi

    echo "$body"
}

is_music_file() {
    local ext="${1##*.}"
    ext="${ext,,}"
    for valid_ext in "${LIDARR_EXTENSIONS[@]}"; do
        [[ "$ext" == "$valid_ext" ]] && return 0
    done
    return 1
}

is_protected_file() {
    local filename
    filename=$(basename "$1")
    for pattern in "${LIDARR_PROTECTED_PATTERNS[@]}"; do
        # shellcheck disable=SC2254
        case "$filename" in
            $pattern) return 0 ;;
        esac
    done
    return 1
}

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_SYNC Fetching Lidarr Tracked Files ━━━
# -----------------------------------------------------------------------------------------------
echo ""
echo "━━━ $ICON_SYNC Fetching Lidarr Tracked Files ━━━"

# Safety Layer 2 — API reachability
check_api "$LIDARR_URL" "Lidarr" || {
    notify "Lidarr cleanup aborted on $(hostname) — API unreachable" "Lidarr Cleanup" "warning"
    exit 1
}

info "Querying Lidarr API: $LIDARR_URL"

# Step 1 — Get all artists
ARTIST_RESPONSE=$(lidarr_api "artist") || {
    error "Failed to fetch artists from Lidarr — check URL and API key"
    notify "Lidarr cleanup failed on $(hostname) — could not fetch artists" "Lidarr Cleanup" "warning"
    exit 1
}

ARTIST_IDS=$(echo "$ARTIST_RESPONSE" | jq -r '.[].id' 2>/dev/null)
ARTIST_COUNT=$(echo "$ARTIST_IDS" | grep -c "[0-9]" 2>/dev/null || echo 0)

# Safety Layer 3 — artist count
if [[ "$ARTIST_COUNT" -eq 0 ]]; then
    error "No artists returned from Lidarr API — aborting to prevent mass deletion"
    notify "Lidarr cleanup aborted on $(hostname) — API returned 0 artists" "Lidarr Cleanup" "warning"
    exit 1
fi

info "Found $ARTIST_COUNT artists — fetching track files..."

TMP_DIR="/tmp/lidarr_cleanup_$$"
mkdir -p "$TMP_DIR"
trap "rm -rf $TMP_DIR" EXIT

TRACKED_FILE="$TMP_DIR/tracked_paths.txt"
> "$TRACKED_FILE"

while IFS= read -r artist_id; do
    [[ -z "$artist_id" ]] && continue
    ARTIST_TRACKS=$(lidarr_api "trackFile?artistId=${artist_id}" 2>/dev/null)
    if [[ -n "$ARTIST_TRACKS" ]]; then
    if [[ -n "$ARTIST_TRACKS" ]]; then
        while IFS= read -r api_path; do
            [[ -z "$api_path" ]] && continue
            translate_path "$api_path" >> "$TRACKED_FILE"
        done < <(echo "$ARTIST_TRACKS" | jq -r '.[].path' 2>/dev/null)
    fi
    fi
done <<< "$ARTIST_IDS"

sort -u "$TRACKED_FILE" -o "$TRACKED_FILE"
TRACKED_COUNT=$(wc -l < "$TRACKED_FILE")

# Safety Layer 4 — tracked file count
if [[ "$TRACKED_COUNT" -eq 0 ]]; then
    error "API returned 0 tracked files — aborting to prevent mass deletion"
    notify "Lidarr cleanup aborted on $(hostname) — API returned 0 tracked files" "Lidarr Cleanup" "warning"
    exit 1
fi

success "Lidarr tracks $TRACKED_COUNT files across $ARTIST_COUNT artists"

# Safety Layer 5 — percentage drop check against last known count
if [[ -f "$LIDARR_TRACKED_COUNT_FILE" ]]; then
    LAST_COUNT=$(cat "$LIDARR_TRACKED_COUNT_FILE" 2>/dev/null || echo 0)
    if [[ "$LAST_COUNT" -gt 0 ]]; then
        PCT=$(awk "BEGIN {printf \"%d\", ($TRACKED_COUNT / $LAST_COUNT) * 100}")
        if [[ "$PCT" -lt "$LIDARR_MIN_TRACKED_PCT" ]]; then
            error "Tracked file count dropped to ${PCT}% of last run ($TRACKED_COUNT vs $LAST_COUNT)"
            error "This suggests an API issue — aborting to prevent mass deletion"
            error "If this is expected (large library removal), delete: $LIDARR_TRACKED_COUNT_FILE"
            notify "Lidarr cleanup aborted on $(hostname) — tracked count dropped to ${PCT}% of last run" "Lidarr Cleanup" "warning"
            exit 1
        fi
        info "Tracked count check: ${PCT}% of last run ($TRACKED_COUNT vs $LAST_COUNT) ✅"
    fi
else
    info "No previous count on record — first run, saving baseline"
fi

# Save current count for next run comparison
echo "$TRACKED_COUNT" > "$LIDARR_TRACKED_COUNT_FILE"

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_CLEAN Scanning Music Root ━━━
# -----------------------------------------------------------------------------------------------
echo ""
echo "━━━ $ICON_CLEAN Scanning Music Root ━━━"
info "Root:              $LIDARR_MUSIC_ROOT"
info "Orphan age:        ${LIDARR_ORPHAN_AGE} days"
info "Protected:         ${LIDARR_PROTECTED_PATTERNS[*]}"
echo ""

START=$(date +%s)
ORPHAN_COUNT=0
JUNK_COUNT=0
RECENT_COUNT=0
PROTECTED_COUNT=0
ORPHAN_BYTES=0
JUNK_BYTES=0

AGE_SECONDS=$(( LIDARR_ORPHAN_AGE * 86400 ))
NOW=$(date +%s)
MAX_DELETE_BYTES=$(awk "BEGIN {printf \"%d\", $LIDARR_MAX_DELETE_GB * 1073741824}")

while IFS= read -r filepath; do
    [[ -z "$filepath" ]] && continue

    if grep -qF "$filepath" "$TRACKED_FILE" 2>/dev/null; then
        log "TRACKED: $filepath"
        continue
    fi

    if is_protected_file "$filepath"; then
        log "$ICON_PROTECTED PROTECTED: $filepath"
        ((PROTECTED_COUNT++))
        continue
    fi

    FILE_SIZE=$(stat -c%s "$filepath" 2>/dev/null || echo 0)

    if is_music_file "$filepath"; then
        FILE_MTIME=$(stat -c %Y "$filepath" 2>/dev/null || echo 0)
        FILE_AGE=$(( NOW - FILE_MTIME ))

        if [[ "$FILE_AGE" -lt "$AGE_SECONDS" ]] && [[ "$SKIP_STRIKES" != true ]]; then
            log "RECENT (skipping): $filepath"
            ((RECENT_COUNT++))
            continue
        fi

        warn "$ICON_TRASH ORPHAN: $filepath"
        ((ORPHAN_COUNT++))
        ORPHAN_BYTES=$((ORPHAN_BYTES + FILE_SIZE))
    else
        log "JUNK: $filepath"
        ((JUNK_COUNT++))
        JUNK_BYTES=$((JUNK_BYTES + FILE_SIZE))
    fi

done < <(find "$LIDARR_MUSIC_ROOT" -type f 2>/dev/null)

TOTAL_DELETE_BYTES=$(( ORPHAN_BYTES + JUNK_BYTES ))
TOTAL_REMOVED=$(( ORPHAN_COUNT + JUNK_COUNT ))

# -----------------------------------------------------------------------------------------------
# Safety Layer 6 — deletion size threshold
# -----------------------------------------------------------------------------------------------
if [[ "$TOTAL_DELETE_BYTES" -gt "$MAX_DELETE_BYTES" ]]; then
    TOTAL_HUMAN=$(awk "BEGIN {printf \"%.1fGB\", $TOTAL_DELETE_BYTES / 1073741824}")
    if [[ "$I_KNOW" != true ]]; then
        echo ""
        error "Deletion would exceed ${LIDARR_MAX_DELETE_GB}GB threshold — $TOTAL_HUMAN would be deleted"
        error "Review the ORPHAN lines above carefully before proceeding"
        error "If this is expected, rerun with: --i-know-what-im-doing"
        error "To also bypass age check and delete on first pass: add --skip-strike-list"
        notify "Lidarr cleanup halted on $(hostname) — ${TOTAL_HUMAN} deletion requires --i-know-what-im-doing" "Lidarr Cleanup" "warning"
        exit 1
    else
        warn "OVERRIDE — deletion is ${TOTAL_HUMAN} — proceeding because --i-know-what-im-doing"
    fi
fi

# All safety layers passed — execute deletions
if [[ "$DRY_RUN" == false ]]; then
    while IFS= read -r filepath; do
        [[ -z "$filepath" ]] && continue

        if grep -qF "$filepath" "$TRACKED_FILE" 2>/dev/null; then continue; fi
        if is_protected_file "$filepath"; then continue; fi

        FILE_MTIME=$(stat -c %Y "$filepath" 2>/dev/null || echo 0)
        FILE_AGE=$(( NOW - FILE_MTIME ))

        if is_music_file "$filepath"; then
            [[ "$FILE_AGE" -lt "$AGE_SECONDS" ]] && [[ "$SKIP_STRIKES" != true ]] && continue
        fi

        rm -f "$filepath" 2>/dev/null || error "Failed to delete: $filepath"

    done < <(find "$LIDARR_MUSIC_ROOT" -type f 2>/dev/null)

    echo ""
    info "Cleaning up empty folders..."
    find "$LIDARR_MUSIC_ROOT" -mindepth 1 -type d -empty -delete 2>/dev/null
    success "Empty folders removed"
fi

END=$(date +%s)

format_bytes() {
    local bytes=$1
    if (( bytes > 1073741824 )); then
        awk "BEGIN {printf \"%.1fGB\", $bytes / 1073741824}"
    elif (( bytes > 1048576 )); then
        awk "BEGIN {printf \"%.1fMB\", $bytes / 1048576}"
    else
        echo "${bytes}B"
    fi
}

ORPHAN_HUMAN=$(format_bytes $ORPHAN_BYTES)
JUNK_HUMAN=$(format_bytes $JUNK_BYTES)

# -----------------------------------------------------------------------------------------------
# ━━━ $ICON_SUMMARY Summary ━━━
# -----------------------------------------------------------------------------------------------
echo ""
echo "━━━━━ $ICON_SUMMARY LIDARR CLEANUP SUMMARY ━━━━━"
echo "$ICON_SYNC   Tracked by Lidarr: $TRACKED_COUNT files ($ARTIST_COUNT artists)"
echo "$ICON_SHIELD Protected:         $PROTECTED_COUNT files (cover art, metadata)"
echo "$ICON_TRASH  Orphans:           $ORPHAN_COUNT files ($ORPHAN_HUMAN)"
echo "$ICON_TRASH  Junk:              $JUNK_COUNT files ($JUNK_HUMAN)"
echo "$ICON_TIME   Recent skipped:    $RECENT_COUNT files (under ${LIDARR_ORPHAN_AGE} days)"
echo "$ICON_TIME   Duration:          $(format_duration $((END - START)))"
echo ""
if [[ "$DRY_RUN" == true ]]; then
    echo "$ICON_WARN  Status: DRY RUN — no files deleted"
elif [[ "$TOTAL_REMOVED" -eq 0 ]]; then
    echo "$ICON_DONE  Status: $ICON_SUCCESS CLEAN — nothing to remove"
    notify "Lidarr cleanup complete on $(hostname) — library is clean" "Lidarr Cleanup" "normal"
else
    echo "$ICON_DONE  Status: $ICON_SUCCESS DONE — $TOTAL_REMOVED files removed (orphans: $ORPHAN_HUMAN junk: $JUNK_HUMAN)"
    notify "Lidarr cleanup on $(hostname) — removed $TOTAL_REMOVED files (orphans: $ORPHAN_HUMAN junk: $JUNK_HUMAN)" "Lidarr Cleanup" "normal"
fi

# Write stats for sunday_morning_coffee_report.sh
if [[ "$DRY_RUN" == false ]] && [[ -n "${ARR_CLEANUP_STATS:-}" ]]; then
    DATE=$(date '+%Y-%m-%d')
    echo "${DATE}|lidarr|${ORPHAN_COUNT}|${ORPHAN_BYTES}|${JUNK_COUNT}|${JUNK_BYTES}|${RECENT_COUNT}|${TRACKED_COUNT}" \
        >> "$ARR_CLEANUP_STATS" 2>/dev/null || true
fi
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"