move stuff around 2

db/atproto.go

···
 			atproto_token_expiry = ?,
 			atproto_scope = ?,
 			atproto_sub = ?,
-			atproto_authserver_iss = ?,
+			atproto_authserver_issuer = ?,
 			atproto_token_type = ?,
 			atproto_authserver_nonce = ?,
 			atproto_dpop_private_jwk = ?,

db/db.go

···
 import (
 	"database/sql"
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"time"
···
 	return users, nil
 }
 
-func (db *DB) AddLastFMUsername(userID int64, lastfmUsername string) error {
-	_, err := db.Exec(`
-    UPDATE users
-    SET lastfm_username = ?
-    WHERE user_id = ?`, lastfmUsername, userID)
+// debug to view current user's information
+// put everything in an 'any' type
+func (db *DB) DebugViewUserInformation(userID int64) (map[string]any, error) {
+	// Use Query instead of QueryRow to get access to column names and ensure only one row is processed
+	rows, err := db.Query(`
+				SELECT *
+				FROM users
+				WHERE id = ? LIMIT 1`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("query failed: %w", err)
+	}
+	defer rows.Close()
 
-	return err
-}
+	// Get column names
+	cols, err := rows.Columns()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get columns: %w", err)
+	}
 
-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`)
+	// Check if there's a row to process
+	if !rows.Next() {
+		if err := rows.Err(); err != nil {
+			// Error during rows.Next() or preparing the result set
+			return nil, fmt.Errorf("error checking for row: %w", err)
+		}
+		// No rows found, which is a valid outcome but might be considered an error in some contexts.
+		// Returning sql.ErrNoRows is conventional.
+		return nil, sql.ErrNoRows
+	}
 
+	// Prepare scan arguments: pointers to interface{} slices
+	values := make([]any, len(cols))
+	scanArgs := make([]any, len(cols))
+	for i := range values {
+		scanArgs[i] = &values[i]
+	}
+
+	// Scan the row values
+	err = rows.Scan(scanArgs...)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to scan row: %w", err)
 	}
-	defer rows.Close()
 
-	var users []*models.User
+	// Check for errors that might have occurred during iteration (after Scan)
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error after scanning row: %w", err)
+	}
 
-	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
+	// Create the result map
+	resultMap := make(map[string]any, len(cols))
+	for i, colName := range cols {
+		val := values[i]
+		// SQLite often returns []byte for TEXT columns, convert to string for usability.
+		// Also handle potential nil values appropriately.
+		if b, ok := val.([]byte); ok {
+			resultMap[colName] = string(b)
+		} else {
+			resultMap[colName] = val // Keep nil as nil, numbers as numbers, etc.
 		}
-		users = append(users, user)
 	}
 
-	return users, nil
+	return resultMap, nil
+}
+
+func (db *DB) GetLastScrobbleTimestamp(userID int64) (*time.Time, error) {
+	var lastTimestamp time.Time
+	err := db.QueryRow(`
+		SELECT timestamp
+		FROM tracks
+		WHERE user_id = ?
+		ORDER BY timestamp DESC
+		LIMIT 1`, userID).Scan(&lastTimestamp)
+
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to query last scrobble timestamp for user %d: %w", userID, err)
+	}
+
+	return &lastTimestamp, nil
 }

main.go

···
 
 func handleLinkLastfmForm(database *db.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		userID, _ := session.GetUserID(r.Context()) // Auth middleware ensures this exists
+		userID, _ := session.GetUserID(r.Context())
+		if r.Method == http.MethodPost {
+			if err := r.ParseForm(); err != nil {
+				http.Error(w, "Failed to parse form", http.StatusBadRequest)
+				return
+			}
+
+			lastfmUsername := r.FormValue("lastfm_username")
+			if lastfmUsername == "" {
+				http.Error(w, "Last.fm username cannot be empty", http.StatusBadRequest)
+				return
+			}
+
+			err := database.AddLastFMUsername(userID, lastfmUsername)
+			if err != nil {
+				log.Printf("Error saving Last.fm username for user %d: %v", userID, err)
+				http.Error(w, "Failed to save Last.fm username", http.StatusInternalServerError)
+				return
+			}
+
+			log.Printf("Successfully linked Last.fm username '%s' for user ID %d", lastfmUsername, userID)
+
+			http.Redirect(w, r, "/", http.StatusSeeOther)
+		}
 
 		currentUser, err := database.GetUserByID(userID)
 		currentUsername := ""
···
 
 	mbService := musicbrainz.NewMusicBrainzService(database)
 	spotifyService := spotify.NewSpotifyService(database, atprotoService, mbService)
-	lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"))
+	lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"), mbService)
 
-	sessionManager := session.NewSessionManager()
-	oauthManager := oauth.NewOAuthServiceManager()
+	sessionManager := session.NewSessionManager(database)
+	oauthManager := oauth.NewOAuthServiceManager(sessionManager)
 
 	spotifyOAuth := oauth.NewOAuth2Service(
 		viper.GetString("spotify.client_id"),
···
 	http.HandleFunc("/api-keys", session.WithAuth(apiKeyService.HandleAPIKeyManagement, sessionManager))
 	http.HandleFunc("/link-lastfm", session.WithAuth(handleLinkLastfmForm(database), sessionManager))          // GET form
 	http.HandleFunc("/link-lastfm/submit", session.WithAuth(handleLinkLastfmSubmit(database), sessionManager)) // POST submit - Changed route slightly
-	http.HandleFunc("/logout", sessionManager.HandleLogout)                                                    // Logout doesn't strictly need auth middleware, but handles session deletion
+	http.HandleFunc("/logout", sessionManager.HandleLogout)
+	http.HandleFunc("/debug/", session.WithAuth(sessionManager.HandleDebug, sessionManager))
 
 	http.HandleFunc("/api/v1/current-track", session.WithAPIAuth(apiCurrentTrack(spotifyService), sessionManager)) // Spotify Current
 	http.HandleFunc("/api/v1/history", session.WithAPIAuth(apiTrackHistory(spotifyService), sessionManager))       // Spotify History

models/user.go

···
 // an end user of piper
 type User struct {
 	ID       int64
-	Username string
+	Username *string
 	Email    *string
 
 	// spotify information

oauth/oauth_manager.go

···
 	mu             sync.RWMutex
 }
 
-func NewOAuthServiceManager() *OAuthServiceManager {
+func NewOAuthServiceManager(sessionManager *session.SessionManager) *OAuthServiceManager {
 	return &OAuthServiceManager{
 		services:       make(map[string]AuthService),
-		sessionManager: session.NewSessionManager(),
+		sessionManager: sessionManager,
 	}
 }
 

service/lastfm/lastfm.go

···
 	"net/http"
 	"net/url"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/teal-fm/piper/db"
+	"github.com/teal-fm/piper/models"
+	"github.com/teal-fm/piper/service/musicbrainz"
 	"golang.org/x/time/rate"
 )
 
 const (
 	lastfmAPIBaseURL = "https://ws.audioscrobbler.com/2.0/"
-	defaultLimit     = 50 // Default number of tracks to fetch per user
+	defaultLimit     = 1 // Default number of tracks to fetch per user
 )
 
 // Structs to represent the Last.fm API response for user.getrecenttracks
···
 	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"`
+		NowPlaying string `json:"nowplaying"` // Field name corrected to match struct tag
+	} `json:"@attr,omitempty"` // This captures the @attr object within the track
 }
 
 type Artist struct {
···
 }
 
 type LastFMService struct {
-	db         *db.DB
-	httpClient *http.Client
-	limiter    *rate.Limiter
-	apiKey     string
-	Usernames  []string
+	db                 *db.DB
+	httpClient         *http.Client
+	limiter            *rate.Limiter
+	apiKey             string
+	Usernames          []string
+	musicBrainzService *musicbrainz.MusicBrainzService
+	// Removed in-memory map, assuming DB handles last seen state
+	// lastSeenTrackDate map[string]time.Time
+	// mu sync.Mutex // Keep mutex if other shared state is added later
 }
 
-func NewLastFMService(db *db.DB, apiKey string) *LastFMService {
+func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService) *LastFMService {
 	return &LastFMService{
 		db: db,
 		httpClient: &http.Client{
···
 		limiter:   rate.NewLimiter(rate.Every(200*time.Millisecond), 1),
 		apiKey:    apiKey,
 		Usernames: make([]string, 0),
+		// lastSeenTrackDate: make(map[string]time.Time), // Removed
+		musicBrainzService: musicBrainzService,
 	}
 }
 
···
 	params.Set("user", username)
 	params.Set("api_key", l.apiKey)
 	params.Set("format", "json")
-	params.Set("limit", strconv.Itoa(limit))
+	params.Set("limit", strconv.Itoa(limit)) // Fetch a few more to handle duplicates/now playing
 
 	apiURL := lastfmAPIBaseURL + "?" + params.Encode()
 
···
 
 	if resp.StatusCode != http.StatusOK {
 		bodyBytes, _ := io.ReadAll(resp.Body)
+		// Handle specific Last.fm error codes if necessary
+		// e.g., {"error": 6, "message": "User not found"}
 		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 {
+	bodyBytes, err := io.ReadAll(resp.Body) // Read body first for potential decoding errors
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body for %s: %w", username, err)
+	}
+	if err := json.Unmarshal(bodyBytes, &recentTracksResp); err != nil {
+		// Log the body content that failed to decode
+		log.Printf("Failed to decode response body for %s: %s", username, string(bodyBytes))
 		return nil, fmt.Errorf("failed to decode response for %s: %w", username, err)
 	}
 
···
 func (l *LastFMService) StartListeningTracker(interval time.Duration) {
 	if err := l.loadUsernames(); err != nil {
 		log.Printf("Failed to perform initial username load: %v", err)
+		// Decide if we should proceed without initial load or return error
 	}
 
 	if len(l.Usernames) == 0 {
-		log.Println("No Last.fm users configured! Will start listening tracker anyways.")
+		log.Println("No Last.fm users configured. Tracker will run but fetch cycles will be skipped until users are added.")
+	} else {
+		log.Printf("Found %d Last.fm users.", len(l.Usernames))
 	}
 
 	ticker := time.NewTicker(interval)
 	go func() {
-		l.fetchAllUserTracks(context.Background())
+		// Initial fetch immediately
+		if len(l.Usernames) > 0 {
+			l.fetchAllUserTracks(context.Background())
+		} else {
+			log.Println("Skipping initial fetch cycle as no users are configured.")
+		}
 
 		for {
 			select {
···
 				// refresh usernames periodically from db
 				if err := l.loadUsernames(); err != nil {
 					log.Printf("Error reloading usernames in ticker: %v", err)
+					// Continue ticker loop even if reload fails? Or log and potentially stop?
+					continue // Continue for now
 				}
 				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
+				// TODO: Implement graceful shutdown using context cancellation
 				// case <-ctx.Done():
 				//  log.Println("Stopping Last.fm listening tracker.")
 				//	ticker.Stop()
···
 // 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))
+	var wg sync.WaitGroup                             // Use WaitGroup to fetch concurrently (optional)
+	fetchErrors := make(chan error, len(l.Usernames)) // Channel for errors
+
 	for _, username := range l.Usernames {
 		if ctx.Err() != nil {
-			log.Printf("Context cancelled during fetch cycle for user %s.", username)
-			return
+			log.Printf("Context cancelled before starting fetch for user %s.", username)
+			break // Exit loop if context is cancelled
+		}
+
+		wg.Add(1)
+		go func(uname string) { // Launch fetch and process in a goroutine per user
+			defer wg.Done()
+			if ctx.Err() != nil {
+				log.Printf("Context cancelled during fetch cycle for user %s.", uname)
+				return // Exit goroutine if context is cancelled
+			}
+
+			// Fetch slightly more than 1 track to better handle edge cases
+			// where the latest is 'now playing' or duplicates exist.
+			const fetchLimit = 5
+			recentTracks, err := l.getRecentTracks(ctx, uname, fetchLimit)
+			if err != nil {
+				log.Printf("Error fetching tracks for %s: %v", uname, err)
+				fetchErrors <- fmt.Errorf("fetch failed for %s: %w", uname, err) // Report error
+				return
+			}
+
+			if recentTracks == nil || len(recentTracks.RecentTracks.Tracks) == 0 {
+				log.Printf("No tracks returned for user %s", uname)
+				return
+			}
+
+			// Process the fetched tracks
+			if err := l.processTracks(uname, recentTracks.RecentTracks.Tracks); err != nil {
+				log.Printf("Error processing tracks for %s: %v", uname, err)
+				fetchErrors <- fmt.Errorf("process failed for %s: %w", uname, err) // Report error
+			}
+		}(username)
+	}
+
+	wg.Wait()          // Wait for all goroutines to complete
+	close(fetchErrors) // Close the error channel
+
+	// Log any errors that occurred during the fetch cycle
+	errorCount := 0
+	for err := range fetchErrors {
+		log.Printf("Fetch cycle error: %v", err)
+		errorCount++
+	}
+
+	if errorCount > 0 {
+		log.Printf("Finished fetch cycle with %d errors.", errorCount)
+	} else {
+		log.Println("Finished fetch cycle successfully.")
+	}
+}
+
+// processTracks processes the fetched tracks for a user, adding new scrobbles to the DB.
+func (l *LastFMService) processTracks(username string, tracks []Track) error {
+	if l.db == nil {
+		return fmt.Errorf("database connection is nil")
+	}
+
+	// get uid
+	user, err := l.db.GetUserByLastFM(username)
+	if err != nil {
+		return fmt.Errorf("failed to get user ID for %s: %w", username, err)
+	}
+
+	lastKnownTimestamp, err := l.db.GetLastScrobbleTimestamp(user.ID) // Hypothetical DB call
+	if err != nil {
+		return fmt.Errorf("failed to get last scrobble timestamp for %s: %w", username, err)
+	}
+
+	found := lastKnownTimestamp == nil
+	if found {
+		log.Printf("No previous scrobble timestamp found for user %s. Processing latest track.", username)
+	} else {
+		log.Printf("Last known scrobble for %s was at %s", username, lastKnownTimestamp.Format(time.RFC3339))
+	}
+
+	processedCount := 0
+	var latestProcessedTime time.Time
+
+	for i := len(tracks) - 1; i >= 0; i-- {
+		track := tracks[i]
+
+		// skip now playing
+		if track.NowPlaying != nil && track.NowPlaying.NowPlaying == "true" {
+			log.Printf("Skipping 'now playing' track for %s: %s - %s", username, track.Artist.Text, track.Name)
+			continue
 		}
-		recentTracks, err := l.getRecentTracks(ctx, username, defaultLimit)
+
+		// skip tracks w/out valid date (should be none, but just in case)
+		if track.Date == nil || track.Date.UTS == "" {
+			log.Printf("Skipping track without timestamp for %s: %s - %s", username, track.Artist.Text, track.Name)
+			continue
+		}
+
+		// parse uts (unix timestamp string)
+		uts, err := strconv.ParseInt(track.Date.UTS, 10, 64)
 		if err != nil {
-			log.Printf("Error fetching tracks for %s: %v", username, err)
+			log.Printf("Error parsing timestamp '%s' for track %s - %s: %v", track.Date.UTS, track.Artist.Text, track.Name, err)
 			continue
 		}
+		trackTime := time.Unix(uts, 0)
 
-		// 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)
+		if lastKnownTimestamp != nil && !trackTime.After(*lastKnownTimestamp) {
+			if processedCount == 0 {
+				log.Printf("Reached already known scrobbles for user %s (Track time: %s, Last known: %s).",
+					username,
+					trackTime.Format(time.RFC3339),
+					lastKnownTimestamp.UTC().Format(time.RFC3339))
+			}
+			break
+		}
 
+		unhydratedArtist := []models.Artist{
+			{
+				Name: track.Artist.Text,
+				MBID: track.Artist.MBID,
+			},
+		}
+
+		mTrack := models.Track{
+			Name:           track.Name,
+			URL:            track.URL,
+			ServiceBaseUrl: "last.fm",
+			Album:          track.Album.Text,
+			Timestamp:      time.Unix(uts, 0),
+			Artist:         unhydratedArtist,
+		}
+
+		// Fix based on diagnostic: Assume HydrateTrack returns (*models.Track, error)
+		hydratedTrackPtr, err := musicbrainz.HydrateTrack(l.musicBrainzService, mTrack)
+		if err != nil {
+			// Log hydration error specifically
+			log.Printf("Error hydrating track details for user %s, track %s - %s: %v", username, track.Artist.Text, track.Name, err)
+			// fallback to original track if hydration fails
+			hydratedTrackPtr = &mTrack
+			continue
+		}
+
+		l.db.SaveTrack(user.ID, hydratedTrackPtr)
+
+		processedCount++
+
+		if trackTime.After(latestProcessedTime) {
+			latestProcessedTime = trackTime
+		}
+
+		if found {
+			break
+		}
 	}
-	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?
-// }
+	if processedCount > 0 {
+		log.Printf("Successfully processed %d new track(s) for user %s. Latest timestamp in batch: %s",
+			processedCount, username, latestProcessedTime.Format(time.RFC3339))
+	}
+
+	return nil
+}

service/musicbrainz/musicbrainz.go

···
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
 	"net/http"
···
 	"time"
 
 	"github.com/teal-fm/piper/db"
+	"github.com/teal-fm/piper/models"
 	"golang.org/x/time/rate"
 )
 
···
 	r := releases[0]
 	return &r
 }
+
+func HydrateTrack(mb *MusicBrainzService, 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 := SearchParams{
+		Track:   track.Name,
+		Artist:  strings.Join(artistArray, ", "),
+		Release: track.Album,
+	}
+	res, err := 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 := 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
+}

service/spotify/spotify.go

···
 package spotify
 
 import (
-	"context"
-	"encoding/base64" // Added for Basic Auth
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
-	"net/url" // Added for request body
-
-	// "strconv" // Removed unused import
-	"strings" // Added for request body
+	"net/url"
+	"strings"
 	"sync"
 	"time"
 
-	"github.com/spf13/viper" // Added for config access
+	"github.com/spf13/viper"
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/models"
 	"github.com/teal-fm/piper/oauth/atproto"
···
 			// for now log and continue
 			log.Printf("Error updating user token for user ID %d: %v", user.ID, err)
 		} else {
-			log.Printf("Updated token for existing user: %s (ID: %d)", user.Username, user.ID)
+			log.Printf("Updated token for existing user: %s (ID: %d)", *user.Username, user.ID)
 		}
 	}
 	user.AccessToken = &token
···
 	s.userTokens[user.ID] = token
 	s.mu.Unlock()
 
-	log.Printf("User authenticated via Spotify: %s (ID: %d)", user.Username, user.ID)
+	log.Printf("User authenticated via Spotify: %s (ID: %d)", *user.Username, user.ID)
 	return user.ID, nil
 }
 
···
 
 				track.PlayID = id
 
-				// Update in memory
 				s.mu.Lock()
 				s.userTracks[userID] = track
 				s.mu.Unlock()
···
 		}
 	}
 }
-
-// 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
-}

session/session.go

···
 	"context"
 	"crypto/rand"
 	"encoding/base64"
+	"encoding/json"
+	"fmt"
 	"log"
 	"net/http"
 	"sync"
···
 	mu        sync.RWMutex
 }
 
-func NewSessionManager() *SessionManager {
-	database, err := db.New("./data/piper.db")
-	if err != nil {
-		log.Printf("Error connecting to database for sessions, falling back to in memory only: %v", err)
-		// back up to in memory only
-		return &SessionManager{
-			sessions: make(map[string]*Session),
-		}
-	}
+func NewSessionManager(database *db.DB) *SessionManager {
 
-	_, err = database.Exec(`
+	_, err := database.Exec(`
 	CREATE TABLE IF NOT EXISTS sessions (
 		id TEXT PRIMARY KEY,
 		user_id INTEGER NOT NULL,
···
 
 		handler(w, r)
 	}
+}
+
+func (sm *SessionManager) HandleDebug(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	userID, ok := GetUserID(ctx)
+	if !ok {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusUnauthorized)
+		w.Write([]byte(`{"error": "User ID not found in context"}`))
+		return
+	}
+
+	res, err := sm.db.DebugViewUserInformation(userID)
+	if err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte(fmt.Sprintf(`{"error": "Failed to retrieve user information: %v"}`, err)))
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(res)
 }
 
 type contextKey int