#9 Changed the term game to soundtrack everywhere

internal/backend/music.go

@@ -12,8 +12,8 @@ import (
 )
 
 type SongInfo struct {
-	Game             string `json:"Game"`
-	GamePlayed       int32  `json:"GamePlayed"`
+	Soundtrack       string `json:"Soundtrack"`
+	SoundtrackPlayed int32  `json:"SoundtrackPlayed"`
 	Song             string `json:"Song"`
 	SongPlayed       int32  `json:"SongPlayed"`
 	CurrentlyPlaying bool   `json:"CurrentlyPlaying"`
@@ -22,7 +22,7 @@ type SongInfo struct {
 
 var currentSong = -1
 
-var gamesNew []repository.Soundtrack
+var soundtracksNew []repository.Soundtrack
 
 var songQueNew []repository.Song
 
@@ -37,12 +37,12 @@ func initRepo() {
 	}
 }
 
-func getAllGames() []repository.Soundtrack {
-	if len(gamesNew) == 0 {
+func getAllSoundtracks() []repository.Soundtrack {
+	if len(soundtracksNew) == 0 {
 		initRepo()
-		gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
+		soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 	}
-	return gamesNew
+	return soundtracksNew
 
 }
 
@@ -59,7 +59,7 @@ func Reset() {
 	songQueNew = nil
 	currentSong = -1
 	initRepo()
-	gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
+	soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 }
 
 func AddLatestToQue() {
@@ -92,34 +92,34 @@ func SetPlayed(songNumber int) {
 }
 
 func GetRandomSong() string {
-	getAllGames()
-	if len(gamesNew) == 0 {
+	getAllSoundtracks()
+	if len(soundtracksNew) == 0 {
 		return ""
 	}
 
-	song := getSongFromList(gamesNew)
+	song := getSongFromList(soundtracksNew)
 	lastFetchedNew = song
 	return song.Path
 }
 
 func GetRandomSongLowChance() string {
-	getAllGames()
+	getAllSoundtracks()
 
-	var listOfGames []repository.Soundtrack
+	var listOfSoundtracks []repository.Soundtrack
 
 	var averagePlayed = getAveragePlayed()
 
-	for _, data := range gamesNew {
+	for _, data := range soundtracksNew {
 		timesToAdd := averagePlayed - data.TimesPlayed
 		if timesToAdd <= 0 {
-			listOfGames = append(listOfGames, data)
+			listOfSoundtracks = append(listOfSoundtracks, data)
 		} else {
 			for i := int32(0); i < timesToAdd; i++ {
-				listOfGames = append(listOfGames, data)
+				listOfSoundtracks = append(listOfSoundtracks, data)
 			}
 		}
 	}
-	song := getSongFromList(listOfGames)
+	song := getSongFromList(listOfSoundtracks)
 
 	lastFetchedNew = song
 	return song.Path
@@ -127,11 +127,11 @@ func GetRandomSongLowChance() string {
 }
 
 func GetRandomSongClassic() string {
-	getAllGames()
+	getAllSoundtracks()
 
 	var listOfAllSongs []repository.Song
-	for _, game := range gamesNew {
-		songList, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID)
+	for _, soundtrack := range soundtracksNew {
+		songList, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), soundtrack.ID)
 		listOfAllSongs = append(listOfAllSongs, songList...)
 	}
 
@@ -139,25 +139,25 @@ func GetRandomSongClassic() string {
 	var song repository.Song
 	for !songFound {
 		song = listOfAllSongs[rand.Intn(len(listOfAllSongs))]
-		gameData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID)
+		soundtrackData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID)
 
 		if err != nil {
 			BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", gameData.SoundtrackName),
+				zap.String("soundtrack", soundtrackData.SoundtrackName),
 				zap.String("filename", *song.FileName))
 			continue
 		}
 
 		//Check if file exists and open
 		openFile, err := os.Open(song.Path)
-		if err != nil || (song.FileName != nil && gameData.Path+*song.FileName != song.Path) {
+		if err != nil || (song.FileName != nil && soundtrackData.Path+*song.FileName != song.Path) {
 			//File not found
 			BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", gameData.SoundtrackName),
+				zap.String("soundtrack", soundtrackData.SoundtrackName),
 				zap.String("filename", *song.FileName))
 		} else {
 			songFound = true
@@ -177,11 +177,11 @@ func GetSongInfo() SongInfo {
 	}
 	var currentSongData = songQueNew[currentSong]
 
-	currentGameData := getCurrentGame(currentSongData)
+	currentSoundtrackData := getCurrentSoundtrack(currentSongData)
 
 	return SongInfo{
-		Game:             currentGameData.SoundtrackName,
-		GamePlayed:       currentGameData.TimesPlayed,
+		Soundtrack:       currentSoundtrackData.SoundtrackName,
+		SoundtrackPlayed: currentSoundtrackData.TimesPlayed,
 		Song:             currentSongData.SongName,
 		SongPlayed:       currentSongData.TimesPlayed,
 		CurrentlyPlaying: true,
@@ -193,10 +193,10 @@ func GetPlayedSongs() []SongInfo {
 	var songList []SongInfo
 
 	for i, song := range songQueNew {
-		gameData := getCurrentGame(song)
+		soundtrackData := getCurrentSoundtrack(song)
 		songList = append(songList, SongInfo{
-			Game:             gameData.SoundtrackName,
-			GamePlayed:       gameData.TimesPlayed,
+			Soundtrack:       soundtrackData.SoundtrackName,
+			SoundtrackPlayed: soundtrackData.TimesPlayed,
 			Song:             song.SongName,
 			SongPlayed:       song.TimesPlayed,
 			CurrentlyPlaying: i == currentSong,
@@ -218,21 +218,21 @@ func GetSong(song string) string {
 }
 
 func GetAllSoundtracks() []string {
-	getAllGames()
+	getAllSoundtracks()
 
 	var jsonArray []string
-	for _, game := range gamesNew {
-		jsonArray = append(jsonArray, game.SoundtrackName)
+	for _, soundtrack := range soundtracksNew {
+		jsonArray = append(jsonArray, soundtrack.SoundtrackName)
 	}
 	return jsonArray
 }
 
 func GetAllSoundtracksRandom() []string {
-	getAllGames()
+	getAllSoundtracks()
 
 	var jsonArray []string
-	for _, game := range gamesNew {
-		jsonArray = append(jsonArray, game.SoundtrackName)
+	for _, soundtrack := range soundtracksNew {
+		jsonArray = append(jsonArray, soundtrack.SoundtrackName)
 	}
 	rand.Shuffle(len(jsonArray), func(i, j int) { jsonArray[i], jsonArray[j] = jsonArray[j], jsonArray[i] })
 	return jsonArray
@@ -266,12 +266,12 @@ func GetPreviousSong() string {
 	}
 }
 
-func getSongFromList(games []repository.Soundtrack) repository.Song {
+func getSongFromList(soundtracks []repository.Soundtrack) repository.Song {
 	songFound := false
 	var song repository.Song
 	for !songFound {
-		game := getRandomGame(games)
-		songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID)
+		soundtrack := getRandomSoundtrack(soundtracks)
+		songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), soundtrack.ID)
 		if len(songs) == 0 {
 			continue
 		}
@@ -280,12 +280,12 @@ func getSongFromList(games []repository.Soundtrack) repository.Song {
 
 		//Check if file exists and open
 		openFile, err := os.Open(song.Path)
-		if err != nil || (song.FileName != nil && game.Path+*song.FileName != song.Path) || (song.FileName != nil && strings.HasSuffix(*song.FileName, ".wav")) {
+		if err != nil || (song.FileName != nil && soundtrack.Path+*song.FileName != song.Path) || (song.FileName != nil && strings.HasSuffix(*song.FileName, ".wav")) {
 			//File not found
 			BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", game.SoundtrackName),
+				zap.String("soundtrack", soundtrack.SoundtrackName),
 				zap.Any("filename", song.FileName))
 		} else {
 			songFound = true
@@ -299,24 +299,24 @@ func getSongFromList(games []repository.Soundtrack) repository.Song {
 	return song
 }
 
-func getCurrentGame(currentSongData repository.Song) repository.Soundtrack {
-	for _, game := range gamesNew {
-		if game.ID == currentSongData.SoundtrackID {
-			return game
+func getCurrentSoundtrack(currentSongData repository.Song) repository.Soundtrack {
+	for _, soundtrack := range soundtracksNew {
+		if soundtrack.ID == currentSongData.SoundtrackID {
+			return soundtrack
 		}
 	}
 	return repository.Soundtrack{}
 }
 
 func getAveragePlayed() int32 {
-	getAllGames()
+	getAllSoundtracks()
 	var sum int32
-	for _, data := range gamesNew {
+	for _, data := range soundtracksNew {
 		sum += data.TimesPlayed
 	}
-	return sum / int32(len(gamesNew))
+	return sum / int32(len(soundtracksNew))
 }
 
-func getRandomGame(listOfGames []repository.Soundtrack) repository.Soundtrack {
-	return listOfGames[rand.Intn(len(listOfGames))]
+func getRandomSoundtrack(listOfSoundtracks []repository.Soundtrack) repository.Soundtrack {
+	return listOfSoundtracks[rand.Intn(len(listOfSoundtracks))]
 }

internal/backend/music_test.go

@@ -9,17 +9,17 @@ import (
 
 // Test the average calculation logic directly without database access
 func TestCalculateAverage(t *testing.T) {
-	games := []repository.Soundtrack{
-		{SoundtrackName: "Game1", TimesPlayed: 10},
-		{SoundtrackName: "Game2", TimesPlayed: 20},
-		{SoundtrackName: "Game3", TimesPlayed: 30},
+	soundtracks := []repository.Soundtrack{
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	var sum int32
-	for _, data := range games {
+	for _, data := range soundtracks {
 		sum += data.TimesPlayed
 	}
-	result := sum / int32(len(games))
+	result := sum / int32(len(soundtracks))
 	expected := int32(20)
 
 	if result != expected {
@@ -28,9 +28,9 @@ func TestCalculateAverage(t *testing.T) {
 }
 
 func TestCalculateAverageEmpty(t *testing.T) {
-	games := []repository.Soundtrack{}
+	soundtracks := []repository.Soundtrack{}
 
-	if len(games) == 0 {
+	if len(soundtracks) == 0 {
 		result := int32(0)
 		expected := int32(0)
 		if result != expected {
@@ -40,10 +40,10 @@ func TestCalculateAverageEmpty(t *testing.T) {
 	}
 
 	var sum int32
-	for _, data := range games {
+	for _, data := range soundtracks {
 		sum += data.TimesPlayed
 	}
-	result := sum / int32(len(games))
+	result := sum / int32(len(soundtracks))
 	expected := int32(0)
 
 	if result != expected {
@@ -52,107 +52,107 @@ func TestCalculateAverageEmpty(t *testing.T) {
 }
 
 func TestCalculateAverageSingle(t *testing.T) {
-	games := []repository.Soundtrack{
-		{SoundtrackName: "Game1", TimesPlayed: 42},
+	soundtracks := []repository.Soundtrack{
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 42},
 	}
 
 	var sum int32
-	for _, data := range games {
+	for _, data := range soundtracks {
 		sum += data.TimesPlayed
 	}
-	result := sum / int32(len(games))
+	result := sum / int32(len(soundtracks))
 	expected := int32(42)
 
 	if result != expected {
-		t.Errorf("Average calculation with single game = %v, want %v", result, expected)
+		t.Errorf("Average calculation with single soundtrack = %v, want %v", result, expected)
 	}
 }
 
-func TestGetRandomGame(t *testing.T) {
-	games := []repository.Soundtrack{
-		{SoundtrackName: "Game1", TimesPlayed: 10},
-		{SoundtrackName: "Game2", TimesPlayed: 20},
-		{SoundtrackName: "Game3", TimesPlayed: 30},
+func TestGetRandomSoundtrack(t *testing.T) {
+	soundtracks := []repository.Soundtrack{
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	// Set seed for reproducible tests
 	rand.Seed(42)
 
-	result := games[rand.Intn(len(games))]
+	result := soundtracks[rand.Intn(len(soundtracks))]
 
 	if result.SoundtrackName == "" {
-		t.Error("random game selection returned empty game")
+		t.Error("random soundtrack selection returned empty soundtrack")
 	}
 
 	found := false
-	for _, g := range games {
-		if g.SoundtrackName == result.SoundtrackName {
+	for _, s := range soundtracks {
+		if s.SoundtrackName == result.SoundtrackName {
 			found = true
 			break
 		}
 	}
 
 	if !found {
-		t.Errorf("random game selection returned game not in list: %v", result.SoundtrackName)
+		t.Errorf("random soundtrack selection returned soundtrack not in list: %v", result.SoundtrackName)
 	}
 }
 
-func TestFindGameByID(t *testing.T) {
-	games := []repository.Soundtrack{
-		{ID: 1, SoundtrackName: "Game1", TimesPlayed: 10},
-		{ID: 2, SoundtrackName: "Game2", TimesPlayed: 20},
-		{ID: 3, SoundtrackName: "Game3", TimesPlayed: 30},
+func TestFindSoundtrackByID(t *testing.T) {
+	soundtracks := []repository.Soundtrack{
+		{ID: 1, SoundtrackName: "Soundtrack1", TimesPlayed: 10},
+		{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
+		{ID: 3, SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	tests := []struct {
-		name     string
-		games    []repository.Soundtrack
-		gameID   int32
-		expected repository.Soundtrack
+		name         string
+		soundtracks  []repository.Soundtrack
+		soundtrackID int32
+		expected     repository.Soundtrack
 	}{
 		{
-			name:     "existing game",
-			games:    games,
-			gameID:   2,
-			expected: repository.Soundtrack{ID: 2, SoundtrackName: "Game2", TimesPlayed: 20},
+			name:         "existing soundtrack",
+			soundtracks:  soundtracks,
+			soundtrackID: 2,
+			expected:     repository.Soundtrack{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
 		},
 		{
-			name:     "non-existing game",
-			games:    games,
-			gameID:   99,
-			expected: repository.Soundtrack{},
+			name:         "non-existing soundtrack",
+			soundtracks:  soundtracks,
+			soundtrackID: 99,
+			expected:     repository.Soundtrack{},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var result repository.Soundtrack
-			for _, game := range tt.games {
-				if game.ID == tt.gameID {
-					result = game
+			for _, s := range tt.soundtracks {
+				if s.ID == tt.soundtrackID {
+					result = s
 					break
 				}
 			}
 			if result.ID != tt.expected.ID || result.SoundtrackName != tt.expected.SoundtrackName {
-				t.Errorf("findGameByID() = %v, want %v", result, tt.expected)
+				t.Errorf("findSoundtrackByID() = %v, want %v", result, tt.expected)
 			}
 		})
 	}
 }
 
 func TestExtractSoundtrackNames(t *testing.T) {
-	games := []repository.Soundtrack{
-		{SoundtrackName: "Game1", TimesPlayed: 10},
-		{SoundtrackName: "Game2", TimesPlayed: 20},
-		{SoundtrackName: "Game3", TimesPlayed: 30},
+	soundtracks := []repository.Soundtrack{
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	var result []string
-	for _, game := range games {
-		result = append(result, game.SoundtrackName)
+	for _, s := range soundtracks {
+		result = append(result, s.SoundtrackName)
 	}
 
-	expected := []string{"Game1", "Game2", "Game3"}
+	expected := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
 
 	if len(result) != len(expected) {
 		t.Errorf("extractSoundtrackNames() length = %d, want %d", len(result), len(expected))
@@ -167,29 +167,29 @@ func TestExtractSoundtrackNames(t *testing.T) {
 }
 
 func TestShuffleSoundtrackNames(t *testing.T) {
-	games := []string{"Game1", "Game2", "Game3"}
+	soundtracks := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
 
 	// Test that shuffle doesn't lose any elements
 	// We can't test the order since it's random, but we can test length and contents
-	original := make([]string, len(games))
-	copy(original, games)
+	original := make([]string, len(soundtracks))
+	copy(original, soundtracks)
 
 	// Simple shuffle implementation for testing
-	for i := range games {
+	for i := range soundtracks {
 		j := i // In real code this would be random
-		games[i], games[j] = games[j], games[i]
+		soundtracks[i], soundtracks[j] = soundtracks[j], soundtracks[i]
 	}
 
-	if len(games) != len(original) {
-		t.Errorf("shuffleSoundtrackNames() changed length from %d to %d", len(original), len(games))
+	if len(soundtracks) != len(original) {
+		t.Errorf("shuffleSoundtrackNames() changed length from %d to %d", len(original), len(soundtracks))
 		return
 	}
 
 	// Check all original elements are still present
 	for _, orig := range original {
 		found := false
-		for _, g := range games {
-			if g == orig {
+		for _, s := range soundtracks {
+			if s == orig {
 				found = true
 				break
 			}

internal/backend/statistics.go

@@ -9,34 +9,34 @@ import (
 	"go.uber.org/zap"
 )
 
-// GameWithSongs represents a game with its songs for statistics
-type GameWithSongs struct {
-	SoundtrackID        int32     `json:"game_id"`
-	SoundtrackName      string    `json:"game_name"`
-	SoundtrackPlayed    int32     `json:"game_played"`
-	SoundtrackLastPlayed *time.Time `json:"game_last_played,omitempty"`
-	Songs        []SongInfoForStats `json:"songs"`
+// SoundtrackWithSongs represents a soundtrack with its songs for statistics
+type SoundtrackWithSongs struct {
+	SoundtrackID         int32              `json:"soundtrack_id"`
+	SoundtrackName       string             `json:"soundtrack_name"`
+	SoundtrackPlayed     int32              `json:"soundtrack_played"`
+	SoundtrackLastPlayed *time.Time         `json:"soundtrack_last_played,omitempty"`
+	Songs                []SongInfoForStats `json:"songs"`
 }
 
-// SongInfoForStats represents a song with game info for statistics
+// SongInfoForStats represents a song with soundtrack info for statistics
 type SongInfoForStats struct {
-	SoundtrackID      int32     `json:"game_id"`
-	SoundtrackName    string    `json:"game_name"`
-	SongName    string    `json:"song_name"`
-	Path        string    `json:"path"`
-	TimesPlayed int32     `json:"times_played"`
-	FileName    *string   `json:"file_name,omitempty"`
+	SoundtrackID   int32   `json:"soundtrack_id"`
+	SoundtrackName string  `json:"soundtrack_name"`
+	SongName       string  `json:"song_name"`
+	Path           string  `json:"path"`
+	TimesPlayed    int32   `json:"times_played"`
+	FileName       *string `json:"file_name,omitempty"`
 }
 
 // StatisticsSummary holds overall statistics
 type StatisticsSummary struct {
-	TotalGames        int64   `json:"total_games"`
-	PlayedGames       int64   `json:"played_games"`
-	NeverPlayedGames  int64   `json:"never_played_games"`
-	TotalGamePlays    int64   `json:"total_game_plays"`
-	AvgGamePlays      float64 `json:"avg_game_plays"`
-	MaxGamePlays      int64   `json:"max_game_plays"`
-	MinGamePlays      int64   `json:"min_game_plays"`
+	TotalSoundtracks       int64   `json:"total_soundtracks"`
+	PlayedSoundtracks      int64   `json:"played_soundtracks"`
+	NeverPlayedSoundtracks int64   `json:"never_played_soundtracks"`
+	TotalSoundtrackPlays   int64   `json:"total_soundtrack_plays"`
+	AvgSoundtrackPlays     float64 `json:"avg_soundtrack_plays"`
+	MaxSoundtrackPlays     int64   `json:"max_soundtrack_plays"`
+	MinSoundtrackPlays     int64   `json:"min_soundtrack_plays"`
 }
 
 // StatisticsHandler manages statistics operations
@@ -49,19 +49,19 @@ func NewStatisticsHandler() *StatisticsHandler {
 	return &StatisticsHandler{}
 }
 
-// GetMostPlayedGamesWithSongs returns the top N most played games with their songs
-func (h *StatisticsHandler) GetMostPlayedGamesWithSongs(limit int32) ([]GameWithSongs, error) {
+// GetMostPlayedSoundtracksWithSongs returns the top N most played soundtracks with their songs
+func (h *StatisticsHandler) GetMostPlayedSoundtracksWithSongs(limit int32) ([]SoundtrackWithSongs, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
+
 	// Get raw results
-	rows, err := queries.GetMostPlayedGamesWithSongs(ctx, limit)
+	rows, err := queries.GetMostPlayedSoundtracksWithSongs(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
-	// Convert to GameWithSongs
-	var result []GameWithSongs
+
+	// Convert to SoundtrackWithSongs
+	var result []SoundtrackWithSongs
 	for _, row := range rows {
 		var songs []SongInfoForStats
 		if row.Songs != nil {
@@ -71,28 +71,28 @@ func (h *StatisticsHandler) GetMostPlayedGamesWithSongs(limit int32) ([]GameWith
 				songs = make([]SongInfoForStats, 0)
 			}
 		}
-		result = append(result, GameWithSongs{
-			SoundtrackID:        row.SoundtrackID,
-			SoundtrackName:      row.SoundtrackName,
-			SoundtrackPlayed:    row.SoundtrackPlayed,
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
 			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
-			Songs:         songs,
+			Songs:                songs,
 		})
 	}
 	return result, nil
 }
 
-// GetLeastPlayedGamesWithSongs returns the top N least played games with their songs
-func (h *StatisticsHandler) GetLeastPlayedGamesWithSongs(limit int32) ([]GameWithSongs, error) {
+// GetLeastPlayedSoundtracksWithSongs returns the top N least played soundtracks with their songs
+func (h *StatisticsHandler) GetLeastPlayedSoundtracksWithSongs(limit int32) ([]SoundtrackWithSongs, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetLeastPlayedGamesWithSongs(ctx, limit)
+
+	rows, err := queries.GetLeastPlayedSoundtracksWithSongs(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
-	var result []GameWithSongs
+
+	var result []SoundtrackWithSongs
 	for _, row := range rows {
 		var songs []SongInfoForStats
 		if row.Songs != nil {
@@ -100,76 +100,76 @@ func (h *StatisticsHandler) GetLeastPlayedGamesWithSongs(limit int32) ([]GameWit
 				songs = make([]SongInfoForStats, 0)
 			}
 		}
-		result = append(result, GameWithSongs{
-			SoundtrackID:        row.SoundtrackID,
-			SoundtrackName:      row.SoundtrackName,
-			SoundtrackPlayed:    row.SoundtrackPlayed,
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
 			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
-			Songs:         songs,
+			Songs:                songs,
 		})
 	}
 	return result, nil
 }
 
-// GetMostPlayedSongsWithGame returns the top N most played songs with their game info
-func (h *StatisticsHandler) GetMostPlayedSongsWithGame(limit int32) ([]SongInfoForStats, error) {
+// GetMostPlayedSongsWithSoundtrack returns the top N most played songs with their soundtrack info
+func (h *StatisticsHandler) GetMostPlayedSongsWithSoundtrack(limit int32) ([]SongInfoForStats, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetMostPlayedSongsWithGame(ctx, limit)
+
+	rows, err := queries.GetMostPlayedSongsWithSoundtrack(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
+
 	var result []SongInfoForStats
 	for _, row := range rows {
 		result = append(result, SongInfoForStats{
-			SoundtrackID:      row.SoundtrackID,
-			SoundtrackName:    row.SoundtrackName,
-			SongName:    row.SongName,
-			Path:        row.Path,
-			TimesPlayed: row.TimesPlayed,
-			FileName:    row.FileName,
+			SoundtrackID:   row.SoundtrackID,
+			SoundtrackName: row.SoundtrackName,
+			SongName:       row.SongName,
+			Path:           row.Path,
+			TimesPlayed:    row.TimesPlayed,
+			FileName:       row.FileName,
 		})
 	}
 	return result, nil
 }
 
-// GetLeastPlayedSongsWithGame returns the top N least played songs with their game info
-func (h *StatisticsHandler) GetLeastPlayedSongsWithGame(limit int32) ([]SongInfoForStats, error) {
+// GetLeastPlayedSongsWithSoundtrack returns the top N least played songs with their soundtrack info
+func (h *StatisticsHandler) GetLeastPlayedSongsWithSoundtrack(limit int32) ([]SongInfoForStats, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetLeastPlayedSongsWithGame(ctx, limit)
+
+	rows, err := queries.GetLeastPlayedSongsWithSoundtrack(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
+
 	var result []SongInfoForStats
 	for _, row := range rows {
 		result = append(result, SongInfoForStats{
-			SoundtrackID:      row.SoundtrackID,
-			SoundtrackName:    row.SoundtrackName,
-			SongName:    row.SongName,
-			Path:        row.Path,
-			TimesPlayed: row.TimesPlayed,
-			FileName:    row.FileName,
+			SoundtrackID:   row.SoundtrackID,
+			SoundtrackName: row.SoundtrackName,
+			SongName:       row.SongName,
+			Path:           row.Path,
+			TimesPlayed:    row.TimesPlayed,
+			FileName:       row.FileName,
 		})
 	}
 	return result, nil
 }
 
-// GetNeverPlayedGames returns games that have never been played
-func (h *StatisticsHandler) GetNeverPlayedGames() ([]GameWithSongs, error) {
+// GetNeverPlayedSoundtracks returns soundtracks that have never been played
+func (h *StatisticsHandler) GetNeverPlayedSoundtracks() ([]SoundtrackWithSongs, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetNeverPlayedGames(ctx)
+
+	rows, err := queries.GetNeverPlayedSoundtracks(ctx)
 	if err != nil {
 		return nil, err
 	}
-	
-	var result []GameWithSongs
+
+	var result []SoundtrackWithSongs
 	for _, row := range rows {
 		var songs []SongInfoForStats
 		if row.Songs != nil {
@@ -177,28 +177,28 @@ func (h *StatisticsHandler) GetNeverPlayedGames() ([]GameWithSongs, error) {
 				songs = make([]SongInfoForStats, 0)
 			}
 		}
-		result = append(result, GameWithSongs{
-			SoundtrackID:        row.SoundtrackID,
-			SoundtrackName:      row.SoundtrackName,
-			SoundtrackPlayed:    row.SoundtrackPlayed,
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
 			SoundtrackLastPlayed: nil,
-			Songs:         songs,
+			Songs:                songs,
 		})
 	}
 	return result, nil
 }
 
-// GetLastPlayedGames returns the most recently played games
-func (h *StatisticsHandler) GetLastPlayedGames(limit int32) ([]GameWithSongs, error) {
+// GetLastPlayedSoundtracks returns the most recently played soundtracks
+func (h *StatisticsHandler) GetLastPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetLastPlayedGames(ctx, limit)
+
+	rows, err := queries.GetLastPlayedSoundtracks(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
-	var result []GameWithSongs
+
+	var result []SoundtrackWithSongs
 	for _, row := range rows {
 		var songs []SongInfoForStats
 		if row.Songs != nil {
@@ -206,28 +206,28 @@ func (h *StatisticsHandler) GetLastPlayedGames(limit int32) ([]GameWithSongs, er
 				songs = make([]SongInfoForStats, 0)
 			}
 		}
-		result = append(result, GameWithSongs{
-			SoundtrackID:        row.SoundtrackID,
-			SoundtrackName:      row.SoundtrackName,
-			SoundtrackPlayed:    row.SoundtrackPlayed,
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
 			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
-			Songs:         songs,
+			Songs:                songs,
 		})
 	}
 	return result, nil
 }
 
-// GetOldestPlayedGames returns the least recently played games
-func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs, error) {
+// GetOldestPlayedSoundtracks returns the least recently played soundtracks
+func (h *StatisticsHandler) GetOldestPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
-	rows, err := queries.GetOldestPlayedGames(ctx, limit)
+
+	rows, err := queries.GetOldestPlayedSoundtracks(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
-	
-	var result []GameWithSongs
+
+	var result []SoundtrackWithSongs
 	for _, row := range rows {
 		var songs []SongInfoForStats
 		if row.Songs != nil {
@@ -235,12 +235,12 @@ func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs,
 				songs = make([]SongInfoForStats, 0)
 			}
 		}
-		result = append(result, GameWithSongs{
-			SoundtrackID:        row.SoundtrackID,
-			SoundtrackName:      row.SoundtrackName,
-			SoundtrackPlayed:    row.SoundtrackPlayed,
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
 			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
-			Songs:         songs,
+			Songs:                songs,
 		})
 	}
 	return result, nil
@@ -250,20 +250,20 @@ func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs,
 func (h *StatisticsHandler) GetStatisticsSummary() (*StatisticsSummary, error) {
 	queries := BackendRepo()
 	ctx := BackendCtx()
-	
+
 	row, err := queries.GetStatisticsSummary(ctx)
 	if err != nil {
 		return nil, err
 	}
-	
+
 	return &StatisticsSummary{
-		TotalGames:       int64(row.TotalSoundtracks),
-		PlayedGames:      int64(row.PlayedSoundtracks),
-		NeverPlayedGames: int64(row.NeverPlayedSoundtracks),
-		TotalGamePlays:   int64(row.TotalSoundtrackPlays),
-		AvgGamePlays:     float64(row.AvgSoundtrackPlays),
-		MaxGamePlays:     int64(row.MaxSoundtrackPlays),
-		MinGamePlays:     int64(row.MinSoundtrackPlays),
+		TotalSoundtracks:       int64(row.TotalSoundtracks),
+		PlayedSoundtracks:      int64(row.PlayedSoundtracks),
+		NeverPlayedSoundtracks: int64(row.NeverPlayedSoundtracks),
+		TotalSoundtrackPlays:   int64(row.TotalSoundtrackPlays),
+		AvgSoundtrackPlays:     float64(row.AvgSoundtrackPlays),
+		MaxSoundtrackPlays:     int64(row.MaxSoundtrackPlays),
+		MinSoundtrackPlays:     int64(row.MinSoundtrackPlays),
 	}, nil
 }
 

internal/backend/sync.go

@@ -30,14 +30,14 @@ var start time.Time
 var totalTime time.Duration
 var timeSpent time.Duration
 
-var allGames []repository.Soundtrack
-var gamesBeforeSync []repository.Soundtrack
-var gamesAfterSync []repository.Soundtrack
-var gamesAdded []string
-var gamesReAdded []string
-var gamesChangedTitle map[string]string
-var gamesChangedContent []string
-var gamesRemoved []string
+var allSoundtracks []repository.Soundtrack
+var soundtracksBeforeSync []repository.Soundtrack
+var soundtracksAfterSync []repository.Soundtrack
+var soundtracksAdded []string
+var soundtracksReAdded []string
+var soundtracksChangedTitle map[string]string
+var soundtracksChangedContent []string
+var soundtracksRemoved []string
 var catchedErrors []string
 
 type brokenSong struct {
@@ -50,13 +50,13 @@ var pool *ants.Pool
 var poolSong *ants.Pool
 
 type SyncResponse struct {
-	GamesAdded          []string          `json:"games_added"`
-	GamesReAdded        []string          `json:"games_re_added"`
-	GamesChangedTitle   map[string]string `json:"games_changed_title"`
-	GamesChangedContent []string          `json:"games_changed_content"`
-	GamesRemoved        []string          `json:"games_removed"`
-	CatchedErrors       []string          `json:"catched_errors"`
-	TotalTime           string            `json:"total_time"`
+	SoundtracksAdded          []string          `json:"soundtracks_added"`
+	SoundtracksReAdded        []string          `json:"soundtracks_re_added"`
+	SoundtracksChangedTitle   map[string]string `json:"soundtracks_changed_title"`
+	SoundtracksChangedContent []string          `json:"soundtracks_changed_content"`
+	SoundtracksRemoved        []string          `json:"soundtracks_removed"`
+	CatchedErrors             []string          `json:"catched_errors"`
+	TotalTime                 string            `json:"total_time"`
 }
 
 type ProgressResponse struct {
@@ -64,24 +64,24 @@ type ProgressResponse struct {
 	TimeSpent string `json:"time_spent"`
 }
 
-type GameStatus int
+type SoundtrackStatus int
 
 const (
-	NotChanged GameStatus = iota
+	NotChanged SoundtrackStatus = iota
 	TitleChanged
-	GameChanged
-	NewGame
+	SoundtrackChanged
+	NewSoundtrack
 )
 
-var statusName = map[GameStatus]string{
-	NotChanged:   "Not changed",
-	TitleChanged: "Title changed",
-	GameChanged:  "Game changed",
-	NewGame:      "New game",
+var statusName = map[SoundtrackStatus]string{
+	NotChanged:        "Not changed",
+	TitleChanged:      "Title changed",
+	SoundtrackChanged: "Soundtrack changed",
+	NewSoundtrack:     "New soundtrack",
 }
 
-func (gs GameStatus) String() string {
-	return statusName[gs]
+func (ss SoundtrackStatus) String() string {
+	return statusName[ss]
 }
 
 func ResetDB() {
@@ -107,54 +107,54 @@ func SyncProgress() ProgressResponse {
 
 func SyncResult() SyncResponse {
 	logging.GetLogger().Info("Sync completed",
-		zap.Int("games_before", len(gamesBeforeSync)),
-		zap.Int("games_after", len(gamesAfterSync)))
+		zap.Int("soundtracks_before", len(soundtracksBeforeSync)),
+		zap.Int("soundtracks_after", len(soundtracksAfterSync)))
 
-	if len(gamesAdded) > 0 {
-		logging.GetLogger().Debug("Games added", zap.Strings("games", gamesAdded))
+	if len(soundtracksAdded) > 0 {
+		logging.GetLogger().Debug("Soundtracks added", zap.Strings("soundtracks", soundtracksAdded))
 	}
 
-	if len(gamesReAdded) > 0 {
-		logging.GetLogger().Debug("Games readded", zap.Strings("games", gamesReAdded))
+	if len(soundtracksReAdded) > 0 {
+		logging.GetLogger().Debug("Soundtracks readded", zap.Strings("soundtracks", soundtracksReAdded))
 	}
 
-	if len(gamesChangedTitle) > 0 {
-		logging.GetLogger().Debug("Games with changed title", zap.Any("changes", gamesChangedTitle))
+	if len(soundtracksChangedTitle) > 0 {
+		logging.GetLogger().Debug("Soundtracks with changed title", zap.Any("changes", soundtracksChangedTitle))
 	}
 
-	if len(gamesChangedContent) > 0 {
-		logging.GetLogger().Debug("Games with changed content", zap.Strings("games", gamesChangedContent))
+	if len(soundtracksChangedContent) > 0 {
+		logging.GetLogger().Debug("Soundtracks with changed content", zap.Strings("soundtracks", soundtracksChangedContent))
 	}
 
-	var gamesRemovedTemp []string
-	for _, beforeGame := range gamesBeforeSync {
+	var soundtracksRemovedTemp []string
+	for _, beforeSoundtrack := range soundtracksBeforeSync {
 		var found = false
-		for _, afterGame := range gamesAfterSync {
-			if beforeGame.SoundtrackName == afterGame.SoundtrackName {
+		for _, afterSoundtrack := range soundtracksAfterSync {
+			if beforeSoundtrack.SoundtrackName == afterSoundtrack.SoundtrackName {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.SoundtrackName)
+			soundtracksRemovedTemp = append(soundtracksRemovedTemp, beforeSoundtrack.SoundtrackName)
 		}
 	}
 
-	for _, game := range gamesRemovedTemp {
+	for _, soundtrack := range soundtracksRemovedTemp {
 		var found bool = false
-		for key := range gamesChangedTitle {
-			if game == key {
+		for key := range soundtracksChangedTitle {
+			if soundtrack == key {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemoved = append(gamesRemoved, game)
+			soundtracksRemoved = append(soundtracksRemoved, soundtrack)
 		}
 	}
 
-	if len(gamesRemoved) > 0 {
-		logging.GetLogger().Debug("Games removed", zap.Strings("games", gamesRemoved))
+	if len(soundtracksRemoved) > 0 {
+		logging.GetLogger().Debug("Soundtracks removed", zap.Strings("soundtracks", soundtracksRemoved))
 	}
 
 	if len(catchedErrors) > 0 {
@@ -165,27 +165,27 @@ func SyncResult() SyncResponse {
 	logging.GetLogger().Info("Sync completed", zap.String("total_time", out.Format("15:04:05.00000")))
 
 	return SyncResponse{
-		GamesAdded:          gamesAdded,
-		GamesReAdded:        gamesReAdded,
-		GamesChangedTitle:   gamesChangedTitle,
-		GamesChangedContent: gamesChangedContent,
-		GamesRemoved:        gamesRemoved,
-		CatchedErrors:       catchedErrors,
-		TotalTime:           out.Format("15:04:05"),
+		SoundtracksAdded:          soundtracksAdded,
+		SoundtracksReAdded:        soundtracksReAdded,
+		SoundtracksChangedTitle:   soundtracksChangedTitle,
+		SoundtracksChangedContent: soundtracksChangedContent,
+		SoundtracksRemoved:        soundtracksRemoved,
+		CatchedErrors:             catchedErrors,
+		TotalTime:                 out.Format("15:04:05"),
 	}
 }
 
 func SyncSoundtracksNewFull() {
-	syncGamesNew(true)
+	syncSoundtracksNew(true)
 	Reset()
 }
 
 func SyncSoundtracksNewOnlyChanges() {
-	syncGamesNew(false)
+	syncSoundtracksNew(false)
 	Reset()
 }
 
-func syncGamesNew(full bool) {
+func syncSoundtracksNew(full bool) {
 	musicPath := os.Getenv("MUSIC_PATH")
 	fmt.Printf("dir: %s\n", musicPath)
 	logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath))
@@ -201,19 +201,19 @@ func syncGamesNew(full bool) {
 	logging.GetLogger().Debug("Folders to skip during sync", zap.Strings("folders", foldersToSkip))
 
 	var err error
-	gamesAdded = nil
-	gamesReAdded = nil
-	gamesChangedTitle = nil
-	gamesChangedContent = nil
-	gamesRemoved = nil
+	soundtracksAdded = nil
+	soundtracksReAdded = nil
+	soundtracksChangedTitle = nil
+	soundtracksChangedContent = nil
+	soundtracksRemoved = nil
 	catchedErrors = nil
 	brokenSongs = nil
 
-	gamesBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
+	soundtracksBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
 	handleError("FindAllSoundtracks Before", err, "")
-	logging.GetLogger().Info("Starting sync", zap.Int("games_before", len(gamesBeforeSync)))
+	logging.GetLogger().Info("Starting sync", zap.Int("soundtracks_before", len(soundtracksBeforeSync)))
 
-	allGames, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
+	allSoundtracks, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
 	handleError("GetAllSoundtracksIncludingDeleted", err, "")
 	err = repo.SetSoundtrackDeletionDate(BackendCtx())
 	handleError("SetSoundtrackDeletionDate", err, "")
@@ -233,13 +233,13 @@ func syncGamesNew(full bool) {
 	for _, dir := range directories {
 		pool.Submit(func() {
 			defer syncWg.Done()
-			syncGameNew(dir, foldersToSkip, musicPath, full)
+			syncSoundtrackNew(dir, foldersToSkip, musicPath, full)
 		})
 	}
 	syncWg.Wait()
 	checkBrokenSongsNew()
 
-	gamesAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
+	soundtracksAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
 	handleError("FindAllSoundtracks After", err, "")
 
 	finished := time.Now()
@@ -286,48 +286,48 @@ func checkBrokenSongNew(song repository.Song) {
 	}
 }
 
-func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
+func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
 	if file.IsDir() && !contains(foldersToSkip, file.Name()) {
-		logging.GetLogger().Debug("Syncing game", zap.String("game", file.Name()))
-		gameDir := baseDir + file.Name() + "/"
-		dirHash := getHashForDir(gameDir)
+		logging.GetLogger().Debug("Syncing soundtrack", zap.String("soundtrack", file.Name()))
+		soundtrackDir := baseDir + file.Name() + "/"
+		dirHash := getHashForDir(soundtrackDir)
 
-		var status GameStatus = NewGame
-		var oldGame repository.Soundtrack
+		var status SoundtrackStatus = NewSoundtrack
+		var oldSoundtrack repository.Soundtrack
 		var id int32 = -1
 
-		//fmt.Printf("Games before: %d\n", len(gamesBeforeSync))
+		//fmt.Printf("Soundtracks before: %d\n", len(soundtracksBeforeSync))
 
-		for _, currentGame := range allGames {
-			oldGame = currentGame
-			//fmt.Printf("%s | %s\n", oldGame.SoundtrackName, oldGame.Hash)
-			if oldGame.SoundtrackName == file.Name() && oldGame.Hash == dirHash {
+		for _, currentSoundtrack := range allSoundtracks {
+			oldSoundtrack = currentSoundtrack
+			//fmt.Printf("%s | %s\n", oldSoundtrack.SoundtrackName, oldSoundtrack.Hash)
+			if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash == dirHash {
 				status = NotChanged
-				id = oldGame.ID
-				//fmt.Printf("Game not changed\n")
+				id = oldSoundtrack.ID
+				//fmt.Printf("Soundtrack not changed\n")
 				break
-			} else if oldGame.SoundtrackName == file.Name() && oldGame.Hash != dirHash {
-				status = GameChanged
-				id = oldGame.ID
-				//fmt.Printf("Game changed\n")
+			} else if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash != dirHash {
+				status = SoundtrackChanged
+				id = oldSoundtrack.ID
+				//fmt.Printf("Soundtrack changed\n")
 				break
-			} else if oldGame.SoundtrackName != file.Name() && oldGame.Hash == dirHash {
+			} else if oldSoundtrack.SoundtrackName != file.Name() && oldSoundtrack.Hash == dirHash {
 				status = TitleChanged
-				id = oldGame.ID
+				id = oldSoundtrack.ID
 				//fmt.Printf("SoundtrackName changed\n")
 				break
 			}
 		}
 
-		if full && status != NewGame {
+		if full && status != NewSoundtrack {
 			status = TitleChanged
 		}
-		entries, err := os.ReadDir(gameDir)
+		entries, err := os.ReadDir(soundtrackDir)
 		if err != nil {
-			logging.GetLogger().Error("Failed to read game directory", zap.String("path", gameDir), zap.String("error", err.Error()))
+			logging.GetLogger().Error("Failed to read soundtrack directory", zap.String("path", soundtrackDir), zap.String("error", err.Error()))
 		}
 		switch status {
-		case NewGame:
+		case NewSoundtrack:
 			if id != -1 {
 				for _, entry := range entries {
 					fileInfo, err := entry.Info()
@@ -340,13 +340,13 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 						break
 					}
 				}
-				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: gameDir, Hash: dirHash})
+				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: soundtrackDir, Hash: dirHash})
 				handleError("InsertSoundtrackWithExistingId", err, "")
 				if err != nil {
-					logging.GetLogger().Debug("Game already exists, removing old ID file",
+					logging.GetLogger().Debug("Soundtrack already exists, removing old ID file",
 						zap.Int32("id", id),
-						zap.String("game_dir", gameDir))
-					fileName := gameDir + "/." + strconv.Itoa(int(id)) + ".id"
+						zap.String("soundtrack_dir", soundtrackDir))
+					fileName := soundtrackDir + "/." + strconv.Itoa(int(id)) + ".id"
 					logging.GetLogger().Debug("Removing ID file", zap.String("filename", fileName))
 
 					err := os.Remove(fileName)
@@ -354,50 +354,50 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 						logging.GetLogger().Error("Failed to remove ID file", zap.String("filename", fileName), zap.String("error", err.Error()))
 					}
 
-					newDirHash := getHashForDir(gameDir)
+					newDirHash := getHashForDir(soundtrackDir)
 
-					id = insertGameNew(file.Name(), gameDir, newDirHash)
+					id = insertSoundtrackNew(file.Name(), soundtrackDir, newDirHash)
 				}
 			} else {
-				id = insertGameNew(file.Name(), gameDir, dirHash)
+				id = insertSoundtrackNew(file.Name(), soundtrackDir, dirHash)
 			}
-			logging.GetLogger().Debug("New game detected",
+			logging.GetLogger().Debug("New soundtrack detected",
 				zap.Int32("id", id),
-				zap.String("game", file.Name()),
+				zap.String("soundtrack", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			gamesAdded = append(gamesAdded, file.Name())
-			newCheckSongs(entries, gameDir, id)
-		case GameChanged:
-			logging.GetLogger().Debug("Game changed",
+			soundtracksAdded = append(soundtracksAdded, file.Name())
+			newCheckSongs(entries, soundtrackDir, id)
+		case SoundtrackChanged:
+			logging.GetLogger().Debug("Soundtrack changed",
 				zap.Int32("id", id),
-				zap.String("game", file.Name()),
+				zap.String("soundtrack", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
 			err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
 			handleError("UpdateSoundtrackHash", err, "")
-			gamesChangedContent = append(gamesChangedContent, file.Name())
-			newCheckSongs(entries, gameDir, id)
+			soundtracksChangedContent = append(soundtracksChangedContent, file.Name())
+			newCheckSongs(entries, soundtrackDir, id)
 		case TitleChanged:
-			logging.GetLogger().Debug("Game title changed",
+			logging.GetLogger().Debug("Soundtrack title changed",
 				zap.Int32("id", id),
-				zap.String("oldName", oldGame.SoundtrackName),
+				zap.String("oldName", oldSoundtrack.SoundtrackName),
 				zap.String("newName", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: gameDir, ID: id})
+			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: soundtrackDir, ID: id})
 			handleError("UpdateSoundtrackName", err, "")
-			newCheckSongs(entries, gameDir, id)
-			if gamesChangedTitle == nil {
-				gamesChangedTitle = make(map[string]string)
+			newCheckSongs(entries, soundtrackDir, id)
+			if soundtracksChangedTitle == nil {
+				soundtracksChangedTitle = make(map[string]string)
 			}
-			gamesChangedTitle[oldGame.SoundtrackName] = file.Name()
+			soundtracksChangedTitle[oldSoundtrack.SoundtrackName] = file.Name()
 		case NotChanged:
 			var found bool = false
-			for _, beforeGame := range gamesBeforeSync {
-				if dirHash == beforeGame.Hash {
+			for _, beforeSoundtrack := range soundtracksBeforeSync {
+				if dirHash == beforeSoundtrack.Hash {
 					found = true
-					logging.GetLogger().Debug("Game not changed",
+					logging.GetLogger().Debug("Soundtrack not changed",
 						zap.Int32("id", id),
 						zap.String("newName", file.Name()),
 						zap.String("hash", dirHash),
@@ -405,9 +405,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 				}
 			}
 			if !found {
-				newCheckSongs(entries, gameDir, id)
-				gamesReAdded = append(gamesReAdded, file.Name())
-				logging.GetLogger().Debug("Game added again",
+				newCheckSongs(entries, soundtrackDir, id)
+				soundtracksReAdded = append(soundtracksReAdded, file.Name())
+				logging.GetLogger().Debug("Soundtrack added again",
 					zap.Int32("id", id),
 					zap.String("newName", file.Name()),
 					zap.String("hash", dirHash),
@@ -415,9 +415,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 
 			}
 		}
-		logging.GetLogger().Debug("Game sync status",
+		logging.GetLogger().Debug("Soundtrack sync status",
 			zap.Int32("id", id),
-			zap.String("game", file.Name()),
+			zap.String("soundtrack", file.Name()),
 			zap.String("hash", dirHash),
 			zap.String("status", status.String()))
 		err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id)
@@ -430,24 +430,24 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 		zap.Int("percent", int((foldersSynced/numberOfFoldersToSync)*100)))
 }
 
-func insertGameNew(name string, path string, hash string) int32 {
+func insertSoundtrackNew(name string, path string, hash string) int32 {
 	var duplicateError = errors.New("ERROR: duplicate key value violates unique")
 	id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash})
 	handleError("InsertSoundtrack", err, "")
 	if err != nil {
 		logging.GetLogger().Warn("ID collision detected, resetting sequence")
 		if strings.HasPrefix(err.Error(), duplicateError.Error()) {
-			logging.GetLogger().Debug("Resetting game ID sequence")
+			logging.GetLogger().Debug("Resetting soundtrack ID sequence")
 			_, err = repo.ResetSoundtrackIdSeq(BackendCtx())
 			handleError("ResetSoundtrackIdSeq", err, "")
-			id = insertGameNew(name, path, hash)
+			id = insertSoundtrackNew(name, path, hash)
 		}
 	}
 	return id
 
 }
 
-func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
+func newCheckSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
 	//hasher := md5.New()
 	var numberOfSongs int32
 	numberOfFiles := len(entries)
@@ -457,7 +457,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
 	for _, entry := range entries {
 		poolSong.Submit(func() {
 			defer songWg.Done()
-			if newCheckSong(entry, gameDir, id) {
+			if newCheckSong(entry, soundtrackDir, id) {
 				numberOfSongs++
 			}
 		})
@@ -466,7 +466,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
 	return numberOfSongs
 }
 
-func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
+func newCheckSong(entry os.DirEntry, soundtrackDir string, id int32) bool {
 	fileInfo, err := entry.Info()
 	if err != nil {
 		logging.GetLogger().Error("Failed to get file info", zap.String("filename", entry.Name()), zap.String("error", err.Error()))
@@ -474,7 +474,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 	}
 
 	if isSong(fileInfo) {
-		path := gameDir + entry.Name()
+		path := soundtrackDir + entry.Name()
 
 		songHash := getHashForFile(path)
 		//numberOfSongs++
@@ -490,7 +490,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 			}
 		}
 		logging.GetLogger().Debug("Song changed",
-			zap.Int32("game_id", id),
+			zap.Int32("soundtrack_id", id),
 			zap.String("path", path),
 			zap.String("song_name", songName),
 			zap.String("song_hash", songHash))
@@ -548,8 +548,8 @@ func handleError(funcName string, err error, msg string) {
 	}
 }
 
-func getHashForDir(gameDir string) string {
-	directory, _ := directory_checksum.ScanDirectory(gameDir, afero.NewOsFs())
+func getHashForDir(soundtrackDir string) string {
+	directory, _ := directory_checksum.ScanDirectory(soundtrackDir, afero.NewOsFs())
 	hash, _ := directory.ComputeDirectoryChecksums()
 
 	return hash

internal/db/dbHelper.go

@@ -56,10 +56,10 @@ func CloseDb() {
 	Dbpool.Close()
 }
 
-func ResetGameIdSeq() {
-	_, err := Dbpool.Query(Ctx, "SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);")
+func ResetSoundtrackIdSeq() {
+	_, err := Dbpool.Query(Ctx, "SELECT setval('soundtrack_id_seq', (SELECT MAX(id) FROM soundtrack)+1);")
 	if err != nil {
-		logging.GetLogger().Error("Failed to reset game ID sequence", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to reset soundtrack ID sequence", zap.String("error", err.Error()))
 	}
 }
 

internal/db/queries/statistics.sql

@@ -1,5 +1,5 @@
 -- Most played soundtracks with their songs
--- name: GetMostPlayedGamesWithSongs :many
+-- name: GetMostPlayedSoundtracksWithSongs :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -21,7 +21,7 @@ ORDER BY g.times_played DESC, g.soundtrack_name
 LIMIT $1;
 
 -- Least played soundtracks with their songs
--- name: GetLeastPlayedGamesWithSongs :many
+-- name: GetLeastPlayedSoundtracksWithSongs :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -43,7 +43,7 @@ ORDER BY g.times_played ASC, g.soundtrack_name
 LIMIT $1;
 
 -- Most played songs with their soundtrack info
--- name: GetMostPlayedSongsWithGame :many
+-- name: GetMostPlayedSongsWithSoundtrack :many
 SELECT 
     s.soundtrack_id as soundtrack_id,
     g.soundtrack_name,
@@ -58,7 +58,7 @@ ORDER BY s.times_played DESC, s.song_name
 LIMIT $1;
 
 -- Least played songs with their soundtrack info
--- name: GetLeastPlayedSongsWithGame :many
+-- name: GetLeastPlayedSongsWithSoundtrack :many
 SELECT 
     s.soundtrack_id as soundtrack_id,
     g.soundtrack_name,
@@ -72,8 +72,8 @@ WHERE g.deleted IS NULL
 ORDER BY s.times_played ASC, s.song_name
 LIMIT $1;
 
--- Games that have never been played (times_played = 0)
--- name: GetNeverPlayedGames :many
+-- Soundtracks that have never been played (times_played = 0)
+-- name: GetNeverPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -93,7 +93,7 @@ GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
 ORDER BY g.soundtrack_name;
 
 -- Last played soundtracks (most recently played)
--- name: GetLastPlayedGames :many
+-- name: GetLastPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -114,7 +114,7 @@ ORDER BY g.last_played DESC
 LIMIT $1;
 
 -- Oldest played soundtracks (least recently played, but has been played at least once)
--- name: GetOldestPlayedGames :many
+-- name: GetOldestPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,

internal/db/repository/statistics.sql.go

@@ -10,7 +10,7 @@ import (
 	"time"
 )
 
-const getLastPlayedGames = `-- name: GetLastPlayedGames :many
+const getLastPlayedSoundtracks = `-- name: GetLastPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -31,7 +31,7 @@ ORDER BY g.last_played DESC
 LIMIT $1
 `
 
-type GetLastPlayedGamesRow struct {
+type GetLastPlayedSoundtracksRow struct {
 	SoundtrackID         int32      `json:"soundtrack_id"`
 	SoundtrackName       string     `json:"soundtrack_name"`
 	SoundtrackPlayed     int32      `json:"soundtrack_played"`
@@ -40,15 +40,15 @@ type GetLastPlayedGamesRow struct {
 }
 
 // Last played soundtracks (most recently played)
-func (q *Queries) GetLastPlayedGames(ctx context.Context, limit int32) ([]GetLastPlayedGamesRow, error) {
-	rows, err := q.db.Query(ctx, getLastPlayedGames, limit)
+func (q *Queries) GetLastPlayedSoundtracks(ctx context.Context, limit int32) ([]GetLastPlayedSoundtracksRow, error) {
+	rows, err := q.db.Query(ctx, getLastPlayedSoundtracks, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetLastPlayedGamesRow
+	var items []GetLastPlayedSoundtracksRow
 	for rows.Next() {
-		var i GetLastPlayedGamesRow
+		var i GetLastPlayedSoundtracksRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -66,7 +66,7 @@ func (q *Queries) GetLastPlayedGames(ctx context.Context, limit int32) ([]GetLas
 	return items, nil
 }
 
-const getLeastPlayedGamesWithSongs = `-- name: GetLeastPlayedGamesWithSongs :many
+const getLeastPlayedSoundtracksWithSongs = `-- name: GetLeastPlayedSoundtracksWithSongs :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -88,7 +88,7 @@ ORDER BY g.times_played ASC, g.soundtrack_name
 LIMIT $1
 `
 
-type GetLeastPlayedGamesWithSongsRow struct {
+type GetLeastPlayedSoundtracksWithSongsRow struct {
 	SoundtrackID         int32      `json:"soundtrack_id"`
 	SoundtrackName       string     `json:"soundtrack_name"`
 	SoundtrackPlayed     int32      `json:"soundtrack_played"`
@@ -97,15 +97,15 @@ type GetLeastPlayedGamesWithSongsRow struct {
 }
 
 // Least played soundtracks with their songs
-func (q *Queries) GetLeastPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedGamesWithSongsRow, error) {
-	rows, err := q.db.Query(ctx, getLeastPlayedGamesWithSongs, limit)
+func (q *Queries) GetLeastPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedSoundtracksWithSongsRow, error) {
+	rows, err := q.db.Query(ctx, getLeastPlayedSoundtracksWithSongs, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetLeastPlayedGamesWithSongsRow
+	var items []GetLeastPlayedSoundtracksWithSongsRow
 	for rows.Next() {
-		var i GetLeastPlayedGamesWithSongsRow
+		var i GetLeastPlayedSoundtracksWithSongsRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -123,7 +123,7 @@ func (q *Queries) GetLeastPlayedGamesWithSongs(ctx context.Context, limit int32)
 	return items, nil
 }
 
-const getLeastPlayedSongsWithGame = `-- name: GetLeastPlayedSongsWithGame :many
+const getLeastPlayedSongsWithSoundtrack = `-- name: GetLeastPlayedSongsWithSoundtrack :many
 SELECT 
     s.soundtrack_id as soundtrack_id,
     g.soundtrack_name,
@@ -138,7 +138,7 @@ ORDER BY s.times_played ASC, s.song_name
 LIMIT $1
 `
 
-type GetLeastPlayedSongsWithGameRow struct {
+type GetLeastPlayedSongsWithSoundtrackRow struct {
 	SoundtrackID   int32   `json:"soundtrack_id"`
 	SoundtrackName string  `json:"soundtrack_name"`
 	SongName       string  `json:"song_name"`
@@ -148,15 +148,15 @@ type GetLeastPlayedSongsWithGameRow struct {
 }
 
 // Least played songs with their soundtrack info
-func (q *Queries) GetLeastPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithGameRow, error) {
-	rows, err := q.db.Query(ctx, getLeastPlayedSongsWithGame, limit)
+func (q *Queries) GetLeastPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithSoundtrackRow, error) {
+	rows, err := q.db.Query(ctx, getLeastPlayedSongsWithSoundtrack, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetLeastPlayedSongsWithGameRow
+	var items []GetLeastPlayedSongsWithSoundtrackRow
 	for rows.Next() {
-		var i GetLeastPlayedSongsWithGameRow
+		var i GetLeastPlayedSongsWithSoundtrackRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -175,7 +175,7 @@ func (q *Queries) GetLeastPlayedSongsWithGame(ctx context.Context, limit int32)
 	return items, nil
 }
 
-const getMostPlayedGamesWithSongs = `-- name: GetMostPlayedGamesWithSongs :many
+const getMostPlayedSoundtracksWithSongs = `-- name: GetMostPlayedSoundtracksWithSongs :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -197,7 +197,7 @@ ORDER BY g.times_played DESC, g.soundtrack_name
 LIMIT $1
 `
 
-type GetMostPlayedGamesWithSongsRow struct {
+type GetMostPlayedSoundtracksWithSongsRow struct {
 	SoundtrackID         int32      `json:"soundtrack_id"`
 	SoundtrackName       string     `json:"soundtrack_name"`
 	SoundtrackPlayed     int32      `json:"soundtrack_played"`
@@ -206,15 +206,15 @@ type GetMostPlayedGamesWithSongsRow struct {
 }
 
 // Most played soundtracks with their songs
-func (q *Queries) GetMostPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedGamesWithSongsRow, error) {
-	rows, err := q.db.Query(ctx, getMostPlayedGamesWithSongs, limit)
+func (q *Queries) GetMostPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedSoundtracksWithSongsRow, error) {
+	rows, err := q.db.Query(ctx, getMostPlayedSoundtracksWithSongs, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetMostPlayedGamesWithSongsRow
+	var items []GetMostPlayedSoundtracksWithSongsRow
 	for rows.Next() {
-		var i GetMostPlayedGamesWithSongsRow
+		var i GetMostPlayedSoundtracksWithSongsRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -232,7 +232,7 @@ func (q *Queries) GetMostPlayedGamesWithSongs(ctx context.Context, limit int32)
 	return items, nil
 }
 
-const getMostPlayedSongsWithGame = `-- name: GetMostPlayedSongsWithGame :many
+const getMostPlayedSongsWithSoundtrack = `-- name: GetMostPlayedSongsWithSoundtrack :many
 SELECT 
     s.soundtrack_id as soundtrack_id,
     g.soundtrack_name,
@@ -247,7 +247,7 @@ ORDER BY s.times_played DESC, s.song_name
 LIMIT $1
 `
 
-type GetMostPlayedSongsWithGameRow struct {
+type GetMostPlayedSongsWithSoundtrackRow struct {
 	SoundtrackID   int32   `json:"soundtrack_id"`
 	SoundtrackName string  `json:"soundtrack_name"`
 	SongName       string  `json:"song_name"`
@@ -257,15 +257,15 @@ type GetMostPlayedSongsWithGameRow struct {
 }
 
 // Most played songs with their soundtrack info
-func (q *Queries) GetMostPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithGameRow, error) {
-	rows, err := q.db.Query(ctx, getMostPlayedSongsWithGame, limit)
+func (q *Queries) GetMostPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithSoundtrackRow, error) {
+	rows, err := q.db.Query(ctx, getMostPlayedSongsWithSoundtrack, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetMostPlayedSongsWithGameRow
+	var items []GetMostPlayedSongsWithSoundtrackRow
 	for rows.Next() {
-		var i GetMostPlayedSongsWithGameRow
+		var i GetMostPlayedSongsWithSoundtrackRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -284,7 +284,7 @@ func (q *Queries) GetMostPlayedSongsWithGame(ctx context.Context, limit int32) (
 	return items, nil
 }
 
-const getNeverPlayedGames = `-- name: GetNeverPlayedGames :many
+const getNeverPlayedSoundtracks = `-- name: GetNeverPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -304,7 +304,7 @@ GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
 ORDER BY g.soundtrack_name
 `
 
-type GetNeverPlayedGamesRow struct {
+type GetNeverPlayedSoundtracksRow struct {
 	SoundtrackID     int32     `json:"soundtrack_id"`
 	SoundtrackName   string    `json:"soundtrack_name"`
 	SoundtrackPlayed int32     `json:"soundtrack_played"`
@@ -312,16 +312,16 @@ type GetNeverPlayedGamesRow struct {
 	Songs            []byte    `json:"songs"`
 }
 
-// Games that have never been played (times_played = 0)
-func (q *Queries) GetNeverPlayedGames(ctx context.Context) ([]GetNeverPlayedGamesRow, error) {
-	rows, err := q.db.Query(ctx, getNeverPlayedGames)
+// Soundtracks that have never been played (times_played = 0)
+func (q *Queries) GetNeverPlayedSoundtracks(ctx context.Context) ([]GetNeverPlayedSoundtracksRow, error) {
+	rows, err := q.db.Query(ctx, getNeverPlayedSoundtracks)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetNeverPlayedGamesRow
+	var items []GetNeverPlayedSoundtracksRow
 	for rows.Next() {
-		var i GetNeverPlayedGamesRow
+		var i GetNeverPlayedSoundtracksRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,
@@ -339,7 +339,7 @@ func (q *Queries) GetNeverPlayedGames(ctx context.Context) ([]GetNeverPlayedGame
 	return items, nil
 }
 
-const getOldestPlayedGames = `-- name: GetOldestPlayedGames :many
+const getOldestPlayedSoundtracks = `-- name: GetOldestPlayedSoundtracks :many
 SELECT 
     g.id as soundtrack_id,
     g.soundtrack_name,
@@ -360,7 +360,7 @@ ORDER BY g.last_played ASC
 LIMIT $1
 `
 
-type GetOldestPlayedGamesRow struct {
+type GetOldestPlayedSoundtracksRow struct {
 	SoundtrackID         int32      `json:"soundtrack_id"`
 	SoundtrackName       string     `json:"soundtrack_name"`
 	SoundtrackPlayed     int32      `json:"soundtrack_played"`
@@ -369,15 +369,15 @@ type GetOldestPlayedGamesRow struct {
 }
 
 // Oldest played soundtracks (least recently played, but has been played at least once)
-func (q *Queries) GetOldestPlayedGames(ctx context.Context, limit int32) ([]GetOldestPlayedGamesRow, error) {
-	rows, err := q.db.Query(ctx, getOldestPlayedGames, limit)
+func (q *Queries) GetOldestPlayedSoundtracks(ctx context.Context, limit int32) ([]GetOldestPlayedSoundtracksRow, error) {
+	rows, err := q.db.Query(ctx, getOldestPlayedSoundtracks, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetOldestPlayedGamesRow
+	var items []GetOldestPlayedSoundtracksRow
 	for rows.Next() {
-		var i GetOldestPlayedGamesRow
+		var i GetOldestPlayedSoundtracksRow
 		if err := rows.Scan(
 			&i.SoundtrackID,
 			&i.SoundtrackName,

internal/server/musicHandler.go

@@ -231,7 +231,7 @@ func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
 
 // GetAllSoundtracks godoc
 // @Summary Get all soundtracks
-// @Description Returns a list of all games in order
+// @Description Returns a list of all soundtracks in order
 // @Tags music
 // @Accept json
 // @Produce json
@@ -249,7 +249,7 @@ func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
 
 // GetAllSoundtracksRandom godoc
 // @Summary Get all soundtracks random
-// @Description Returns a list of all games in random order
+// @Description Returns a list of all soundtracks in random order
 // @Tags music
 // @Accept json
 // @Produce json
@@ -285,7 +285,7 @@ func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
 	if err != nil {
 		return ctx.JSON(http.StatusBadRequest, err.Error())
 	}
-		logging.GetLogger().Info("Marking song as played", zap.Int("song_id", song))
+	logging.GetLogger().Info("Marking song as played", zap.Int("song_id", song))
 	backend.SetPlayed(song)
 	return ctx.NoContent(http.StatusOK)
 }

internal/server/routes.go

@@ -51,7 +51,7 @@ func (s *Server) RegisterRoutes() http.Handler {
 	e.GET("/assets/*", echo.WrapHandler(fileServer))
 
 	e.GET("/search", echo.WrapHandler(templ.Handler(web.HelloForm())))
-	e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindGameWebHandler)))
+	e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackWebHandler)))
 
 	e.Static("/", "/frontend")
 
@@ -136,20 +136,20 @@ func (s *Server) RegisterRoutes() http.Handler {
 
 	// Statistics API endpoints (protected by token auth)
 	statistics := s.statisticsHandler
-	protectedV1.GET("/statistics/games/most-played", func(c *echo.Context) error {
-		return statistics.GetMostPlayedGames(c)
+	protectedV1.GET("/statistics/soundtracks/most-played", func(c *echo.Context) error {
+		return statistics.GetMostPlayedSoundtracks(c)
 	})
-	protectedV1.GET("/statistics/games/least-played", func(c *echo.Context) error {
-		return statistics.GetLeastPlayedGames(c)
+	protectedV1.GET("/statistics/soundtracks/least-played", func(c *echo.Context) error {
+		return statistics.GetLeastPlayedSoundtracks(c)
 	})
-	protectedV1.GET("/statistics/games/never-played", func(c *echo.Context) error {
-		return statistics.GetNeverPlayedGames(c)
+	protectedV1.GET("/statistics/soundtracks/never-played", func(c *echo.Context) error {
+		return statistics.GetNeverPlayedSoundtracks(c)
 	})
-	protectedV1.GET("/statistics/games/last-played", func(c *echo.Context) error {
-		return statistics.GetLastPlayedGames(c)
+	protectedV1.GET("/statistics/soundtracks/last-played", func(c *echo.Context) error {
+		return statistics.GetLastPlayedSoundtracks(c)
 	})
-	protectedV1.GET("/statistics/games/oldest-played", func(c *echo.Context) error {
-		return statistics.GetOldestPlayedGames(c)
+	protectedV1.GET("/statistics/soundtracks/oldest-played", func(c *echo.Context) error {
+		return statistics.GetOldestPlayedSoundtracks(c)
 	})
 	protectedV1.GET("/statistics/songs/most-played", func(c *echo.Context) error {
 		return statistics.GetMostPlayedSongs(c)

internal/server/statistics_handler.go

@@ -23,20 +23,20 @@ func NewStatisticsHandler() *StatisticsHandler {
 	}
 }
 
-// GetMostPlayedGames returns top N most played games with songs
-// GET /api/v1/statistics/games/most-played
+// GetMostPlayedSoundtracks returns top N most played soundtracks with songs
+// GET /api/v1/statistics/soundtracks/most-played
 //
-//	@Summary		Get most played games
-//	@Description	Returns the top N most played games with their songs
+//	@Summary		Get most played soundtracks
+//	@Description	Returns the top N most played soundtracks with their songs
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
 //	@Param			limit	query	int	false	"Number of results (default: 10)"
-//	@Success		200	{array}	backend.GameWithSongs
+//	@Success		200	{array}	backend.SoundtrackWithSongs
 //	@Failure		400	{object}	map[string]string
 //	@Failure		500	{object}	map[string]string
-//	@Router		/api/v1/statistics/games/most-played [get]
-func (h *StatisticsHandler) GetMostPlayedGames(ctx *echo.Context) error {
+//	@Router		/api/v1/statistics/soundtracks/most-played [get]
+func (h *StatisticsHandler) GetMostPlayedSoundtracks(ctx *echo.Context) error {
 	limit := 10 // default
 	limitStr := ctx.QueryParam("limit")
 	if limitStr != "" {
@@ -50,29 +50,29 @@ func (h *StatisticsHandler) GetMostPlayedGames(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	games, err := h.statsBackend.GetMostPlayedGamesWithSongs(int32(limit))
+
+	soundtracks, err := h.statsBackend.GetMostPlayedSoundtracksWithSongs(int32(limit))
 	if err != nil {
-		logging.GetLogger().Error("Failed to get most played games", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to get most played soundtracks", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
 	}
-	return ctx.JSON(http.StatusOK, games)
+	return ctx.JSON(http.StatusOK, soundtracks)
 }
 
-// GetLeastPlayedGames returns top N least played games with songs
-// GET /api/v1/statistics/games/least-played
+// GetLeastPlayedSoundtracks returns top N least played soundtracks with songs
+// GET /api/v1/statistics/soundtracks/least-played
 //
-//	@Summary		Get least played games
-//	@Description	Returns the top N least played games with their songs
+//	@Summary		Get least played soundtracks
+//	@Description	Returns the top N least played soundtracks with their songs
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
 //	@Param			limit	query	int	false	"Number of results (default: 10)"
-//	@Success		200	{array}	backend.GameWithSongs
+//	@Success		200	{array}	backend.SoundtrackWithSongs
 //	@Failure		400	{object}	map[string]string
 //	@Failure		500	{object}	map[string]string
-//	@Router		/api/v1/statistics/games/least-played [get]
-func (h *StatisticsHandler) GetLeastPlayedGames(ctx *echo.Context) error {
+//	@Router		/api/v1/statistics/soundtracks/least-played [get]
+func (h *StatisticsHandler) GetLeastPlayedSoundtracks(ctx *echo.Context) error {
 	limit := 10
 	limitStr := ctx.QueryParam("limit")
 	if limitStr != "" {
@@ -85,20 +85,20 @@ func (h *StatisticsHandler) GetLeastPlayedGames(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	games, err := h.statsBackend.GetLeastPlayedGamesWithSongs(int32(limit))
+
+	soundtracks, err := h.statsBackend.GetLeastPlayedSoundtracksWithSongs(int32(limit))
 	if err != nil {
-		logging.GetLogger().Error("Failed to get least played games", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to get least played soundtracks", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
 	}
-	return ctx.JSON(http.StatusOK, games)
+	return ctx.JSON(http.StatusOK, soundtracks)
 }
 
-// GetMostPlayedSongs returns top N most played songs with game info
+// GetMostPlayedSongs returns top N most played songs with soundtrack info
 // GET /api/v1/statistics/songs/most-played
 //
 //	@Summary		Get most played songs
-//	@Description	Returns the top N most played songs with their game info
+//	@Description	Returns the top N most played songs with their soundtrack info
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
@@ -120,8 +120,8 @@ func (h *StatisticsHandler) GetMostPlayedSongs(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	songs, err := h.statsBackend.GetMostPlayedSongsWithGame(int32(limit))
+
+	songs, err := h.statsBackend.GetMostPlayedSongsWithSoundtrack(int32(limit))
 	if err != nil {
 		logging.GetLogger().Error("Failed to get most played songs", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
@@ -129,11 +129,11 @@ func (h *StatisticsHandler) GetMostPlayedSongs(ctx *echo.Context) error {
 	return ctx.JSON(http.StatusOK, songs)
 }
 
-// GetLeastPlayedSongs returns top N least played songs with game info
+// GetLeastPlayedSongs returns top N least played songs with soundtrack info
 // GET /api/v1/statistics/songs/least-played
 //
 //	@Summary		Get least played songs
-//	@Description	Returns the top N least played songs with their game info
+//	@Description	Returns the top N least played songs with their soundtrack info
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
@@ -155,8 +155,8 @@ func (h *StatisticsHandler) GetLeastPlayedSongs(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	songs, err := h.statsBackend.GetLeastPlayedSongsWithGame(int32(limit))
+
+	songs, err := h.statsBackend.GetLeastPlayedSongsWithSoundtrack(int32(limit))
 	if err != nil {
 		logging.GetLogger().Error("Failed to get least played songs", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
@@ -164,40 +164,40 @@ func (h *StatisticsHandler) GetLeastPlayedSongs(ctx *echo.Context) error {
 	return ctx.JSON(http.StatusOK, songs)
 }
 
-// GetNeverPlayedGames returns games that have never been played
-// GET /api/v1/statistics/games/never-played
+// GetNeverPlayedSoundtracks returns soundtracks that have never been played
+// GET /api/v1/statistics/soundtracks/never-played
 //
-//	@Summary		Get never played games
-//	@Description	Returns all games that have never been played (times_played = 0)
+//	@Summary		Get never played soundtracks
+//	@Description	Returns all soundtracks that have never been played (times_played = 0)
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
-//	@Success		200	{array}	backend.GameWithSongs
+//	@Success		200	{array}	backend.SoundtrackWithSongs
 //	@Failure		500	{object}	map[string]string
-//	@Router		/api/v1/statistics/games/never-played [get]
-func (h *StatisticsHandler) GetNeverPlayedGames(ctx *echo.Context) error {
-	games, err := h.statsBackend.GetNeverPlayedGames()
+//	@Router		/api/v1/statistics/soundtracks/never-played [get]
+func (h *StatisticsHandler) GetNeverPlayedSoundtracks(ctx *echo.Context) error {
+	soundtracks, err := h.statsBackend.GetNeverPlayedSoundtracks()
 	if err != nil {
-		logging.GetLogger().Error("Failed to get never played games", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to get never played soundtracks", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
 	}
-	return ctx.JSON(http.StatusOK, games)
+	return ctx.JSON(http.StatusOK, soundtracks)
 }
 
-// GetLastPlayedGames returns most recently played games
-// GET /api/v1/statistics/games/last-played
+// GetLastPlayedSoundtracks returns most recently played soundtracks
+// GET /api/v1/statistics/soundtracks/last-played
 //
-//	@Summary		Get last played games
-//	@Description	Returns the most recently played games
+//	@Summary		Get last played soundtracks
+//	@Description	Returns the most recently played soundtracks
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
 //	@Param			limit	query	int	false	"Number of results (default: 10)"
-//	@Success		200	{array}	backend.GameWithSongs
+//	@Success		200	{array}	backend.SoundtrackWithSongs
 //	@Failure		400	{object}	map[string]string
 //	@Failure		500	{object}	map[string]string
-//	@Router		/api/v1/statistics/games/last-played [get]
-func (h *StatisticsHandler) GetLastPlayedGames(ctx *echo.Context) error {
+//	@Router		/api/v1/statistics/soundtracks/last-played [get]
+func (h *StatisticsHandler) GetLastPlayedSoundtracks(ctx *echo.Context) error {
 	limit := 10
 	limitStr := ctx.QueryParam("limit")
 	if limitStr != "" {
@@ -210,29 +210,29 @@ func (h *StatisticsHandler) GetLastPlayedGames(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	games, err := h.statsBackend.GetLastPlayedGames(int32(limit))
+
+	soundtracks, err := h.statsBackend.GetLastPlayedSoundtracks(int32(limit))
 	if err != nil {
-		logging.GetLogger().Error("Failed to get last played games", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to get last played soundtracks", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
 	}
-	return ctx.JSON(http.StatusOK, games)
+	return ctx.JSON(http.StatusOK, soundtracks)
 }
 
-// GetOldestPlayedGames returns least recently played games
-// GET /api/v1/statistics/games/oldest-played
+// GetOldestPlayedSoundtracks returns least recently played soundtracks
+// GET /api/v1/statistics/soundtracks/oldest-played
 //
-//	@Summary		Get oldest played games
-//	@Description	Returns the least recently played games (that have been played at least once)
+//	@Summary		Get oldest played soundtracks
+//	@Description	Returns the least recently played soundtracks (that have been played at least once)
 //	@Tags			statistics
 //	@Accept		json
 //	@Produce		json
 //	@Param			limit	query	int	false	"Number of results (default: 10)"
-//	@Success		200	{array}	backend.GameWithSongs
+//	@Success		200	{array}	backend.SoundtrackWithSongs
 //	@Failure		400	{object}	map[string]string
 //	@Failure		500	{object}	map[string]string
-//	@Router		/api/v1/statistics/games/oldest-played [get]
-func (h *StatisticsHandler) GetOldestPlayedGames(ctx *echo.Context) error {
+//	@Router		/api/v1/statistics/soundtracks/oldest-played [get]
+func (h *StatisticsHandler) GetOldestPlayedSoundtracks(ctx *echo.Context) error {
 	limit := 10
 	limitStr := ctx.QueryParam("limit")
 	if limitStr != "" {
@@ -245,13 +245,13 @@ func (h *StatisticsHandler) GetOldestPlayedGames(ctx *echo.Context) error {
 			limit = 100
 		}
 	}
-	
-	games, err := h.statsBackend.GetOldestPlayedGames(int32(limit))
+
+	soundtracks, err := h.statsBackend.GetOldestPlayedSoundtracks(int32(limit))
 	if err != nil {
-		logging.GetLogger().Error("Failed to get oldest played games", zap.String("error", err.Error()))
+		logging.GetLogger().Error("Failed to get oldest played soundtracks", zap.String("error", err.Error()))
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
 	}
-	return ctx.JSON(http.StatusOK, games)
+	return ctx.JSON(http.StatusOK, soundtracks)
 }
 
 // GetStatisticsSummary returns overall statistics

internal/server/statistics_handler_test.go

@@ -91,8 +91,8 @@ func TestPartialMigrationThenSyncThenComplete(t *testing.T) {
 	require.NoError(t, err)
 
 	// After sync with /sync/new, only soundtracks matching filesystem remain
-	// testMusic has 3 games
-	require.Equal(t, int64(3), summary.TotalGames)
+	// testMusic has 3 soundtracks
+	require.Equal(t, int64(3), summary.TotalSoundtracks)
 }
 
 // insertTestData inserts 5 test soundtracks with songs into the database

internal/server/syncHandler.go

@@ -36,7 +36,7 @@ func (s *SyncHandler) SyncProgress(ctx *echo.Context) error {
 
 // SyncSoundtracksNewOnlyChanges godoc
 // @Summary Sync soundtracks with only changes
-// @Description Starts syncing games with only new changes
+// @Description Starts syncing soundtracks with only new changes
 // @Tags sync
 // @Accept json
 // @Produce json
@@ -55,8 +55,8 @@ func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
 }
 
 // SyncSoundtracksNewFull godoc
-// @Summary Sync all games fully
-// @Description Starts a full sync of all games
+// @Summary Sync all soundtracks fully
+// @Description Starts a full sync of all soundtracks
 // @Tags sync
 // @Accept json
 // @Produce json
@@ -76,7 +76,7 @@ func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
 
 // ResetDB godoc
 // @Summary Reset soundtracks database
-// @Description Resets the games database by deleting all games and songs
+// @Description Resets the soundtracks database by deleting all soundtracks and songs
 // @Tags sync
 // @Accept json
 // @Produce json

internal/server/sync_handler_test.go

@@ -28,7 +28,7 @@ func waitForSyncCompletion(t *testing.T, e *echo.Echo, maxAttempts int) bool {
 		if err == nil && progress.Progress != "" {
 			// Successfully parsed as ProgressResponse with non-empty progress
 			t.Logf("Sync progress: %s%%", progress.Progress)
-				if progress.Progress == "100" {
+			if progress.Progress == "100" {
 				t.Log("Sync completed!")
 				// Wait for Syncing flag to be updated
 				for j := 0; j < 50; j++ {
@@ -61,7 +61,7 @@ func waitForSyncCompletion(t *testing.T, e *echo.Echo, maxAttempts int) bool {
 	return false
 }
 
-// TestSyncPopulatesDatabase verifies that sync populates the database with games
+// TestSyncPopulatesDatabase verifies that sync populates the database with soundtracks
 func TestSyncPopulatesDatabase(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
@@ -74,12 +74,12 @@ func TestSyncPopulatesDatabase(t *testing.T) {
 	// Clear any existing data first
 	db.TestClearDatabase(t)
 
-	// Before sync - should have no games
+	// Before sync - should have no soundtracks
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	soundtracksBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	beforeCount := len(gamesBefore)
-	t.Logf("Games before sync: %d", beforeCount)
+	beforeCount := len(soundtracksBefore)
+	t.Logf("Soundtracks before sync: %d", beforeCount)
 	assert.Equal(t, 0, beforeCount, "Database should be empty after clear")
 
 	// Run sync
@@ -91,14 +91,14 @@ func TestSyncPopulatesDatabase(t *testing.T) {
 		t.Error("Sync did not complete within timeout")
 	}
 
-	// After sync - should have games
-	gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	// After sync - should have soundtracks
+	soundtracksAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	afterCount := len(gamesAfter)
-	t.Logf("Games after sync: %d", afterCount)
+	afterCount := len(soundtracksAfter)
+	t.Logf("Soundtracks after sync: %d", afterCount)
 
-	// Should have more games than before (unless database was already populated)
-	assert.True(t, afterCount > 0, "Database should have games after sync")
+	// Should have more soundtracks than before (unless database was already populated)
+	assert.True(t, afterCount > 0, "Database should have soundtracks after sync")
 }
 
 // TestSyncMakesDifference verifies that sync actually changes the database state
@@ -111,11 +111,11 @@ func TestSyncMakesDifference(t *testing.T) {
 	// Clear any existing data first
 	db.TestClearDatabase(t)
 
-	// Before sync - should have no games
+	// Before sync - should have no soundtracks
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	soundtracksBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	assert.Equal(t, 0, len(gamesBefore), "Should have no games before sync")
+	assert.Equal(t, 0, len(soundtracksBefore), "Should have no soundtracks before sync")
 
 	// Run sync
 	resp := MakeTestRequest(t, e, "GET", "/sync/full")
@@ -126,10 +126,10 @@ func TestSyncMakesDifference(t *testing.T) {
 		t.Error("Sync did not complete within timeout")
 	}
 
-	// After sync - should have games
-	gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	// After sync - should have soundtracks
+	soundtracksAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	assert.True(t, len(gamesAfter) > 0, "Should have games after sync")
+	assert.True(t, len(soundtracksAfter) > 0, "Should have soundtracks after sync")
 }
 
 // TestSyncProgress verifies the sync progress endpoint
@@ -183,8 +183,8 @@ func TestSyncProgress(t *testing.T) {
 	assert.True(t, foundComplete, "Should have seen completion")
 }
 
-// TestSyncGamesNewOnlyChanges verifies the incremental sync endpoint
-func TestSyncGamesNewOnlyChanges(t *testing.T) {
+// TestSyncSoundtracksNewOnlyChanges verifies the incremental sync endpoint
+func TestSyncSoundtracksNewOnlyChanges(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
 
@@ -200,8 +200,8 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
 
 	// Get initial count
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	beforeCount := len(gamesBefore)
+	soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
+	beforeCount := len(soundtracksBefore)
 
 	// Run incremental sync (should not change count if nothing changed)
 	resp := MakeTestRequest(t, e, "GET", "/sync/new")
@@ -211,16 +211,16 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
 	time.Sleep(2 * time.Second)
 
 	// Count should be the same
-	gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	afterCount := len(gamesAfter)
+	soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
+	afterCount := len(soundtracksAfter)
 
 	// Note: This might not be exactly equal due to timing, but should be close
-	t.Logf("Games before incremental sync: %d, after: %d", beforeCount, afterCount)
+	t.Logf("Soundtracks before incremental sync: %d, after: %d", beforeCount, afterCount)
 }
 
-// TestResetGames verifies the reset endpoint clears the database
+// TestResetSoundtracks verifies the reset endpoint clears the database
 // RUN THIS LAST
-func TestResetGames(t *testing.T) {
+func TestResetSoundtracks(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
 
@@ -228,8 +228,8 @@ func TestResetGames(t *testing.T) {
 
 	// First ensure we have data
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	beforeCount := len(gamesBefore)
+	soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
+	beforeCount := len(soundtracksBefore)
 
 	if beforeCount == 0 {
 		// Run sync to populate
@@ -238,12 +238,12 @@ func TestResetGames(t *testing.T) {
 			t.Error("Sync did not complete within timeout")
 			return
 		}
-		gamesBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx())
-		beforeCount = len(gamesBefore)
+		soundtracksBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx())
+		beforeCount = len(soundtracksBefore)
 	}
 
-	t.Logf("Games before reset: %d", beforeCount)
-	assert.True(t, beforeCount > 0, "Should have games to reset")
+	t.Logf("Soundtracks before reset: %d", beforeCount)
+	assert.True(t, beforeCount > 0, "Should have soundtracks to reset")
 
 	// Call reset
 	resp := MakeTestRequest(t, e, "GET", "/sync/reset")
@@ -253,16 +253,16 @@ func TestResetGames(t *testing.T) {
 	// Note: reset might take a moment to propagate
 	time.Sleep(1 * time.Second)
 
-	gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	afterCount := len(gamesAfter)
+	soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
+	afterCount := len(soundtracksAfter)
 
-	t.Logf("Games after reset: %d", afterCount)
+	t.Logf("Soundtracks after reset: %d", afterCount)
 	assert.Equal(t, 0, afterCount, "Database should be empty after reset")
 }
 
-// TestSyncGamesNewFull verifies the full sync endpoint
-// RUN THIS LAST (before TestResetGames)
-func TestSyncGamesNewFull(t *testing.T) {
+// TestSyncSoundtracksNewFull verifies the full sync endpoint
+// RUN THIS LAST (before TestResetSoundtracks)
+func TestSyncSoundtracksNewFull(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
 
@@ -282,8 +282,8 @@ func TestSyncGamesNewFull(t *testing.T) {
 
 	// Verify database is populated
 	repo := repository.New(backend.BackendPool())
-	games, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	soundtracks, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	assert.True(t, len(games) > 0, "Database should be populated after full sync")
-	t.Logf("Full sync populated %d games", len(games))
+	assert.True(t, len(soundtracks) > 0, "Database should be populated after full sync")
+	t.Logf("Full sync populated %d soundtracks", len(soundtracks))
 }

internal/server/zz_music_handler_test.go

@@ -16,12 +16,12 @@ import (
 // ensureSyncRan ensures that sync has been run before testing music endpoints
 func ensureSyncRan(t *testing.T, e *echo.Echo) {
 	repo := repository.New(backend.BackendPool())
-	games, err := repo.FindAllSoundtracks(backend.BackendCtx())
+	soundtracks, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 
-	if len(games) == 0 {
+	if len(soundtracks) == 0 {
 		// Run sync
-		t.Log("No games found, running sync first...")
+		t.Log("No soundtracks found, running sync first...")
 		resp := MakeTestRequest(t, e, "GET", "/sync/full")
 		assert.Equal(t, http.StatusOK, resp.Code)
 
@@ -32,8 +32,8 @@ func ensureSyncRan(t *testing.T, e *echo.Echo) {
 	}
 }
 
-// TestGetAllGames verifies the /music/all/order endpoint
-func TestZGetAllGames(t *testing.T) {
+// TestGetAllSoundtracks verifies the /music/all/order endpoint
+func TestZGetAllSoundtracks(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
 
@@ -45,15 +45,15 @@ func TestZGetAllGames(t *testing.T) {
 	resp := MakeTestRequest(t, e, "GET", "/music/all/order")
 	assert.Equal(t, http.StatusOK, resp.Code)
 
-	var games []string
-	err := json.Unmarshal(resp.Body.Bytes(), &games)
+	var soundtracks []string
+	err := json.Unmarshal(resp.Body.Bytes(), &soundtracks)
 	assert.NoError(t, err)
-	assert.NotEmpty(t, games, "Should have games after sync")
-	t.Logf("Found %d games", len(games))
+	assert.NotEmpty(t, soundtracks, "Should have soundtracks after sync")
+	t.Logf("Found %d soundtracks", len(soundtracks))
 }
 
-// TestGetAllGamesRandom verifies the /music/all/random endpoint
-func TestZGetAllGamesRandom(t *testing.T) {
+// TestGetAllSoundtracksRandom verifies the /music/all/random endpoint
+func TestZGetAllSoundtracksRandom(t *testing.T) {
 	db.TestSetupDB(t)
 	defer db.TestTearDownDB(t)
 
@@ -65,17 +65,17 @@ func TestZGetAllGamesRandom(t *testing.T) {
 	resp := MakeTestRequest(t, e, "GET", "/music/all/random")
 	assert.Equal(t, http.StatusOK, resp.Code)
 
-	var games []string
-	err := json.Unmarshal(resp.Body.Bytes(), &games)
+	var soundtracks []string
+	err := json.Unmarshal(resp.Body.Bytes(), &soundtracks)
 	assert.NoError(t, err)
-	assert.NotEmpty(t, games, "Should have games after sync")
+	assert.NotEmpty(t, soundtracks, "Should have soundtracks after sync")
 
 	// Verify it's shuffled (not in original order)
 	// We can't easily verify randomness, but we can check it's the same length
 	resp2 := MakeTestRequest(t, e, "GET", "/music/all/order")
-	var gamesOrdered []string
-	json.Unmarshal(resp2.Body.Bytes(), &gamesOrdered)
-	assert.Equal(t, len(games), len(gamesOrdered), "Random and ordered should have same count")
+	var soundtracksOrdered []string
+	json.Unmarshal(resp2.Body.Bytes(), &soundtracksOrdered)
+	assert.Equal(t, len(soundtracks), len(soundtracksOrdered), "Random and ordered should have same count")
 }
 
 // TestGetRandomSong verifies the /music/rand endpoint
@@ -153,7 +153,7 @@ func TestZGetSongInfo(t *testing.T) {
 	assert.NoError(t, err)
 	// Note: CurrentlyPlaying might be false if no song is currently set
 	// Just verify we got a valid response
-	t.Logf("Song info: Game=%s, Song=%s", info.Game, info.Song)
+	t.Logf("Song info: Soundtrack=%s, Song=%s", info.Soundtrack, info.Song)
 }
 
 // TestGetPlayedSongs verifies the /music/list endpoint