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) {
	let responseBody = await request.json();

	if (!responseBody) {
		return new Error('nuh uh');
	} else {
		if (responseBody.eventId) {
			let eventData = await getRegisteredEvents(responseBody.eventId);

			if (eventData.events[0].state != 1) {
				return new Error();
			}
			let scoringPreset = eventData.events[0].scoringPreset;

			// Create ledger entry to record this scoring event
			let newLedgerEntry = await db
				.insert(schema.mainLedger)
				.values({ registeredEvent: responseBody.eventId })
				.returning();

			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
				);
			}

			// Accumulate scores per team, then batch insert
			const teamScores = new Map<any, number>();

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

					if (currentPlayerPosition > 0) {
						let score = getPoints(scoringPreset, currentPlayerPosition);
						if (currentPlayer.scores.length > 0) {
							if (score > 0) {
								const currentTeamScore = teamScores.get(currentPlayerTeam) || 0;
								teamScores.set(currentPlayerTeam, currentTeamScore + score);
							}

							for (let result in currentPlayer.scores) {
								let currentResult = currentPlayer.scores[result];
								let newScoreEntry = await db
									.insert(schema.registeredResults)
									.values({
										registeredPlayerId: currentPlayer.registeredPlayerId,
										resultIndex: parseInt(result),
										result: currentResult
									})
									.returning();
								console.log(newScoreEntry);
							}

							// Update player placement in the database
							let newPlayerPlacement = await db
								.update(schema.registeredPlayers)
								.set({ placement: currentPlayerPosition })
								.where(eq(schema.registeredPlayers.id, currentPlayer.registeredPlayerId))
								.returning();
						}
					}
				}
			}

			// 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();
			}

			// Determine the winning team from accumulated scores
			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();
			}
		}

		globalEmitter.emit('scoreUpdate');
		globalEmitter.emit('eventUpdate');
		return new Response('coolsies');
	}
}