feat(lidarr): ask Lidarr for release groups; repair stored release-id requests (M483 #5244)

Lidarr's metadata is keyed by MusicBrainz release group, but re-acquisition
requested albums by their release id, so every add came back "not found".

- Sweeper requests an album by its tag-supplied release group, else the one
  MusicBrainz names (cached onto the album). An album MusicBrainz cannot name
  is skipped and counted, with no attempt spent.
- Reconciler: an add refused as not found re-reads the request's album id as
  a release (library first, then MusicBrainz), rewrites the request to the
  group and adds again. This repairs the requests already stored.
- Completion matches an album by release id or release group, and only once a
  track of it is on disk, so a re-acquisition request no longer completes
  against the row of the album it is trying to bring back.

Closes #5241.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/lidarrrequests/reconciler.go

@@ -2,6 +2,7 @@ package lidarrrequests
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log/slog"
 	"time"
@@ -14,6 +15,7 @@ import (
 	"git.fabledsword.com/bvandeusen/minstrel/internal/eventbus"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarr"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrconfig"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/tags"
 )
 
 // Reconciler is a background worker that periodically scans approved
@@ -30,6 +32,10 @@ type Reconciler struct {
 	bus       *eventbus.Bus
 	tick      time.Duration
 	batch     int32
+	// releaseGroup names the MusicBrainz release group of a release id, to
+	// repair a request stored under a release id Lidarr does not index
+	// (#5241). A field so tests can stand in for MusicBrainz.
+	releaseGroup func(ctx context.Context, releaseMBID string) (string, error)
 }
 
 // NewReconciler constructs a Reconciler with production defaults:
@@ -50,6 +56,8 @@ func NewReconciler(pool *pgxpool.Pool, cfg *lidarrconfig.Service, clientFn func(
 		bus:       bus,
 		tick:      5 * time.Minute,
 		batch:     50,
+
+		releaseGroup: tags.ReleaseGroupForRelease,
 	}
 }
 
@@ -185,12 +193,84 @@ func (r *Reconciler) ensureLidarrAdd(ctx context.Context, q *dbq.Queries, cfg li
 		// cfg.Enabled, so this is just defensive — nothing to do.
 		return nil
 	}
-	if err := sendLidarrAdd(ctx, client, cfg, row); err != nil {
+	err := sendLidarrAdd(ctx, client, cfg, row)
+	if errors.Is(err, lidarr.ErrNotFound) {
+		// Lidarr's metadata has no album under this id. Requests made before
+		// albums carried a release group (#5241) name the album by its
+		// MusicBrainz release id, which Lidarr does not index: repoint the
+		// request at the release group and try once more.
+		if repaired, ok := r.repointAtReleaseGroup(ctx, q, row); ok {
+			row = repaired
+			err = sendLidarrAdd(ctx, client, cfg, row)
+		}
+	}
+	if err != nil {
 		return fmt.Errorf("lidarr add retry: %w", err)
 	}
 	return q.MarkLidarrRequestAddConfirmed(ctx, row.ID)
 }
 
+// repointAtReleaseGroup reads an album or track request's album id as a
+// MusicBrainz release and, when its release group can be named, rewrites the
+// request to it. The library's own albums answer first; MusicBrainz is asked
+// only for a release no album row knows the group of, and its answer is cached
+// onto that album. Reports false when there is nothing to repoint: not an
+// album request, the group is unknown, or the id already is the group.
+func (r *Reconciler) repointAtReleaseGroup(ctx context.Context, q *dbq.Queries, row dbq.LidarrRequest) (dbq.LidarrRequest, bool) {
+	if row.Kind == dbq.LidarrRequestKindArtist || row.LidarrAlbumMbid == nil || *row.LidarrAlbumMbid == "" {
+		return row, false
+	}
+	release := *row.LidarrAlbumMbid
+	group, err := q.GetReleaseGroupForReleaseMbid(ctx, &release)
+	if err != nil {
+		if !isNoRows(err) {
+			r.logger.Warn("lidarrrequests: release group lookup failed", "request_id", row.ID, "err", err)
+			return row, false
+		}
+		group, err = r.releaseGroup(ctx, release)
+		if err != nil {
+			if !errors.Is(err, tags.ErrNotFound) {
+				r.logger.Warn("lidarrrequests: MusicBrainz release group lookup failed",
+					"request_id", row.ID, "release_mbid", release, "err", err)
+			}
+			return row, false
+		}
+		if cerr := q.SetReleaseGroupForReleaseMbidIfNull(ctx, dbq.SetReleaseGroupForReleaseMbidIfNullParams{
+			ReleaseGroupMbid: group,
+			ReleaseMbid:      release,
+		}); cerr != nil {
+			r.logger.Warn("lidarrrequests: cache release group failed", "release_mbid", release, "err", cerr)
+		}
+	}
+	if group == "" || group == release {
+		return row, false
+	}
+	if err := q.SetLidarrRequestAlbumMbid(ctx, dbq.SetLidarrRequestAlbumMbidParams{
+		ID:              row.ID,
+		LidarrAlbumMbid: &group,
+	}); err != nil {
+		r.logger.Warn("lidarrrequests: repoint request failed", "request_id", row.ID, "err", err)
+		return row, false
+	}
+	r.logger.Info("lidarrrequests: request repointed from release to release group",
+		"request_id", row.ID, "release_mbid", release, "release_group_mbid", group)
+	row.LidarrAlbumMbid = &group
+	return row, true
+}
+
+// albumForRequest finds the library album a request's album id names, by
+// release id or release group, and only once it has a track back on disk. A
+// re-acquisition request names an album whose row never went away; matching
+// the row alone would complete the request before Lidarr delivered anything.
+// An exact release match is preferred over another release of the group.
+const albumForRequest = `
+SELECT a.id
+  FROM albums a
+ WHERE (a.mbid = $1 OR a.release_group_mbid = $1)
+   AND EXISTS (SELECT 1 FROM tracks t WHERE t.album_id = a.id AND t.missing_since IS NULL)
+ ORDER BY (a.mbid = $1) DESC, a.id
+ LIMIT 1`
+
 func (r *Reconciler) reconcileArtist(ctx context.Context, q *dbq.Queries, row dbq.LidarrRequest) error {
 	var artistID pgtype.UUID
 	err := r.pool.QueryRow(ctx,
@@ -221,10 +301,7 @@ func (r *Reconciler) reconcileAlbum(ctx context.Context, q *dbq.Queries, row dbq
 		return nil
 	}
 	var albumID pgtype.UUID
-	err := r.pool.QueryRow(ctx,
-		"SELECT id FROM albums WHERE mbid = $1",
-		*row.LidarrAlbumMbid,
-	).Scan(&albumID)
+	err := r.pool.QueryRow(ctx, albumForRequest, *row.LidarrAlbumMbid).Scan(&albumID)
 	if err != nil {
 		if isNoRows(err) {
 			return nil
@@ -250,10 +327,7 @@ func (r *Reconciler) reconcileTrack(ctx context.Context, q *dbq.Queries, row dbq
 	}
 	// Track-kind requests match via their parent album's MBID, not track.mbid.
 	var albumID pgtype.UUID
-	err := r.pool.QueryRow(ctx,
-		"SELECT id FROM albums WHERE mbid = $1",
-		*row.LidarrAlbumMbid,
-	).Scan(&albumID)
+	err := r.pool.QueryRow(ctx, albumForRequest, *row.LidarrAlbumMbid).Scan(&albumID)
 	if err != nil {
 		if isNoRows(err) {
 			return nil
@@ -264,7 +338,7 @@ func (r *Reconciler) reconcileTrack(ctx context.Context, q *dbq.Queries, row dbq
 	// Load any track from that album to set matched_track_id.
 	var trackID pgtype.UUID
 	err = r.pool.QueryRow(ctx,
-		"SELECT id FROM tracks WHERE album_id = $1 ORDER BY id LIMIT 1",
+		"SELECT id FROM tracks WHERE album_id = $1 AND missing_since IS NULL ORDER BY id LIMIT 1",
 		albumID,
 	).Scan(&trackID)
 	if err != nil {