add musicbrainz/initial lfm

db/db.go

···
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		username TEXT,                      -- Made nullable, might not have username initially
 		email TEXT UNIQUE,                  -- Made nullable
-		spotify_id TEXT UNIQUE,             -- Spotify specific ID
-		access_token TEXT,                  -- Spotify access token
-		refresh_token TEXT,                 -- Spotify refresh token
-		token_expiry TIMESTAMP,             -- Spotify token expiry
 		atproto_did TEXT UNIQUE,            -- Atproto DID (identifier)
 		atproto_authserver_issuer TEXT,
 		atproto_access_token TEXT,          -- Atproto access token
···
 		atproto_token_type TEXT,            -- Atproto token type
 		atproto_authserver_nonce TEXT,
 		atproto_dpop_private_jwk TEXT,
+		spotify_id TEXT UNIQUE,             -- Spotify specific ID
+		access_token TEXT,                  -- Spotify access token
+		refresh_token TEXT,                 -- Spotify refresh token
+		token_expiry TIMESTAMP,             -- Spotify token expiry
+		lastfm_username TEXT,                     -- Last.fm username
 		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Use default
 		updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP  -- Use default
 	)`)
···
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		user_id INTEGER NOT NULL,
 		name TEXT NOT NULL,
+		recording_mbid TEXT, -- Added
 		artist TEXT NOT NULL, -- should be JSONB in PostgreSQL if we ever switch
 		album TEXT NOT NULL,
+		release_mbid TEXT, -- Added
 		url TEXT NOT NULL,
 		timestamp TIMESTAMP,
 		duration_ms INTEGER,
···
 		return err
 	}
 
+	// Add columns recording_mbid and release_mbid to tracks table if they don't exist
+	_, err = db.Exec(`ALTER TABLE tracks ADD COLUMN recording_mbid TEXT`)
+	if err != nil && err.Error() != "duplicate column name: recording_mbid" {
+		// Handle errors other than 'duplicate column'
+		return err
+	}
+	_, err = db.Exec(`ALTER TABLE tracks ADD COLUMN release_mbid TEXT`)
+	if err != nil && err.Error() != "duplicate column name: release_mbid" {
+		// Handle errors other than 'duplicate column'
+		return err
+	}
+
 	return nil
 }
 
···
 	var trackID int64
 
 	err := db.QueryRow(`
-	INSERT INTO tracks (user_id, name, artist, album, url, timestamp, duration_ms, progress_ms, service_base_url, isrc, has_stamped)
-	VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+	INSERT INTO tracks (user_id, name, recording_mbid, artist, album, release_mbid, url, timestamp, duration_ms, progress_ms, service_base_url, isrc, has_stamped)
+	VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 	RETURNING id`,
-		userID, track.Name, artistString, track.Album, track.URL, track.Timestamp,
+		userID, track.Name, track.RecordingMBID, artistString, track.Album, track.ReleaseMBID, track.URL, track.Timestamp,
 		track.DurationMs, track.ProgressMs, track.ServiceBaseUrl, track.ISRC, track.HasStamped).Scan(&trackID)
 
 	return trackID, err
···
 	_, err := db.Exec(`
 	UPDATE tracks
 	SET name = ?,
+	    recording_mbid = ?,
 		artist = ?,
 		album = ?,
+		release_mbid = ?,
 		url = ?,
 		timestamp = ?,
 		duration_ms = ?,
···
 		isrc = ?,
 		has_stamped = ?
 	WHERE id = ?`,
-		track.Name, artistString, track.Album, track.URL, track.Timestamp,
+		track.Name, track.RecordingMBID, artistString, track.Album, track.ReleaseMBID, track.URL, track.Timestamp,
 		track.DurationMs, track.ProgressMs, track.ServiceBaseUrl, track.ISRC, track.HasStamped,
 		trackID)
 
···
 
 func (db *DB) GetRecentTracks(userID int64, limit int) ([]*models.Track, error) {
 	rows, err := db.Query(`
-    SELECT id, name, artist, album, url, timestamp, duration_ms, progress_ms, service_base_url, isrc, has_stamped
+    SELECT id, name, recording_mbid, artist, album, release_mbid, url, timestamp, duration_ms, progress_ms, service_base_url, isrc, has_stamped
     FROM tracks
     WHERE user_id = ?
     ORDER BY timestamp DESC
···
 		err := rows.Scan(
 			&track.PlayID,
 			&track.Name,
-			&artistString, // scan to be unmarshaled later
+			&track.RecordingMBID, // Scan new field
+			&artistString,        // scan to be unmarshaled later
 			&track.Album,
+			&track.ReleaseMBID, // Scan new field
 			&track.URL,
 			&track.Timestamp,
 			&track.DurationMs,
···
 
 	return users, nil
 }
+
+func (db *DB) GetAllUsersWithLastFM() ([]*models.User, error) {
+	rows, err := db.Query(`
+    SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at, lastfm_username
+    FROM users
+    ORDER BY id`)
+
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var users []*models.User
+
+	for rows.Next() {
+		user := &models.User{}
+		err := rows.Scan(
+			&user.ID, &user.Username, &user.Email, &user.SpotifyID,
+			&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
+			&user.CreatedAt, &user.UpdatedAt, &user.LastFMUsername)
+		if err != nil {
+			return nil, err
+		}
+		users = append(users, user)
+	}
+
+	return users, nil
+}

go.mod

···
 	github.com/cli/safeexec v1.0.1 // indirect
 	github.com/creack/pty v1.1.23 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
+	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/fatih/color v1.17.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.8.0 // indirect
···
 	golang.org/x/crypto v0.32.0 // indirect
 	golang.org/x/sys v0.29.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/time v0.11.0 // indirect
 	golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 // indirect
 	google.golang.org/protobuf v1.36.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

···
 github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
+github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
···
 golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
+golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=

main.go

···
 	"github.com/teal-fm/piper/oauth"
 	"github.com/teal-fm/piper/oauth/atproto"
 	apikeyService "github.com/teal-fm/piper/service/apikey"
+	"github.com/teal-fm/piper/service/musicbrainz" // Added musicbrainz service
 	"github.com/teal-fm/piper/service/spotify"
 	"github.com/teal-fm/piper/session"
 )
···
 	}
 }
 
+// apiMusicBrainzSearch handles requests to the MusicBrainz search API.
+func apiMusicBrainzSearch(mbService *musicbrainz.MusicBrainzService) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Optional: Add authentication/rate limiting if needed
+
+		params := musicbrainz.SearchParams{
+			Track:   r.URL.Query().Get("track"),
+			Artist:  r.URL.Query().Get("artist"),
+			Release: r.URL.Query().Get("release"),
+		}
+
+		if params.Track == "" && params.Artist == "" && params.Release == "" {
+			jsonResponse(w, http.StatusBadRequest, map[string]string{"error": "At least one query parameter (track, artist, release) is required"})
+			return
+		}
+
+		recordings, err := mbService.SearchMusicBrainz(r.Context(), params)
+		if err != nil {
+			log.Printf("Error searching MusicBrainz: %v", err) // Log the error
+			jsonResponse(w, http.StatusInternalServerError, map[string]string{"error": "Failed to search MusicBrainz"})
+			return
+		}
+
+		// Optionally process recordings (e.g., select best release) before responding
+		// For now, just return the raw results
+		jsonResponse(w, http.StatusOK, recordings)
+	}
+}
+
 func main() {
 	config.Load()
 
···
 		log.Fatalf("Error initializing database: %v", err)
 	}
 
-	spotifyService := spotify.NewSpotifyService(database)
-	sessionManager := session.NewSessionManager()
-	oauthManager := oauth.NewOAuthServiceManager()
-
-	spotifyOAuth := oauth.NewOAuth2Service(
-		viper.GetString("spotify.client_id"),
-		viper.GetString("spotify.client_secret"),
-		viper.GetString("callback.spotify"),
-		viper.GetStringSlice("spotify.scopes"),
-		"spotify",
-		spotifyService,
-	)
-	oauthManager.RegisterService("spotify", spotifyOAuth)
-	apiKeyService := apikeyService.NewAPIKeyService(database, sessionManager)
-
 	// init atproto svc
 	jwksBytes, err := os.ReadFile("./jwks.json")
 	if err != nil {
···
 	if err != nil {
 		log.Fatalf("Error creating ATproto auth service: %v", err)
 	}
+	mbService := musicbrainz.NewMusicBrainzService(database)
+
+	spotifyService := spotify.NewSpotifyService(database, atprotoService, mbService)
+	sessionManager := session.NewSessionManager()
+	oauthManager := oauth.NewOAuthServiceManager()
+
+	spotifyOAuth := oauth.NewOAuth2Service(
+		viper.GetString("spotify.client_id"),
+		viper.GetString("spotify.client_secret"),
+		viper.GetString("callback.spotify"),
+		viper.GetStringSlice("spotify.scopes"),
+		"spotify",
+		spotifyService,
+	)
+	oauthManager.RegisterService("spotify", spotifyOAuth)
+	apiKeyService := apikeyService.NewAPIKeyService(database, sessionManager)
 
 	oauthManager.RegisterService("atproto", atprotoService)
 
···
 	// API routes
 	http.HandleFunc("/api/v1/current-track", session.WithAPIAuth(apiCurrentTrack(spotifyService), sessionManager))
 	http.HandleFunc("/api/v1/history", session.WithAPIAuth(apiTrackHistory(spotifyService), sessionManager))
+	http.HandleFunc("/api/v1/musicbrainz/search", apiMusicBrainzSearch(mbService)) // Added MusicBrainz search endpoint
 
 	serverUrlRoot := viper.GetString("server.root_url")
 	atpClientId := viper.GetString("atproto.client_id")

models/track.go

···
 
 // Track represents a Spotify track
 type Track struct {
-	PlayID         int64     `json:"playId"`
-	Name           string    `json:"name"`
-	Artist         []Artist  `json:"artist"`
-	Album          string    `json:"album"`
+	PlayID int64  `json:"playId"`
+	Name   string `json:"name"`
+	// analogous to "track"
+	RecordingMBID string   `json:"trackMBID"`
+	Artist        []Artist `json:"artist"`
+	Album         string   `json:"album"`
+	// analogous to "album"
+	ReleaseMBID    string    `json:"releaseMBID"`
 	URL            string    `json:"url"`
 	Timestamp      time.Time `json:"timestamp"`
 	DurationMs     int64     `json:"durationMs"`
···
 type Artist struct {
 	Name string `json:"name"`
 	ID   string `json:"id"`
+	MBID string `json:"mbid"`
 }

models/user.go

···
 	RefreshToken *string
 	TokenExpiry  *time.Time
 
+	// lfm information
+	LastFMUsername *string
+
 	// atp info
 	ATProtoDID          *string
 	ATProtoAccessToken  *string

service/lastfm/lastfm.go

···
+package lastfm
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/teal-fm/piper/db"
+	"golang.org/x/time/rate"
+)
+
+const (
+	lastfmAPIBaseURL = "https://ws.audioscrobbler.com/2.0/"
+	defaultLimit     = 50 // Default number of tracks to fetch per user
+)
+
+// Structs to represent the Last.fm API response for user.getrecenttracks
+type RecentTracksResponse struct {
+	RecentTracks RecentTracks `json:"recenttracks"`
+}
+
+type RecentTracks struct {
+	Tracks []Track      `json:"track"`
+	Attr   TrackXMLAttr `json:"@attr"`
+}
+
+type Track struct {
+	Artist     Artist     `json:"artist"`
+	Streamable string     `json:"streamable"` // Typically "0" or "1"
+	Image      []Image    `json:"image"`
+	MBID       string     `json:"mbid"` // MusicBrainz ID for the track
+	Album      Album      `json:"album"`
+	Name       string     `json:"name"`
+	URL        string     `json:"url"`
+	Date       *TrackDate `json:"date,omitempty"` // Use pointer for optional fields
+	NowPlaying *struct {  // Custom handling for @attr.nowplaying
+		NowPlaying string `json:"nowplaying"`
+	} `json:"@attr,omitempty"`
+}
+
+type Artist struct {
+	MBID string `json:"mbid"` // MusicBrainz ID for the artist
+	Text string `json:"#text"`
+}
+
+type Image struct {
+	Size string `json:"size"`  // "small", "medium", "large", "extralarge"
+	Text string `json:"#text"` // URL of the image
+}
+
+type Album struct {
+	MBID string `json:"mbid"`  // MusicBrainz ID for the album
+	Text string `json:"#text"` // Album name
+}
+
+type TrackDate struct {
+	UTS  string `json:"uts"`   // Unix timestamp string
+	Text string `json:"#text"` // Human-readable date string
+}
+
+type TrackXMLAttr struct {
+	User       string `json:"user"`
+	TotalPages string `json:"totalPages"`
+	Page       string `json:"page"`
+	PerPage    string `json:"perPage"`
+	Total      string `json:"total"`
+}
+
+type LastFMService struct {
+	db         *db.DB
+	httpClient *http.Client
+	limiter    *rate.Limiter
+	apiKey     string
+	Usernames  []string
+}
+
+func NewLastFMService(db *db.DB, apiKey string) *LastFMService {
+	return &LastFMService{
+		db: db,
+		httpClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+		// Last.fm unofficial rate limit is ~5 requests per second
+		limiter:   rate.NewLimiter(rate.Every(200*time.Millisecond), 1),
+		apiKey:    apiKey,
+		Usernames: make([]string, 0),
+	}
+}
+
+func (l *LastFMService) loadUsernames() error {
+	u, err := l.db.GetAllUsersWithLastFM()
+	if err != nil {
+		log.Printf("Error loading users with Last.fm from DB: %v", err)
+		return fmt.Errorf("failed to load users from database: %w", err)
+	}
+	usernames := make([]string, len(u))
+	for i, user := range u {
+		// Assuming the User struct has a LastFMUsername field
+		if user.LastFMUsername != nil { // Check if the username is set
+			usernames[i] = *user.LastFMUsername
+		} else {
+			log.Printf("User ID %d has Last.fm enabled but no username set", user.ID)
+			// Handle this case - maybe skip the user or log differently
+		}
+	}
+
+	// Filter out empty usernames if any were added due to missing data
+	filteredUsernames := make([]string, 0, len(usernames))
+	for _, name := range usernames {
+		if name != "" {
+			filteredUsernames = append(filteredUsernames, name)
+		}
+	}
+
+	l.Usernames = filteredUsernames
+	log.Printf("Loaded %d Last.fm usernames", len(l.Usernames))
+
+	return nil
+}
+
+// getRecentTracks fetches the most recent tracks for a given Last.fm user.
+func (l *LastFMService) getRecentTracks(ctx context.Context, username string, limit int) (*RecentTracksResponse, error) {
+	if username == "" {
+		return nil, fmt.Errorf("username cannot be empty")
+	}
+
+	params := url.Values{}
+	params.Set("method", "user.getrecenttracks")
+	params.Set("user", username)
+	params.Set("api_key", l.apiKey)
+	params.Set("format", "json")
+	params.Set("limit", strconv.Itoa(limit))
+
+	apiURL := lastfmAPIBaseURL + "?" + params.Encode()
+
+	if err := l.limiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("rate limiter error: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request for %s: %w", username, err)
+	}
+
+	log.Printf("Fetching recent tracks for user: %s", username)
+	resp, err := l.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch recent tracks for %s: %w", username, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("last.fm API error for %s: status %d, body: %s", username, resp.StatusCode, string(bodyBytes))
+	}
+
+	var recentTracksResp RecentTracksResponse
+	if err := json.NewDecoder(resp.Body).Decode(&recentTracksResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response for %s: %w", username, err)
+	}
+
+	if len(recentTracksResp.RecentTracks.Tracks) > 0 {
+		log.Printf("Fetched %d tracks for %s. Most recent: %s - %s",
+			len(recentTracksResp.RecentTracks.Tracks),
+			username,
+			recentTracksResp.RecentTracks.Tracks[0].Artist.Text,
+			recentTracksResp.RecentTracks.Tracks[0].Name)
+	} else {
+		log.Printf("No recent tracks found for %s", username)
+	}
+
+	return &recentTracksResp, nil
+}
+
+func (l *LastFMService) StartListeningTracker(interval time.Duration) {
+	if err := l.loadUsernames(); err != nil {
+		log.Printf("Failed to perform initial username load: %v", err)
+	}
+
+	if len(l.Usernames) == 0 {
+		log.Println("No Last.fm users configured! Will start listening tracker anyways.")
+	}
+
+	ticker := time.NewTicker(interval)
+	go func() {
+		l.fetchAllUserTracks(context.Background())
+
+		for {
+			select {
+			case <-ticker.C:
+				// refresh usernames periodically from db
+				if err := l.loadUsernames(); err != nil {
+					log.Printf("Error reloading usernames in ticker: %v", err)
+				}
+				if len(l.Usernames) > 0 {
+					l.fetchAllUserTracks(context.Background())
+				} else {
+					log.Println("No Last.fm users configured. Skipping fetch cycle.")
+				}
+				// Add a way to stop the goroutine if needed, e.g., via a context or channel
+				// case <-ctx.Done():
+				//  log.Println("Stopping Last.fm listening tracker.")
+				//	ticker.Stop()
+				//  return
+			}
+		}
+	}()
+
+	log.Printf("Last.fm Listening Tracker started with interval %v", interval)
+}
+
+// fetchAllUserTracks iterates through users and fetches their tracks.
+func (l *LastFMService) fetchAllUserTracks(ctx context.Context) {
+	log.Printf("Starting fetch cycle for %d users...", len(l.Usernames))
+	for _, username := range l.Usernames {
+		if ctx.Err() != nil {
+			log.Printf("Context cancelled during fetch cycle for user %s.", username)
+			return
+		}
+		recentTracks, err := l.getRecentTracks(ctx, username, defaultLimit)
+		if err != nil {
+			log.Printf("Error fetching tracks for %s: %v", username, err)
+			continue
+		}
+
+		// TODO: Process the fetched tracks (e.g., store in DB, update stats)
+		_ = recentTracks // Avoid unused variable warning for now
+		// Example processing:
+		// l.processTracks(username, recentTracks.RecentTracks.Tracks)
+
+	}
+	log.Println("Finished fetch cycle.")
+}
+
+// Placeholder for processing logic
+// func (l *LastFMService) processTracks(username string, tracks []Track) {
+//  log.Printf("Processing %d tracks for user %s", len(tracks), username)
+//  // Implement logic to store tracks, update user scrobble counts, etc.
+//  // Consider handling 'now playing' tracks differently (track.NowPlaying != nil)
+//  // Be mindful of duplicates if the interval is short. Store the last fetched timestamp?
+// }

service/musicbrainz/clean.go

···
+package musicbrainz
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/dlclark/regexp2"
+)
+
+var symbols = "1234567890!@#$%^&*()-=_+[]{};\"|;'\\<>?/.,~`"
+
+var guffParenWords = []string{
+	"a cappella", "acoustic", "bonus", "censored", "clean", "club", "clubmix", "composition",
+	"cut", "dance", "demo", "dialogue", "dirty", "edit", "excerpt", "explicit", "extended",
+	"instrumental", "interlude", "intro", "karaoke", "live", "long", "main", "maxi", "megamix",
+	"mix", "mono", "official", "orchestral", "original", "outro", "outtake", "outtakes", "piano",
+	"quadraphonic", "radio", "rap", "re-edit", "reedit", "refix", "rehearsal", "reinterpreted",
+	"released", "release", "remake", "remastered", "remaster", "master", "remix", "remixed",
+	"remode", "reprise", "rework", "reworked", "rmx", "session", "short", "single", "skit",
+	"stereo", "studio", "take", "takes", "tape", "track", "tryout", "uncensored", "unknown",
+	"unplugged", "untitled", "version", "ver", "video", "vocal", "vs", "with", "without",
+}
+
+type MetadataCleaner struct {
+	recordingExpressions []*regexp2.Regexp
+	artistExpressions    []*regexp2.Regexp
+	parenGuffExpr        *regexp2.Regexp
+	preferredScript      string
+}
+
+func NewMetadataCleaner(preferredScript string) *MetadataCleaner {
+	recordingPatterns := []string{
+		`(?<title>.+?)\s+(?<enclosed>\(.+\)|\[.+\]|\{.+\}|\<.+\>)$`,
+		`(?<title>.+?)\s+?(?<feat>[\[\(]?(?:feat(?:uring)?|ft)\b\.?)\s*?(?<artists>.+)\s*`,
+		`(?<title>.+?)(?:\s+?[\u2010\u2012\u2013\u2014~/-])(?![^(]*\))(?<dash>.*)`,
+	}
+
+	artistPatterns := []string{
+		`(?<title>.+?)(?:\s*?,)(?<comma>.*)`,
+		`(?<title>.+?)(?:\s+?(&|with))(?<dash>.*)`,
+	}
+
+	compiledRecording := make([]*regexp2.Regexp, 0, len(recordingPatterns))
+	for _, pattern := range recordingPatterns {
+		compiledRecording = append(compiledRecording, regexp2.MustCompile(`(?i)`+pattern, 0))
+	}
+
+	compiledArtist := make([]*regexp2.Regexp, 0, len(artistPatterns))
+	for _, pattern := range artistPatterns {
+		compiledArtist = append(compiledArtist, regexp2.MustCompile(`(?i)`+pattern, 0))
+	}
+
+	return &MetadataCleaner{
+		recordingExpressions: compiledRecording,
+		artistExpressions:    compiledArtist,
+		preferredScript:      preferredScript,
+		parenGuffExpr:        regexp2.MustCompile(`(20[0-9]{2}|19[0-9]{2})`, 0),
+	}
+}
+
+func (mc *MetadataCleaner) DropForeignChars(text string) string {
+	var b strings.Builder
+	b.Grow(len(text))
+
+	hasForeign := false
+	hasLetter := false
+
+	for _, r := range text {
+		if unicode.Is(unicode.Common, r) || mc.isPreferredScript(r) {
+			b.WriteRune(r)
+			if unicode.IsLetter(r) {
+				hasLetter = true
+			}
+		} else {
+			hasForeign = true
+		}
+	}
+
+	cleaned := strings.TrimSpace(b.String())
+	if hasForeign && len(cleaned) > 0 && hasLetter {
+		return cleaned
+	}
+	return text
+}
+
+func (mc *MetadataCleaner) isPreferredScript(r rune) bool {
+	switch mc.preferredScript {
+	case "Latin":
+		return unicode.Is(unicode.Latin, r)
+	case "Han":
+		return unicode.Is(unicode.Han, r)
+	case "Cyrillic":
+		return unicode.Is(unicode.Cyrillic, r)
+	case "Devanagari":
+		return unicode.Is(unicode.Devanagari, r)
+	default:
+		return false
+	}
+}
+
+func (mc *MetadataCleaner) IsParenTextLikelyGuff(parenText string) bool {
+	pt := strings.ToLower(parenText)
+	beforeLen := utf8.RuneCountInString(pt)
+
+	for _, guff := range guffParenWords {
+		pt = strings.ReplaceAll(pt, guff, "")
+	}
+
+	pt, _ = mc.parenGuffExpr.Replace(pt, "", -1, -1)
+	afterLen := utf8.RuneCountInString(pt)
+	replaced := beforeLen - afterLen
+
+	chars := 0
+	guffChars := replaced
+	for _, ch := range pt {
+		if strings.ContainsRune(symbols, ch) {
+			guffChars++
+		}
+		if unicode.IsLetter(ch) {
+			chars++
+		}
+	}
+
+	return guffChars > chars
+}
+
+func (mc *MetadataCleaner) ParenChecker(text string) bool {
+	brackets := []struct {
+		open, close rune
+	}{
+		{'(', ')'}, {'[', ']'}, {'{', '}'}, {'<', '>'},
+	}
+	for _, pair := range brackets {
+		if strings.Count(text, string(pair.open)) != strings.Count(text, string(pair.close)) {
+			return false
+		}
+	}
+	return true
+}
+
+func (mc *MetadataCleaner) CleanRecording(text string) (string, bool) {
+	text = strings.TrimSpace(text)
+
+	if !mc.ParenChecker(text) {
+		return text, false
+	}
+
+	text = mc.DropForeignChars(text)
+	var changed bool
+
+	for _, expr := range mc.recordingExpressions {
+		match, _ := expr.FindStringMatch(text)
+		if match != nil {
+			groups := make(map[string]string)
+			for _, name := range expr.GetGroupNames() {
+				groups[name] = strings.TrimSpace(match.GroupByName(name).String())
+			}
+
+			if guffy := groups["enclosed"]; guffy != "" && mc.IsParenTextLikelyGuff(guffy) {
+				text = groups["title"]
+				changed = true
+				break
+			}
+
+			if feat := groups["feat"]; feat != "" {
+				text = groups["title"]
+				changed = true
+				break
+			}
+
+			if dash := groups["dash"]; dash != "" {
+				if mc.IsParenTextLikelyGuff(dash) {
+					text = groups["title"]
+					changed = true
+					break
+				}
+			}
+		}
+	}
+
+	return strings.TrimSpace(text), changed
+}
+
+func (mc *MetadataCleaner) CleanArtist(text string) (string, bool) {
+	text = strings.TrimSpace(text)
+
+	if !mc.ParenChecker(text) {
+		return text, false
+	}
+
+	text = mc.DropForeignChars(text)
+	var changed bool
+
+	for _, expr := range mc.artistExpressions {
+		match, _ := expr.FindStringMatch(text)
+		if match != nil {
+			groups := make(map[string]string)
+			for _, name := range expr.GetGroupNames() {
+				groups[name] = strings.TrimSpace(match.GroupByName(name).String())
+			}
+
+			title := groups["title"]
+			if len(title) > 2 && unicode.IsLetter(rune(title[0])) {
+				text = title
+				changed = true
+				break
+			}
+		}
+	}
+
+	return strings.TrimSpace(text), changed
+}

service/musicbrainz/musicbrainz.go

···
+package musicbrainz
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"sort"
+	"strings"
+	"sync" // Added for mutex
+	"time"
+
+	"github.com/teal-fm/piper/db"
+	"golang.org/x/time/rate"
+)
+
+// MusicBrainz API Types
+type MusicBrainzArtistCredit struct {
+	Artist struct {
+		ID       string `json:"id"`
+		Name     string `json:"name"`
+		SortName string `json:"sort-name,omitempty"`
+	} `json:"artist"`
+	Joinphrase string `json:"joinphrase,omitempty"`
+	Name       string `json:"name"`
+}
+
+type MusicBrainzRelease struct {
+	ID             string `json:"id"`
+	Title          string `json:"title"`
+	Status         string `json:"status,omitempty"`
+	Date           string `json:"date,omitempty"` // YYYY-MM-DD, YYYY-MM, or YYYY
+	Country        string `json:"country,omitempty"`
+	Disambiguation string `json:"disambiguation,omitempty"`
+	TrackCount     int    `json:"track-count,omitempty"`
+}
+
+type MusicBrainzRecording struct {
+	ID           string                    `json:"id"`
+	Title        string                    `json:"title"`
+	Length       int                       `json:"length,omitempty"` // milliseconds
+	ISRCs        []string                  `json:"isrcs,omitempty"`
+	ArtistCredit []MusicBrainzArtistCredit `json:"artist-credit,omitempty"`
+	Releases     []MusicBrainzRelease      `json:"releases,omitempty"`
+}
+
+type MusicBrainzSearchResponse struct {
+	Created    time.Time              `json:"created"`
+	Count      int                    `json:"count"`
+	Offset     int                    `json:"offset"`
+	Recordings []MusicBrainzRecording `json:"recordings"`
+}
+
+type SearchParams struct {
+	Track   string
+	Artist  string
+	Release string
+}
+
+// cacheEntry holds the cached data and its expiration time.
+type cacheEntry struct {
+	recordings []MusicBrainzRecording
+	expiresAt  time.Time
+}
+
+type MusicBrainzService struct {
+	db          *db.DB
+	httpClient  *http.Client
+	limiter     *rate.Limiter
+	searchCache map[string]cacheEntry // In-memory cache for search results
+	cacheMutex  sync.RWMutex          // Mutex to protect the cache
+	cacheTTL    time.Duration         // Time-to-live for cache entries
+	cleaner     MetadataCleaner       // Cleaner for cleaning up expired cache entries
+}
+
+// NewMusicBrainzService creates a new service instance with rate limiting and caching.
+func NewMusicBrainzService(db *db.DB) *MusicBrainzService {
+	// MusicBrainz allows 1 request per second
+	limiter := rate.NewLimiter(rate.Every(time.Second), 1)
+	// Set a default cache TTL (e.g., 1 hour)
+	defaultCacheTTL := 1 * time.Hour
+
+	return &MusicBrainzService{
+		db: db,
+		httpClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+		limiter:     limiter,
+		searchCache: make(map[string]cacheEntry),  // Initialize the cache map
+		cacheTTL:    defaultCacheTTL,              // Set the cache TTL
+		cleaner:     *NewMetadataCleaner("Latin"), // Initialize the cleaner
+		// cacheMutex is zero-value ready
+	}
+}
+
+// generateCacheKey creates a unique string key for caching based on search parameters.
+func generateCacheKey(params SearchParams) string {
+	// Use a structured format to avoid collisions and ensure order doesn't matter implicitly
+	// url.QueryEscape handles potential special characters in parameters
+	return fmt.Sprintf("track=%s&artist=%s&release=%s",
+		url.QueryEscape(params.Track),
+		url.QueryEscape(params.Artist),
+		url.QueryEscape(params.Release))
+}
+
+// SearchMusicBrainz searches the MusicBrainz API for recordings, using an in-memory cache.
+func (s *MusicBrainzService) SearchMusicBrainz(ctx context.Context, params SearchParams) ([]MusicBrainzRecording, error) {
+	// Validate parameters first
+	if params.Track == "" && params.Artist == "" && params.Release == "" {
+		return nil, fmt.Errorf("at least one search parameter (Track, Artist, Release) must be provided")
+	}
+
+	// clean params
+	params.Track, _ = s.cleaner.CleanRecording(params.Track)
+	params.Artist, _ = s.cleaner.CleanArtist(params.Artist)
+
+	cacheKey := generateCacheKey(params)
+	now := time.Now()
+
+	// --- Check Cache (Read Lock) ---
+	s.cacheMutex.RLock()
+	entry, found := s.searchCache[cacheKey]
+	s.cacheMutex.RUnlock()
+
+	if found && now.Before(entry.expiresAt) {
+		log.Printf("Cache hit for MusicBrainz search: key=%s", cacheKey)
+		// Return the cached data directly. Consider if a deep copy is needed if callers modify results.
+		return entry.recordings, nil
+	}
+	// --- Cache Miss or Expired ---
+	if found {
+		log.Printf("Cache expired for MusicBrainz search: key=%s", cacheKey)
+	} else {
+		log.Printf("Cache miss for MusicBrainz search: key=%s", cacheKey)
+	}
+
+	// --- Proceed with API call ---
+	queryParts := []string{}
+	if params.Track != "" {
+		queryParts = append(queryParts, fmt.Sprintf(`recording:"%s"`, params.Track))
+	}
+	if params.Artist != "" {
+		queryParts = append(queryParts, fmt.Sprintf(`artist:"%s"`, params.Artist))
+	}
+	if params.Release != "" {
+		queryParts = append(queryParts, fmt.Sprintf(`release:"%s"`, params.Release))
+	}
+	query := strings.Join(queryParts, " AND ")
+	endpoint := fmt.Sprintf("https://musicbrainz.org/ws/2/recording?query=%s&fmt=json&inc=artists+releases+isrcs", url.QueryEscape(query))
+
+	if err := s.limiter.Wait(ctx); err != nil {
+		if ctx.Err() != nil {
+			return nil, fmt.Errorf("context cancelled during rate limiter wait: %w", ctx.Err())
+		}
+		return nil, fmt.Errorf("rate limiter error: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", "piper/0.0.1 ( https://github.com/teal-fm/piper )")
+
+	resp, err := s.httpClient.Do(req)
+	if err != nil {
+		if ctx.Err() != nil {
+			return nil, fmt.Errorf("context error during request execution: %w", ctx.Err())
+		}
+		return nil, fmt.Errorf("failed to execute request to %s: %w", endpoint, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		// TODO: Consider reading body for detailed error message from MusicBrainz
+		return nil, fmt.Errorf("MusicBrainz API request to %s returned status %d", endpoint, resp.StatusCode)
+	}
+
+	var result MusicBrainzSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response from %s: %w", endpoint, err)
+	}
+
+	// cache result for later
+	s.cacheMutex.Lock()
+	s.searchCache[cacheKey] = cacheEntry{
+		recordings: result.Recordings,
+		expiresAt:  time.Now().Add(s.cacheTTL),
+	}
+	s.cacheMutex.Unlock()
+	log.Printf("Cached MusicBrainz search result for key=%s, TTL=%s", cacheKey, s.cacheTTL)
+
+	// Return the newly fetched results
+	return result.Recordings, nil
+}
+
+// GetBestRelease selects the 'best' release from a list based on specific criteria.
+func GetBestRelease(releases []MusicBrainzRelease, trackTitle string) *MusicBrainzRelease {
+	if len(releases) == 0 {
+		return nil
+	}
+	if len(releases) == 1 {
+		// Return a pointer to the single element
+		r := releases[0]
+		return &r
+	}
+
+	// Sort releases: Prefer valid dates first, then sort by date, title, id.
+	sort.SliceStable(releases, func(i, j int) bool {
+		dateA := releases[i].Date
+		dateB := releases[j].Date
+		validDateA := len(dateA) >= 4 // Basic check for YYYY format or longer
+		validDateB := len(dateB) >= 4
+
+		// Put invalid/empty dates at the end
+		if validDateA && !validDateB {
+			return true
+		}
+		if !validDateA && validDateB {
+			return false
+		}
+		// If both valid or both invalid, compare dates lexicographically
+		if dateA != dateB {
+			return dateA < dateB
+		}
+		// If dates are same, compare by title
+		if releases[i].Title != releases[j].Title {
+			return releases[i].Title < releases[j].Title
+		}
+		// If titles are same, compare by ID
+		return releases[i].ID < releases[j].ID
+	})
+
+	// 1. Find oldest release where country is 'XW' or 'US' AND title is NOT track title
+	for i := range releases {
+		release := &releases[i]
+		if (release.Country == "XW" || release.Country == "US") && release.Title != trackTitle {
+			return release
+		}
+	}
+
+	// 2. If none, find oldest release where title is NOT track title
+	for i := range releases {
+		release := &releases[i]
+		if release.Title != trackTitle {
+			return release
+		}
+	}
+
+	// 3. If none found, return the oldest release overall (which is the first one after sorting)
+	log.Printf("Could not find a suitable release for '%s', picking oldest: '%s' (%s)", trackTitle, releases[0].Title, releases[0].ID)
+	r := releases[0]
+	return &r
+}

service/spotify/spotify.go

···
 package spotify
 
 import (
+	"context"
+	"encoding/base64" // Added for Basic Auth
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
-	"strconv"
+	"net/url" // Added for request body
+
+	// "strconv" // Removed unused import
+	"strings" // Added for request body
 	"sync"
 	"time"
 
+	"github.com/spf13/viper" // Added for config access
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/models"
+	"github.com/teal-fm/piper/oauth/atproto"
+	"github.com/teal-fm/piper/service/musicbrainz"
 	"github.com/teal-fm/piper/session"
 )
 
 type SpotifyService struct {
-	DB         *db.DB
-	userTracks map[int64]*models.Track
-	userTokens map[int64]string
-	mu         sync.RWMutex
+	DB             *db.DB
+	atprotoService *atproto.ATprotoAuthService     // Added field
+	mb             *musicbrainz.MusicBrainzService // Added field
+	userTracks     map[int64]*models.Track
+	userTokens     map[int64]string
+	mu             sync.RWMutex
 }
 
-func NewSpotifyService(database *db.DB) *SpotifyService {
+func NewSpotifyService(database *db.DB, atprotoService *atproto.ATprotoAuthService, musicBrainzService *musicbrainz.MusicBrainzService) *SpotifyService {
 	return &SpotifyService{
-		DB:         database,
-		userTracks: make(map[int64]*models.Track),
-		userTokens: make(map[int64]string),
+		DB:             database,
+		atprotoService: atprotoService,
+		mb:             musicBrainzService,
+		userTracks:     make(map[int64]*models.Track),
+		userTokens:     make(map[int64]string),
 	}
 }
 
···
 	return nil
 }
 
-func (s *SpotifyService) refreshTokenInner(user models.User) error {
-	// implement token refresh logic here using Spotify's token refresh endpoint
-	// this would make a request to Spotify's token endpoint with grant_type=refresh_token
-	return errors.New("Not implemented yet")
-	// if successful, update the database and in-memory cache
-}
+// refreshTokenInner handles the actual Spotify token refresh logic.
+// It returns the new access token or an error.
+func (s *SpotifyService) refreshTokenInner(userID int64) (string, error) {
+	user, err := s.DB.GetUserByID(userID)
+	if err != nil {
+		return "", fmt.Errorf("error loading user %d for refresh: %w", userID, err)
+	}
+
+	if user == nil {
+		return "", fmt.Errorf("user %d not found for refresh", userID)
+	}
+
+	if user.RefreshToken == nil || *user.RefreshToken == "" {
+		// If no refresh token, remove potentially stale access token from cache and return error
+		s.mu.Lock()
+		delete(s.userTokens, userID)
+		s.mu.Unlock()
+		return "", fmt.Errorf("no refresh token available for user %d", userID)
+	}
+
+	clientID := viper.GetString("spotify.client_id")
+	clientSecret := viper.GetString("spotify.client_secret")
+	if clientID == "" || clientSecret == "" {
+		return "", errors.New("spotify client ID or secret not configured")
+	}
 
-func (s *SpotifyService) RefreshToken(userID string) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
+	data := url.Values{}
+	data.Set("grant_type", "refresh_token")
+	data.Set("refresh_token", *user.RefreshToken)
 
-	user, err := s.DB.GetUserBySpotifyID(userID)
+	req, err := http.NewRequest("POST", "https://accounts.spotify.com/api/token", strings.NewReader(data.Encode()))
 	if err != nil {
-		return fmt.Errorf("error loading user: %v", err)
+		return "", fmt.Errorf("failed to create refresh request: %w", err)
 	}
 
-	if user.RefreshToken == nil {
-		return fmt.Errorf("no refresh token for user %s", userID)
+	authHeader := base64.StdEncoding.EncodeToString([]byte(clientID + ":" + clientSecret))
+	req.Header.Set("Authorization", "Basic "+authHeader)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to execute refresh request: %w", err)
 	}
+	defer resp.Body.Close()
 
-	return s.refreshTokenInner(*user)
+	body, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		return "", fmt.Errorf("failed to read refresh response body: %w", readErr)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		// If refresh fails (e.g., bad refresh token), remove tokens from cache
+		s.mu.Lock()
+		delete(s.userTokens, userID)
+		s.mu.Unlock()
+		// Also clear the bad refresh token from the DB
+		updateErr := s.DB.UpdateUserToken(userID, "", "", time.Now()) // Clear tokens
+		if updateErr != nil {
+			log.Printf("Failed to clear bad refresh token for user %d: %v", userID, updateErr)
+		}
+		return "", fmt.Errorf("spotify token refresh failed (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var tokenResponse struct {
+		AccessToken  string `json:"access_token"`
+		TokenType    string `json:"token_type"`
+		Scope        string `json:"scope"`
+		ExpiresIn    int    `json:"expires_in"`              // Seconds
+		RefreshToken string `json:"refresh_token,omitempty"` // Spotify might issue a new refresh token
+	}
+
+	if err := json.Unmarshal(body, &tokenResponse); err != nil {
+		return "", fmt.Errorf("failed to decode refresh response: %w", err)
+	}
+
+	newExpiry := time.Now().Add(time.Duration(tokenResponse.ExpiresIn) * time.Second)
+	newRefreshToken := *user.RefreshToken // Default to old one
+	if tokenResponse.RefreshToken != "" {
+		newRefreshToken = tokenResponse.RefreshToken // Use new one if provided
+	}
+
+	// Update DB
+	if err := s.DB.UpdateUserToken(userID, tokenResponse.AccessToken, newRefreshToken, newExpiry); err != nil {
+		// Log error but continue, as we have the token in memory
+		log.Printf("Error updating user token in DB for user %d after refresh: %v", userID, err)
+	}
+
+	// Update in-memory cache
+	s.mu.Lock()
+	s.userTokens[userID] = tokenResponse.AccessToken
+	s.mu.Unlock()
+
+	log.Printf("Successfully refreshed token for user %d", userID)
+	return tokenResponse.AccessToken, nil
+}
+
+// RefreshToken attempts to refresh the token for a given user ID.
+// It's less commonly needed now refreshTokenInner handles fetching the user.
+func (s *SpotifyService) RefreshToken(userID int64) error {
+	_, err := s.refreshTokenInner(userID)
+	return err
 }
 
 // attempt to refresh expired tokens
···
 			continue
 		}
 
-		err := s.refreshTokenInner(*user)
+		_, err := s.refreshTokenInner(user.ID)
 
 		if err != nil {
 			// just print out errors here for now
···
 		return nil, fmt.Errorf("no access token for user %d", userID)
 	}
 
-	req, err := http.NewRequest("GET", "https://api.spotify.com/v1/me/player/currently-playing", nil)
-	if err != nil {
-		return nil, err
+	req, rErr := http.NewRequest("GET", "https://api.spotify.com/v1/me/player/currently-playing", nil)
+	if rErr != nil {
+		return nil, rErr
 	}
 
 	req.Header.Set("Authorization", "Bearer "+token)
 	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
+	var resp *http.Response
+	var err error
+
+	// Retry logic: try once, if 401, refresh and try again
+	for attempt := 0; attempt < 2; attempt++ {
+		// We need to be able to re-read the body if the request is retried,
+		// but since this is a GET request with no body, we don't need to worry about it.
+		resp, err = client.Do(req) // Use = instead of := inside loop
+		if err != nil {
+			// Network or other client error, don't retry
+			return nil, fmt.Errorf("failed to execute spotify request on attempt %d: %w", attempt+1, err)
+		}
+		// Defer close inside the loop IF we continue, otherwise close after the loop
+		// Simplified: Always defer close, it's idempotent for nil resp.Body
+		// defer resp.Body.Close() // Moved defer outside loop to avoid potential issues
+
+		// oops, token expired or other client error
+		if resp.StatusCode == 401 && attempt == 0 { // Only refresh on 401 on the first attempt
+			log.Printf("Spotify token potentially expired for user %d, attempting refresh...", userID)
+			newAccessToken, refreshErr := s.refreshTokenInner(userID)
+			if refreshErr != nil {
+				log.Printf("Token refresh failed for user %d: %v", userID, refreshErr)
+				// No point retrying if refresh failed
+				return nil, fmt.Errorf("spotify token expired or invalid for user %d and refresh failed: %w", userID, refreshErr)
+			}
+			log.Printf("Token refreshed for user %d, retrying request...", userID)
+			token = newAccessToken                           // Update token for the next attempt
+			req.Header.Set("Authorization", "Bearer "+token) // Update header for retry
+			continue                                         // Go to next attempt in the loop
+		}
+
+		// If it's not 200 or 204, or if it's 401 on the second attempt, break and return error
+		if resp.StatusCode != 200 && resp.StatusCode != 204 {
+			body, _ := io.ReadAll(resp.Body)
+			return nil, fmt.Errorf("spotify API error (%d) for user %d after %d attempts: %s", resp.StatusCode, userID, attempt+1, string(body))
+		}
+
+		// If status is 200 or 204, break the loop, we have a valid response (or no content)
+		break
+	} // End of retry loop
+
+	// Ensure body is closed regardless of loop outcome
+	if resp != nil && resp.Body != nil {
+		defer resp.Body.Close()
 	}
-	defer resp.Body.Close()
 
-	// nothing playing
+	// Handle final response after loop
+	if resp == nil {
+		// This should ideally not happen if client.Do succeeded but we check defensively
+		return nil, fmt.Errorf("spotify request failed with no response after retries")
+	}
 	if resp.StatusCode == 204 {
-		return nil, nil
+		return nil, nil // Nothing playing
 	}
 
-	// oops, token expired
-	if resp.StatusCode == 401 {
-		// attempt to refresh token
-		if err := s.RefreshToken(strconv.FormatInt(userID, 10)); err != nil {
-			s.mu.Lock()
-			delete(s.userTokens, userID)
-			s.mu.Unlock()
-			return nil, fmt.Errorf("spotify token expired for user %d", userID)
-		}
-	}
-
-	if resp.StatusCode != 200 {
-		body, _ := io.ReadAll(resp.Body)
-		return nil, fmt.Errorf("spotify API error: %s", body)
+	// Read body now that we know it's a successful 200
+	bodyBytes, err := io.ReadAll(resp.Body) // Read the already fetched successful response body
+	if err != nil {
+		return nil, fmt.Errorf("failed to read successful spotify response body: %w", err)
 	}
 
 	var response struct {
···
 		ProgressMS int `json:"progress_ms"`
 	}
 
-	body, err := io.ReadAll(resp.Body)
+	err = json.Unmarshal(bodyBytes, &response) // Use bodyBytes here
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to unmarshal spotify response: %w", err)
+	}
+
+	body, ioErr := io.ReadAll(resp.Body)
+	if ioErr != nil {
+		return nil, ioErr
 	}
 
 	err = json.Unmarshal(body, &response)
···
 		}
 	}
 }
+
+// Take a track, with any IDs and hydrate it with MusicBrainz data
+func (s *SpotifyService) hydrateTrack(track *models.Track) (*models.Track, error) {
+	ctx := context.Background()
+	// array of strings
+	artistArray := make([]string, len(track.Artist)) // Assuming Name is string type
+	for i, a := range track.Artist {
+		artistArray[i] = a.Name
+	}
+
+	params := musicbrainz.SearchParams{
+		Track:   track.Name,
+		Artist:  strings.Join(artistArray, ", "),
+		Release: track.Album,
+	}
+	res, err := s.mb.SearchMusicBrainz(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(res) == 0 {
+		return nil, errors.New("no results found")
+	}
+
+	firstResult := res[0]
+	firstResultAlbum := musicbrainz.GetBestRelease(firstResult.Releases, firstResult.Title)
+
+	bestISRC := firstResult.ISRCs[0]
+
+	if len(firstResult.ISRCs) == 0 {
+		bestISRC = track.ISRC
+	}
+
+	artists := make([]models.Artist, len(firstResult.ArtistCredit))
+
+	for i, a := range firstResult.ArtistCredit {
+		artists[i] = models.Artist{
+			Name: a.Name,
+			ID:   a.Artist.ID,
+			MBID: a.Artist.ID,
+		}
+	}
+
+	resTrack := models.Track{
+		HasStamped:     track.HasStamped,
+		PlayID:         track.PlayID,
+		Name:           track.Name,
+		URL:            track.URL,
+		ServiceBaseUrl: track.ServiceBaseUrl,
+		RecordingMBID:  firstResult.ID,
+		Album:          firstResultAlbum.Title,
+		ReleaseMBID:    firstResultAlbum.ID,
+		ISRC:           bestISRC,
+		Timestamp:      track.Timestamp,
+		ProgressMs:     track.ProgressMs,
+		DurationMs:     int64(firstResult.Length),
+		Artist:         artists,
+	}
+
+	return &resTrack, nil
+}