import { globalEmitter } from '$lib/server/globalEmitter';
import { eq } from 'drizzle-orm';
import { db } from '$lib/server/db';
import * as schema from '$lib/server/db/schema';
import { getRegisteredEvents } from '$lib/server/databaseManager';

export async function POST({ request }: any) {
	// Decode body
	let responseBody = await request.json();

	// If there is no request then dont respond
	if (!responseBody) {
		return new Error('nuh uh');
	} else {
		console.log(JSON.stringify(responseBody));
		if (responseBody.eventId) {
			// Get the event
			let eventData = await getRegisteredEvents(responseBody.eventId);

			// If the event hasnt started or ended
			if (eventData.events[0].state != 1) {
				return new Error();
			}
			let scoringPreset = eventData.events[0].scoringPreset;

			// make a new main ledger entry
			let newLedgerEntry = await db
				.insert(schema.mainLedger)
				.values({ registeredEvent: responseBody.eventId })
				.returning();

			// get the id so i can use it in the sub ledgers
			let ledgerEntryId = newLedgerEntry[0].id;

			function getPoints(
				scoringPreset: { placement: number; points: number }[] | string,
				position: number
			): number {
				const preset =
					typeof scoringPreset === 'string' ? JSON.parse(scoringPreset) : scoringPreset;
				return (
					preset.find((s: { placement: number; points: number }) => s.placement === position)
						?.points ?? 0
				);
			}

			// Create a Map to collect total scores per team
			const teamScores = new Map<any, number>();

			// for every bracket
			for (let bracket in responseBody.brackets) {
				// for every player
				for (let player in responseBody.brackets[bracket].players) {
					// variable fun
					let currentPlayer = responseBody.brackets[bracket].players[player];
					let currentPlayerTeam = currentPlayer.teamId;
					let currentPlayerPosition = currentPlayer.position;

					// If they put in a score / result
					if (currentPlayerPosition > 0) {
						let score = getPoints(scoringPreset, currentPlayerPosition);
						// If their score is in the preset and they put in a score
						if (currentPlayer.scores.length > 0) {
							if (score > 0) {
								// Accumulate points for this team instead of inserting right away
								const currentTeamScore = teamScores.get(currentPlayerTeam) || 0;
								teamScores.set(currentPlayerTeam, currentTeamScore + score);
							}

							// PLACEMENT LOGIC (Left untouched)
							let newPlayerPlacement = await db
								.update(schema.registeredPlayers)
								.set({ placement: currentPlayerPosition })
								.where(eq(schema.registeredPlayers.id, currentPlayer.registeredPlayerId))
								.returning();
							console.log(newPlayerPlacement[0].placement, currentPlayer.firstName);
						}
					}
				}
			}

			// After calculating all player scores, batch insert team scores into the ledger
			if (teamScores.size > 0) {
				const ledgerEntries = Array.from(teamScores.entries()).map(([teamID, points]) => ({
					ledgerID: ledgerEntryId,
					teamID,
					points
				}));

				let newScores = await db.insert(schema.scoreLedger).values(ledgerEntries).returning();
				console.log(newScores);
			}

			// 2. Determine the winner right here using the same Map data
			let highestScore = -1;
			let winningTeamId = null;

			for (let [teamID, points] of teamScores.entries()) {
				if (points > highestScore) {
					highestScore = points;
					winningTeamId = teamID;
				}
			}

			if (winningTeamId) {
				let teamWinnerUpdate = await db
					.update(schema.registeredEvents)
					.set({ teamWinner: winningTeamId, state: 2, timeCompleted: Date.now() })
					.where(eq(schema.registeredEvents.id, responseBody.eventId))
					.returning();
				console.log(teamWinnerUpdate);
			}
		}

		// Update the frontends
		globalEmitter.emit('scoreUpdate');
		// Return a response because
		return new Response('coolsies');
	}
}