src/app/api/tournaments/[id]/schedule/route.ts

@@ -0,0 +1,239 @@
+import { NextResponse } from "next/server";
+import { prisma } from "@/lib/prisma";
+import { canManageTournament } from "@/lib/permissions";
+import { generateRoundRobin, validateScheduleInput } from "@/lib/schedule-generator";
+
+interface RouteParams {
+  params: Promise<{
+    id: string;
+  }>;
+}
+
+/**
+ * GET /api/tournaments/[id]/schedule
+ *
+ * Fetch the tournament schedule (rounds with matchups).
+ */
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const tournamentId = parseInt(id);
+
+    if (isNaN(tournamentId)) {
+      return NextResponse.json(
+        { error: "Invalid tournament ID" },
+        { status: 400 }
+      );
+    }
+
+    const permission = await canManageTournament(tournamentId);
+    if (!permission.allowed) {
+      return NextResponse.json(
+        { error: permission.reason || "Not authorized to view this tournament" },
+        { status: 403 }
+      );
+    }
+
+    const tournament = await prisma.event.findUnique({
+      where: { id: tournamentId },
+      include: {
+        rounds: {
+          orderBy: { roundNumber: "asc" },
+          include: {
+            bracketMatchups: {
+              include: {
+                team1: {
+                  include: { player1: true, player2: true },
+                },
+                team2: {
+                  include: { player1: true, player2: true },
+                },
+                match: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!tournament) {
+      return NextResponse.json(
+        { error: "Tournament not found" },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({ rounds: tournament.rounds });
+  } catch (error: unknown) {
+    console.error("Error fetching schedule:", error);
+    const message =
+      error instanceof Error ? error.message : "Failed to fetch schedule";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/tournaments/[id]/schedule
+ *
+ * Generate a round-robin schedule for the tournament.
+ * Creates TournamentRound and BracketMatchup records.
+ */
+export async function POST(_request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const tournamentId = parseInt(id);
+
+    if (isNaN(tournamentId)) {
+      return NextResponse.json(
+        { error: "Invalid tournament ID" },
+        { status: 400 }
+      );
+    }
+
+    const permission = await canManageTournament(tournamentId);
+    if (!permission.allowed) {
+      return NextResponse.json(
+        { error: permission.reason || "Not authorized to manage this tournament" },
+        { status: 403 }
+      );
+    }
+
+    // Check tournament exists
+    const tournament = await prisma.event.findUnique({
+      where: { id: tournamentId },
+      include: {
+        teams: true,
+        rounds: true,
+      },
+    });
+
+    if (!tournament) {
+      return NextResponse.json(
+        { error: "Tournament not found" },
+        { status: 404 }
+      );
+    }
+
+    // Check if schedule already exists
+    if (tournament.rounds.length > 0) {
+      return NextResponse.json(
+        {
+          error: "Schedule already exists. Delete existing rounds before regenerating.",
+          existingRounds: tournament.rounds.length,
+        },
+        { status: 409 }
+      );
+    }
+
+    // Get team IDs
+    const teamIds = tournament.teams.map((t) => t.id);
+
+    const validation = validateScheduleInput(teamIds);
+    if (!validation.valid) {
+      return NextResponse.json(
+        { error: validation.error },
+        { status: 400 }
+      );
+    }
+
+    // Generate schedule
+    const schedule = generateRoundRobin(teamIds);
+
+    // Create rounds and matchups in a transaction
+    const created = await prisma.$transaction(
+      schedule.map((round) =>
+        prisma.tournamentRound.create({
+          data: {
+            eventId: tournamentId,
+            roundNumber: round.roundNumber,
+            status: "pending",
+            bracketMatchups: {
+              create: round.matchups.map((matchup, idx) => ({
+                eventId: tournamentId,
+                team1Id: matchup.team1Id,
+                team2Id: matchup.team2Id,
+                bracketPosition: idx + 1,
+                status: "pending",
+              })),
+            },
+          },
+          include: {
+            bracketMatchups: {
+              include: {
+                team1: {
+                  include: { player1: true, player2: true },
+                },
+                team2: {
+                  include: { player1: true, player2: true },
+                },
+              },
+            },
+          },
+        })
+      )
+    );
+
+    return NextResponse.json({
+      success: true,
+      roundsCreated: created.length,
+      matchupsCreated: created.reduce(
+        (sum, r) => sum + r.bracketMatchups.length,
+        0
+      ),
+      rounds: created,
+    });
+  } catch (error: unknown) {
+    console.error("Error generating schedule:", error);
+    const message =
+      error instanceof Error ? error.message : "Failed to generate schedule";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+/**
+ * DELETE /api/tournaments/[id]/schedule
+ *
+ * Delete all rounds and matchups for a tournament.
+ */
+export async function DELETE(_request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const tournamentId = parseInt(id);
+
+    if (isNaN(tournamentId)) {
+      return NextResponse.json(
+        { error: "Invalid tournament ID" },
+        { status: 400 }
+      );
+    }
+
+    const permission = await canManageTournament(tournamentId);
+    if (!permission.allowed) {
+      return NextResponse.json(
+        { error: permission.reason || "Not authorized to manage this tournament" },
+        { status: 403 }
+      );
+    }
+
+    // Delete bracket matchups first (FK constraint)
+    const deletedMatchups = await prisma.bracketMatchup.deleteMany({
+      where: { eventId: tournamentId },
+    });
+
+    // Delete rounds
+    const deletedRounds = await prisma.tournamentRound.deleteMany({
+      where: { eventId: tournamentId },
+    });
+
+    return NextResponse.json({
+      success: true,
+      deletedRounds: deletedRounds.count,
+      deletedMatchups: deletedMatchups.count,
+    });
+  } catch (error: unknown) {
+    console.error("Error deleting schedule:", error);
+    const message =
+      error instanceof Error ? error.message : "Failed to delete schedule";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}