Added fuzzy finder to search, made sync check as middleware, .id file is never used

Reviewed-on: #26

.dockerignore

@@ -0,0 +1,31 @@
+# Directories
+.gitea
+git
+.idea
+testMusic
+testCharacters
+
+# Files
+Dockerfile
+docker-compose*
+compose.yaml
+.dockerignore
+.gitignore
+*.pprof
+main
+conf.yaml
+output.css
+tailwindcss
+.env
+
+# Node.js (frontend build artifacts)
+node_modules
+package.json
+package-lock.json
+
+# Test files
+*_test.go
+integration_test.go
+
+# OS
+.DS_Store

Dockerfile

@@ -1,33 +1,28 @@
-# Stage 1: Build frontend
+# Stage 1: Build backend
-FROM node:18-alpine AS frontend-builder
-RUN apk add --no-cache git
-WORKDIR /app
-RUN git clone https://gitea.sanplex.xyz/Sansan/MusicFrontend.git
-WORKDIR /app/MusicFrontend
-RUN npm install
-RUN npm run build
-# Generate config.js with empty API_HOSTNAME (relative paths)
-RUN echo "window.__RUNTIME_CONFIG__ = { API_HOSTNAME: '' };" > dist/config.js
-
-# Stage 2: Build backend
 FROM golang:1.25-alpine as build_go
 RUN apk add --no-cache curl
 WORKDIR /app
 COPY go.mod go.sum ./
 RUN go mod download
-COPY . .
+COPY cmd/ ./cmd/
+COPY internal/ ./internal/
+COPY *.go ./
+RUN find . -name "*_test.go" -delete && \
+    find . -name "integration_test.go" -delete
 RUN go install github.com/a-h/templ/cmd/templ@latest
 RUN templ generate
 RUN go build -o main cmd/main.go
 
-# Stage 3: Final image
+# Stage 2: Final image
 FROM golang:1.25-alpine
 EXPOSE 8080
 VOLUME /sorted
 VOLUME /characters
 
 COPY --from=build_go /app/main .
-COPY --from=frontend-builder /app/MusicFrontend/dist /frontend
+COPY --from=gitea.sanplex.xyz/sansan/musicfrontend:latest /usr/share/nginx/html /frontend
+# Generate config.js with empty API_HOSTNAME (relative paths)
+RUN echo "window.__RUNTIME_CONFIG__ = { API_HOSTNAME: '' };" > /frontend/config.js
 COPY ./songs/ ./songs/
 
 ENV PORT 8080

cmd/docs/docs.go

@@ -23,6 +23,385 @@ var doc = `{
     "host": "{{.Host}}",
     "basePath": "{{.BasePath}}",
     "paths": {
+        "/api/v1/statistics/soundtracks/last-played": {
+            "get": {
+                "description": "Returns the most recently played soundtracks",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get last played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/least-played": {
+            "get": {
+                "description": "Returns the top N least played soundtracks with their songs",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get least played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/most-played": {
+            "get": {
+                "description": "Returns the top N most played soundtracks with their songs",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get most played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/never-played": {
+            "get": {
+                "description": "Returns all soundtracks that have never been played (times_played = 0)",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get never played soundtracks",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/oldest-played": {
+            "get": {
+                "description": "Returns the least recently played soundtracks (that have been played at least once)",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get oldest played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/songs/least-played": {
+            "get": {
+                "description": "Returns the top N least played songs with their game info",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get least played songs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SongInfoForStats"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/songs/most-played": {
+            "get": {
+                "description": "Returns the top N most played songs with their game info",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get most played songs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SongInfoForStats"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/summary": {
+            "get": {
+                "description": "Returns overall statistics about the music library",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get statistics summary",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/backend.StatisticsSummary"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/token": {
             "post": {
                 "description": "Returns a new session token for API access",
@@ -445,7 +824,7 @@ var doc = `{
         },
         "/music/all/order": {
             "get": {
-                "description": "Returns a list of all games in order",
+                "description": "Returns a list of all soundtracks in order",
                 "consumes": [
                     "application/json"
                 ],
@@ -455,7 +834,7 @@ var doc = `{
                 "tags": [
                     "music"
                 ],
-                "summary": "Get all games",
+                "summary": "Get all soundtracks",
                 "responses": {
                     "200": {
                         "description": "OK",
@@ -478,7 +857,7 @@ var doc = `{
         },
         "/music/all/random": {
             "get": {
-                "description": "Returns a list of all games in random order",
+                "description": "Returns a list of all soundtracks in random order",
                 "consumes": [
                     "application/json"
                 ],
@@ -488,7 +867,7 @@ var doc = `{
                 "tags": [
                     "music"
                 ],
-                "summary": "Get all games random",
+                "summary": "Get all soundtracks random",
                 "responses": {
                     "200": {
                         "description": "OK",
@@ -818,7 +1197,7 @@ var doc = `{
         },
         "/sync": {
             "get": {
-                "description": "Starts syncing games with only new changes",
+                "description": "Starts syncing soundtracks with only new changes",
                 "consumes": [
                     "application/json"
                 ],
@@ -828,10 +1207,10 @@ var doc = `{
                 "tags": [
                     "sync"
                 ],
-                "summary": "Sync games with only changes",
+                "summary": "Sync soundtracks with only changes",
                 "responses": {
                     "200": {
-                        "description": "Start syncing games",
+                        "description": "Start syncing soundtracks",
                         "schema": {
                             "type": "string"
                         }
@@ -847,7 +1226,7 @@ var doc = `{
         },
         "/sync/full": {
             "get": {
-                "description": "Starts a full sync of all games",
+                "description": "Starts a full sync of all soundtracks",
                 "consumes": [
                     "application/json"
                 ],
@@ -857,10 +1236,10 @@ var doc = `{
                 "tags": [
                     "sync"
                 ],
-                "summary": "Sync all games fully",
+                "summary": "Sync all soundtracks fully",
                 "responses": {
                     "200": {
-                        "description": "Start syncing games full",
+                        "description": "Start syncing soundtracks full",
                         "schema": {
                             "type": "string"
                         }
@@ -900,7 +1279,7 @@ var doc = `{
         },
         "/sync/reset": {
             "get": {
-                "description": "Resets the games database by deleting all games and songs",
+                "description": "Resets the soundtracks database by deleting all soundtracks and songs",
                 "consumes": [
                     "application/json"
                 ],
@@ -910,10 +1289,10 @@ var doc = `{
                 "tags": [
                     "sync"
                 ],
-                "summary": "Reset games database",
+                "summary": "Reset soundtracks database",
                 "responses": {
                     "200": {
-                        "description": "Games and songs are deleted from the database",
+                        "description": "Soundtracks and songs are deleted from the database",
                         "schema": {
                             "type": "string"
                         }
@@ -990,6 +1369,78 @@ var doc = `{
         }
     },
     "definitions": {
+        "backend.SoundtrackWithSongs": {
+            "type": "object",
+            "properties": {
+                "soundtrack_id": {
+                    "type": "integer"
+                },
+                "soundtrack_last_played": {
+                    "type": "string"
+                },
+                "soundtrack_name": {
+                    "type": "string"
+                },
+                "soundtrack_played": {
+                    "type": "integer"
+                },
+                "songs": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/backend.SongInfoForStats"
+                    }
+                }
+            }
+        },
+        "backend.SongInfoForStats": {
+            "type": "object",
+            "properties": {
+                "file_name": {
+                    "type": "string"
+                },
+                "soundtrack_id": {
+                    "type": "integer"
+                },
+                "soundtrack_name": {
+                    "type": "string"
+                },
+                "path": {
+                    "type": "string"
+                },
+                "song_name": {
+                    "type": "string"
+                },
+                "times_played": {
+                    "type": "integer"
+                }
+            }
+        },
+        "backend.StatisticsSummary": {
+            "type": "object",
+            "properties": {
+                "avg_soundtrack_plays": {
+                    "type": "number"
+                },
+                "max_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "min_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "never_played_soundtracks": {
+                    "type": "integer"
+                },
+                "played_soundtracks": {
+                    "type": "integer"
+                },
+                "total_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "total_soundtracks": {
+                    "type": "integer"
+                }
+            }
+        },
         "backend.VersionData": {
             "type": "object",
             "properties": {

cmd/docs/swagger.json

@@ -4,6 +4,385 @@
         "contact": {}
     },
     "paths": {
+        "/api/v1/statistics/soundtracks/last-played": {
+            "get": {
+                "description": "Returns the most recently played soundtracks",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get last played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/least-played": {
+            "get": {
+                "description": "Returns the top N least played soundtracks with their songs",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get least played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/most-played": {
+            "get": {
+                "description": "Returns the top N most played soundtracks with their songs",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get most played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/never-played": {
+            "get": {
+                "description": "Returns all soundtracks that have never been played (times_played = 0)",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get never played soundtracks",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/soundtracks/oldest-played": {
+            "get": {
+                "description": "Returns the least recently played soundtracks (that have been played at least once)",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get oldest played soundtracks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SoundtrackWithSongs"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/songs/least-played": {
+            "get": {
+                "description": "Returns the top N least played songs with their soundtrack info",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get least played songs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SongInfoForStats"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/songs/most-played": {
+            "get": {
+                "description": "Returns the top N most played songs with their soundtrack info",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get most played songs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Number of results (default: 10)",
+                        "name": "limit",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/backend.SongInfoForStats"
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/statistics/summary": {
+            "get": {
+                "description": "Returns overall statistics about the music library",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "statistics"
+                ],
+                "summary": "Get statistics summary",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/backend.StatisticsSummary"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/token": {
             "post": {
                 "description": "Returns a new session token for API access",
@@ -426,7 +805,7 @@
         },
         "/music/all/order": {
             "get": {
-                "description": "Returns a list of all games in order",
+                "description": "Returns a list of all soundtracks in order",
                 "consumes": [
                     "application/json"
                 ],
@@ -436,7 +815,7 @@
                 "tags": [
                     "music"
                 ],
-                "summary": "Get all games",
+                "summary": "Get all soundtracks",
                 "responses": {
                     "200": {
                         "description": "OK",
@@ -459,7 +838,7 @@
         },
         "/music/all/random": {
             "get": {
-                "description": "Returns a list of all games in random order",
+                "description": "Returns a list of all soundtracks in random order",
                 "consumes": [
                     "application/json"
                 ],
@@ -469,7 +848,7 @@
                 "tags": [
                     "music"
                 ],
-                "summary": "Get all games random",
+                "summary": "Get all soundtracks random",
                 "responses": {
                     "200": {
                         "description": "OK",
@@ -799,7 +1178,7 @@
         },
         "/sync": {
             "get": {
-                "description": "Starts syncing games with only new changes",
+                "description": "Starts syncing soundtracks with only new changes",
                 "consumes": [
                     "application/json"
                 ],
@@ -809,10 +1188,10 @@
                 "tags": [
                     "sync"
                 ],
-                "summary": "Sync games with only changes",
+                "summary": "Sync soundtracks with only changes",
                 "responses": {
                     "200": {
-                        "description": "Start syncing games",
+                        "description": "Start syncing soundtracks",
                         "schema": {
                             "type": "string"
                         }
@@ -828,7 +1207,7 @@
         },
         "/sync/full": {
             "get": {
-                "description": "Starts a full sync of all games",
+                "description": "Starts a full sync of all soundtracks",
                 "consumes": [
                     "application/json"
                 ],
@@ -838,10 +1217,10 @@
                 "tags": [
                     "sync"
                 ],
-                "summary": "Sync all games fully",
+                "summary": "Sync all soundtracks fully",
                 "responses": {
                     "200": {
-                        "description": "Start syncing games full",
+                        "description": "Start syncing soundtracks full",
                         "schema": {
                             "type": "string"
                         }
@@ -881,7 +1260,7 @@
         },
         "/sync/reset": {
             "get": {
-                "description": "Resets the games database by deleting all games and songs",
+                "description": "Resets the soundtracks database by deleting all soundtracks and songs",
                 "consumes": [
                     "application/json"
                 ],
@@ -891,10 +1270,10 @@
                 "tags": [
                     "sync"
                 ],
-                "summary": "Reset games database",
+                "summary": "Reset soundtracks database",
                 "responses": {
                     "200": {
-                        "description": "Games and songs are deleted from the database",
+                        "description": "Soundtracks and songs are deleted from the database",
                         "schema": {
                             "type": "string"
                         }
@@ -971,6 +1350,78 @@
         }
     },
     "definitions": {
+        "backend.SoundtrackWithSongs": {
+            "type": "object",
+            "properties": {
+                "soundtrack_id": {
+                    "type": "integer"
+                },
+                "soundtrack_last_played": {
+                    "type": "string"
+                },
+                "soundtrack_name": {
+                    "type": "string"
+                },
+                "soundtrack_played": {
+                    "type": "integer"
+                },
+                "songs": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/backend.SongInfoForStats"
+                    }
+                }
+            }
+        },
+        "backend.SongInfoForStats": {
+            "type": "object",
+            "properties": {
+                "file_name": {
+                    "type": "string"
+                },
+                "soundtrack_id": {
+                    "type": "integer"
+                },
+                "soundtrack_name": {
+                    "type": "string"
+                },
+                "path": {
+                    "type": "string"
+                },
+                "song_name": {
+                    "type": "string"
+                },
+                "times_played": {
+                    "type": "integer"
+                }
+            }
+        },
+        "backend.StatisticsSummary": {
+            "type": "object",
+            "properties": {
+                "avg_soundtrack_plays": {
+                    "type": "number"
+                },
+                "max_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "min_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "never_played_soundtracks": {
+                    "type": "integer"
+                },
+                "played_soundtracks": {
+                    "type": "integer"
+                },
+                "total_soundtrack_plays": {
+                    "type": "integer"
+                },
+                "total_soundtracks": {
+                    "type": "integer"
+                }
+            }
+        },
         "backend.VersionData": {
             "type": "object",
             "properties": {

cmd/docs/swagger.yaml

@@ -1,4 +1,51 @@
 definitions:
+  backend.GameWithSongs:
+    properties:
+      game_id:
+        type: integer
+      game_last_played:
+        type: string
+      game_name:
+        type: string
+      game_played:
+        type: integer
+      songs:
+        items:
+          $ref: '#/definitions/backend.SongInfoForStats'
+        type: array
+    type: object
+  backend.SongInfoForStats:
+    properties:
+      file_name:
+        type: string
+      game_id:
+        type: integer
+      game_name:
+        type: string
+      path:
+        type: string
+      song_name:
+        type: string
+      times_played:
+        type: integer
+    type: object
+  backend.StatisticsSummary:
+    properties:
+      avg_game_plays:
+        type: number
+      max_game_plays:
+        type: integer
+      min_game_plays:
+        type: integer
+      never_played_games:
+        type: integer
+      played_games:
+        type: integer
+      total_game_plays:
+        type: integer
+      total_games:
+        type: integer
+    type: object
   backend.VersionData:
     properties:
       changelog:
@@ -30,6 +77,255 @@ definitions:
 info:
   contact: {}
 paths:
+  /api/v1/statistics/games/last-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the most recently played games
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.GameWithSongs'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get last played games
+      tags:
+      - statistics
+  /api/v1/statistics/games/least-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the top N least played games with their songs
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.GameWithSongs'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get least played games
+      tags:
+      - statistics
+  /api/v1/statistics/games/most-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the top N most played games with their songs
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.GameWithSongs'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get most played games
+      tags:
+      - statistics
+  /api/v1/statistics/games/never-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns all games that have never been played (times_played = 0)
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.GameWithSongs'
+            type: array
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get never played games
+      tags:
+      - statistics
+  /api/v1/statistics/games/oldest-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the least recently played games (that have been played
+        at least once)
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.GameWithSongs'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get oldest played games
+      tags:
+      - statistics
+  /api/v1/statistics/songs/least-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the top N least played songs with their game info
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.SongInfoForStats'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get least played songs
+      tags:
+      - statistics
+  /api/v1/statistics/songs/most-played:
+    get:
+      consumes:
+      - application/json
+      description: Returns the top N most played songs with their game info
+      parameters:
+      - description: 'Number of results (default: 10)'
+        in: query
+        name: limit
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            items:
+              $ref: '#/definitions/backend.SongInfoForStats'
+            type: array
+        "400":
+          description: Bad Request
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get most played songs
+      tags:
+      - statistics
+  /api/v1/statistics/summary:
+    get:
+      consumes:
+      - application/json
+      description: Returns overall statistics about the music library
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/backend.StatisticsSummary'
+        "500":
+          description: Internal Server Error
+          schema:
+            additionalProperties:
+              type: string
+            type: object
+      summary: Get statistics summary
+      tags:
+      - statistics
   /api/v1/token:
     delete:
       consumes:
@@ -325,7 +621,7 @@ paths:
           description: Syncing is in progress
           schema:
             type: string
-      summary: Get all games
+      summary: Get all soundtracks
       tags:
       - music
   /music/all/random:
@@ -347,7 +643,7 @@ paths:
           description: Syncing is in progress
           schema:
             type: string
-      summary: Get all games random
+      summary: Get all soundtracks random
       tags:
       - music
   /music/info:
@@ -561,14 +857,14 @@ paths:
       - application/json
       responses:
         "200":
-          description: Start syncing games
+          description: Start syncing soundtracks
           schema:
             type: string
         "423":
           description: Syncing is in progress
           schema:
             type: string
-      summary: Sync games with only changes
+      summary: Sync soundtracks with only changes
       tags:
       - sync
   /sync/full:
@@ -580,7 +876,7 @@ paths:
       - application/json
       responses:
         "200":
-          description: Start syncing games full
+          description: Start syncing soundtracks full
           schema:
             type: string
         "423":
@@ -615,14 +911,14 @@ paths:
       - application/json
       responses:
         "200":
-          description: Games and songs are deleted from the database
+          description: Soundtracks and songs are deleted from the database
           schema:
             type: string
         "423":
           description: Syncing is in progress
           schema:
             type: string
-      summary: Reset games database
+      summary: Reset soundtracks database
       tags:
       - sync
   /version:

cmd/web/assets/css/styles.css

@@ -1,5 +1,33 @@
 /* Pure CSS styles for Music Search */
 
+:root {
+    /* Light mode colors (default) */
+    --bg-primary: #f3f4f6;
+    --bg-secondary: #e5e7eb;
+    --bg-tertiary: #dcfce7;
+    --text-primary: #000;
+    --text-secondary: #374151;
+    --border-primary: #9ca3af;
+    --border-focus: #6b7280;
+    --accent-primary: #f97316;
+    --accent-hover: #ea580c;
+    --shadow-color: rgba(0, 0, 0, 0.1);
+}
+
+[data-theme="dark"] {
+    /* Dark mode colors matching frontend */
+    --bg-primary: #555;
+    --bg-secondary: #333;
+    --bg-tertiary: #2a2a2a;
+    --text-primary: #fff;
+    --text-secondary: #ff9c00;
+    --border-primary: #666;
+    --border-focus: #ff9c00;
+    --accent-primary: #ff9c00;
+    --accent-hover: #e68a00;
+    --shadow-color: rgba(0, 0, 0, 0.3);
+}
+
 * {
     box-sizing: border-box;
     margin: 0;
@@ -10,7 +38,9 @@ html, body {
     height: 100%;
     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
     line-height: 1.5;
-    background-color: #f3f4f6;
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    transition: background-color 0.3s ease, color 0.3s ease;
 }
 
 main {
@@ -29,15 +59,15 @@ main {
     max-width: 600px;
     font-size: 1.5rem;
     padding: 0.5rem;
-    border: 1px solid #9ca3af;
+    border: 1px solid var(--border-primary);
     border-radius: 0.5rem;
-    background-color: #e5e7eb;
+    background-color: var(--bg-secondary);
-    color: #000;
+    color: var(--text-primary);
 }
 
 #search_term:focus {
     outline: none;
-    border-color: #6b7280;
+    border-color: var(--border-focus);
 }
 
 #clear {
@@ -45,23 +75,48 @@ main {
     padding: 0.5rem 1rem;
     border: none;
     border-radius: 0.5rem;
-    background-color: #f97316;
+    background-color: var(--accent-primary);
-    color: #fff;
+    color: var(--text-primary);
     cursor: pointer;
     margin-left: 1rem;
 }
 
 #clear:hover {
-    background-color: #ea580c;
+    background-color: var(--accent-hover);
 }
 
 #games-container {
     font-size: 1.5rem;
 }
 
+.game-text {
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+/* Dark mode toggle */
+#dark-mode-toggle {
+    position: fixed;
+    top: 1rem;
+    right: 1rem;
+    font-size: 1.2rem;
+    padding: 0.4rem 0.8rem;
+    border: none;
+    border-radius: 0.5rem;
+    background-color: var(--bg-secondary);
+    color: var(--text-primary);
+    cursor: pointer;
+    z-index: 1000;
+    transition: all 0.3s ease;
+}
+
+#dark-mode-toggle:hover {
+    background-color: var(--border-primary);
+}
+
 /* Game result cards */
 .bg-green-100 {
-    background-color: #dcfce7;
+    background-color: var(--bg-tertiary);
 }
 
 .p-4 {
@@ -69,7 +124,7 @@ main {
 }
 
 .shadow-md {
-    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1);
+    box-shadow: 0 4px 6px -1px var(--shadow-color), 0 2px 4px -2px var(--shadow-color);
 }
 
 .rounded-lg {

cmd/web/hello.go

@@ -1,117 +0,0 @@
-package web
-
-import (
-	"log"
-	"music-server/internal/backend"
-	"net/http"
-	"regexp"
-	"strings"
-)
-
-var games_added []string
-
-func FindGameWebHandler(w http.ResponseWriter, r *http.Request) {
-	err := r.ParseForm()
-	if err != nil {
-		http.Error(w, "Bad Request", http.StatusBadRequest)
-	}
-
-	search_term := r.FormValue("search_term")
-
-	search(search_term)
-
-	component := FoundGames(games_added)
-	err = component.Render(r.Context(), w)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		log.Fatalf("Error rendering in FindGameWebHandler: %e", err)
-	}
-}
-
-func search(searchText string) {
-	games_added = nil
-	games := backend.GetAllGames()
-	for _, game := range games {
-		if is_match_exact(searchText, game) {
-			add_game(game)
-		}
-	}
-	for _, game := range games {
-		if is_match_contains(clean_term(searchText), clean_term(game)) {
-			add_game(game)
-		}
-	}
-	for _, game := range games {
-		if is_match_regex(clean_term(searchText), clean_term(game)) {
-			add_game(game)
-		}
-	}
-}
-
-func is_match_exact(search_term string, game_name string) bool {
-	search_term = strings.ToLower(search_term)
-	game_name = strings.ToLower(game_name)
-
-	if search_term == "" {
-		return true
-	} else if strings.Contains(game_name, search_term) {
-		return true
-	} else {
-		return false
-	}
-}
-
-func is_match_contains(search_term string, game_name string) bool {
-	if search_term == "" {
-		return true
-	} else if strings.Contains(game_name, search_term) {
-		return true
-	} else {
-		return false
-	}
-}
-
-func is_match_regex(search_term string, game_name string) bool {
-	if search_term == "" {
-		return true
-	} else if compile_regex(search_term).MatchString(game_name) {
-		return true
-	} else {
-		return false
-	}
-}
-
-func add_game(game string) {
-	if !check_if_game_exists(game) {
-		games_added = append(games_added, game)
-	}
-}
-
-func check_if_game_exists(gameName string) bool {
-	game_exists := false
-	for _, child := range games_added {
-		if child == gameName {
-			game_exists = true
-		}
-	}
-	return game_exists
-}
-
-func compile_regex(search_term string) *regexp.Regexp {
-	regText := ".*"
-	for _, letter := range search_term {
-		regText += string(letter) + ".*"
-	}
-	r, _ := regexp.Compile(regText)
-
-	return r
-}
-
-func clean_term(term string) string {
-	term = strings.ReplaceAll(term, " ", "")
-	term = strings.ReplaceAll(term, "é", "e")
-	term = strings.ReplaceAll(term, "+", "plus")
-	term = strings.ReplaceAll(term, "&", "and")
-	term = strings.ReplaceAll(term, "'n", "and")
-	return strings.ToLower(term)
-}

cmd/web/hello.templ

@@ -1,32 +0,0 @@
-package web
-
-templ HelloForm() {
-	@Base() {
-		<div id="search-container">
-			<input id="search_term" name="search_term" type="text" hx-post="/find" hx-trigger="keyup changed delay:0.25s" hx-target="#games-container"/>
-			<button type="button" id="clear" name="clear">Clear</button>
-		</div>
-		<div id="games-container"></div>
-		<script>
-			document.addEventListener('readystatechange', () => {	    
-				if (document.readyState == 'complete') {
-					htmx.ajax('POST', '/find', '#games-container');
-					document.getElementById("search_term").focus();
-				}
-			});
-			document.getElementById("clear").addEventListener("click", function (event) {
-				document.getElementById("search_term").value = "";
-				htmx.ajax('POST', '/find', '#games-container');
-				document.getElementById("search_term").focus();
-			});
-		</script>
-	}
-}
-
-templ FoundGames(games []string) {
-	for _, game := range games {
-		<div class="bg-green-100 p-4 shadow-md rounded-lg mt-6">
-			<p>{ game }</p>
-		</div>
-	}
-}

cmd/web/search.go

@@ -0,0 +1,403 @@
+package web
+
+import (
+	"log"
+	"music-server/internal/backend"
+	"net/http"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"unicode"
+)
+
+var soundtracks_added []string
+
+// Precomputed data for optimization
+type SoundtrackData struct {
+	Original     string
+	Cleaned      string
+	Abbreviation string
+}
+
+var (
+	precomputedSoundtracks []SoundtrackData
+	precomputedOnce        sync.Once
+	regexCache             = make(map[string]*regexp.Regexp)
+	regexCacheMutex        sync.Mutex
+)
+
+func FindSoundtrackWebHandler(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		http.Error(w, "Bad Request", http.StatusBadRequest)
+	}
+
+	search_term := r.FormValue("search_term")
+
+	search(search_term)
+
+	component := FoundSoundtracks(soundtracks_added)
+	err = component.Render(r.Context(), w)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		log.Fatalf("Error rendering in FindSoundtrackWebHandler: %e", err)
+	}
+}
+
+func search(searchText string) {
+	soundtracks_added = nil
+
+	// Precompute cleaned search term once
+	cleanedSearchTerm := clean_term(searchText)
+
+	// Use precomputed data for efficiency
+	soundtrackData := getPrecomputedSoundtracks()
+	seen := make(map[string]bool) // O(1) duplicate checking
+
+	for _, data := range soundtrackData {
+		// Check exact match (case-insensitive contains)
+		if is_match_exact(searchText, data.Original) && !seen[data.Original] {
+			soundtracks_added = append(soundtracks_added, data.Original)
+			seen[data.Original] = true
+		}
+	}
+
+	for _, data := range soundtrackData {
+		// Check contains match with cleaned terms
+		if !seen[data.Original] && is_match_contains(cleanedSearchTerm, data.Cleaned) {
+			soundtracks_added = append(soundtracks_added, data.Original)
+			seen[data.Original] = true
+		}
+	}
+
+	for _, data := range soundtrackData {
+		// Check regex match with cleaned terms
+		if !seen[data.Original] && is_match_regex_cached(cleanedSearchTerm, data.Cleaned) {
+			soundtracks_added = append(soundtracks_added, data.Original)
+			seen[data.Original] = true
+		}
+	}
+}
+
+func is_match_exact(search_term string, soundtrack_name string) bool {
+	search_term = strings.ToLower(search_term)
+	soundtrack_name = strings.ToLower(soundtrack_name)
+
+	if search_term == "" {
+		return true
+	} else if strings.Contains(soundtrack_name, search_term) {
+		return true
+	} else {
+		return false
+	}
+}
+
+func is_match_contains(search_term string, soundtrack_name string) bool {
+	if search_term == "" {
+		return true
+	} else if strings.Contains(soundtrack_name, search_term) {
+		return true
+	} else {
+		return false
+	}
+}
+
+func is_match_regex(search_term string, soundtrack_name string) bool {
+	if search_term == "" {
+		return true
+	} else if compile_regex(search_term).MatchString(soundtrack_name) {
+		return true
+	} else {
+		return false
+	}
+}
+
+func compile_regex(search_term string) *regexp.Regexp {
+	regText := ".*"
+	for _, letter := range search_term {
+		regText += string(letter) + ".*"
+	}
+	r, _ := regexp.Compile(regText)
+
+	return r
+}
+
+// is_match_regex_cached uses cached compiled regex patterns for better performance
+func is_match_regex_cached(search_term string, soundtrack_name string) bool {
+	if search_term == "" {
+		return true
+	}
+
+	// Check cache first
+	regexCacheMutex.Lock()
+	re, exists := regexCache[search_term]
+	if !exists {
+		re = compile_regex(search_term)
+		regexCache[search_term] = re
+	}
+	regexCacheMutex.Unlock()
+
+	return re.MatchString(soundtrack_name)
+}
+
+func clean_term(term string) string {
+	term = strings.ReplaceAll(term, " ", "")
+	term = strings.ReplaceAll(term, "é", "e")
+	term = strings.ReplaceAll(term, "+", "plus")
+	term = strings.ReplaceAll(term, "&", "and")
+	term = strings.ReplaceAll(term, "'n", "and")
+	return strings.ToLower(term)
+}
+
+// toLower converts a string to lowercase.
+func toLower(s string) string {
+	return strings.Map(unicode.ToLower, s)
+}
+
+// levenshteinWithThreshold calculates Levenshtein distance with early termination and space optimization.
+// Uses O(min(n,m)) space instead of O(n*m) and stops early if threshold is exceeded.
+func levenshteinWithThreshold(s, t string, threshold int) int {
+	if threshold < 0 {
+		threshold = 2 // default threshold
+	}
+
+	m, n := len(s), len(t)
+
+	// Quick checks for early termination
+	if m == 0 {
+		return n
+	}
+	if n == 0 {
+		return m
+	}
+	if abs(m-n) > threshold {
+		return threshold + 1 // Can't be within threshold
+	}
+
+	// Use the shorter string for the row to minimize space
+	if m < n {
+		s, t = t, s
+		m, n = n, m
+	}
+
+	// Space optimization: only store two rows
+	prevRow := make([]int, n+1)
+	currRow := make([]int, n+1)
+
+	// Initialize first row
+	for j := 0; j <= n; j++ {
+		prevRow[j] = j
+	}
+
+	for i := 1; i <= m; i++ {
+		currRow[0] = i
+		minInRow := currRow[0]
+
+		for j := 1; j <= n; j++ {
+			if s[i-1] == t[j-1] {
+				currRow[j] = prevRow[j-1]
+			} else {
+				currRow[j] = min3(prevRow[j], currRow[j-1], prevRow[j-1]) + 1
+			}
+			if currRow[j] < minInRow {
+				minInRow = currRow[j]
+			}
+		}
+
+		// Early termination: if minimum in current row exceeds threshold
+		if minInRow > threshold {
+			return threshold + 1
+		}
+
+		// Swap rows for next iteration
+		prevRow, currRow = currRow, prevRow
+	}
+
+	return prevRow[n]
+}
+
+// Helper functions for optimized Levenshtein
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func min3(a, b, c int) int {
+	if a < b {
+		if a < c {
+			return a
+		}
+		return c
+	}
+	if b < c {
+		return b
+	}
+	return c
+}
+
+// precomputeSoundtrackData initializes cleaned terms and abbreviations for all soundtracks
+func precomputeSoundtrackData() {
+	precomputedOnce.Do(func() {
+		soundtracks := backend.GetAllSoundtracks()
+		precomputedSoundtracks = make([]SoundtrackData, len(soundtracks))
+
+		for i, soundtrack := range soundtracks {
+			cleaned := clean_term(soundtrack)
+			precomputedSoundtracks[i] = SoundtrackData{
+				Original:     soundtrack,
+				Cleaned:      cleaned,
+				Abbreviation: extractAbbreviation(soundtrack),
+			}
+		}
+	})
+}
+
+// getPrecomputedSoundtracks ensures precomputed data is available and returns it
+func getPrecomputedSoundtracks() []SoundtrackData {
+	precomputeSoundtrackData()
+	return precomputedSoundtracks
+}
+
+// levenshtein maintains backward compatibility by calling the optimized version
+func levenshtein(s, t string) int {
+	return levenshteinWithThreshold(s, t, -1) // -1 uses default threshold
+}
+
+// extractAbbreviation extracts the first letters of each word in a string.
+func extractAbbreviation(s string) string {
+	words := strings.Fields(s)
+	abbr := ""
+	for _, word := range words {
+		if len(word) > 0 {
+			abbr += string(word[0])
+		}
+	}
+	return toLower(abbr)
+}
+
+// fuzzyFindSubstring checks if the query fuzzy-matches any substring of the item.
+func fuzzyFindSubstring(query, item string, threshold int) (bool, int) {
+	query = toLower(query)
+	item = toLower(item)
+	queryLen := len(query)
+	itemLen := len(item)
+	if queryLen > itemLen {
+		return false, 0
+	}
+
+	// Check for exact substring match first (weight: 100)
+	if strings.Contains(item, query) {
+		return true, 100
+	}
+
+	// Check for fuzzy substring match using optimized Levenshtein
+	for i := 0; i <= itemLen-queryLen; i++ {
+		substring := item[i : i+queryLen]
+		distance := levenshteinWithThreshold(query, substring, threshold)
+		if distance <= threshold {
+			// Weight: higher for matches at the start of the string
+			weight := 50 - i // Higher weight for earlier matches
+			return true, weight
+		}
+	}
+	return false, 0
+}
+
+// fuzzyFind checks if the query matches the item (substring or abbreviation).
+func fuzzyFind(query string, item string, threshold int) (bool, int) {
+	query = toLower(query)
+	item = toLower(item)
+
+	// Check for substring fuzzy match
+	if matched, weight := fuzzyFindSubstring(query, item, threshold); matched {
+		return true, weight
+	}
+
+	// Check for abbreviation match using optimized Levenshtein
+	abbr := extractAbbreviation(item)
+	distance := levenshteinWithThreshold(query, abbr, threshold)
+	if distance <= threshold {
+		// Weight: higher for exact abbreviation matches
+		weight := 100 - distance*10 // Higher weight for exact matches
+		return true, weight
+	}
+
+	return false, 0
+}
+
+// getAdaptiveThreshold returns a threshold based on query length
+func getAdaptiveThreshold(query string) int {
+	threshold := 2 // Base threshold for minor typos
+	queryLen := len(query)
+	if queryLen > 6 {
+		// For longer queries, allow more tolerance
+		threshold = queryLen / 3
+		if threshold < 2 {
+			threshold = 2
+		} else if threshold > 4 {
+			threshold = 4 // Cap at 4 for very long queries
+		}
+	}
+	return threshold
+}
+
+// fuzzySearch performs fuzzy search on soundtracks using the cleaned terms for consistency
+func fuzzySearch(searchText string) []string {
+	query := clean_term(searchText)
+	threshold := getAdaptiveThreshold(query)
+
+	// Use precomputed data for efficiency
+	soundtrackData := getPrecomputedSoundtracks()
+
+	type match struct {
+		item   string
+		weight int
+	}
+	var matches []match
+	seen := make(map[string]bool) // O(1) duplicate checking
+
+	for _, data := range soundtrackData {
+		if matched, weight := fuzzyFind(query, data.Cleaned, threshold); matched {
+			if !seen[data.Original] {
+				matches = append(matches, match{data.Original, weight})
+				seen[data.Original] = true
+			}
+		}
+	}
+
+	// Sort matches by weight (descending)
+	sort.Slice(matches, func(i, j int) bool {
+		return matches[i].weight > matches[j].weight
+	})
+
+	// Extract just the soundtrack names in order
+	result := make([]string, len(matches))
+	for i, m := range matches {
+		result[i] = m.item
+	}
+
+	return result
+}
+
+// FindSoundtrackFuzzyWebHandler handles fuzzy search requests
+func FindSoundtrackFuzzyWebHandler(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		http.Error(w, "Bad Request", http.StatusBadRequest)
+		return
+	}
+
+	search_term := r.FormValue("search_term")
+
+	results := fuzzySearch(search_term)
+
+	component := FoundSoundtracks(results)
+	err = component.Render(r.Context(), w)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		log.Fatalf("Error rendering in FindSoundtrackFuzzyWebHandler: %e", err)
+	}
+}

cmd/web/search.templ

@@ -0,0 +1,81 @@
+package web
+
+templ SearchForm() {
+	@Base() {
+		<button id="dark-mode-toggle">🌙</button>
+		<div id="search-container">
+			<input id="search_term" name="search_term" type="text" hx-post="/findfuzzy" hx-trigger="keyup changed delay:0.25s" hx-target="#soundtracks-container"/>
+			<div class="radio-group" style="display: inline-block; margin-left: 10px;">
+				<label><input type="radio" name="search_type" value="fuzzy" checked> Fuzzy</label>
+				<label><input type="radio" name="search_type" value="normal"> Normal</label>
+			</div>
+			<button type="button" id="clear" name="clear">Clear</button>
+		</div>
+		<div id="soundtracks-container"></div>
+		<script>
+			// Get current search type from radio buttons
+			function getSearchType() {
+				return document.querySelector('input[name="search_type"]:checked').value;
+			}
+			
+			// Get endpoint based on search type
+			function getSearchEndpoint() {
+				return getSearchType() === 'fuzzy' ? '/findfuzzy' : '/find';
+			}
+			
+			// Update search input endpoint
+			function updateSearchEndpoint() {
+				const endpoint = getSearchEndpoint();
+				document.getElementById('search_term').setAttribute('hx-post', endpoint);
+			}
+			
+			document.addEventListener('readystatechange', () => {    
+				if (document.readyState == 'complete') {
+					// Initialize with fuzzy search (default)
+					htmlx.ajax('POST', '/findfuzzy', '#soundtracks-container');
+					document.getElementById("search_term").focus();
+					
+					// Add event listeners for radio buttons
+					document.querySelectorAll('input[name="search_type"]').forEach(radio => {
+						radio.addEventListener('change', updateSearchEndpoint);
+					});
+					
+					// Initialize dark mode from localStorage (default to dark)
+					const savedTheme = localStorage.getItem('theme') || 'dark';
+					if (savedTheme === 'dark') {
+						document.documentElement.setAttribute('data-theme', 'dark');
+						document.getElementById('dark-mode-toggle').textContent = '☀️';
+					}
+				}
+			});
+			
+			// Dark mode toggle functionality
+			document.getElementById("dark-mode-toggle").addEventListener("click", function() {
+				const html = document.documentElement;
+				const currentTheme = html.getAttribute('data-theme');
+				const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+				
+				html.setAttribute('data-theme', newTheme);
+				localStorage.setItem('theme', newTheme);
+				
+				// Update toggle button text
+				this.textContent = newTheme === 'dark' ? '☀️' : '🌙';
+			});
+			
+			document.getElementById("clear").addEventListener("click", function (event) {
+				document.getElementById("search_term").value = "";
+				// Use current search type endpoint
+				htmlx.ajax('POST', getSearchEndpoint(), '#soundtracks-container');
+				document.getElementById("search_term").focus();
+			});
+		</script>
+	}
+}
+
+templ FoundSoundtracks(soundtracks []string) {
+	for _, soundtrack := range soundtracks {
+		<div class="bg-green-100 p-4 shadow-md rounded-lg mt-6">
+			<p class="soundtrack-text">{ soundtrack }</p>
+		</div>
+	}
+}

internal/backend/music.go

@@ -12,8 +12,8 @@ import (
 )
 
 type SongInfo struct {
-	Game             string `json:"Game"`
+	Soundtrack       string `json:"Soundtrack"`
-	GamePlayed       int32  `json:"GamePlayed"`
+	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.Game
+var soundtracksNew []repository.Soundtrack
 
 var songQueNew []repository.Song
 
@@ -37,12 +37,12 @@ func initRepo() {
 	}
 }
 
-func getAllGames() []repository.Game {
+func getAllSoundtracks() []repository.Soundtrack {
-	if len(gamesNew) == 0 {
+	if len(soundtracksNew) == 0 {
 		initRepo()
-		gamesNew, _ = BackendRepo().FindAllGames(BackendCtx())
+		soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 	}
-	return gamesNew
+	return soundtracksNew
 
 }
 
@@ -59,7 +59,7 @@ func Reset() {
 	songQueNew = nil
 	currentSong = -1
 	initRepo()
-	gamesNew, _ = BackendRepo().FindAllGames(BackendCtx())
+	soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 }
 
 func AddLatestToQue() {
@@ -77,8 +77,8 @@ func AddLatestPlayed() {
 	currentSongData := songQueNew[currentSong]
 
 	initRepo()
-	BackendRepo().AddGamePlayed(BackendCtx(), currentSongData.GameID)
+	BackendRepo().AddSoundtrackPlayed(BackendCtx(), currentSongData.SoundtrackID)
-	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{GameID: currentSongData.GameID, SongName: currentSongData.SongName})
+	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{SoundtrackID: currentSongData.SoundtrackID, SongName: currentSongData.SongName})
 }
 
 func SetPlayed(songNumber int) {
@@ -87,39 +87,39 @@ func SetPlayed(songNumber int) {
 	}
 	songData := songQueNew[songNumber]
 	initRepo()
-	BackendRepo().AddGamePlayed(BackendCtx(), songData.GameID)
+	BackendRepo().AddSoundtrackPlayed(BackendCtx(), songData.SoundtrackID)
-	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{GameID: songData.GameID, SongName: songData.SongName})
+	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{SoundtrackID: songData.SoundtrackID, SongName: songData.SongName})
 }
 
 func GetRandomSong() string {
-	getAllGames()
+	getAllSoundtracks()
-	if len(gamesNew) == 0 {
+	if len(soundtracksNew) == 0 {
 		return ""
 	}
 
-	song := getSongFromList(gamesNew)
+	song := getSongFromList(soundtracksNew)
 	lastFetchedNew = song
 	return song.Path
 }
 
 func GetRandomSongLowChance() string {
-	getAllGames()
+	getAllSoundtracks()
 
-	var listOfGames []repository.Game
+	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 {
+	for _, soundtrack := range soundtracksNew {
-		songList, _ := BackendRepo().FindSongsFromGame(BackendCtx(), game.ID)
+		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().GetGameById(BackendCtx(), song.GameID)
+		soundtrackData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID)
 
 		if err != nil {
-			BackendRepo().RemoveBrokenSong(BackendCtx(), song.Path)
+			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.GameName),
+				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(), song.Path)
+			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.GameName),
+				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.GameName,
+		Soundtrack:       currentSoundtrackData.SoundtrackName,
-		GamePlayed:       currentGameData.TimesPlayed,
+		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.GameName,
+			Soundtrack:       soundtrackData.SoundtrackName,
-			GamePlayed:       gameData.TimesPlayed,
+			SoundtrackPlayed: soundtrackData.TimesPlayed,
 			Song:             song.SongName,
 			SongPlayed:       song.TimesPlayed,
 			CurrentlyPlaying: i == currentSong,
@@ -217,22 +217,22 @@ func GetSong(song string) string {
 	return songData.Path
 }
 
-func GetAllGames() []string {
+func GetAllSoundtracks() []string {
-	getAllGames()
+	getAllSoundtracks()
 
 	var jsonArray []string
-	for _, game := range gamesNew {
+	for _, soundtrack := range soundtracksNew {
-		jsonArray = append(jsonArray, game.GameName)
+		jsonArray = append(jsonArray, soundtrack.SoundtrackName)
 	}
 	return jsonArray
 }
 
-func GetAllGamesRandom() []string {
+func GetAllSoundtracksRandom() []string {
-	getAllGames()
+	getAllSoundtracks()
 
 	var jsonArray []string
-	for _, game := range gamesNew {
+	for _, soundtrack := range soundtracksNew {
-		jsonArray = append(jsonArray, game.GameName)
+		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.Game) repository.Song {
+func getSongFromList(soundtracks []repository.Soundtrack) repository.Song {
 	songFound := false
 	var song repository.Song
 	for !songFound {
-		game := getRandomGame(games)
+		soundtrack := getRandomSoundtrack(soundtracks)
-		songs, _ := BackendRepo().FindSongsFromGame(BackendCtx(), game.ID)
+		songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), soundtrack.ID)
 		if len(songs) == 0 {
 			continue
 		}
@@ -280,12 +280,12 @@ func getSongFromList(games []repository.Game) 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(), song.Path)
+			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.GameName),
+				zap.String("soundtrack", soundtrack.SoundtrackName),
 				zap.Any("filename", song.FileName))
 		} else {
 			songFound = true
@@ -299,24 +299,24 @@ func getSongFromList(games []repository.Game) repository.Song {
 	return song
 }
 
-func getCurrentGame(currentSongData repository.Song) repository.Game {
+func getCurrentSoundtrack(currentSongData repository.Song) repository.Soundtrack {
-	for _, game := range gamesNew {
+	for _, soundtrack := range soundtracksNew {
-		if game.ID == currentSongData.GameID {
+		if soundtrack.ID == currentSongData.SoundtrackID {
-			return game
+			return soundtrack
 		}
 	}
-	return repository.Game{}
+	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.Game) repository.Game {
+func getRandomSoundtrack(listOfSoundtracks []repository.Soundtrack) repository.Soundtrack {
-	return listOfGames[rand.Intn(len(listOfGames))]
+	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.Game{
+	soundtracks := []repository.Soundtrack{
-		{GameName: "Game1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
-		{GameName: "Game2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
-		{GameName: "Game3", TimesPlayed: 30},
+		{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.Game{}
+	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,152 +52,150 @@ func TestCalculateAverageEmpty(t *testing.T) {
 }
 
 func TestCalculateAverageSingle(t *testing.T) {
-	games := []repository.Game{
+	soundtracks := []repository.Soundtrack{
-		{GameName: "Game1", TimesPlayed: 42},
+		{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) {
+func TestGetRandomSoundtrack(t *testing.T) {
-	games := []repository.Game{
+	soundtracks := []repository.Soundtrack{
-		{GameName: "Game1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
-		{GameName: "Game2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
-		{GameName: "Game3", TimesPlayed: 30},
+		{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.GameName == "" {
+	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 {
+	for _, s := range soundtracks {
-		if g.GameName == result.GameName {
+		if s.SoundtrackName == result.SoundtrackName {
 			found = true
 			break
 		}
 	}
 
 	if !found {
-		t.Errorf("random game selection returned game not in list: %v", result.GameName)
+		t.Errorf("random soundtrack selection returned soundtrack not in list: %v", result.SoundtrackName)
 	}
 }
 
-func TestFindGameByID(t *testing.T) {
+func TestFindSoundtrackByID(t *testing.T) {
-	games := []repository.Game{
+	soundtracks := []repository.Soundtrack{
-		{ID: 1, GameName: "Game1", TimesPlayed: 10},
+		{ID: 1, SoundtrackName: "Soundtrack1", TimesPlayed: 10},
-		{ID: 2, GameName: "Game2", TimesPlayed: 20},
+		{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
-		{ID: 3, GameName: "Game3", TimesPlayed: 30},
+		{ID: 3, SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	tests := []struct {
-		name     string
+		name         string
-		games    []repository.Game
+		soundtracks  []repository.Soundtrack
-		gameID   int32
+		soundtrackID int32
-		expected repository.Game
+		expected     repository.Soundtrack
 	}{
 		{
-			name:     "existing game",
+			name:         "existing soundtrack",
-			games:    games,
+			soundtracks:  soundtracks,
-			gameID:   2,
+			soundtrackID: 2,
-			expected: repository.Game{ID: 2, GameName: "Game2", TimesPlayed: 20},
+			expected:     repository.Soundtrack{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
 		},
 		{
-			name:     "non-existing game",
+			name:         "non-existing soundtrack",
-			games:    games,
+			soundtracks:  soundtracks,
-			gameID:   99,
+			soundtrackID: 99,
-			expected: repository.Game{},
+			expected:     repository.Soundtrack{},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			var result repository.Game
+			var result repository.Soundtrack
-			for _, game := range tt.games {
+			for _, s := range tt.soundtracks {
-				if game.ID == tt.gameID {
+				if s.ID == tt.soundtrackID {
-					result = game
+					result = s
 					break
 				}
 			}
-			if result.ID != tt.expected.ID || result.GameName != tt.expected.GameName {
+			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 TestExtractGameNames(t *testing.T) {
+func TestExtractSoundtrackNames(t *testing.T) {
-	games := []repository.Game{
+	soundtracks := []repository.Soundtrack{
-		{GameName: "Game1", TimesPlayed: 10},
+		{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
-		{GameName: "Game2", TimesPlayed: 20},
+		{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
-		{GameName: "Game3", TimesPlayed: 30},
+		{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
 	}
 
 	var result []string
-	for _, game := range games {
+	for _, s := range soundtracks {
-		result = append(result, game.GameName)
+		result = append(result, s.SoundtrackName)
 	}
 
-	expected := []string{"Game1", "Game2", "Game3"}
+	expected := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
 
 	if len(result) != len(expected) {
-		t.Errorf("extractGameNames() length = %d, want %d", len(result), len(expected))
+		t.Errorf("extractSoundtrackNames() length = %d, want %d", len(result), len(expected))
 		return
 	}
 
 	for i, v := range result {
 		if v != expected[i] {
-			t.Errorf("extractGameNames()[%d] = %v, want %v", i, v, expected[i])
+			t.Errorf("extractSoundtrackNames()[%d] = %v, want %v", i, v, expected[i])
 		}
 	}
 }
 
-func TestShuffleGameNames(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))
+	original := make([]string, len(soundtracks))
-	copy(original, games)
+	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) {
+	if len(soundtracks) != len(original) {
-		t.Errorf("shuffleGameNames() changed length from %d to %d", len(original), len(games))
+		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 {
+		for _, s := range soundtracks {
-			if g == orig {
+			if s == orig {
 				found = true
 				break
 			}
 		}
 		if !found {
-			t.Errorf("shuffleGameNames() lost element: %v", orig)
+			t.Errorf("shuffleSoundtrackNames() lost element: %v", orig)
 		}
 	}
 }
-
-

internal/backend/statistics.go

@@ -0,0 +1,277 @@
+package backend
+
+import (
+	"encoding/json"
+	"time"
+
+	"music-server/internal/logging"
+
+	"go.uber.org/zap"
+)
+
+// 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 soundtrack info for statistics
+type SongInfoForStats struct {
+	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 {
+	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
+type StatisticsHandler struct {
+	// Uses the global backend repo initialized via InitBackend
+}
+
+// NewStatisticsHandler creates a new StatisticsHandler
+func NewStatisticsHandler() *StatisticsHandler {
+	return &StatisticsHandler{}
+}
+
+// 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.GetMostPlayedSoundtracksWithSongs(ctx, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	// Convert to SoundtrackWithSongs
+	var result []SoundtrackWithSongs
+	for _, row := range rows {
+		var songs []SongInfoForStats
+		if row.Songs != nil {
+			// Parse JSON songs array
+			if err := json.Unmarshal(row.Songs, &songs); err != nil {
+				// Fallback: if JSON parsing fails, create empty song entries
+				songs = make([]SongInfoForStats, 0)
+			}
+		}
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
+			Songs:                songs,
+		})
+	}
+	return result, nil
+}
+
+// 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.GetLeastPlayedSoundtracksWithSongs(ctx, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []SoundtrackWithSongs
+	for _, row := range rows {
+		var songs []SongInfoForStats
+		if row.Songs != nil {
+			if err := json.Unmarshal(row.Songs, &songs); err != nil {
+				songs = make([]SongInfoForStats, 0)
+			}
+		}
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
+			Songs:                songs,
+		})
+	}
+	return result, nil
+}
+
+// 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.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,
+		})
+	}
+	return result, nil
+}
+
+// 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.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,
+		})
+	}
+	return result, nil
+}
+
+// GetNeverPlayedSoundtracks returns soundtracks that have never been played
+func (h *StatisticsHandler) GetNeverPlayedSoundtracks() ([]SoundtrackWithSongs, error) {
+	queries := BackendRepo()
+	ctx := BackendCtx()
+
+	rows, err := queries.GetNeverPlayedSoundtracks(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []SoundtrackWithSongs
+	for _, row := range rows {
+		var songs []SongInfoForStats
+		if row.Songs != nil {
+			if err := json.Unmarshal(row.Songs, &songs); err != nil {
+				songs = make([]SongInfoForStats, 0)
+			}
+		}
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
+			SoundtrackLastPlayed: nil,
+			Songs:                songs,
+		})
+	}
+	return result, nil
+}
+
+// GetLastPlayedSoundtracks returns the most recently played soundtracks
+func (h *StatisticsHandler) GetLastPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
+	queries := BackendRepo()
+	ctx := BackendCtx()
+
+	rows, err := queries.GetLastPlayedSoundtracks(ctx, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []SoundtrackWithSongs
+	for _, row := range rows {
+		var songs []SongInfoForStats
+		if row.Songs != nil {
+			if err := json.Unmarshal(row.Songs, &songs); err != nil {
+				songs = make([]SongInfoForStats, 0)
+			}
+		}
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
+			Songs:                songs,
+		})
+	}
+	return result, nil
+}
+
+// GetOldestPlayedSoundtracks returns the least recently played soundtracks
+func (h *StatisticsHandler) GetOldestPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
+	queries := BackendRepo()
+	ctx := BackendCtx()
+
+	rows, err := queries.GetOldestPlayedSoundtracks(ctx, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []SoundtrackWithSongs
+	for _, row := range rows {
+		var songs []SongInfoForStats
+		if row.Songs != nil {
+			if err := json.Unmarshal(row.Songs, &songs); err != nil {
+				songs = make([]SongInfoForStats, 0)
+			}
+		}
+		result = append(result, SoundtrackWithSongs{
+			SoundtrackID:         row.SoundtrackID,
+			SoundtrackName:       row.SoundtrackName,
+			SoundtrackPlayed:     row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
+			Songs:                songs,
+		})
+	}
+	return result, nil
+}
+
+// GetStatisticsSummary returns overall statistics
+func (h *StatisticsHandler) GetStatisticsSummary() (*StatisticsSummary, error) {
+	queries := BackendRepo()
+	ctx := BackendCtx()
+
+	row, err := queries.GetStatisticsSummary(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &StatisticsSummary{
+		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
+}
+
+// Log helper for statistics operations
+func logStatisticsError(err error, operation string) {
+	if err != nil {
+		logging.GetLogger().Error("Statistics error",
+			zap.String("operation", operation),
+			zap.String("error", err.Error()))
+	}
+}

internal/backend/sync.go

@@ -30,27 +30,33 @@ var start time.Time
 var totalTime time.Duration
 var timeSpent time.Duration
 
-var allGames []repository.Game
+var allSoundtracks []repository.Soundtrack
-var gamesBeforeSync []repository.Game
+var soundtracksBeforeSync []repository.Soundtrack
-var gamesAfterSync []repository.Game
+var soundtracksAfterSync []repository.Soundtrack
-var gamesAdded []string
+var soundtracksAdded []string
-var gamesReAdded []string
+var soundtracksReAdded []string
-var gamesChangedTitle map[string]string
+var soundtracksChangedTitle map[string]string
-var gamesChangedContent []string
+var soundtracksChangedContent []string
-var gamesRemoved []string
+var soundtracksRemoved []string
 var catchedErrors []string
-var brokenSongs []string
+
+type brokenSong struct {
+	SoundtrackID int32
+	Path         string
+}
+
+var brokenSongs []brokenSong
 var pool *ants.Pool
 var poolSong *ants.Pool
 
 type SyncResponse struct {
-	GamesAdded          []string          `json:"games_added"`
+	SoundtracksAdded          []string          `json:"soundtracks_added"`
-	GamesReAdded        []string          `json:"games_re_added"`
+	SoundtracksReAdded        []string          `json:"soundtracks_re_added"`
-	GamesChangedTitle   map[string]string `json:"games_changed_title"`
+	SoundtracksChangedTitle   map[string]string `json:"soundtracks_changed_title"`
-	GamesChangedContent []string          `json:"games_changed_content"`
+	SoundtracksChangedContent []string          `json:"soundtracks_changed_content"`
-	GamesRemoved        []string          `json:"games_removed"`
+	SoundtracksRemoved        []string          `json:"soundtracks_removed"`
-	CatchedErrors       []string          `json:"catched_errors"`
+	CatchedErrors             []string          `json:"catched_errors"`
-	TotalTime           string            `json:"total_time"`
+	TotalTime                 string            `json:"total_time"`
 }
 
 type ProgressResponse struct {
@@ -58,29 +64,29 @@ type ProgressResponse struct {
 	TimeSpent string `json:"time_spent"`
 }
 
-type GameStatus int
+type SoundtrackStatus int
 
 const (
-	NotChanged GameStatus = iota
+	NotChanged SoundtrackStatus = iota
 	TitleChanged
-	GameChanged
+	SoundtrackChanged
-	NewGame
+	NewSoundtrack
 )
 
-var statusName = map[GameStatus]string{
+var statusName = map[SoundtrackStatus]string{
-	NotChanged:   "Not changed",
+	NotChanged:        "Not changed",
-	TitleChanged: "Title changed",
+	TitleChanged:      "Title changed",
-	GameChanged:  "Game changed",
+	SoundtrackChanged: "Soundtrack changed",
-	NewGame:      "New game",
+	NewSoundtrack:     "New soundtrack",
 }
 
-func (gs GameStatus) String() string {
+func (ss SoundtrackStatus) String() string {
-	return statusName[gs]
+	return statusName[ss]
 }
 
 func ResetDB() {
 	repo.ClearSongs(BackendCtx())
-	repo.ClearGames(BackendCtx())
+	repo.ClearSoundtracks(BackendCtx())
 }
 
 func SyncProgress() ProgressResponse {
@@ -101,54 +107,54 @@ func SyncProgress() ProgressResponse {
 
 func SyncResult() SyncResponse {
 	logging.GetLogger().Info("Sync completed",
-		zap.Int("games_before", len(gamesBeforeSync)),
+		zap.Int("soundtracks_before", len(soundtracksBeforeSync)),
-		zap.Int("games_after", len(gamesAfterSync)))
+		zap.Int("soundtracks_after", len(soundtracksAfterSync)))
 
-	if len(gamesAdded) > 0 {
+	if len(soundtracksAdded) > 0 {
-		logging.GetLogger().Debug("Games added", zap.Strings("games", gamesAdded))
+		logging.GetLogger().Debug("Soundtracks added", zap.Strings("soundtracks", soundtracksAdded))
 	}
 
-	if len(gamesReAdded) > 0 {
+	if len(soundtracksReAdded) > 0 {
-		logging.GetLogger().Debug("Games readded", zap.Strings("games", gamesReAdded))
+		logging.GetLogger().Debug("Soundtracks readded", zap.Strings("soundtracks", soundtracksReAdded))
 	}
 
-	if len(gamesChangedTitle) > 0 {
+	if len(soundtracksChangedTitle) > 0 {
-		logging.GetLogger().Debug("Games with changed title", zap.Any("changes", gamesChangedTitle))
+		logging.GetLogger().Debug("Soundtracks with changed title", zap.Any("changes", soundtracksChangedTitle))
 	}
 
-	if len(gamesChangedContent) > 0 {
+	if len(soundtracksChangedContent) > 0 {
-		logging.GetLogger().Debug("Games with changed content", zap.Strings("games", gamesChangedContent))
+		logging.GetLogger().Debug("Soundtracks with changed content", zap.Strings("soundtracks", soundtracksChangedContent))
 	}
 
-	var gamesRemovedTemp []string
+	var soundtracksRemovedTemp []string
-	for _, beforeGame := range gamesBeforeSync {
+	for _, beforeSoundtrack := range soundtracksBeforeSync {
 		var found = false
-		for _, afterGame := range gamesAfterSync {
+		for _, afterSoundtrack := range soundtracksAfterSync {
-			if beforeGame.GameName == afterGame.GameName {
+			if beforeSoundtrack.SoundtrackName == afterSoundtrack.SoundtrackName {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.GameName)
+			soundtracksRemovedTemp = append(soundtracksRemovedTemp, beforeSoundtrack.SoundtrackName)
 		}
 	}
 
-	for _, game := range gamesRemovedTemp {
+	for _, soundtrack := range soundtracksRemovedTemp {
 		var found bool = false
-		for key := range gamesChangedTitle {
+		for key := range soundtracksChangedTitle {
-			if game == key {
+			if soundtrack == key {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemoved = append(gamesRemoved, game)
+			soundtracksRemoved = append(soundtracksRemoved, soundtrack)
 		}
 	}
 
-	if len(gamesRemoved) > 0 {
+	if len(soundtracksRemoved) > 0 {
-		logging.GetLogger().Debug("Games removed", zap.Strings("games", gamesRemoved))
+		logging.GetLogger().Debug("Soundtracks removed", zap.Strings("soundtracks", soundtracksRemoved))
 	}
 
 	if len(catchedErrors) > 0 {
@@ -159,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,
+		SoundtracksAdded:          soundtracksAdded,
-		GamesReAdded:        gamesReAdded,
+		SoundtracksReAdded:        soundtracksReAdded,
-		GamesChangedTitle:   gamesChangedTitle,
+		SoundtracksChangedTitle:   soundtracksChangedTitle,
-		GamesChangedContent: gamesChangedContent,
+		SoundtracksChangedContent: soundtracksChangedContent,
-		GamesRemoved:        gamesRemoved,
+		SoundtracksRemoved:        soundtracksRemoved,
-		CatchedErrors:       catchedErrors,
+		CatchedErrors:             catchedErrors,
-		TotalTime:           out.Format("15:04:05"),
+		TotalTime:                 out.Format("15:04:05"),
 	}
 }
 
-func SyncGamesNewFull() {
+func SyncSoundtracksFull() {
-	syncGamesNew(true)
+	syncSoundtracks(true)
 	Reset()
 }
 
-func SyncGamesNewOnlyChanges() {
+func SyncSoundtracksOnlyChanges() {
-	syncGamesNew(false)
+	syncSoundtracks(false)
 	Reset()
 }
 
-func syncGamesNew(full bool) {
+func syncSoundtracks(full bool) {
 	musicPath := os.Getenv("MUSIC_PATH")
 	fmt.Printf("dir: %s\n", musicPath)
 	logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath))
@@ -195,22 +201,22 @@ func syncGamesNew(full bool) {
 	logging.GetLogger().Debug("Folders to skip during sync", zap.Strings("folders", foldersToSkip))
 
 	var err error
-	gamesAdded = nil
+	soundtracksAdded = nil
-	gamesReAdded = nil
+	soundtracksReAdded = nil
-	gamesChangedTitle = nil
+	soundtracksChangedTitle = nil
-	gamesChangedContent = nil
+	soundtracksChangedContent = nil
-	gamesRemoved = nil
+	soundtracksRemoved = nil
 	catchedErrors = nil
 	brokenSongs = nil
 
-	gamesBeforeSync, err = repo.FindAllGames(BackendCtx())
+	soundtracksBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
-	handleError("FindAllGames Before", err, "")
+	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.GetAllGamesIncludingDeleted(BackendCtx())
+	allSoundtracks, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
-	handleError("GetAllGamesIncludingDeleted", err, "")
+	handleError("GetAllSoundtracksIncludingDeleted", err, "")
-	err = repo.SetGameDeletionDate(BackendCtx())
+	err = repo.SetSoundtrackDeletionDate(BackendCtx())
-	handleError("SetGameDeletionDate", err, "")
+	handleError("SetSoundtrackDeletionDate", err, "")
 
 	directories, err := os.ReadDir(musicPath)
 	if err != nil {
@@ -227,14 +233,14 @@ func syncGamesNew(full bool) {
 	for _, dir := range directories {
 		pool.Submit(func() {
 			defer syncWg.Done()
-			syncGameNew(dir, foldersToSkip, musicPath, full)
+			syncSoundtrack(dir, foldersToSkip, musicPath, full)
 		})
 	}
 	syncWg.Wait()
-	checkBrokenSongsNew()
+	checkBrokenSongs()
 
-	gamesAfterSync, err = repo.FindAllGames(BackendCtx())
+	soundtracksAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
-	handleError("FindAllGames After", err, "")
+	handleError("FindAllSoundtracks After", err, "")
 
 	finished := time.Now()
 	totalTime = finished.Sub(start)
@@ -244,7 +250,7 @@ func syncGamesNew(full bool) {
 	Syncing = false
 }
 
-func checkBrokenSongsNew() {
+func checkBrokenSongs() {
 	allSongs, err := repo.FetchAllSongs(BackendCtx())
 	handleError("FetchAllSongs", err, "")
 	var brokenWg sync.WaitGroup
@@ -255,20 +261,22 @@ func checkBrokenSongsNew() {
 	for _, song := range allSongs {
 		poolBroken.Submit(func() {
 			defer brokenWg.Done()
-			checkBrokenSongNew(song)
+			checkBrokenSong(song)
 		})
 	}
 	brokenWg.Wait()
-	err = repo.RemoveBrokenSongs(BackendCtx(), brokenSongs)
+	for _, bs := range brokenSongs {
-	handleError("RemoveBrokenSongs", err, "")
+		err = repo.RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: bs.SoundtrackID, Path: bs.Path})
+		handleError("RemoveBrokenSong", err, "")
+	}
 }
 
-func checkBrokenSongNew(song repository.Song) {
+func checkBrokenSong(song repository.Song) {
 	//Check if file exists and open
 	openFile, err := os.Open(song.Path)
 	if err != nil {
 		//File not found
-		brokenSongs = append(brokenSongs, song.Path)
+		brokenSongs = append(brokenSongs, brokenSong{SoundtrackID: song.SoundtrackID, Path: song.Path})
 		logging.GetLogger().Warn("Broken song found", zap.String("path", song.Path))
 	} else {
 		err = openFile.Close()
@@ -278,118 +286,86 @@ func checkBrokenSongNew(song repository.Song) {
 	}
 }
 
-func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
+func syncSoundtrack(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()))
+		logging.GetLogger().Debug("Syncing soundtrack", zap.String("soundtrack", file.Name()))
-		gameDir := baseDir + file.Name() + "/"
+		soundtrackDir := baseDir + file.Name() + "/"
-		dirHash := getHashForDir(gameDir)
+		dirHash := getHashForDir(soundtrackDir)
 
-		var status GameStatus = NewGame
+		var status SoundtrackStatus = NewSoundtrack
-		var oldGame repository.Game
+		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 {
+		for _, currentSoundtrack := range allSoundtracks {
-			oldGame = currentGame
+			oldSoundtrack = currentSoundtrack
-			//fmt.Printf("%s | %s\n", oldGame.GameName, oldGame.Hash)
+			//fmt.Printf("%s | %s\n", oldSoundtrack.SoundtrackName, oldSoundtrack.Hash)
-			if oldGame.GameName == file.Name() && oldGame.Hash == dirHash {
+			if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash == dirHash {
 				status = NotChanged
-				id = oldGame.ID
+				id = oldSoundtrack.ID
-				//fmt.Printf("Game not changed\n")
+				//fmt.Printf("Soundtrack not changed\n")
 				break
-			} else if oldGame.GameName == file.Name() && oldGame.Hash != dirHash {
+			} else if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash != dirHash {
-				status = GameChanged
+				status = SoundtrackChanged
-				id = oldGame.ID
+				id = oldSoundtrack.ID
-				//fmt.Printf("Game changed\n")
+				//fmt.Printf("Soundtrack changed\n")
 				break
-			} else if oldGame.GameName != file.Name() && oldGame.Hash == dirHash {
+			} else if oldSoundtrack.SoundtrackName != file.Name() && oldSoundtrack.Hash == dirHash {
 				status = TitleChanged
-				id = oldGame.ID
+				id = oldSoundtrack.ID
-				//fmt.Printf("GameName changed\n")
+				//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 {
+			id = insertSoundtrack(file.Name(), soundtrackDir, dirHash)
-				for _, entry := range entries {
+			logging.GetLogger().Debug("New soundtrack detected",
-					fileInfo, err := entry.Info()
-					if err != nil {
-						logging.GetLogger().Error("Failed to get file info", zap.String("error", err.Error()))
-						continue
-					}
-					id = getIdFromFileNew(fileInfo)
-					if id != -1 {
-						break
-					}
-				}
-				err = repo.InsertGameWithExistingId(BackendCtx(), repository.InsertGameWithExistingIdParams{ID: id, GameName: file.Name(), Path: gameDir, Hash: dirHash})
-				handleError("InsertGameWithExistingId", err, "")
-				if err != nil {
-					logging.GetLogger().Debug("Game already exists, removing old ID file",
-						zap.Int32("id", id),
-						zap.String("game_dir", gameDir))
-					fileName := gameDir + "/." + strconv.Itoa(int(id)) + ".id"
-					logging.GetLogger().Debug("Removing ID file", zap.String("filename", fileName))
-
-					err := os.Remove(fileName)
-					if err != nil {
-						logging.GetLogger().Error("Failed to remove ID file", zap.String("filename", fileName), zap.String("error", err.Error()))
-					}
-
-					newDirHash := getHashForDir(gameDir)
-
-					id = insertGameNew(file.Name(), gameDir, newDirHash)
-				}
-			} else {
-				id = insertGameNew(file.Name(), gameDir, dirHash)
-			}
-			logging.GetLogger().Debug("New game 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())
+			soundtracksAdded = append(soundtracksAdded, file.Name())
-			newCheckSongs(entries, gameDir, id)
+			checkSongs(entries, soundtrackDir, id)
-		case GameChanged:
+		case SoundtrackChanged:
-			logging.GetLogger().Debug("Game changed",
+			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.UpdateGameHash(BackendCtx(), repository.UpdateGameHashParams{Hash: dirHash, ID: id})
+			err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
-			handleError("UpdateGameHash", err, "")
+			handleError("UpdateSoundtrackHash", err, "")
-			gamesChangedContent = append(gamesChangedContent, file.Name())
+			soundtracksChangedContent = append(soundtracksChangedContent, file.Name())
-			newCheckSongs(entries, gameDir, id)
+			checkSongs(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.GameName),
+				zap.String("oldName", oldSoundtrack.SoundtrackName),
 				zap.String("newName", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			err = repo.UpdateGameName(BackendCtx(), repository.UpdateGameNameParams{Name: file.Name(), Path: gameDir, ID: id})
+			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: soundtrackDir, ID: id})
-			handleError("UpdateGameName", err, "")
+			handleError("UpdateSoundtrackName", err, "")
-			newCheckSongs(entries, gameDir, id)
+			checkSongs(entries, soundtrackDir, id)
-			if gamesChangedTitle == nil {
+			if soundtracksChangedTitle == nil {
-				gamesChangedTitle = make(map[string]string)
+				soundtracksChangedTitle = make(map[string]string)
 			}
-			gamesChangedTitle[oldGame.GameName] = file.Name()
+			soundtracksChangedTitle[oldSoundtrack.SoundtrackName] = file.Name()
 		case NotChanged:
 			var found bool = false
-			for _, beforeGame := range gamesBeforeSync {
+			for _, beforeSoundtrack := range soundtracksBeforeSync {
-				if dirHash == beforeGame.Hash {
+				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),
@@ -397,9 +373,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 				}
 			}
 			if !found {
-				newCheckSongs(entries, gameDir, id)
+				checkSongs(entries, soundtrackDir, id)
-				gamesReAdded = append(gamesReAdded, file.Name())
+				soundtracksReAdded = append(soundtracksReAdded, file.Name())
-				logging.GetLogger().Debug("Game added again",
+				logging.GetLogger().Debug("Soundtrack added again",
 					zap.Int32("id", id),
 					zap.String("newName", file.Name()),
 					zap.String("hash", dirHash),
@@ -407,13 +383,13 @@ 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.RemoveDeletionDate(BackendCtx(), id)
+		err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id)
-		handleError("RemoveDeletionDate", err, "")
+		handleError("RemoveSoundtrackDeletionDate", err, "")
 	}
 	foldersSynced++
 	logging.GetLogger().Debug("Sync progress",
@@ -422,24 +398,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 insertSoundtrack(name string, path string, hash string) int32 {
 	var duplicateError = errors.New("ERROR: duplicate key value violates unique")
-	id, err := repo.InsertGame(BackendCtx(), repository.InsertGameParams{GameName: name, Path: path, Hash: hash})
+	id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash})
-	handleError("InsertGame", err, "")
+	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.ResetGameIdSeq(BackendCtx())
+			_, err = repo.ResetSoundtrackIdSeq(BackendCtx())
-			handleError("ResetGameIdSeq", err, "")
+			handleError("ResetSoundtrackIdSeq", err, "")
-			id = insertGameNew(name, path, hash)
+			id = insertSoundtrack(name, path, hash)
 		}
 	}
 	return id
 
 }
 
-func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
+func checkSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
 	//hasher := md5.New()
 	var numberOfSongs int32
 	numberOfFiles := len(entries)
@@ -449,7 +425,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 checkSong(entry, soundtrackDir, id) {
 				numberOfSongs++
 			}
 		})
@@ -458,7 +434,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
 	return numberOfSongs
 }
 
-func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
+func checkSong(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()))
@@ -466,7 +442,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++
@@ -475,44 +451,44 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 		songName, _ := strings.CutSuffix(fileName, ".mp3")
 
 		song, err := repo.GetSongWithHash(BackendCtx(), songHash)
-		handleError("GetSongWithHash", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+		handleError("GetSongWithHash", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 		if err == nil {
 			if song.SongName == songName && song.Path == path {
 				return false
 			}
 		}
 		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))
 
 		count, err := repo.CheckSongWithHash(BackendCtx(), songHash)
-		handleError("CheckSongWithHash", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
+		handleError("CheckSongWithHash", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
 		if err != nil {
-			count2, err := repo.CheckSong(BackendCtx(), path)
+			count2, err := repo.CheckSong(BackendCtx(), repository.CheckSongParams{SoundtrackID: id, Path: path})
-			handleError("CheckSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
+			handleError("CheckSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
 			if count2 > 0 {
-				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, Path: path})
+				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, SoundtrackID: id, Path: path})
-				handleError("AddHashToSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("AddHashToSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 				count, err = repo.CheckSongWithHash(BackendCtx(), songHash)
-				handleError("CheckSongWithHash 2", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("CheckSongWithHash 2", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			}
 		}
 
 		//count, _ := repo.CheckSong(ctx, path)
 		if count > 0 {
 			err = repo.UpdateSong(BackendCtx(), repository.UpdateSongParams{SongName: songName, FileName: &fileName, Path: path, Hash: songHash})
-			handleError("UpdateSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+			handleError("UpdateSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 		} else {
-			count2, err := repo.CheckSong(BackendCtx(), path)
+			count2, err := repo.CheckSong(BackendCtx(), repository.CheckSongParams{SoundtrackID: id, Path: path})
-			handleError("CheckSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+			handleError("CheckSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			if count2 > 0 {
-				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, Path: path})
+				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, SoundtrackID: id, Path: path})
-				handleError("AddHashToSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("AddHashToSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			} else {
-				err = repo.AddSong(BackendCtx(), repository.AddSongParams{GameID: id, SongName: songName, Path: path, FileName: &fileName, Hash: songHash})
+				err = repo.AddSong(BackendCtx(), repository.AddSongParams{SoundtrackID: id, SongName: songName, Path: path, FileName: &fileName, Hash: songHash})
-				handleError("AddSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("AddSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 
 			}
 		}
@@ -540,8 +516,8 @@ func handleError(funcName string, err error, msg string) {
 	}
 }
 
-func getHashForDir(gameDir string) string {
+func getHashForDir(soundtrackDir string) string {
-	directory, _ := directory_checksum.ScanDirectory(gameDir, afero.NewOsFs())
+	directory, _ := directory_checksum.ScanDirectory(soundtrackDir, afero.NewOsFs())
 	hash, _ := directory.ComputeDirectoryChecksums()
 
 	return hash
@@ -562,7 +538,7 @@ func getHashForFile(path string) string {
 	return hex.EncodeToString(hasher.Sum(nil))
 }
 
-func getIdFromFileNew(file os.FileInfo) int32 {
+func getIdFromFile(file os.FileInfo) int32 {
 	name := file.Name()
 	if !file.IsDir() && strings.HasSuffix(name, ".id") {
 		name = strings.Replace(name, ".id", "", 1)

internal/backend/sync_test.go

@@ -9,10 +9,10 @@ import (
 
 func TestContains(t *testing.T) {
 	tests := []struct {
-		name      string
+		name     string
-		slice     []string
+		slice    []string
-		search    string
+		search   string
-		expected  bool
+		expected bool
 	}{
 		{
 			name:     "element exists",
@@ -155,9 +155,9 @@ func TestGetIdFromFileNew(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := getIdFromFileNew(tt.fileInfo)
+			result := getIdFromFile(tt.fileInfo)
 			if result != tt.expected {
-				t.Errorf("getIdFromFileNew() = %v, want %v", result, tt.expected)
+				t.Errorf("getIdFromFile() = %v, want %v", result, tt.expected)
 			}
 		})
 	}
@@ -172,10 +172,10 @@ type mockFileInfoForSong struct {
 
 func (m *mockFileInfoForSong) Name() string       { return m.name }
 func (m *mockFileInfoForSong) Size() int64        { return m.size }
-func (m *mockFileInfoForSong) Mode() os.FileMode   { return 0 }
+func (m *mockFileInfoForSong) Mode() os.FileMode  { return 0 }
-func (m *mockFileInfoForSong) ModTime() time.Time  { return time.Time{} }
+func (m *mockFileInfoForSong) ModTime() time.Time { return time.Time{} }
-func (m *mockFileInfoForSong) IsDir() bool         { return m.isDir }
+func (m *mockFileInfoForSong) IsDir() bool        { return m.isDir }
-func (m *mockFileInfoForSong) Sys() interface{}    { return nil }
+func (m *mockFileInfoForSong) Sys() interface{}   { return nil }
 
 type mockFileInfoForCover struct {
 	name  string
@@ -185,10 +185,10 @@ type mockFileInfoForCover struct {
 
 func (m *mockFileInfoForCover) Name() string       { return m.name }
 func (m *mockFileInfoForCover) Size() int64        { return m.size }
-func (m *mockFileInfoForCover) Mode() os.FileMode   { return 0 }
+func (m *mockFileInfoForCover) Mode() os.FileMode  { return 0 }
-func (m *mockFileInfoForCover) ModTime() time.Time  { return time.Time{} }
+func (m *mockFileInfoForCover) ModTime() time.Time { return time.Time{} }
-func (m *mockFileInfoForCover) IsDir() bool         { return m.isDir }
+func (m *mockFileInfoForCover) IsDir() bool        { return m.isDir }
-func (m *mockFileInfoForCover) Sys() interface{}    { return nil }
+func (m *mockFileInfoForCover) Sys() interface{}   { return nil }
 
 type mockFileInfoForId struct {
 	name  string
@@ -198,7 +198,7 @@ type mockFileInfoForId struct {
 
 func (m *mockFileInfoForId) Name() string       { return m.name }
 func (m *mockFileInfoForId) Size() int64        { return m.size }
-func (m *mockFileInfoForId) Mode() os.FileMode   { return 0 }
+func (m *mockFileInfoForId) Mode() os.FileMode  { return 0 }
-func (m *mockFileInfoForId) ModTime() time.Time  { return time.Time{} }
+func (m *mockFileInfoForId) ModTime() time.Time { return time.Time{} }
-func (m *mockFileInfoForId) IsDir() bool         { return m.isDir }
+func (m *mockFileInfoForId) IsDir() bool        { return m.isDir }
-func (m *mockFileInfoForId) Sys() interface{}    { return nil }
+func (m *mockFileInfoForId) Sys() interface{}   { return nil }

internal/db/database.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"time"
 
 	"music-server/internal/logging"
 
@@ -59,6 +60,26 @@ func (db *Database) Close() {
 	}
 }
 
+// Health checks the health of the database connection by pinging the database.
+// It returns a map with keys indicating various health statistics.
+func (db *Database) Health() map[string]string {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	stats := make(map[string]string)
+
+	// Ping the database
+	err := db.Pool.Ping(ctx)
+	if err != nil {
+		stats["status"] = "down"
+		stats["error"] = err.Error()
+		return stats
+	}
+
+	stats["status"] = "up"
+	return stats
+}
+
 // RunMigrations runs all pending database migrations to the latest version.
 // Uses the existing pool to extract connection details.
 func (db *Database) RunMigrations() error {

internal/db/dbHelper.go

@@ -20,6 +20,9 @@ import (
 	"go.uber.org/zap"
 )
 
+// TODO: DEPRECATED - Remove these global variables once all code is migrated to use Database struct
+// Use database.go's Database struct instead. These globals remain for backward compatibility
+// with legacy code paths. New code should use the Database struct from database.go.
 var Dbpool *pgxpool.Pool
 var Ctx = context.Background()
 
@@ -53,10 +56,10 @@ func CloseDb() {
 	Dbpool.Close()
 }
 
-func ResetGameIdSeq() {
+func ResetSoundtrackIdSeq() {
-	_, err := Dbpool.Query(Ctx, "SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);")
+	_, 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/migration_test.go

@@ -0,0 +1,251 @@
+package db
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database/postgres"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+	_ "github.com/lib/pq"
+	"github.com/stretchr/testify/require"
+)
+
+// TestMigrationsStepByStep tests applying migrations incrementally
+// Then adding data manually, then completing migrations
+func TestMigrationsStepByStep(t *testing.T) {
+	host := os.Getenv("DB_HOST")
+	port := os.Getenv("DB_PORT")
+	user := os.Getenv("DB_USERNAME")
+	password := os.Getenv("DB_PASSWORD")
+	// Use a unique database name for this test
+	dbname := "music_server_migration_test"
+
+	if host == "" || port == "" || user == "" || password == "" {
+		t.Skip("Test database environment variables not set (DB_HOST, DB_PORT, DB_USERNAME, DB_PASSWORD)")
+	}
+
+	// Clean up: drop database if it exists
+	cleanupDB(t, host, port, user, password, dbname)
+	defer cleanupDB(t, host, port, user, password, dbname)
+
+	// Create the database
+	createTestDB(t, host, port, user, password, dbname)
+
+	// Step 1: Apply first 4 migrations (before soundtrack rename)
+	// This creates: game, song, vgmq, song_list tables
+	// And sessions table with indexes
+	t.Run("ApplyFirst4Migrations", func(t *testing.T) {
+		applyMigrations(t, host, port, user, password, dbname, 4)
+	})
+
+	// Step 2: Add data manually to game and song tables
+	t.Run("AddManualData", func(t *testing.T) {
+		connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
+			host, port, user, password, dbname)
+		db, err := sql.Open("postgres", connStr)
+		require.NoError(t, err)
+		defer db.Close()
+
+		// Insert 5 games manually
+		for i := 1; i <= 5; i++ {
+			gameName := fmt.Sprintf("Manual Game %d", i)
+			path := fmt.Sprintf("/manual/path/game%d", i)
+			hash := fmt.Sprintf("hash-%d", i)
+
+			_, err := db.Exec(`INSERT INTO game (game_name, path, hash, added) 
+				VALUES ($1, $2, $3, NOW())`,
+				gameName, path, hash)
+			require.NoError(t, err, "Failed to insert game %d", i)
+		}
+
+		// Insert songs for each game
+		songs := []struct {
+			gameID int
+			name   string
+			path   string
+		}{
+			{1, "Song A", "/path/a.mp3"},
+			{1, "Song B", "/path/b.mp3"},
+			{2, "Song C", "/path/c.mp3"},
+			{2, "Song D", "/path/d.mp3"},
+			{3, "Song E", "/path/e.mp3"},
+			{4, "Song F", "/path/f.mp3"},
+			{4, "Song G", "/path/g.mp3"},
+			{4, "Song H", "/path/h.mp3"},
+			{5, "Song I", "/path/i.mp3"},
+		}
+
+		for _, s := range songs {
+			_, err := db.Exec(`INSERT INTO song (game_id, song_name, path, hash) 
+				VALUES ($1, $2, $3, $4)`,
+				s.gameID, s.name, s.path, fmt.Sprintf("song-hash-%s", s.name))
+			require.NoError(t, err, "Failed to insert song %s", s.name)
+		}
+
+		// Verify data was inserted
+		var gameCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM game").Scan(&gameCount)
+		require.NoError(t, err)
+		require.Equal(t, 5, gameCount, "Expected 5 games")
+
+		var songCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM song").Scan(&songCount)
+		require.NoError(t, err)
+		require.Equal(t, 9, songCount, "Expected 9 songs")
+
+		t.Log("✓ Manually inserted 5 games with 9 songs")
+	})
+
+	// Step 3: Apply migration 5 (rename game→soundtrack)
+	t.Run("ApplyMigration5", func(t *testing.T) {
+		// Apply the remaining migrations (just migration 5)
+		applyMigrations(t, host, port, user, password, dbname, 1)
+
+		// Verify tables were renamed
+		connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
+			host, port, user, password, dbname)
+		db, err := sql.Open("postgres", connStr)
+		require.NoError(t, err)
+		defer db.Close()
+
+		// Check that soundtrack table exists
+		var soundtrackCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM soundtrack").Scan(&soundtrackCount)
+		require.NoError(t, err)
+		require.Equal(t, 5, soundtrackCount, "Expected 5 soundtracks after migration")
+
+		// Check that game table no longer exists
+		_, err = db.Exec("SELECT 1 FROM game LIMIT 1")
+		require.Error(t, err, "game table should not exist after migration")
+
+		// Check that song table has soundtrack_id column
+		var songCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM song").Scan(&songCount)
+		require.NoError(t, err)
+		require.Equal(t, 9, songCount, "Expected 9 songs after migration")
+
+		// Verify data integrity: soundtrack_name values
+		rows, err := db.Query("SELECT soundtrack_name FROM soundtrack ORDER BY id")
+		require.NoError(t, err)
+		defer rows.Close()
+
+		expectedNames := []string{"Manual Game 1", "Manual Game 2", "Manual Game 3", "Manual Game 4", "Manual Game 5"}
+		actualNames := make([]string, 0)
+		for rows.Next() {
+			var name string
+			err := rows.Scan(&name)
+			require.NoError(t, err)
+			actualNames = append(actualNames, name)
+		}
+		require.Equal(t, expectedNames, actualNames, "Soundtrack names should match original game names")
+
+		t.Log("✓ Migration 5 applied successfully, data preserved")
+	})
+}
+
+// cleanupDB drops the test database
+func cleanupDB(t *testing.T, host, port, user, password, dbname string) {
+	connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=postgres sslmode=disable",
+		host, port, user, password)
+	db, err := sql.Open("postgres", connStr)
+	if err != nil {
+		t.Logf("Warning: could not connect to cleanup DB: %v", err)
+		return
+	}
+	defer db.Close()
+
+	// Check if database exists before dropping
+	var exists int
+	err = db.QueryRow("SELECT 1 FROM pg_database WHERE datname = $1", dbname).Scan(&exists)
+	if err != nil && err != sql.ErrNoRows {
+		t.Logf("Warning: could not check if DB exists: %v", err)
+		return
+	}
+
+	if exists == 1 {
+		_, err = db.Exec("DROP DATABASE " + dbname + " WITH (FORCE)")
+		if err != nil {
+			t.Logf("Warning: could not drop DB: %v", err)
+		}
+	}
+}
+
+// createTestDB creates a fresh test database
+func createTestDB(t *testing.T, host, port, user, password, dbname string) {
+	connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=postgres sslmode=disable",
+		host, port, user, password)
+	db, err := sql.Open("postgres", connStr)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Drop if exists
+	cleanupDB(t, host, port, user, password, dbname)
+
+	// Create database
+	_, err = db.Exec("CREATE DATABASE " + dbname)
+	require.NoError(t, err)
+
+	// Enable UUID extension if needed
+	connStrDB := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
+		host, port, user, password, dbname)
+	db2, err := sql.Open("postgres", connStrDB)
+	require.NoError(t, err)
+	defer db2.Close()
+
+	_, err = db2.Exec("CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\"")
+	if err != nil {
+		t.Logf("Note: uuid-ossp extension may not be available: %v", err)
+	}
+}
+
+// applyMigrations applies n migrations to the database using Go migrate library
+func applyMigrations(t *testing.T, host, port, user, password, dbname string, steps int) {
+	migrationURL := fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=disable",
+		user, password, host, port, dbname)
+
+	db, err := sql.Open("postgres", migrationURL)
+	require.NoError(t, err)
+	defer db.Close()
+
+	driver, err := postgres.WithInstance(db, &postgres.Config{})
+	require.NoError(t, err)
+
+	m, err := migrate.NewWithDatabaseInstance(
+		"file://migrations",
+		"postgres", driver)
+	require.NoError(t, err)
+
+	// Get current version
+	version, _, err := m.Version()
+	if err != nil && err != migrate.ErrNilVersion {
+		require.NoError(t, err)
+	}
+	if err == migrate.ErrNilVersion {
+		version = 0
+	}
+	t.Logf("Current migration version: %d", version)
+
+	// Apply exactly 'steps' migrations
+	if steps > 0 {
+		err = m.Steps(steps)
+		if err != nil && err != migrate.ErrNoChange {
+			require.NoError(t, err)
+		}
+	} else if steps < 0 {
+		err = m.Steps(steps)
+		require.NoError(t, err)
+	}
+
+	// Get new version
+	newVersion, _, err := m.Version()
+	if err != nil && err != migrate.ErrNilVersion {
+		require.NoError(t, err)
+	}
+	if err == migrate.ErrNilVersion {
+		newVersion = 0
+	}
+	t.Logf("Migration version after applying %d steps: %d", steps, newVersion)
+}

internal/db/migrations/000005_rename_game_to_soundtrack.down.sql

@@ -0,0 +1,33 @@
+-- Revert: Rename soundtrack table back to game
+ALTER TABLE soundtrack RENAME TO game;
+
+-- Revert primary key sequence
+ALTER SEQUENCE soundtrack_id_seq RENAME TO game_id_seq;
+
+-- Revert columns in game table
+ALTER TABLE game RENAME COLUMN soundtrack_name TO game_name;
+
+-- Revert song table: rename soundtrack_id back to game_id
+ALTER TABLE song RENAME COLUMN soundtrack_id TO game_id;
+
+-- Revert song primary key
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_pkey;
+ALTER TABLE song ADD PRIMARY KEY (game_id, path);
+ALTER TABLE song RENAME CONSTRAINT song_pkey_soundtrack TO song_pkey;
+
+-- Revert song_list table references
+ALTER TABLE song_list RENAME COLUMN soundtrack_name TO game_name;
+
+-- Revert foreign key constraint
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_soundtrack_id_fkey;
+ALTER TABLE song ADD CONSTRAINT song_game_id_fkey 
+    FOREIGN KEY (game_id) REFERENCES game(id);
+
+-- Revert indexes
+ALTER INDEX IF EXISTS idx_soundtrack_deleted RENAME TO idx_game_deleted;
+ALTER INDEX IF EXISTS idx_soundtrack_hash RENAME TO idx_game_hash;
+ALTER INDEX IF EXISTS idx_soundtrack_path RENAME TO idx_game_path;
+ALTER INDEX IF EXISTS idx_soundtrack_name RENAME TO idx_game_name;
+ALTER INDEX IF EXISTS idx_song_soundtrack_id RENAME TO idx_song_game_id;
+ALTER INDEX IF EXISTS idx_song_soundtrack_id_song_name RENAME TO idx_song_game_id_song_name;
+ALTER INDEX IF EXISTS song_list_soundtrack_name_idx RENAME TO song_list_game_name_idx;

internal/db/migrations/000005_rename_game_to_soundtrack.up.sql

@@ -0,0 +1,32 @@
+-- Rename game table to soundtrack
+ALTER TABLE game RENAME TO soundtrack;
+
+-- Rename primary key sequence
+ALTER SEQUENCE game_id_seq RENAME TO soundtrack_id_seq;
+
+-- Rename columns in soundtrack table
+ALTER TABLE soundtrack RENAME COLUMN game_name TO soundtrack_name;
+
+-- Update song table: rename game_id to soundtrack_id
+ALTER TABLE song RENAME COLUMN game_id TO soundtrack_id;
+
+-- Update song primary key
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_pkey;
+ALTER TABLE song ADD PRIMARY KEY (soundtrack_id, path);
+
+-- Update song_list table references
+ALTER TABLE song_list RENAME COLUMN game_name TO soundtrack_name;
+
+-- Rename foreign key constraint
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_game_id_fkey;
+ALTER TABLE song ADD CONSTRAINT song_soundtrack_id_fkey 
+    FOREIGN KEY (soundtrack_id) REFERENCES soundtrack(id);
+
+-- Rename indexes
+ALTER INDEX IF EXISTS idx_game_deleted RENAME TO idx_soundtrack_deleted;
+ALTER INDEX IF EXISTS idx_game_hash RENAME TO idx_soundtrack_hash;
+ALTER INDEX IF EXISTS idx_game_path RENAME TO idx_soundtrack_path;
+ALTER INDEX IF EXISTS idx_game_name RENAME TO idx_soundtrack_name;
+ALTER INDEX IF EXISTS idx_song_game_id RENAME TO idx_song_soundtrack_id;
+ALTER INDEX IF EXISTS idx_song_game_id_song_name RENAME TO idx_song_soundtrack_id_song_name;
+ALTER INDEX IF EXISTS song_list_game_name_idx RENAME TO song_list_soundtrack_name_idx;

internal/db/migrations/000006_add_id_to_song.down.sql

@@ -0,0 +1,24 @@
+-- Rollback: Remove id column and restore composite PK
+
+-- Step 1: Drop indexes created in up migration
+DROP INDEX IF EXISTS idx_song_soundtrack_id;
+DROP INDEX IF EXISTS idx_song_path;
+
+-- Step 2: Drop foreign key constraint
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_soundtrack_id_fkey;
+
+-- Step 3: Drop new primary key
+ALTER TABLE song DROP CONSTRAINT song_pkey;
+
+-- Step 4: Drop unique constraint on id
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_id_unique;
+
+-- Step 5: Restore composite primary key
+ALTER TABLE song ADD CONSTRAINT song_pkey PRIMARY KEY (soundtrack_id, path);
+
+-- Step 6: Drop the id column
+ALTER TABLE song DROP COLUMN id;
+
+-- Step 7: Recreate original foreign key (soundtrack_id references soundtrack.id)
+ALTER TABLE song ADD CONSTRAINT song_soundtrack_id_fkey 
+    FOREIGN KEY (soundtrack_id) REFERENCES soundtrack(id);

internal/db/migrations/000006_add_id_to_song.up.sql

@@ -0,0 +1,36 @@
+-- Migration: Add id column to song table and change PK from composite to single column
+-- This prepares the song table for eventual UUID migration
+
+-- Step 1: Add new id column (nullable initially)
+ALTER TABLE song ADD COLUMN id serial4;
+
+-- Step 2: Create unique constraint on id (allows backfilling)
+ALTER TABLE song ADD CONSTRAINT song_id_unique UNIQUE (id);
+
+-- Step 3: Backfill existing rows with sequential IDs
+-- Use DEFAULT which pulls from the sequence
+UPDATE song SET id = DEFAULT WHERE id IS NULL;
+
+-- Step 4: Verify all rows have an id
+-- If this returns 0, backfill worked
+-- SELECT COUNT(*) FROM song WHERE id IS NULL;
+
+-- Step 5: Drop the composite primary key (soundtrack_id, path)
+ALTER TABLE song DROP CONSTRAINT song_pkey;
+
+-- Step 6: Add new primary key on id column
+ALTER TABLE song ADD CONSTRAINT song_pkey PRIMARY KEY (id);
+
+-- Step 7: Ensure soundtrack_id remains a foreign key to soundtrack
+-- First drop existing FK if it exists (from the rename migration)
+ALTER TABLE song DROP CONSTRAINT IF EXISTS song_soundtrack_id_fkey;
+
+-- Then recreate it
+ALTER TABLE song ADD CONSTRAINT song_soundtrack_id_fkey 
+    FOREIGN KEY (soundtrack_id) REFERENCES soundtrack(id);
+
+-- Step 8: Create index on soundtrack_id for query performance
+CREATE INDEX IF NOT EXISTS idx_song_soundtrack_id ON song(soundtrack_id);
+
+-- Step 9: Create index on path for lookups (previously part of PK)
+CREATE INDEX IF NOT EXISTS idx_song_path ON song(path);

internal/db/queries/game.sql

@@ -1,49 +0,0 @@
--- name: ResetGameIdSeq :one
-SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);
-
--- name: GetGameNameById :one
-SELECT game_name FROM game WHERE id = $1;
-
--- name: GetGameById :one
-SELECT * 
-FROM game 
-WHERE id = $1 
-AND deleted IS NULL;
-
--- name: SetGameDeletionDate :exec
-UPDATE game SET deleted=now() WHERE deleted IS NULL;
-
--- name: ClearGames :exec
-DELETE FROM game;
-
--- name: UpdateGameName :exec
-UPDATE game SET game_name=sqlc.arg(name), path=sqlc.arg(path), last_changed=now() WHERE id=sqlc.arg(id);
-
--- name: UpdateGameHash :exec
-UPDATE game SET hash=sqlc.arg(hash), last_changed=now() WHERE id=sqlc.arg(id);
-
--- name: RemoveDeletionDate :exec
-UPDATE game SET deleted=NULL WHERE id=$1;
-
--- name: GetIdByGameName :one
-SELECT id FROM game WHERE game_name = $1;
-
--- name: InsertGame :one
-INSERT INTO game (game_name, path, hash, added) VALUES ($1, $2, $3, now()) returning id;
-
--- name: InsertGameWithExistingId :exec
-INSERT INTO game (id, game_name, path, hash, added) VALUES ($1, $2, $3, $4, now());
-
--- name: FindAllGames :many
-SELECT *
-FROM game
-WHERE deleted IS NULL
-ORDER BY game_name;
-
--- name: GetAllGamesIncludingDeleted :many
-SELECT *
-FROM game
-ORDER BY game_name;
-
--- name: AddGamePlayed :exec
-UPDATE game SET times_played = times_played + 1, last_played = now() WHERE id = $1;

internal/db/queries/song.sql

@@ -1,14 +1,14 @@
 -- name: ClearSongs :exec
 DELETE FROM song;
 
--- name: ClearSongsByGameId :exec
+-- name: ClearSongsBySoundtrackId :exec
-DELETE FROM song WHERE game_id = $1;
+DELETE FROM song WHERE soundtrack_id = $1;
 
 -- name: AddSong :exec
-INSERT INTO song(game_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5);
+INSERT INTO song(soundtrack_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5);
 
 -- name: CheckSong :one
-SELECT COUNT(*) FROM song WHERE path = $1;
+SELECT COUNT(*) FROM song WHERE soundtrack_id = $1 AND path = $2;
 
 -- name: CheckSongWithHash :one
 SELECT COUNT(*) FROM song WHERE hash = $1;
@@ -20,22 +20,25 @@ SELECT * FROM song WHERE hash = $1;
 UPDATE song SET song_name=$1, file_name=$2, path=$3 where hash=$4;
 
 -- name: AddHashToSong :exec
-UPDATE song SET hash=$1 where path=$2;
+UPDATE song SET hash=$1 where soundtrack_id = $2 AND path = $3;
 
--- name: FindSongsFromGame :many
+-- name: FindSongsFromSoundtrack :many
 SELECT *
 FROM song
-WHERE game_id = $1;
+WHERE soundtrack_id = $1;
 
 -- name: AddSongPlayed :exec
 UPDATE song SET times_played = times_played + 1
-WHERE game_id = $1 AND song_name = $2;
+WHERE soundtrack_id = $1 AND song_name = $2;
 
 -- name: FetchAllSongs :many
 SELECT * FROM song;
 
+-- name: GetSongById :one
+SELECT * FROM song WHERE id = $1;
+
 -- name: RemoveBrokenSong :exec
-DELETE FROM song WHERE path = $1;
+DELETE FROM song WHERE soundtrack_id = $1 AND path = $2;
 
 -- name: RemoveBrokenSongs :exec
-DELETE FROM song where path = any (sqlc.slice('paths'));
+DELETE FROM song WHERE id = ANY($1);

internal/db/queries/song_list.sql

@@ -1,5 +1,5 @@
 -- name: InsertSongInList :exec
-INSERT INTO song_list (match_date, match_id, song_no, game_name, song_name)
+INSERT INTO song_list (match_date, match_id, song_no, soundtrack_name, song_name)
 VALUES ($1, $2, $3, $4, $5);
 
 -- name: GetSongList :many

internal/db/queries/soundtrack.sql

@@ -0,0 +1,49 @@
+-- name: ResetSoundtrackIdSeq :one
+SELECT setval('soundtrack_id_seq', (SELECT MAX(id) FROM soundtrack)+1);
+
+-- name: GetSoundtrackNameById :one
+SELECT soundtrack_name FROM soundtrack WHERE id = $1;
+
+-- name: GetSoundtrackById :one
+SELECT * 
+FROM soundtrack 
+WHERE id = $1 
+AND deleted IS NULL;
+
+-- name: SetSoundtrackDeletionDate :exec
+UPDATE soundtrack SET deleted=now() WHERE deleted IS NULL;
+
+-- name: ClearSoundtracks :exec
+DELETE FROM soundtrack;
+
+-- name: UpdateSoundtrackName :exec
+UPDATE soundtrack SET soundtrack_name=sqlc.arg(name), path=sqlc.arg(path), last_changed=now() WHERE id=sqlc.arg(id);
+
+-- name: UpdateSoundtrackHash :exec
+UPDATE soundtrack SET hash=sqlc.arg(hash), last_changed=now() WHERE id=sqlc.arg(id);
+
+-- name: RemoveSoundtrackDeletionDate :exec
+UPDATE soundtrack SET deleted=NULL WHERE id=$1;
+
+-- name: GetIdBySoundtrackName :one
+SELECT id FROM soundtrack WHERE soundtrack_name = $1;
+
+-- name: InsertSoundtrack :one
+INSERT INTO soundtrack (soundtrack_name, path, hash, added) VALUES ($1, $2, $3, now()) returning id;
+
+-- name: InsertSoundtrackWithExistingId :exec
+INSERT INTO soundtrack (id, soundtrack_name, path, hash, added) VALUES ($1, $2, $3, $4, now());
+
+-- name: FindAllSoundtracks :many
+SELECT *
+FROM soundtrack
+WHERE deleted IS NULL
+ORDER BY soundtrack_name;
+
+-- name: GetAllSoundtracksIncludingDeleted :many
+SELECT *
+FROM soundtrack
+ORDER BY soundtrack_name;
+
+-- name: AddSoundtrackPlayed :exec
+UPDATE soundtrack SET times_played = times_played + 1, last_played = now() WHERE id = $1;

internal/db/queries/statistics.sql

@@ -0,0 +1,148 @@
+-- Most played soundtracks with their songs
+-- name: GetMostPlayedSoundtracksWithSongs :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played,
+            'file_name', s.file_name
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.times_played DESC, g.soundtrack_name
+LIMIT $1;
+
+-- Least played soundtracks with their songs
+-- name: GetLeastPlayedSoundtracksWithSongs :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played,
+            'file_name', s.file_name
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.times_played ASC, g.soundtrack_name
+LIMIT $1;
+
+-- Most played songs with their soundtrack info
+-- name: GetMostPlayedSongsWithSoundtrack :many
+SELECT 
+    s.soundtrack_id as soundtrack_id,
+    g.soundtrack_name,
+    s.song_name,
+    s.path,
+    s.times_played,
+    s.file_name
+FROM song s
+JOIN soundtrack g ON s.soundtrack_id = g.id
+WHERE g.deleted IS NULL
+ORDER BY s.times_played DESC, s.song_name
+LIMIT $1;
+
+-- Least played songs with their soundtrack info
+-- name: GetLeastPlayedSongsWithSoundtrack :many
+SELECT 
+    s.soundtrack_id as soundtrack_id,
+    g.soundtrack_name,
+    s.song_name,
+    s.path,
+    s.times_played,
+    s.file_name
+FROM song s
+JOIN soundtrack g ON s.soundtrack_id = g.id
+WHERE g.deleted IS NULL
+ORDER BY s.times_played ASC, s.song_name
+LIMIT $1;
+
+-- Soundtracks that have never been played (times_played = 0)
+-- name: GetNeverPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.added,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.times_played = 0
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
+ORDER BY g.soundtrack_name;
+
+-- Last played soundtracks (most recently played)
+-- name: GetLastPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.last_played DESC
+LIMIT $1;
+
+-- Oldest played soundtracks (least recently played, but has been played at least once)
+-- name: GetOldestPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.last_played ASC
+LIMIT $1;
+
+-- Get statistics summary
+-- name: GetStatisticsSummary :one
+SELECT 
+    COUNT(*) as total_soundtracks,
+    COALESCE(SUM(CASE WHEN times_played > 0 THEN 1 ELSE 0 END), 0)::bigint as played_soundtracks,
+    COALESCE(SUM(CASE WHEN times_played = 0 THEN 1 ELSE 0 END), 0)::bigint as never_played_soundtracks,
+    COALESCE(SUM(times_played), 0)::bigint as total_soundtrack_plays,
+    COALESCE(AVG(times_played), 0)::float as avg_soundtrack_plays,
+    COALESCE(MAX(times_played), 0)::bigint as max_soundtrack_plays,
+    COALESCE(MIN(times_played), 0)::bigint as min_soundtrack_plays
+FROM soundtrack
+WHERE deleted IS NULL;

internal/db/repository/game.sql.go

@@ -1,246 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: game.sql
-
-package repository
-
-import (
-	"context"
-)
-
-const addGamePlayed = `-- name: AddGamePlayed :exec
-UPDATE game SET times_played = times_played + 1, last_played = now() WHERE id = $1
-`
-
-func (q *Queries) AddGamePlayed(ctx context.Context, id int32) error {
-	_, err := q.db.Exec(ctx, addGamePlayed, id)
-	return err
-}
-
-const clearGames = `-- name: ClearGames :exec
-DELETE FROM game
-`
-
-func (q *Queries) ClearGames(ctx context.Context) error {
-	_, err := q.db.Exec(ctx, clearGames)
-	return err
-}
-
-const findAllGames = `-- name: FindAllGames :many
-SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
-FROM game
-WHERE deleted IS NULL
-ORDER BY game_name
-`
-
-func (q *Queries) FindAllGames(ctx context.Context) ([]Game, error) {
-	rows, err := q.db.Query(ctx, findAllGames)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Game
-	for rows.Next() {
-		var i Game
-		if err := rows.Scan(
-			&i.ID,
-			&i.GameName,
-			&i.Added,
-			&i.Deleted,
-			&i.LastChanged,
-			&i.Path,
-			&i.TimesPlayed,
-			&i.LastPlayed,
-			&i.NumberOfSongs,
-			&i.Hash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getAllGamesIncludingDeleted = `-- name: GetAllGamesIncludingDeleted :many
-SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
-FROM game
-ORDER BY game_name
-`
-
-func (q *Queries) GetAllGamesIncludingDeleted(ctx context.Context) ([]Game, error) {
-	rows, err := q.db.Query(ctx, getAllGamesIncludingDeleted)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Game
-	for rows.Next() {
-		var i Game
-		if err := rows.Scan(
-			&i.ID,
-			&i.GameName,
-			&i.Added,
-			&i.Deleted,
-			&i.LastChanged,
-			&i.Path,
-			&i.TimesPlayed,
-			&i.LastPlayed,
-			&i.NumberOfSongs,
-			&i.Hash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getGameById = `-- name: GetGameById :one
-SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash 
-FROM game 
-WHERE id = $1 
-AND deleted IS NULL
-`
-
-func (q *Queries) GetGameById(ctx context.Context, id int32) (Game, error) {
-	row := q.db.QueryRow(ctx, getGameById, id)
-	var i Game
-	err := row.Scan(
-		&i.ID,
-		&i.GameName,
-		&i.Added,
-		&i.Deleted,
-		&i.LastChanged,
-		&i.Path,
-		&i.TimesPlayed,
-		&i.LastPlayed,
-		&i.NumberOfSongs,
-		&i.Hash,
-	)
-	return i, err
-}
-
-const getGameNameById = `-- name: GetGameNameById :one
-SELECT game_name FROM game WHERE id = $1
-`
-
-func (q *Queries) GetGameNameById(ctx context.Context, id int32) (string, error) {
-	row := q.db.QueryRow(ctx, getGameNameById, id)
-	var game_name string
-	err := row.Scan(&game_name)
-	return game_name, err
-}
-
-const getIdByGameName = `-- name: GetIdByGameName :one
-SELECT id FROM game WHERE game_name = $1
-`
-
-func (q *Queries) GetIdByGameName(ctx context.Context, gameName string) (int32, error) {
-	row := q.db.QueryRow(ctx, getIdByGameName, gameName)
-	var id int32
-	err := row.Scan(&id)
-	return id, err
-}
-
-const insertGame = `-- name: InsertGame :one
-INSERT INTO game (game_name, path, hash, added) VALUES ($1, $2, $3, now()) returning id
-`
-
-type InsertGameParams struct {
-	GameName string `json:"game_name"`
-	Path     string `json:"path"`
-	Hash     string `json:"hash"`
-}
-
-func (q *Queries) InsertGame(ctx context.Context, arg InsertGameParams) (int32, error) {
-	row := q.db.QueryRow(ctx, insertGame, arg.GameName, arg.Path, arg.Hash)
-	var id int32
-	err := row.Scan(&id)
-	return id, err
-}
-
-const insertGameWithExistingId = `-- name: InsertGameWithExistingId :exec
-INSERT INTO game (id, game_name, path, hash, added) VALUES ($1, $2, $3, $4, now())
-`
-
-type InsertGameWithExistingIdParams struct {
-	ID       int32  `json:"id"`
-	GameName string `json:"game_name"`
-	Path     string `json:"path"`
-	Hash     string `json:"hash"`
-}
-
-func (q *Queries) InsertGameWithExistingId(ctx context.Context, arg InsertGameWithExistingIdParams) error {
-	_, err := q.db.Exec(ctx, insertGameWithExistingId,
-		arg.ID,
-		arg.GameName,
-		arg.Path,
-		arg.Hash,
-	)
-	return err
-}
-
-const removeDeletionDate = `-- name: RemoveDeletionDate :exec
-UPDATE game SET deleted=NULL WHERE id=$1
-`
-
-func (q *Queries) RemoveDeletionDate(ctx context.Context, id int32) error {
-	_, err := q.db.Exec(ctx, removeDeletionDate, id)
-	return err
-}
-
-const resetGameIdSeq = `-- name: ResetGameIdSeq :one
-SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1)
-`
-
-func (q *Queries) ResetGameIdSeq(ctx context.Context) (int64, error) {
-	row := q.db.QueryRow(ctx, resetGameIdSeq)
-	var setval int64
-	err := row.Scan(&setval)
-	return setval, err
-}
-
-const setGameDeletionDate = `-- name: SetGameDeletionDate :exec
-UPDATE game SET deleted=now() WHERE deleted IS NULL
-`
-
-func (q *Queries) SetGameDeletionDate(ctx context.Context) error {
-	_, err := q.db.Exec(ctx, setGameDeletionDate)
-	return err
-}
-
-const updateGameHash = `-- name: UpdateGameHash :exec
-UPDATE game SET hash=$1, last_changed=now() WHERE id=$2
-`
-
-type UpdateGameHashParams struct {
-	Hash string `json:"hash"`
-	ID   int32  `json:"id"`
-}
-
-func (q *Queries) UpdateGameHash(ctx context.Context, arg UpdateGameHashParams) error {
-	_, err := q.db.Exec(ctx, updateGameHash, arg.Hash, arg.ID)
-	return err
-}
-
-const updateGameName = `-- name: UpdateGameName :exec
-UPDATE game SET game_name=$1, path=$2, last_changed=now() WHERE id=$3
-`
-
-type UpdateGameNameParams struct {
-	Name string `json:"name"`
-	Path string `json:"path"`
-	ID   int32  `json:"id"`
-}
-
-func (q *Queries) UpdateGameName(ctx context.Context, arg UpdateGameNameParams) error {
-	_, err := q.db.Exec(ctx, updateGameName, arg.Name, arg.Path, arg.ID)
-	return err
-}

internal/db/repository/models.go

@@ -10,19 +10,6 @@ import (
 	"github.com/jackc/pgx/v5/pgtype"
 )
 
-type Game struct {
-	ID            int32      `json:"id"`
-	GameName      string     `json:"game_name"`
-	Added         time.Time  `json:"added"`
-	Deleted       *time.Time `json:"deleted"`
-	LastChanged   *time.Time `json:"last_changed"`
-	Path          string     `json:"path"`
-	TimesPlayed   int32      `json:"times_played"`
-	LastPlayed    *time.Time `json:"last_played"`
-	NumberOfSongs int32      `json:"number_of_songs"`
-	Hash          string     `json:"hash"`
-}
-
 type Session struct {
 	Token      string             `json:"token"`
 	IpAddress  string             `json:"ip_address"`
@@ -33,20 +20,34 @@ type Session struct {
 }
 
 type Song struct {
-	GameID      int32   `json:"game_id"`
+	SoundtrackID int32       `json:"soundtrack_id"`
-	SongName    string  `json:"song_name"`
+	SongName     string      `json:"song_name"`
-	Path        string  `json:"path"`
+	Path         string      `json:"path"`
-	TimesPlayed int32   `json:"times_played"`
+	TimesPlayed  int32       `json:"times_played"`
-	Hash        string  `json:"hash"`
+	Hash         string      `json:"hash"`
-	FileName    *string `json:"file_name"`
+	FileName     *string     `json:"file_name"`
+	ID           pgtype.Int4 `json:"id"`
 }
 
 type SongList struct {
-	MatchDate time.Time `json:"match_date"`
+	MatchDate      time.Time `json:"match_date"`
-	MatchID   int32     `json:"match_id"`
+	MatchID        int32     `json:"match_id"`
-	SongNo    int32     `json:"song_no"`
+	SongNo         int32     `json:"song_no"`
-	GameName  *string   `json:"game_name"`
+	SoundtrackName *string   `json:"soundtrack_name"`
-	SongName  *string   `json:"song_name"`
+	SongName       *string   `json:"song_name"`
+}
+
+type Soundtrack struct {
+	ID             int32      `json:"id"`
+	SoundtrackName string     `json:"soundtrack_name"`
+	Added          time.Time  `json:"added"`
+	Deleted        *time.Time `json:"deleted"`
+	LastChanged    *time.Time `json:"last_changed"`
+	Path           string     `json:"path"`
+	TimesPlayed    int32      `json:"times_played"`
+	LastPlayed     *time.Time `json:"last_played"`
+	NumberOfSongs  int32      `json:"number_of_songs"`
+	Hash           string     `json:"hash"`
 }
 
 type Vgmq struct {

internal/db/repository/song.sql.go

@@ -7,37 +7,40 @@ package repository
 
 import (
 	"context"
+
+	"github.com/jackc/pgx/v5/pgtype"
 )
 
 const addHashToSong = `-- name: AddHashToSong :exec
-UPDATE song SET hash=$1 where path=$2
+UPDATE song SET hash=$1 where soundtrack_id = $2 AND path = $3
 `
 
 type AddHashToSongParams struct {
-	Hash string `json:"hash"`
+	Hash         string `json:"hash"`
-	Path string `json:"path"`
+	SoundtrackID int32  `json:"soundtrack_id"`
+	Path         string `json:"path"`
 }
 
 func (q *Queries) AddHashToSong(ctx context.Context, arg AddHashToSongParams) error {
-	_, err := q.db.Exec(ctx, addHashToSong, arg.Hash, arg.Path)
+	_, err := q.db.Exec(ctx, addHashToSong, arg.Hash, arg.SoundtrackID, arg.Path)
 	return err
 }
 
 const addSong = `-- name: AddSong :exec
-INSERT INTO song(game_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5)
+INSERT INTO song(soundtrack_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5)
 `
 
 type AddSongParams struct {
-	GameID   int32   `json:"game_id"`
+	SoundtrackID int32   `json:"soundtrack_id"`
-	SongName string  `json:"song_name"`
+	SongName     string  `json:"song_name"`
-	Path     string  `json:"path"`
+	Path         string  `json:"path"`
-	FileName *string `json:"file_name"`
+	FileName     *string `json:"file_name"`
-	Hash     string  `json:"hash"`
+	Hash         string  `json:"hash"`
 }
 
 func (q *Queries) AddSong(ctx context.Context, arg AddSongParams) error {
 	_, err := q.db.Exec(ctx, addSong,
-		arg.GameID,
+		arg.SoundtrackID,
 		arg.SongName,
 		arg.Path,
 		arg.FileName,
@@ -48,25 +51,30 @@ func (q *Queries) AddSong(ctx context.Context, arg AddSongParams) error {
 
 const addSongPlayed = `-- name: AddSongPlayed :exec
 UPDATE song SET times_played = times_played + 1
-WHERE game_id = $1 AND song_name = $2
+WHERE soundtrack_id = $1 AND song_name = $2
 `
 
 type AddSongPlayedParams struct {
-	GameID   int32  `json:"game_id"`
+	SoundtrackID int32  `json:"soundtrack_id"`
-	SongName string `json:"song_name"`
+	SongName     string `json:"song_name"`
 }
 
 func (q *Queries) AddSongPlayed(ctx context.Context, arg AddSongPlayedParams) error {
-	_, err := q.db.Exec(ctx, addSongPlayed, arg.GameID, arg.SongName)
+	_, err := q.db.Exec(ctx, addSongPlayed, arg.SoundtrackID, arg.SongName)
 	return err
 }
 
 const checkSong = `-- name: CheckSong :one
-SELECT COUNT(*) FROM song WHERE path = $1
+SELECT COUNT(*) FROM song WHERE soundtrack_id = $1 AND path = $2
 `
 
-func (q *Queries) CheckSong(ctx context.Context, path string) (int64, error) {
+type CheckSongParams struct {
-	row := q.db.QueryRow(ctx, checkSong, path)
+	SoundtrackID int32  `json:"soundtrack_id"`
+	Path         string `json:"path"`
+}
+
+func (q *Queries) CheckSong(ctx context.Context, arg CheckSongParams) (int64, error) {
+	row := q.db.QueryRow(ctx, checkSong, arg.SoundtrackID, arg.Path)
 	var count int64
 	err := row.Scan(&count)
 	return count, err
@@ -92,17 +100,17 @@ func (q *Queries) ClearSongs(ctx context.Context) error {
 	return err
 }
 
-const clearSongsByGameId = `-- name: ClearSongsByGameId :exec
+const clearSongsBySoundtrackId = `-- name: ClearSongsBySoundtrackId :exec
-DELETE FROM song WHERE game_id = $1
+DELETE FROM song WHERE soundtrack_id = $1
 `
 
-func (q *Queries) ClearSongsByGameId(ctx context.Context, gameID int32) error {
+func (q *Queries) ClearSongsBySoundtrackId(ctx context.Context, soundtrackID int32) error {
-	_, err := q.db.Exec(ctx, clearSongsByGameId, gameID)
+	_, err := q.db.Exec(ctx, clearSongsBySoundtrackId, soundtrackID)
 	return err
 }
 
 const fetchAllSongs = `-- name: FetchAllSongs :many
-SELECT game_id, song_name, path, times_played, hash, file_name FROM song
+SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id FROM song
 `
 
 func (q *Queries) FetchAllSongs(ctx context.Context) ([]Song, error) {
@@ -115,12 +123,13 @@ func (q *Queries) FetchAllSongs(ctx context.Context) ([]Song, error) {
 	for rows.Next() {
 		var i Song
 		if err := rows.Scan(
-			&i.GameID,
+			&i.SoundtrackID,
 			&i.SongName,
 			&i.Path,
 			&i.TimesPlayed,
 			&i.Hash,
 			&i.FileName,
+			&i.ID,
 		); err != nil {
 			return nil, err
 		}
@@ -132,14 +141,14 @@ func (q *Queries) FetchAllSongs(ctx context.Context) ([]Song, error) {
 	return items, nil
 }
 
-const findSongsFromGame = `-- name: FindSongsFromGame :many
+const findSongsFromSoundtrack = `-- name: FindSongsFromSoundtrack :many
-SELECT game_id, song_name, path, times_played, hash, file_name
+SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id
 FROM song
-WHERE game_id = $1
+WHERE soundtrack_id = $1
 `
 
-func (q *Queries) FindSongsFromGame(ctx context.Context, gameID int32) ([]Song, error) {
+func (q *Queries) FindSongsFromSoundtrack(ctx context.Context, soundtrackID int32) ([]Song, error) {
-	rows, err := q.db.Query(ctx, findSongsFromGame, gameID)
+	rows, err := q.db.Query(ctx, findSongsFromSoundtrack, soundtrackID)
 	if err != nil {
 		return nil, err
 	}
@@ -148,12 +157,13 @@ func (q *Queries) FindSongsFromGame(ctx context.Context, gameID int32) ([]Song,
 	for rows.Next() {
 		var i Song
 		if err := rows.Scan(
-			&i.GameID,
+			&i.SoundtrackID,
 			&i.SongName,
 			&i.Path,
 			&i.TimesPlayed,
 			&i.Hash,
 			&i.FileName,
+			&i.ID,
 		); err != nil {
 			return nil, err
 		}
@@ -165,39 +175,64 @@ func (q *Queries) FindSongsFromGame(ctx context.Context, gameID int32) ([]Song,
 	return items, nil
 }
 
+const getSongById = `-- name: GetSongById :one
+SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id FROM song WHERE id = $1
+`
+
+func (q *Queries) GetSongById(ctx context.Context, id pgtype.Int4) (Song, error) {
+	row := q.db.QueryRow(ctx, getSongById, id)
+	var i Song
+	err := row.Scan(
+		&i.SoundtrackID,
+		&i.SongName,
+		&i.Path,
+		&i.TimesPlayed,
+		&i.Hash,
+		&i.FileName,
+		&i.ID,
+	)
+	return i, err
+}
+
 const getSongWithHash = `-- name: GetSongWithHash :one
-SELECT game_id, song_name, path, times_played, hash, file_name FROM song WHERE hash = $1
+SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id FROM song WHERE hash = $1
 `
 
 func (q *Queries) GetSongWithHash(ctx context.Context, hash string) (Song, error) {
 	row := q.db.QueryRow(ctx, getSongWithHash, hash)
 	var i Song
 	err := row.Scan(
-		&i.GameID,
+		&i.SoundtrackID,
 		&i.SongName,
 		&i.Path,
 		&i.TimesPlayed,
 		&i.Hash,
 		&i.FileName,
+		&i.ID,
 	)
 	return i, err
 }
 
 const removeBrokenSong = `-- name: RemoveBrokenSong :exec
-DELETE FROM song WHERE path = $1
+DELETE FROM song WHERE soundtrack_id = $1 AND path = $2
 `
 
-func (q *Queries) RemoveBrokenSong(ctx context.Context, path string) error {
+type RemoveBrokenSongParams struct {
-	_, err := q.db.Exec(ctx, removeBrokenSong, path)
+	SoundtrackID int32  `json:"soundtrack_id"`
+	Path         string `json:"path"`
+}
+
+func (q *Queries) RemoveBrokenSong(ctx context.Context, arg RemoveBrokenSongParams) error {
+	_, err := q.db.Exec(ctx, removeBrokenSong, arg.SoundtrackID, arg.Path)
 	return err
 }
 
 const removeBrokenSongs = `-- name: RemoveBrokenSongs :exec
-DELETE FROM song where path = any ($1)
+DELETE FROM song WHERE id = ANY($1)
 `
 
-func (q *Queries) RemoveBrokenSongs(ctx context.Context, paths []string) error {
+func (q *Queries) RemoveBrokenSongs(ctx context.Context, id pgtype.Int4) error {
-	_, err := q.db.Exec(ctx, removeBrokenSongs, paths)
+	_, err := q.db.Exec(ctx, removeBrokenSongs, id)
 	return err
 }
 

internal/db/repository/song_list.sql.go

@@ -11,7 +11,7 @@ import (
 )
 
 const getSongList = `-- name: GetSongList :many
-SELECT match_date, match_id, song_no, game_name, song_name
+SELECT match_date, match_id, song_no, soundtrack_name, song_name
 FROM song_list
 WHERE match_date = $1
 ORDER BY song_no DESC
@@ -30,7 +30,7 @@ func (q *Queries) GetSongList(ctx context.Context, matchDate time.Time) ([]SongL
 			&i.MatchDate,
 			&i.MatchID,
 			&i.SongNo,
-			&i.GameName,
+			&i.SoundtrackName,
 			&i.SongName,
 		); err != nil {
 			return nil, err
@@ -44,16 +44,16 @@ func (q *Queries) GetSongList(ctx context.Context, matchDate time.Time) ([]SongL
 }
 
 const insertSongInList = `-- name: InsertSongInList :exec
-INSERT INTO song_list (match_date, match_id, song_no, game_name, song_name)
+INSERT INTO song_list (match_date, match_id, song_no, soundtrack_name, song_name)
 VALUES ($1, $2, $3, $4, $5)
 `
 
 type InsertSongInListParams struct {
-	MatchDate time.Time `json:"match_date"`
+	MatchDate      time.Time `json:"match_date"`
-	MatchID   int32     `json:"match_id"`
+	MatchID        int32     `json:"match_id"`
-	SongNo    int32     `json:"song_no"`
+	SongNo         int32     `json:"song_no"`
-	GameName  *string   `json:"game_name"`
+	SoundtrackName *string   `json:"soundtrack_name"`
-	SongName  *string   `json:"song_name"`
+	SongName       *string   `json:"song_name"`
 }
 
 func (q *Queries) InsertSongInList(ctx context.Context, arg InsertSongInListParams) error {
@@ -61,7 +61,7 @@ func (q *Queries) InsertSongInList(ctx context.Context, arg InsertSongInListPara
 		arg.MatchDate,
 		arg.MatchID,
 		arg.SongNo,
-		arg.GameName,
+		arg.SoundtrackName,
 		arg.SongName,
 	)
 	return err

internal/db/repository/soundtrack.sql.go

@@ -0,0 +1,246 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: soundtrack.sql
+
+package repository
+
+import (
+	"context"
+)
+
+const addSoundtrackPlayed = `-- name: AddSoundtrackPlayed :exec
+UPDATE soundtrack SET times_played = times_played + 1, last_played = now() WHERE id = $1
+`
+
+func (q *Queries) AddSoundtrackPlayed(ctx context.Context, id int32) error {
+	_, err := q.db.Exec(ctx, addSoundtrackPlayed, id)
+	return err
+}
+
+const clearSoundtracks = `-- name: ClearSoundtracks :exec
+DELETE FROM soundtrack
+`
+
+func (q *Queries) ClearSoundtracks(ctx context.Context) error {
+	_, err := q.db.Exec(ctx, clearSoundtracks)
+	return err
+}
+
+const findAllSoundtracks = `-- name: FindAllSoundtracks :many
+SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
+FROM soundtrack
+WHERE deleted IS NULL
+ORDER BY soundtrack_name
+`
+
+func (q *Queries) FindAllSoundtracks(ctx context.Context) ([]Soundtrack, error) {
+	rows, err := q.db.Query(ctx, findAllSoundtracks)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []Soundtrack
+	for rows.Next() {
+		var i Soundtrack
+		if err := rows.Scan(
+			&i.ID,
+			&i.SoundtrackName,
+			&i.Added,
+			&i.Deleted,
+			&i.LastChanged,
+			&i.Path,
+			&i.TimesPlayed,
+			&i.LastPlayed,
+			&i.NumberOfSongs,
+			&i.Hash,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getAllSoundtracksIncludingDeleted = `-- name: GetAllSoundtracksIncludingDeleted :many
+SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
+FROM soundtrack
+ORDER BY soundtrack_name
+`
+
+func (q *Queries) GetAllSoundtracksIncludingDeleted(ctx context.Context) ([]Soundtrack, error) {
+	rows, err := q.db.Query(ctx, getAllSoundtracksIncludingDeleted)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []Soundtrack
+	for rows.Next() {
+		var i Soundtrack
+		if err := rows.Scan(
+			&i.ID,
+			&i.SoundtrackName,
+			&i.Added,
+			&i.Deleted,
+			&i.LastChanged,
+			&i.Path,
+			&i.TimesPlayed,
+			&i.LastPlayed,
+			&i.NumberOfSongs,
+			&i.Hash,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getIdBySoundtrackName = `-- name: GetIdBySoundtrackName :one
+SELECT id FROM soundtrack WHERE soundtrack_name = $1
+`
+
+func (q *Queries) GetIdBySoundtrackName(ctx context.Context, soundtrackName string) (int32, error) {
+	row := q.db.QueryRow(ctx, getIdBySoundtrackName, soundtrackName)
+	var id int32
+	err := row.Scan(&id)
+	return id, err
+}
+
+const getSoundtrackById = `-- name: GetSoundtrackById :one
+SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash 
+FROM soundtrack 
+WHERE id = $1 
+AND deleted IS NULL
+`
+
+func (q *Queries) GetSoundtrackById(ctx context.Context, id int32) (Soundtrack, error) {
+	row := q.db.QueryRow(ctx, getSoundtrackById, id)
+	var i Soundtrack
+	err := row.Scan(
+		&i.ID,
+		&i.SoundtrackName,
+		&i.Added,
+		&i.Deleted,
+		&i.LastChanged,
+		&i.Path,
+		&i.TimesPlayed,
+		&i.LastPlayed,
+		&i.NumberOfSongs,
+		&i.Hash,
+	)
+	return i, err
+}
+
+const getSoundtrackNameById = `-- name: GetSoundtrackNameById :one
+SELECT soundtrack_name FROM soundtrack WHERE id = $1
+`
+
+func (q *Queries) GetSoundtrackNameById(ctx context.Context, id int32) (string, error) {
+	row := q.db.QueryRow(ctx, getSoundtrackNameById, id)
+	var soundtrack_name string
+	err := row.Scan(&soundtrack_name)
+	return soundtrack_name, err
+}
+
+const insertSoundtrack = `-- name: InsertSoundtrack :one
+INSERT INTO soundtrack (soundtrack_name, path, hash, added) VALUES ($1, $2, $3, now()) returning id
+`
+
+type InsertSoundtrackParams struct {
+	SoundtrackName string `json:"soundtrack_name"`
+	Path           string `json:"path"`
+	Hash           string `json:"hash"`
+}
+
+func (q *Queries) InsertSoundtrack(ctx context.Context, arg InsertSoundtrackParams) (int32, error) {
+	row := q.db.QueryRow(ctx, insertSoundtrack, arg.SoundtrackName, arg.Path, arg.Hash)
+	var id int32
+	err := row.Scan(&id)
+	return id, err
+}
+
+const insertSoundtrackWithExistingId = `-- name: InsertSoundtrackWithExistingId :exec
+INSERT INTO soundtrack (id, soundtrack_name, path, hash, added) VALUES ($1, $2, $3, $4, now())
+`
+
+type InsertSoundtrackWithExistingIdParams struct {
+	ID             int32  `json:"id"`
+	SoundtrackName string `json:"soundtrack_name"`
+	Path           string `json:"path"`
+	Hash           string `json:"hash"`
+}
+
+func (q *Queries) InsertSoundtrackWithExistingId(ctx context.Context, arg InsertSoundtrackWithExistingIdParams) error {
+	_, err := q.db.Exec(ctx, insertSoundtrackWithExistingId,
+		arg.ID,
+		arg.SoundtrackName,
+		arg.Path,
+		arg.Hash,
+	)
+	return err
+}
+
+const removeSoundtrackDeletionDate = `-- name: RemoveSoundtrackDeletionDate :exec
+UPDATE soundtrack SET deleted=NULL WHERE id=$1
+`
+
+func (q *Queries) RemoveSoundtrackDeletionDate(ctx context.Context, id int32) error {
+	_, err := q.db.Exec(ctx, removeSoundtrackDeletionDate, id)
+	return err
+}
+
+const resetSoundtrackIdSeq = `-- name: ResetSoundtrackIdSeq :one
+SELECT setval('soundtrack_id_seq', (SELECT MAX(id) FROM soundtrack)+1)
+`
+
+func (q *Queries) ResetSoundtrackIdSeq(ctx context.Context) (int64, error) {
+	row := q.db.QueryRow(ctx, resetSoundtrackIdSeq)
+	var setval int64
+	err := row.Scan(&setval)
+	return setval, err
+}
+
+const setSoundtrackDeletionDate = `-- name: SetSoundtrackDeletionDate :exec
+UPDATE soundtrack SET deleted=now() WHERE deleted IS NULL
+`
+
+func (q *Queries) SetSoundtrackDeletionDate(ctx context.Context) error {
+	_, err := q.db.Exec(ctx, setSoundtrackDeletionDate)
+	return err
+}
+
+const updateSoundtrackHash = `-- name: UpdateSoundtrackHash :exec
+UPDATE soundtrack SET hash=$1, last_changed=now() WHERE id=$2
+`
+
+type UpdateSoundtrackHashParams struct {
+	Hash string `json:"hash"`
+	ID   int32  `json:"id"`
+}
+
+func (q *Queries) UpdateSoundtrackHash(ctx context.Context, arg UpdateSoundtrackHashParams) error {
+	_, err := q.db.Exec(ctx, updateSoundtrackHash, arg.Hash, arg.ID)
+	return err
+}
+
+const updateSoundtrackName = `-- name: UpdateSoundtrackName :exec
+UPDATE soundtrack SET soundtrack_name=$1, path=$2, last_changed=now() WHERE id=$3
+`
+
+type UpdateSoundtrackNameParams struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+	ID   int32  `json:"id"`
+}
+
+func (q *Queries) UpdateSoundtrackName(ctx context.Context, arg UpdateSoundtrackNameParams) error {
+	_, err := q.db.Exec(ctx, updateSoundtrackName, arg.Name, arg.Path, arg.ID)
+	return err
+}

internal/db/repository/statistics.sql.go

@@ -0,0 +1,435 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: statistics.sql
+
+package repository
+
+import (
+	"context"
+	"time"
+)
+
+const getLastPlayedSoundtracks = `-- name: GetLastPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.last_played DESC
+LIMIT $1
+`
+
+type GetLastPlayedSoundtracksRow struct {
+	SoundtrackID         int32      `json:"soundtrack_id"`
+	SoundtrackName       string     `json:"soundtrack_name"`
+	SoundtrackPlayed     int32      `json:"soundtrack_played"`
+	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
+	Songs                []byte     `json:"songs"`
+}
+
+// Last played soundtracks (most recently played)
+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 []GetLastPlayedSoundtracksRow
+	for rows.Next() {
+		var i GetLastPlayedSoundtracksRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SoundtrackPlayed,
+			&i.SoundtrackLastPlayed,
+			&i.Songs,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getLeastPlayedSoundtracksWithSongs = `-- name: GetLeastPlayedSoundtracksWithSongs :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played,
+            'file_name', s.file_name
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.times_played ASC, g.soundtrack_name
+LIMIT $1
+`
+
+type GetLeastPlayedSoundtracksWithSongsRow struct {
+	SoundtrackID         int32      `json:"soundtrack_id"`
+	SoundtrackName       string     `json:"soundtrack_name"`
+	SoundtrackPlayed     int32      `json:"soundtrack_played"`
+	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
+	Songs                []byte     `json:"songs"`
+}
+
+// Least played soundtracks with their songs
+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 []GetLeastPlayedSoundtracksWithSongsRow
+	for rows.Next() {
+		var i GetLeastPlayedSoundtracksWithSongsRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SoundtrackPlayed,
+			&i.SoundtrackLastPlayed,
+			&i.Songs,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getLeastPlayedSongsWithSoundtrack = `-- name: GetLeastPlayedSongsWithSoundtrack :many
+SELECT 
+    s.soundtrack_id as soundtrack_id,
+    g.soundtrack_name,
+    s.song_name,
+    s.path,
+    s.times_played,
+    s.file_name
+FROM song s
+JOIN soundtrack g ON s.soundtrack_id = g.id
+WHERE g.deleted IS NULL
+ORDER BY s.times_played ASC, s.song_name
+LIMIT $1
+`
+
+type GetLeastPlayedSongsWithSoundtrackRow struct {
+	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"`
+}
+
+// Least played songs with their soundtrack info
+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 []GetLeastPlayedSongsWithSoundtrackRow
+	for rows.Next() {
+		var i GetLeastPlayedSongsWithSoundtrackRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SongName,
+			&i.Path,
+			&i.TimesPlayed,
+			&i.FileName,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getMostPlayedSoundtracksWithSongs = `-- name: GetMostPlayedSoundtracksWithSongs :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played,
+            'file_name', s.file_name
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.times_played DESC, g.soundtrack_name
+LIMIT $1
+`
+
+type GetMostPlayedSoundtracksWithSongsRow struct {
+	SoundtrackID         int32      `json:"soundtrack_id"`
+	SoundtrackName       string     `json:"soundtrack_name"`
+	SoundtrackPlayed     int32      `json:"soundtrack_played"`
+	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
+	Songs                []byte     `json:"songs"`
+}
+
+// Most played soundtracks with their songs
+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 []GetMostPlayedSoundtracksWithSongsRow
+	for rows.Next() {
+		var i GetMostPlayedSoundtracksWithSongsRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SoundtrackPlayed,
+			&i.SoundtrackLastPlayed,
+			&i.Songs,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getMostPlayedSongsWithSoundtrack = `-- name: GetMostPlayedSongsWithSoundtrack :many
+SELECT 
+    s.soundtrack_id as soundtrack_id,
+    g.soundtrack_name,
+    s.song_name,
+    s.path,
+    s.times_played,
+    s.file_name
+FROM song s
+JOIN soundtrack g ON s.soundtrack_id = g.id
+WHERE g.deleted IS NULL
+ORDER BY s.times_played DESC, s.song_name
+LIMIT $1
+`
+
+type GetMostPlayedSongsWithSoundtrackRow struct {
+	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"`
+}
+
+// Most played songs with their soundtrack info
+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 []GetMostPlayedSongsWithSoundtrackRow
+	for rows.Next() {
+		var i GetMostPlayedSongsWithSoundtrackRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SongName,
+			&i.Path,
+			&i.TimesPlayed,
+			&i.FileName,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getNeverPlayedSoundtracks = `-- name: GetNeverPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.added,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.times_played = 0
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
+ORDER BY g.soundtrack_name
+`
+
+type GetNeverPlayedSoundtracksRow struct {
+	SoundtrackID     int32     `json:"soundtrack_id"`
+	SoundtrackName   string    `json:"soundtrack_name"`
+	SoundtrackPlayed int32     `json:"soundtrack_played"`
+	Added            time.Time `json:"added"`
+	Songs            []byte    `json:"songs"`
+}
+
+// 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 []GetNeverPlayedSoundtracksRow
+	for rows.Next() {
+		var i GetNeverPlayedSoundtracksRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SoundtrackPlayed,
+			&i.Added,
+			&i.Songs,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getOldestPlayedSoundtracks = `-- name: GetOldestPlayedSoundtracks :many
+SELECT 
+    g.id as soundtrack_id,
+    g.soundtrack_name,
+    g.times_played as soundtrack_played,
+    g.last_played as soundtrack_last_played,
+    json_agg(
+        json_build_object(
+            'song_name', s.song_name,
+            'path', s.path,
+            'times_played', s.times_played
+        )
+    ) as songs
+FROM soundtrack g
+LEFT JOIN song s ON g.id = s.soundtrack_id
+WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
+GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
+ORDER BY g.last_played ASC
+LIMIT $1
+`
+
+type GetOldestPlayedSoundtracksRow struct {
+	SoundtrackID         int32      `json:"soundtrack_id"`
+	SoundtrackName       string     `json:"soundtrack_name"`
+	SoundtrackPlayed     int32      `json:"soundtrack_played"`
+	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
+	Songs                []byte     `json:"songs"`
+}
+
+// Oldest played soundtracks (least recently played, but has been played at least once)
+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 []GetOldestPlayedSoundtracksRow
+	for rows.Next() {
+		var i GetOldestPlayedSoundtracksRow
+		if err := rows.Scan(
+			&i.SoundtrackID,
+			&i.SoundtrackName,
+			&i.SoundtrackPlayed,
+			&i.SoundtrackLastPlayed,
+			&i.Songs,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getStatisticsSummary = `-- name: GetStatisticsSummary :one
+SELECT 
+    COUNT(*) as total_soundtracks,
+    COALESCE(SUM(CASE WHEN times_played > 0 THEN 1 ELSE 0 END), 0)::bigint as played_soundtracks,
+    COALESCE(SUM(CASE WHEN times_played = 0 THEN 1 ELSE 0 END), 0)::bigint as never_played_soundtracks,
+    COALESCE(SUM(times_played), 0)::bigint as total_soundtrack_plays,
+    COALESCE(AVG(times_played), 0)::float as avg_soundtrack_plays,
+    COALESCE(MAX(times_played), 0)::bigint as max_soundtrack_plays,
+    COALESCE(MIN(times_played), 0)::bigint as min_soundtrack_plays
+FROM soundtrack
+WHERE deleted IS NULL
+`
+
+type GetStatisticsSummaryRow struct {
+	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"`
+}
+
+// Get statistics summary
+func (q *Queries) GetStatisticsSummary(ctx context.Context) (GetStatisticsSummaryRow, error) {
+	row := q.db.QueryRow(ctx, getStatisticsSummary)
+	var i GetStatisticsSummaryRow
+	err := row.Scan(
+		&i.TotalSoundtracks,
+		&i.PlayedSoundtracks,
+		&i.NeverPlayedSoundtracks,
+		&i.TotalSoundtrackPlays,
+		&i.AvgSoundtrackPlays,
+		&i.MaxSoundtrackPlays,
+		&i.MinSoundtrackPlays,
+	)
+	return i, err
+}

internal/db/test_helpers.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"log"
@@ -16,6 +17,8 @@ var (
 	testDBUser      string
 	testDBPassword  string
 	testDBName      string
+	// TestDatabase is the database instance for tests
+	TestDatabase *Database
 )
 
 // TestSetupDB initializes the test database using existing functions
@@ -44,9 +47,28 @@ func TestSetupDB(t *testing.T) {
 		// Create the database first (testuser is a superuser in the container)
 		createTestDatabase(host, port, dbname, user, password)
 
-		// Now run migrations using the existing function
+		// Create database instance and run migrations
-		Migrate_db(host, port, user, password, dbname)
+		var err error
-		InitDB(host, port, user, password, dbname)
+		TestDatabase, err = NewDatabase(host, port, user, password, dbname)
+		if err != nil {
+			t.Fatalf("Failed to initialize test database: %v", err)
+		}
+
+		// Clean up any existing schema to ensure clean state
+		ctx := context.Background()
+		_, err = TestDatabase.Pool.Exec(ctx, "DROP SCHEMA IF EXISTS public CASCADE; CREATE SCHEMA public;")
+		if err != nil {
+			t.Logf("Warning: Could not clean schema: %v", err)
+			// Continue anyway, migrations might still work
+		}
+
+		// Run migrations
+		if err := TestDatabase.RunMigrations(); err != nil {
+			// Clean up on failure to prevent nil pointer issues in other tests
+			TestDatabase.Close()
+			TestDatabase = nil
+			t.Fatalf("Failed to run migrations: %v", err)
+		}
 	})
 }
 
@@ -86,33 +108,43 @@ func createTestDatabase(host, port, dbname, user, password string) {
 // "closed pool" errors when tests run sequentially
 func TestTearDownDB(t *testing.T) {
 	// CloseDb() // Disabled to prevent pool closure between sequential tests
+	// Note: We also don't nil TestDatabase to allow reuse across tests
+	// if TestDatabase != nil {
+	// 	TestDatabase.Close()
+	// 	TestDatabase = nil
+	// }
 }
 
 // TestClearDatabase clears all data from the test database
 // Useful for running tests with a clean slate
 func TestClearDatabase(t *testing.T) {
-	if Dbpool == nil {
+	if TestDatabase == nil || TestDatabase.Pool == nil {
 		t.Skip("Database not initialized")
 	}
 
 	// Clear all tables in reverse order to respect foreign keys
 	// Note: This assumes the tables exist and have the expected structure
+	// After migration 000005, game table was renamed to soundtrack
 	tables := []string{
 		"song_list",
 		"song",
-		"game",
+		"soundtrack",
+		"vgmq",
+		"sessions",
 	}
 
+	ctx := context.Background()
 	for _, table := range tables {
-		_, err := Dbpool.Exec(Ctx, "TRUNCATE TABLE "+table+" CASCADE")
+		_, err := TestDatabase.Pool.Exec(ctx, "TRUNCATE TABLE "+table+" CASCADE")
 		if err != nil {
 			t.Logf("Failed to truncate table %s: %v", table, err)
 		}
 	}
 
-	// Reset sequences
+	// Reset sequences (renamed from game_id_seq to soundtrack_id_seq in migration 000005)
-	_, err := Dbpool.Exec(Ctx, "SELECT setval('game_id_seq', 1, false)")
+	var seqErr error
-	if err != nil {
+	_, seqErr = TestDatabase.Pool.Exec(ctx, "SELECT setval('soundtrack_id_seq', 1, false)")
-		t.Logf("Failed to reset game_id_seq: %v", err)
+	if seqErr != nil {
+		t.Logf("Failed to reset soundtrack_id_seq: %v", seqErr)
 	}
 }

internal/server/healthHandler.go

@@ -8,10 +8,11 @@ import (
 )
 
 type HealthHandler struct {
+	db *db.Database
 }
 
-func NewHealthHandler() *HealthHandler {
+func NewHealthHandler(database *db.Database) *HealthHandler {
-	return &HealthHandler{}
+	return &HealthHandler{db: database}
 }
 
 // HealthCheck godoc
@@ -24,5 +25,5 @@ func NewHealthHandler() *HealthHandler {
 //	@Success		200	{string}	string	"OK"
 //	@Router			/health [get]
 func (h *HealthHandler) HealthCheck(ctx *echo.Context) error {
-	return ctx.JSON(http.StatusOK, db.Health())
+	return ctx.JSON(http.StatusOK, h.db.Health())
 }

internal/server/health_handler_test.go

@@ -5,18 +5,13 @@ import (
 	"net/http"
 	"testing"
 
-	"music-server/internal/db"
-
 	"github.com/stretchr/testify/assert"
 )
 
 // TestHealthCheck verifies the health endpoint returns database status
 func TestHealthCheck(t *testing.T) {
-	// Setup database
-	db.TestSetupDB(t)
-	defer db.TestTearDownDB(t)
-
 	e := StartTestServer(t)
+	// No explicit teardown - handled by StartTestServer's sync.Once
 
 	resp := MakeTestRequest(t, e, "GET", "/health")
 	assert.Equal(t, http.StatusOK, resp.Code)

internal/server/middleware/deprecation.go

@@ -0,0 +1,16 @@
+package middleware
+
+import (
+	"github.com/labstack/echo/v5"
+)
+
+// DeprecationMiddleware adds deprecation warning to responses
+// for old endpoints that are being phased out in favor of /api/v1/*
+func DeprecationMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c *echo.Context) error {
+		// Add deprecation warning header
+		c.Response().Header().Add("Warning", `299 - "Deprecated: This endpoint is deprecated. Use /api/v1/ endpoints instead."`)
+		c.Response().Header().Add("Deprecation", "true")
+		return next(c)
+	}
+}

internal/server/middleware/sync_check.go

@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"music-server/internal/backend"
+	"music-server/internal/logging"
+	"net/http"
+
+	"github.com/labstack/echo/v5"
+)
+
+// SyncCheckMiddleware blocks requests when syncing is in progress.
+// It returns HTTP 423 Locked with a standard message.
+// This middleware should be applied to handlers that cannot execute during sync.
+func SyncCheckMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c *echo.Context) error {
+		if backend.Syncing {
+			logging.GetLogger().Info("Syncing is in progress - request blocked")
+			return c.JSON(http.StatusLocked, "Syncing is in progress")
+		}
+		return next(c)
+	}
+}

internal/server/musicHandler.go

@@ -31,10 +31,6 @@ func NewMusicHandler() *MusicHandler {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music [get]
 func (m *MusicHandler) GetSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	song := ctx.QueryParam("song")
 	if song == "" {
 		return ctx.String(http.StatusBadRequest, "song can't be empty")
@@ -58,10 +54,6 @@ func (m *MusicHandler) GetSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/soundTest [get]
 func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetSoundCheckSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -80,10 +72,6 @@ func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/reset [get]
 func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.Reset()
 	return ctx.NoContent(http.StatusOK)
 }
@@ -98,10 +86,6 @@ func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand [get]
 func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -121,10 +105,6 @@ func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand/low [get]
 func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSongLowChance()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -144,10 +124,6 @@ func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand/classic [get]
 func (m *MusicHandler) GetRandomSongClassic(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSongClassic()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -193,10 +169,6 @@ func (m *MusicHandler) GetPlayedSongs(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/next [get]
 func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetNextSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -216,10 +188,6 @@ func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/previous [get]
 func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetPreviousSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -229,40 +197,32 @@ func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
 	return ctx.Stream(http.StatusOK, "audio/mpeg", file)
 }
 
-// GetAllGames godoc
+// GetAllSoundtracks godoc
-// @Summary Get all games
+// @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
 // @Success 200 {array} map[string]interface{}
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/all/order [get]
-func (m *MusicHandler) GetAllGames(ctx *echo.Context) error {
+func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
-	if backend.Syncing {
+	soundtrackList := backend.GetAllSoundtracks()
-		logging.GetLogger().Info("Syncing is in progress")
+	return ctx.JSON(http.StatusOK, soundtrackList)
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
-	gameList := backend.GetAllGames()
-	return ctx.JSON(http.StatusOK, gameList)
 }
 
-// GetAllGamesRandom godoc
+// GetAllSoundtracksRandom godoc
-// @Summary Get all games random
+// @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
 // @Success 200 {array} map[string]interface{}
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/all/random [get]
-func (m *MusicHandler) GetAllGamesRandom(ctx *echo.Context) error {
+func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error {
-	if backend.Syncing {
+	soundtrackList := backend.GetAllSoundtracksRandom()
-		logging.GetLogger().Info("Syncing is in progress")
+	return ctx.JSON(http.StatusOK, soundtrackList)
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
-	gameList := backend.GetAllGamesRandom()
-	return ctx.JSON(http.StatusOK, gameList)
 }
 
 // PutPlayed godoc
@@ -277,15 +237,11 @@ func (m *MusicHandler) GetAllGamesRandom(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/played [put]
 func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	song, err := strconv.Atoi(ctx.QueryParam("song"))
 	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)
 }
@@ -299,10 +255,6 @@ func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/addQue [get]
 func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.AddLatestToQue()
 	return ctx.NoContent(http.StatusOK)
 }
@@ -316,10 +268,6 @@ func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/addPlayed [get]
 func (m *MusicHandler) AddLatestPlayed(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.AddLatestPlayed()
 	return ctx.NoContent(http.StatusOK)
 }

internal/server/routes.go

@@ -50,59 +50,65 @@ func (s *Server) RegisterRoutes() http.Handler {
 	fileServer := http.FileServer(http.FS(web.Assets))
 	e.GET("/assets/*", echo.WrapHandler(fileServer))
 
-	e.GET("/search", echo.WrapHandler(templ.Handler(web.HelloForm())))
+	e.GET("/search", echo.WrapHandler(templ.Handler(web.SearchForm())))
-	e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindGameWebHandler)))
+	e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackWebHandler)))
+	e.POST("/findfuzzy", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackFuzzyWebHandler)))
 
 	e.Static("/", "/frontend")
 
 	// Swagger UI
 	e.GET("/swagger/*", echoSwagger.WrapHandler)
 
-	health := NewHealthHandler()
+	// ============================================
-	e.GET("/health", health.HealthCheck)
+	// Legacy Endpoints (Deprecated - use /api/v1/ instead)
+	// ============================================
+	deprecatedMiddleware := middleware.DeprecationMiddleware
+
+	health := NewHealthHandler(s.db)
+	e.GET("/health", deprecatedMiddleware(health.HealthCheck))
 
 	version := NewVersionHandler()
-	e.GET("/version", version.GetLatestVersion)
+	e.GET("/version", deprecatedMiddleware(version.GetLatestVersion))
-	e.GET("/version/history", version.GetVersionHistory)
+	e.GET("/version/history", deprecatedMiddleware(version.GetVersionHistory))
 
 	character := NewCharacterHandler()
-	e.GET("/character", character.GetCharacter)
+	e.GET("/character", deprecatedMiddleware(character.GetCharacter))
-	e.GET("/characters", character.GetCharacterList)
+	e.GET("/characters", deprecatedMiddleware(character.GetCharacterList))
 
 	download := NewDownloadHandler()
-	e.GET("/download", download.checkLatest)
+	e.GET("/download", deprecatedMiddleware(download.checkLatest))
-	e.GET("/download/list", download.listAssetsOfLatest)
+	e.GET("/download/list", deprecatedMiddleware(download.listAssetsOfLatest))
-	e.GET("/download/windows", download.downloadLatestWindows)
+	e.GET("/download/windows", deprecatedMiddleware(download.downloadLatestWindows))
-	e.GET("/download/linux", download.downloadLatestLinux)
+	e.GET("/download/linux", deprecatedMiddleware(download.downloadLatestLinux))
 
 	sync := NewSyncHandler()
 	syncGroup := e.Group("/sync")
-	syncGroup.GET("", sync.SyncGamesNewOnlyChanges)
+	syncGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
-	syncGroup.GET("/progress", sync.SyncProgress)
+	syncGroup.GET("/progress", deprecatedMiddleware(sync.SyncProgress))
-	syncGroup.GET("/new", sync.SyncGamesNewOnlyChanges)
+	syncGroup.GET("/new", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
-	syncGroup.GET("/full", sync.SyncGamesNewFull)
+	syncGroup.GET("/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
-	syncGroup.GET("/new/full", sync.SyncGamesNewFull)
+	syncGroup.GET("/new/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
-	syncGroup.GET("/quick", sync.SyncGamesNewOnlyChanges)
+	syncGroup.GET("/quick", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
-	syncGroup.GET("/reset", sync.ResetGames)
+	syncGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.ResetDB)))
 
 	music := NewMusicHandler()
 	musicGroup := e.Group("/music")
-	musicGroup.GET("", music.GetSong)
+	musicGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSong)))
-	musicGroup.GET("/soundTest", music.GetSoundCheckSong)
+	musicGroup.GET("/soundTest", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSoundCheckSong)))
-	musicGroup.GET("/reset", music.ResetMusic)
+	musicGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.ResetMusic)))
-	musicGroup.GET("/rand", music.GetRandomSong)
+	musicGroup.GET("/rand", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSong)))
-	musicGroup.GET("/rand/low", music.GetRandomSongLowChance)
+	musicGroup.GET("/rand/low", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongLowChance)))
-	musicGroup.GET("/rand/classic", music.GetRandomSongClassic)
+	musicGroup.GET("/rand/classic", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongClassic)))
-	musicGroup.GET("/info", music.GetSongInfo)
+	musicGroup.GET("/info", deprecatedMiddleware(music.GetSongInfo))
-	musicGroup.GET("/list", music.GetPlayedSongs)
+	musicGroup.GET("/list", deprecatedMiddleware(music.GetPlayedSongs))
-	musicGroup.GET("/next", music.GetNextSong)
+	musicGroup.GET("/next", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetNextSong)))
-	musicGroup.GET("/previous", music.GetPreviousSong)
+	musicGroup.GET("/previous", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetPreviousSong)))
-	musicGroup.GET("/all", music.GetAllGamesRandom)
+	musicGroup.GET("/all", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
-	musicGroup.GET("/all/order", music.GetAllGames)
+	musicGroup.GET("/all/order", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracks)))
-	musicGroup.GET("/all/random", music.GetAllGamesRandom)
+	musicGroup.GET("/all/random", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
-	musicGroup.PUT("/played", music.PutPlayed)
+	musicGroup.PUT("/played", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.PutPlayed)))
-	musicGroup.GET("/addQue", music.AddLatestToQue)
+	musicGroup.GET("/addQue", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestToQue)))
-	musicGroup.GET("/addPlayed", music.AddLatestPlayed)
+	musicGroup.GET("/addPlayed", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestPlayed)))
 
 	// ============================================
 	// API v1 Routes with Token Authentication
@@ -126,10 +132,38 @@ func (s *Server) RegisterRoutes() http.Handler {
 	// Create token auth middleware with pool access
 	tokenAuthMiddleware := middleware.TokenAuthMiddleware(s.db.Pool)
 
-	// Protected group with token authentication - will be used by VGMQ and Statistics API
+	// Protected group with token authentication
-	_ = apiV1.Group("", tokenAuthMiddleware)
+	protectedV1 := apiV1.Group("", tokenAuthMiddleware)
 
-	// Note: Future protected endpoints (VGMQ, Statistics) will be added here
+	// Statistics API endpoints (protected by token auth)
+	statistics := s.statisticsHandler
+	protectedV1.GET("/statistics/soundtracks/most-played", func(c *echo.Context) error {
+		return statistics.GetMostPlayedSoundtracks(c)
+	})
+	protectedV1.GET("/statistics/soundtracks/least-played", func(c *echo.Context) error {
+		return statistics.GetLeastPlayedSoundtracks(c)
+	})
+	protectedV1.GET("/statistics/soundtracks/never-played", func(c *echo.Context) error {
+		return statistics.GetNeverPlayedSoundtracks(c)
+	})
+	protectedV1.GET("/statistics/soundtracks/last-played", func(c *echo.Context) error {
+		return statistics.GetLastPlayedSoundtracks(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)
+	})
+	protectedV1.GET("/statistics/songs/least-played", func(c *echo.Context) error {
+		return statistics.GetLeastPlayedSongs(c)
+	})
+	protectedV1.GET("/statistics/summary", func(c *echo.Context) error {
+		return statistics.GetStatisticsSummary(c)
+	})
+
+	// Future: VGMQ endpoints will be added to protectedV1 group
+	_ = protectedV1 // Use the variable to avoid unused variable error
 
 	routes := e.Router().Routes()
 	sort.Slice(routes, func(i, j int) bool {

internal/server/server.go

@@ -15,10 +15,11 @@ import (
 )
 
 type Server struct {
-	port         int
+	port            int
-	db          *db.Database
+	db             *db.Database
-	tokenHandler *TokenHandler
+	tokenHandler   *TokenHandler
-	httpServer  *http.Server
+	statisticsHandler *StatisticsHandler
+	httpServer     *http.Server
 }
 
 var (
@@ -68,11 +69,15 @@ func NewServerInstance() *Server {
 	// Initialize token handler with database pool
 	tokenHandler := NewTokenHandler(database.Pool)
 	
+	// Initialize statistics handler
+	statisticsHandler := NewStatisticsHandler()
+
 	// Create the server instance
 	appServer := &Server{
-		port:         port,
+		port:            port,
-		db:          database,
+		db:             database,
-		tokenHandler: tokenHandler,
+		tokenHandler:   tokenHandler,
+		statisticsHandler: statisticsHandler,
 	}
 
 	// Create the HTTP server

internal/server/statistics_handler.go

@@ -0,0 +1,275 @@
+package server
+
+import (
+	"net/http"
+	"strconv"
+
+	"music-server/internal/backend"
+	"music-server/internal/logging"
+
+	"github.com/labstack/echo/v5"
+	"go.uber.org/zap"
+)
+
+// StatisticsHandler handles statistics-related HTTP requests
+type StatisticsHandler struct {
+	statsBackend *backend.StatisticsHandler
+}
+
+// NewStatisticsHandler creates a new StatisticsHandler
+func NewStatisticsHandler() *StatisticsHandler {
+	return &StatisticsHandler{
+		statsBackend: backend.NewStatisticsHandler(),
+	}
+}
+
+// GetMostPlayedSoundtracks returns top N most played soundtracks with songs
+// GET /api/v1/statistics/soundtracks/most-played
+//
+//	@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.SoundtrackWithSongs
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@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 != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		// Cap at 100 for performance
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	soundtracks, err := h.statsBackend.GetMostPlayedSoundtracksWithSongs(int32(limit))
+	if err != nil {
+		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, soundtracks)
+}
+
+// GetLeastPlayedSoundtracks returns top N least played soundtracks with songs
+// GET /api/v1/statistics/soundtracks/least-played
+//
+//	@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.SoundtrackWithSongs
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/soundtracks/least-played [get]
+func (h *StatisticsHandler) GetLeastPlayedSoundtracks(ctx *echo.Context) error {
+	limit := 10
+	limitStr := ctx.QueryParam("limit")
+	if limitStr != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	soundtracks, err := h.statsBackend.GetLeastPlayedSoundtracksWithSongs(int32(limit))
+	if err != nil {
+		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, soundtracks)
+}
+
+// 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 soundtrack info
+//	@Tags			statistics
+//	@Accept		json
+//	@Produce		json
+//	@Param			limit	query	int	false	"Number of results (default: 10)"
+//	@Success		200	{array}	backend.SongInfoForStats
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/songs/most-played [get]
+func (h *StatisticsHandler) GetMostPlayedSongs(ctx *echo.Context) error {
+	limit := 10
+	limitStr := ctx.QueryParam("limit")
+	if limitStr != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	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"})
+	}
+	return ctx.JSON(http.StatusOK, songs)
+}
+
+// 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 soundtrack info
+//	@Tags			statistics
+//	@Accept		json
+//	@Produce		json
+//	@Param			limit	query	int	false	"Number of results (default: 10)"
+//	@Success		200	{array}	backend.SongInfoForStats
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/songs/least-played [get]
+func (h *StatisticsHandler) GetLeastPlayedSongs(ctx *echo.Context) error {
+	limit := 10
+	limitStr := ctx.QueryParam("limit")
+	if limitStr != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	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"})
+	}
+	return ctx.JSON(http.StatusOK, songs)
+}
+
+// GetNeverPlayedSoundtracks returns soundtracks that have never been played
+// GET /api/v1/statistics/soundtracks/never-played
+//
+//	@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.SoundtrackWithSongs
+//	@Failure		500	{object}	map[string]string
+//	@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 soundtracks", zap.String("error", err.Error()))
+		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
+	}
+	return ctx.JSON(http.StatusOK, soundtracks)
+}
+
+// GetLastPlayedSoundtracks returns most recently played soundtracks
+// GET /api/v1/statistics/soundtracks/last-played
+//
+//	@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.SoundtrackWithSongs
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/soundtracks/last-played [get]
+func (h *StatisticsHandler) GetLastPlayedSoundtracks(ctx *echo.Context) error {
+	limit := 10
+	limitStr := ctx.QueryParam("limit")
+	if limitStr != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	soundtracks, err := h.statsBackend.GetLastPlayedSoundtracks(int32(limit))
+	if err != nil {
+		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, soundtracks)
+}
+
+// GetOldestPlayedSoundtracks returns least recently played soundtracks
+// GET /api/v1/statistics/soundtracks/oldest-played
+//
+//	@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.SoundtrackWithSongs
+//	@Failure		400	{object}	map[string]string
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/soundtracks/oldest-played [get]
+func (h *StatisticsHandler) GetOldestPlayedSoundtracks(ctx *echo.Context) error {
+	limit := 10
+	limitStr := ctx.QueryParam("limit")
+	if limitStr != "" {
+		var err error
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil || limit <= 0 {
+			return ctx.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid limit parameter"})
+		}
+		if limit > 100 {
+			limit = 100
+		}
+	}
+
+	soundtracks, err := h.statsBackend.GetOldestPlayedSoundtracks(int32(limit))
+	if err != nil {
+		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, soundtracks)
+}
+
+// GetStatisticsSummary returns overall statistics
+// GET /api/v1/statistics/summary
+//
+//	@Summary		Get statistics summary
+//	@Description	Returns overall statistics about the music library
+//	@Tags			statistics
+//	@Accept		json
+//	@Produce		json
+//	@Success		200	{object}	backend.StatisticsSummary
+//	@Failure		500	{object}	map[string]string
+//	@Router		/api/v1/statistics/summary [get]
+func (h *StatisticsHandler) GetStatisticsSummary(ctx *echo.Context) error {
+	summary, err := h.statsBackend.GetStatisticsSummary()
+	if err != nil {
+		logging.GetLogger().Error("Failed to get statistics summary", zap.String("error", err.Error()))
+		return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
+	}
+	return ctx.JSON(http.StatusOK, summary)
+}

internal/server/statistics_handler_test.go

@@ -0,0 +1,179 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"music-server/internal/backend"
+	"music-server/internal/db"
+	"music-server/internal/db/repository"
+
+	"github.com/labstack/echo/v5"
+	"github.com/stretchr/testify/require"
+)
+
+// TestStatisticsEndpoints tests the statistics API endpoints
+func TestStatisticsEndpoints(t *testing.T) {
+	// Skip if test database not configured
+	e := StartTestServer(t)
+	if e == nil {
+		t.Skip("Test database not configured")
+	}
+
+	// Get token first
+	token := getTestToken(t, e)
+	if token == "" {
+		t.Skip("Could not get test token")
+	}
+
+	// Test /api/v1/statistics/summary
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/statistics/summary", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	var summary backend.StatisticsSummary
+	err := json.Unmarshal(rec.Body.Bytes(), &summary)
+	require.NoError(t, err)
+	require.NotNil(t, summary)
+}
+
+// TestPartialMigrationThenSyncThenComplete tests migration workflow
+// Note: This test requires the database to be in a specific state
+// It tests: partial migration → data insert → sync → complete migration
+func TestPartialMigrationThenSyncThenComplete(t *testing.T) {
+	// This test is complex and requires careful setup
+	// For now, we test the final state: all migrations + sync
+
+	e := StartTestServer(t)
+	if e == nil {
+		t.Skip("Test database not configured")
+	}
+
+	// Get token
+	token := getTestToken(t, e)
+	if token == "" {
+		t.Skip("Could not get test token")
+	}
+
+	// Insert test data manually (5 soundtracks with songs)
+	insertTestData(t)
+
+	// Run sync to ensure data is properly loaded
+	req := httptest.NewRequest(http.MethodGet, "/sync/new", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	// Wait for sync to complete
+	if !waitForSyncCompletion(t, e, 60) {
+		t.Error("Sync did not complete within timeout")
+	}
+
+	// Verify data via statistics endpoint
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/statistics/summary", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec = httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	var summary backend.StatisticsSummary
+	err := json.Unmarshal(rec.Body.Bytes(), &summary)
+	require.NoError(t, err)
+
+	// After sync with /sync/new, only soundtracks matching filesystem remain
+	// testMusic has 3 soundtracks
+	require.Equal(t, int64(3), summary.TotalSoundtracks)
+}
+
+// insertTestData inserts 5 test soundtracks with songs into the database
+func insertTestData(t *testing.T) {
+	if db.TestDatabase == nil || db.TestDatabase.Pool == nil {
+		t.Skip("Test database not initialized")
+		return
+	}
+
+	ctx := context.Background()
+	queries := repository.New(db.TestDatabase.Pool)
+
+	// Insert 5 soundtracks
+	soundtracks := []struct {
+		name string
+		path string
+	}{
+		{"Test Soundtrack 1", "/path/to/soundtrack1"},
+		{"Test Soundtrack 2", "/path/to/soundtrack2"},
+		{"Test Soundtrack 3", "/path/to/soundtrack3"},
+		{"Test Soundtrack 4", "/path/to/soundtrack4"},
+		{"Test Soundtrack 5", "/path/to/soundtrack5"},
+	}
+
+	for _, st := range soundtracks {
+		_, err := queries.InsertSoundtrack(ctx, repository.InsertSoundtrackParams{
+			SoundtrackName: st.name,
+			Path:           st.path,
+			Hash:           "test-hash-" + st.name,
+		})
+		require.NoError(t, err, "Failed to insert soundtrack: %s", st.name)
+	}
+
+	// Get soundtrack IDs
+	soundtrackIDs, err := queries.FindAllSoundtracks(ctx)
+	require.NoError(t, err)
+	require.GreaterOrEqual(t, len(soundtrackIDs), 5)
+
+	// Insert songs for each soundtrack
+	songData := []struct {
+		soundtrackID int32
+		songs        []string
+	}{
+		{soundtrackIDs[0].ID, []string{"Song A", "Song B"}},
+		{soundtrackIDs[1].ID, []string{"Song C", "Song D"}},
+		{soundtrackIDs[2].ID, []string{"Song E"}},
+		{soundtrackIDs[3].ID, []string{"Song F", "Song G", "Song H"}},
+		{soundtrackIDs[4].ID, []string{"Song I"}},
+	}
+
+	for _, sd := range songData {
+		for _, songName := range sd.songs {
+			err := queries.AddSong(ctx, repository.AddSongParams{
+				SoundtrackID: sd.soundtrackID,
+				SongName:     songName,
+				Path:         "/path/to/" + songName + ".mp3",
+			})
+			require.NoError(t, err, "Failed to insert song: %s", songName)
+		}
+	}
+
+	t.Logf("Inserted %d soundtracks with %d total songs", len(soundtracks), 8)
+}
+
+// getTestToken gets a valid token for testing
+func getTestToken(t *testing.T, e *echo.Echo) string {
+	reqBody := `{"client_type": "test"}`
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/token", strings.NewReader(reqBody))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Logf("Failed to get token: %s", rec.Body.String())
+		return ""
+	}
+
+	var resp struct {
+		Token string `json:"token"`
+	}
+	err := json.Unmarshal(rec.Body.Bytes(), &resp)
+	require.NoError(t, err)
+	return resp.Token
+}

internal/server/syncHandler.go

@@ -34,61 +34,49 @@ func (s *SyncHandler) SyncProgress(ctx *echo.Context) error {
 	return ctx.JSON(http.StatusOK, response)
 }
 
-// SyncGamesNewOnlyChanges godoc
+// SyncSoundtracksNewOnlyChanges godoc
-// @Summary Sync games with only changes
+// @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
-// @Success 200 {string} string "Start syncing games"
+// @Success 200 {string} string "Start syncing soundtracks"
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync [get]
-func (s *SyncHandler) SyncGamesNewOnlyChanges(ctx *echo.Context) error {
+func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Warn("Syncing is already in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	logging.GetLogger().Info("Starting sync with only changes")
 	backend.Syncing = true
-	go backend.SyncGamesNewOnlyChanges()
+	go backend.SyncSoundtracksOnlyChanges()
-	return ctx.JSON(http.StatusOK, "Start syncing games")
+	return ctx.JSON(http.StatusOK, "Start syncing soundtracks")
 }
 
-// SyncGamesNewFull godoc
+// SyncSoundtracksNewFull godoc
-// @Summary Sync all games fully
+// @Summary Sync all soundtracks fully
-// @Description Starts a full sync of all games
+// @Description Starts a full sync of all soundtracks
 // @Tags sync
 // @Accept json
 // @Produce json
-// @Success 200 {string} string "Start syncing games full"
+// @Success 200 {string} string "Start syncing soundtracks full"
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync/full [get]
-func (s *SyncHandler) SyncGamesNewFull(ctx *echo.Context) error {
+func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Warn("Syncing is already in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	logging.GetLogger().Info("Starting full sync")
 	backend.Syncing = true
-	go backend.SyncGamesNewFull()
+	go backend.SyncSoundtracksFull()
-	return ctx.JSON(http.StatusOK, "Start syncing games full")
+	return ctx.JSON(http.StatusOK, "Start syncing soundtracks full")
 }
 
-// ResetGames godoc
+// ResetDB godoc
-// @Summary Reset games database
+// @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
-// @Success 200 {string} string "Games and songs are deleted from the database"
+// @Success 200 {string} string "Soundtracks and songs are deleted from the database"
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync/reset [get]
-func (s *SyncHandler) ResetGames(ctx *echo.Context) error {
+func (s *SyncHandler) ResetDB(ctx *echo.Context) error {
-	if backend.Syncing {
+	logging.GetLogger().Info("Resetting soundtracks database")
-		logging.GetLogger().Warn("Cannot reset - syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
-	logging.GetLogger().Info("Resetting games database")
 	backend.ResetDB()
-	return ctx.JSON(http.StatusOK, "Games and songs are deleted from the database")
+	return ctx.JSON(http.StatusOK, "Soundtracks and songs are deleted from the database")
 }

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.FindAllGames(backend.BackendCtx())
+	soundtracksBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	beforeCount := len(gamesBefore)
+	beforeCount := len(soundtracksBefore)
-	t.Logf("Games before sync: %d", beforeCount)
+	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
+	// After sync - should have soundtracks
-	gamesAfter, err := repo.FindAllGames(backend.BackendCtx())
+	soundtracksAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
-	afterCount := len(gamesAfter)
+	afterCount := len(soundtracksAfter)
-	t.Logf("Games after sync: %d", afterCount)
+	t.Logf("Soundtracks after sync: %d", afterCount)
 
-	// Should have more games than before (unless database was already populated)
+	// Should have more soundtracks than before (unless database was already populated)
-	assert.True(t, afterCount > 0, "Database should have games after sync")
+	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.FindAllGames(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
+	// After sync - should have soundtracks
-	gamesAfter, err := repo.FindAllGames(backend.BackendCtx())
+	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
+// TestSyncSoundtracksNewOnlyChanges verifies the incremental sync endpoint
-func TestSyncGamesNewOnlyChanges(t *testing.T) {
+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.FindAllGames(backend.BackendCtx())
+	soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	beforeCount := len(gamesBefore)
+	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.FindAllGames(backend.BackendCtx())
+	soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	afterCount := len(gamesAfter)
+	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.FindAllGames(backend.BackendCtx())
+	soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	beforeCount := len(gamesBefore)
+	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.FindAllGames(backend.BackendCtx())
+		soundtracksBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx())
-		beforeCount = len(gamesBefore)
+		beforeCount = len(soundtracksBefore)
 	}
 
-	t.Logf("Games before reset: %d", beforeCount)
+	t.Logf("Soundtracks before reset: %d", beforeCount)
-	assert.True(t, beforeCount > 0, "Should have games to reset")
+	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.FindAllGames(backend.BackendCtx())
+	soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
-	afterCount := len(gamesAfter)
+	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
+// TestSyncSoundtracksNewFull verifies the full sync endpoint
-// RUN THIS LAST (before TestResetGames)
+// RUN THIS LAST (before TestResetSoundtracks)
-func TestSyncGamesNewFull(t *testing.T) {
+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.FindAllGames(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")
+	assert.True(t, len(soundtracks) > 0, "Database should be populated after full sync")
-	t.Logf("Full sync populated %d games", len(games))
+	t.Logf("Full sync populated %d soundtracks", len(soundtracks))
 }

internal/server/test_helpers.go

@@ -51,19 +51,17 @@ func StartTestServer(t *testing.T) *echo.Echo {
 	// Initialize database for tests
 	db.TestSetupDB(t)
 
-	// Initialize backend with the global Dbpool
+	// Initialize backend with test database pool
 	// This ensures BackendRepo() and BackendCtx() are available
-	if db.Dbpool != nil {
+	if db.TestDatabase != nil && db.TestDatabase.Pool != nil {
-		backend.InitBackend(db.Dbpool)
+		backend.InitBackend(db.TestDatabase.Pool)
 	}
 
 	// Create a Server instance and get its routes
 	s := &Server{
-		db: &db.Database{
+		db:                db.TestDatabase,
-			Pool: db.Dbpool,
+		tokenHandler:      NewTokenHandler(db.TestDatabase.Pool),
-			Ctx:  db.Ctx,
+		statisticsHandler: NewStatisticsHandler(),
-		},
-		tokenHandler: NewTokenHandler(db.Dbpool),
 	}
 	handler := s.RegisterRoutes()
 

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.FindAllGames(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
+// TestGetAllSoundtracks verifies the /music/all/order endpoint
-func TestZGetAllGames(t *testing.T) {
+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
+	var soundtracks []string
-	err := json.Unmarshal(resp.Body.Bytes(), &games)
+	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")
-	t.Logf("Found %d games", len(games))
+	t.Logf("Found %d soundtracks", len(soundtracks))
 }
 
-// TestGetAllGamesRandom verifies the /music/all/random endpoint
+// TestGetAllSoundtracksRandom verifies the /music/all/random endpoint
-func TestZGetAllGamesRandom(t *testing.T) {
+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
+	var soundtracks []string
-	err := json.Unmarshal(resp.Body.Bytes(), &games)
+	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
+	var soundtracksOrdered []string
-	json.Unmarshal(resp2.Body.Bytes(), &gamesOrdered)
+	json.Unmarshal(resp2.Body.Bytes(), &soundtracksOrdered)
-	assert.Equal(t, len(games), len(gamesOrdered), "Random and ordered should have same count")
+	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

justfile

@@ -84,8 +84,13 @@ build-run: build
 	@go run cmd/main.go
 
 test: build
-	@echo "Testing..."
+	@echo "Starting test database container..."
-	@go test ./... -v
+	@podman-compose -f compose.test.yaml up -d
+	@sleep 10
+	@echo "Running integration tests..."
+	@just test-integration
+	@echo "Stopping test database container..."
+	@just test-integration-down
 
 # Clean the binary
 clean:
@@ -105,7 +110,9 @@ podman-down:
 # Run integration tests with podman
 # Starts a test PostgreSQL container, runs tests, then cleans up
 test-integration:
-	@echo "Starting test database container..."
+	@echo "Cleaning old test database..."
+	@podman-compose -f compose.test.yaml down -v
+	@echo "Starting fresh test database container..."
 	@podman-compose -f compose.test.yaml up -d
 	@sleep 10
 	@echo "Running integration tests..."