score-system/src/lib/server/databaseManager.ts

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

// Initial data for page load
export async function getAllInitialInfo() {
	return {
		teams: await getTeams(),
		events: await getRegisteredEvents()
	};
}

// Fetch teams with optional filter
export async function getTeams(teamId?: number) {
	const allTeams = await db
		.select()
		.from(schema.teamScoresView)
		.where(teamId ? eq(schema.teamScoresView.teamId, teamId) : undefined);
	for (let team in allTeams) {
		let currentTeam = allTeams[team];
		if (!currentTeam.totalPoints) {
			currentTeam.totalPoints = 0;
		}
	}
	return {
		teams: allTeams.map((team) => ({
			name: team.teamName,
			color: team.teamColor,
			points: team.totalPoints
		}))
	};
}

// Fetch registered events with optional filter
export async function getRegisteredEvents(eventId?: number) {
	async function getWinnerInfo(teamId: number) {
		const teamInfo = await getTeams(teamId);
		return teamInfo.teams[0];
	}

	async function getScoringPreset(presetId: number) {
		const presets = await db
			.select()
			.from(schema.scoringPresets)
			.where(presetId ? eq(schema.scoringPresets.presetID, presetId) : undefined);
		return presets;
	}

	const allEvents = await db
		.select()
		.from(schema.registeredEventsView)
		.where(eventId ? eq(schema.registeredEventsView.eventId, eventId) : undefined);

	const events = await Promise.all(
		allEvents.map(async (events) => ({
			id: events.eventId,
			name: events.eventName,
			division: events.division,
			state: events.state,
			completed: events.timeCompleted || 0,
			resultPreset: events.resultPreset,
			scoringPreset: events.scorePreset ? await getScoringPreset(events.scorePreset) : 'UNDECIDED',
			winner: events.winner ? await getWinnerInfo(events.winner) : 'UNDECIDED'
		}))
	);

	return { events };
}

export async function startEvent(eventId: number) {
	let event = await db
		.select()
		.from(schema.registeredEventsView)
		.where(eq(schema.registeredEventsView.eventId, eventId));
	let requestedEvent = event[0];
	console.log(requestedEvent);
	if (requestedEvent.state != 0) {
		console.log('not startable');
		return false;
	} else {
		let replacedEvent = await db
			.update(schema.registeredEvents)
			.set({ state: 1 })
			.where(eq(schema.registeredEvents.id, requestedEvent.eventId))
			.returning();
		console.log(replacedEvent);
		globalEmitter.emit('eventUpdate');
		return true;
	}
}

// Fetch all players registered for a specific event
export async function getAllRegisteredEventPlayers(eventId: number) {
	const eventPlayers = await db
		.select()
		.from(schema.registeredEventPlayersView)
		// Filter by event ID
		.where(eq(schema.registeredEventPlayersView.eventId, eventId))
		.orderBy(
			schema.registeredEventPlayersView.bracket,
			schema.registeredEventPlayersView.placement,
			schema.registeredEventPlayersView.teamName
		);
	return {
		eventPlayers: eventPlayers.map((players) => ({
			id: players.playerId,
			firstName: players.firstName,
			lastName: players.lastName,
			registeredPlayerId: players.registeredPlayerId,
			placement: players.placement,
			bracket: players.bracket,
			eventId: players.eventId,
			eventName: players.eventName,
			teamId: players.teamId,
			teamName: players.teamName,
			teamColor: players.teamColor
		}))
	};
}

export async function getAllBrackets() {
	const brackets = await db.select().from(schema.brackets);

	return {
		brackets: brackets
	};
}

export async function getPlayerInfo(playerId: number) {
	const playerInfo = await db.select().from(schema.players).where(eq(schema.players.id), playerId);
	return playerInfo;
}

export async function getResultPreset(presetId?: number) {
	const resultPresets = await db
		.select()
		.from(schema.resultPresets)
		.where(presetId ? eq(schema.resultPresets.id, presetId) : undefined);

	return {
		resultPresets: resultPresets
	};
}

// Merge events, players, brackets, and presets into a frontend-ready structure
export async function getRegisteredEventsWithPlayers(eventId?: number) {
	let newEvents = await getRegisteredEvents(eventId);
	let registeredEventList = newEvents['events'];

	let brackets = await getAllBrackets();

	let fullEventList: any[] = [];

	for (let registeredEvent in registeredEventList) {
		let event = registeredEventList[registeredEvent];
		let resultPreset = await getResultPreset(event.resultPreset);
		let registeredPlayers = await getAllRegisteredEventPlayers(event.id);

		// Group players by bracket category for the frontend
		const bracketOrder = brackets.brackets.map((category) => {
			return {
				...category,
				items: registeredPlayers.eventPlayers.filter((item) => item.bracket === category.name)
			};
		});

		let eventWithPlayers = {
			...event,
			registeredPlayers: bracketOrder,
			...resultPreset
		};
		fullEventList.push(eventWithPlayers);
	}
	return fullEventList;
}