Feat: Genre system with per-genre daily puzzles

app/api/daily/route.ts

@@ -1,78 +1,18 @@
 import { NextResponse } from 'next/server';
-import { PrismaClient } from '@prisma/client';
-import { getTodayISOString } from '@/lib/dateUtils';
+import { getOrCreateDailyPuzzle } from '@/lib/dailyPuzzle';
 
-const prisma = new PrismaClient();
-
-export async function GET() {
+export async function GET(request: Request) {
     try {
-        const today = getTodayISOString();
+        const { searchParams } = new URL(request.url);
+        const genreName = searchParams.get('genre');
 
-        let dailyPuzzle = await prisma.dailyPuzzle.findUnique({
-            where: { date: today },
-            include: { song: true },
-        });
+        const puzzle = await getOrCreateDailyPuzzle(genreName);
 
-        console.log(`[Daily Puzzle] Date: ${today}, Found existing: ${!!dailyPuzzle}`);
-
-        if (!dailyPuzzle) {
-            // Get all songs with their usage count
-            const allSongs = await prisma.song.findMany({
-                include: {
-                    puzzles: true,
-                },
-            });
-
-            if (allSongs.length === 0) {
-                return NextResponse.json({ error: 'No songs available' }, { status: 404 });
-            }
-
-            // Calculate weights: songs never used get weight 1.0, 
-            // songs used once get 0.5, twice 0.33, etc.
-            const weightedSongs = allSongs.map(song => ({
-                song,
-                weight: 1.0 / (song.puzzles.length + 1),
-            }));
-
-            // Calculate total weight
-            const totalWeight = weightedSongs.reduce((sum, item) => sum + item.weight, 0);
-
-            // Pick a random song based on weights
-            let random = Math.random() * totalWeight;
-            let selectedSong = weightedSongs[0].song;
-
-            for (const item of weightedSongs) {
-                random -= item.weight;
-                if (random <= 0) {
-                    selectedSong = item.song;
-                    break;
-                }
-            }
-
-            // Create the daily puzzle
-            dailyPuzzle = await prisma.dailyPuzzle.create({
-                data: {
-                    date: today,
-                    songId: selectedSong.id,
-                },
-                include: { song: true },
-            });
-
-            console.log(`[Daily Puzzle] Created new puzzle for ${today} with song: ${selectedSong.title} (ID: ${selectedSong.id})`);
+        if (!puzzle) {
+            return NextResponse.json({ error: 'Failed to get or create puzzle' }, { status: 404 });
         }
 
-        if (!dailyPuzzle) {
-            return NextResponse.json({ error: 'Failed to create puzzle' }, { status: 500 });
-        }
-
-        return NextResponse.json({
-            id: dailyPuzzle.id,
-            audioUrl: `/uploads/${dailyPuzzle.song.filename}`,
-            songId: dailyPuzzle.songId,
-            title: dailyPuzzle.song.title,
-            artist: dailyPuzzle.song.artist,
-            coverImage: dailyPuzzle.song.coverImage ? `/uploads/covers/${dailyPuzzle.song.coverImage}` : null,
-        });
+        return NextResponse.json(puzzle);
 
     } catch (error) {
         console.error('Error fetching daily puzzle:', error);

app/api/genres/route.ts

@@ -0,0 +1,59 @@
+import { NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+export async function GET() {
+    try {
+        const genres = await prisma.genre.findMany({
+            orderBy: { name: 'asc' },
+            include: {
+                _count: {
+                    select: { songs: true }
+                }
+            }
+        });
+        return NextResponse.json(genres);
+    } catch (error) {
+        console.error('Error fetching genres:', error);
+        return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+    }
+}
+
+export async function POST(request: Request) {
+    try {
+        const { name } = await request.json();
+
+        if (!name || typeof name !== 'string') {
+            return NextResponse.json({ error: 'Invalid name' }, { status: 400 });
+        }
+
+        const genre = await prisma.genre.create({
+            data: { name: name.trim() },
+        });
+
+        return NextResponse.json(genre);
+    } catch (error) {
+        console.error('Error creating genre:', error);
+        return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+    }
+}
+
+export async function DELETE(request: Request) {
+    try {
+        const { id } = await request.json();
+
+        if (!id) {
+            return NextResponse.json({ error: 'Missing id' }, { status: 400 });
+        }
+
+        await prisma.genre.delete({
+            where: { id: Number(id) },
+        });
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Error deleting genre:', error);
+        return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+    }
+}

app/api/songs/route.ts

@@ -11,6 +11,7 @@ export async function GET() {
         orderBy: { createdAt: 'desc' },
         include: {
             puzzles: true,
+            genres: true,
         },
     });
 
@@ -23,6 +24,7 @@ export async function GET() {
         createdAt: song.createdAt,
         coverImage: song.coverImage,
         activations: song.puzzles.length,
+        genres: song.genres,
     }));
 
     return NextResponse.json(songsWithActivations);
@@ -144,6 +146,7 @@ export async function POST(request: Request) {
                 filename,
                 coverImage,
             },
+            include: { genres: true }
         });
 
         return NextResponse.json({
@@ -158,15 +161,24 @@ export async function POST(request: Request) {
 
 export async function PUT(request: Request) {
     try {
-        const { id, title, artist } = await request.json();
+        const { id, title, artist, genreIds } = await request.json();
 
         if (!id || !title || !artist) {
             return NextResponse.json({ error: 'Missing fields' }, { status: 400 });
         }
 
+        const data: any = { title, artist };
+
+        if (genreIds) {
+            data.genres = {
+                set: genreIds.map((gId: number) => ({ id: gId }))
+            };
+        }
+
         const updatedSong = await prisma.song.update({
             where: { id: Number(id) },
-            data: { title, artist },
+            data,
+            include: { genres: true }
         });
 
         return NextResponse.json(updatedSong);