import { sql, eq } from 'drizzle-orm';
import { integer, sqliteTable, text, sqliteView } from 'drizzle-orm/sqlite-core';

export const players = sqliteTable('players', {
	id: integer('players_id').primaryKey({ autoIncrement: true }),
	firstName: text('firstName').notNull(),
	lastName: text('lastName').notNull(),
	team: integer('team')
		.references(() => teams.id)
		.notNull(),
	division: integer('division').references(() => divisions.id)
});

export const teams = sqliteTable('teams', {
	id: integer('teams_id').primaryKey({ autoIncrement: true }),
	name: text('team_name').notNull(),
	color: text('color').notNull().default('white')
});

export const divisions = sqliteTable('divisions', {
	id: integer('divisions_id').primaryKey({ autoIncrement: true }),
	name: text('div_name').notNull()
});

export const brackets = sqliteTable('brackets', {
	id: integer('brackets_id').primaryKey({ autoIncrement: true }),
	name: text('bracket_name').notNull()
});

export const scoringPresets = sqliteTable('scoringPresets', {
	id: integer('scoringPresets_id').primaryKey({ autoIncrement: true }),
	presetID: integer('preset').notNull(),
	placement: integer('placement').notNull().default(0),
	points: integer('points').notNull().default(0)
});

export const resultPresets = sqliteTable('resultPresets', {
	id: integer('resultPresets_id').primaryKey({ autoIncrement: true }),
	presetName: text('preset_name').notNull(),
	numberOfResults: integer('result_amount').notNull().default(1),
	unit: text('result_unit').notNull().default('m'),
	lowerIsBetter: integer('is_lower_result_better').notNull().default(0),
	averageResults: integer('should_results_average').notNull().default(1)
});

export const eventTypes = sqliteTable('eventTypes', {
	id: integer('eventTypes_id').primaryKey({ autoIncrement: true }),
	name: text('event_name').notNull(),
	preset: integer('preset')
		.references(() => scoringPresets.presetID)
		.notNull(),
	resultPreset: integer('result_preset')
		.references(() => resultPresets.id)
		.notNull()
});

export const registeredEvents = sqliteTable('registeredEvents', {
	id: integer('registeredEvents_id').primaryKey({ autoIncrement: true }),
	eventType: integer('event_type')
		.references(() => eventTypes.id)
		.notNull(),
	division: integer('division')
		.references(() => divisions.id)
		.notNull(),
	state: integer('event_state').notNull().default(0),
	timeCompleted: integer('time_completed'),
	teamWinner: integer('event_team_winner').references(() => teams.id)
});

export const registeredPlayers = sqliteTable('registeredPlayers', {
	id: integer('registeredPlayers_id').primaryKey({ autoIncrement: true }),
	playerID: integer('player_registered')
		.references(() => players.id)
		.notNull(),
	registeredEventID: integer('event_registered')
		.references(() => registeredEvents.id)
		.notNull(),
	bracket: integer('bracket_registered')
		.references(() => brackets.id)
		.notNull(),
	placement: integer('player_placement').notNull().default(0)
});

export const registeredResults = sqliteTable('registeredResults', {
	id: integer('results_id').primaryKey({ autoIncrement: true }),
	registeredPlayerId: integer('player_result_attribution')
		.references(() => registeredPlayers.id)
		.notNull(),
	resultIndex: integer('result_number').notNull().default(1),
	result: integer('result_result').notNull().default(0)
});

export const mainLedger = sqliteTable('mainLedger', {
	id: integer('mainLedger_id').primaryKey({ autoIncrement: true }),
	timestamp: integer('ledger_timestamp', { mode: 'timestamp' })
		.notNull()
		.default(sql`(unixepoch())`),
	updateType: text('update_type').notNull().default('event'),
	registeredEvent: integer('registered_event_reference').references(() => registeredEvents.id),
	scorer: text('scorer_logged').default('some dude idk')
});

export const scoreLedger = sqliteTable('scoresLedger', {
	id: integer('scoreLedger_id').primaryKey({ autoIncrement: true }),
	ledgerID: integer('ledger_address')
		.references(() => mainLedger.id)
		.notNull(),
	teamID: integer('team_being_scored')
		.references(() => teams.id)
		.notNull(),
	points: integer('pointsAwarded').default(0).notNull()
});

export const teamScoresView = sqliteView('teamScoresView').as((qb) => {
	return qb
		.select({
			teamId: teams.id,
			teamName: teams.name,
			teamColor: teams.color,
			totalPoints: sql<number>`sum(${scoreLedger.points})`.mapWith(Number).as('totalPoints')
		})
		.from(teams)
		.leftJoin(scoreLedger, eq(teams.id, scoreLedger.teamID))
		.groupBy(teams.id, teams.name, teams.color);
});

export const registeredEventsView = sqliteView('registeredEventsView').as((qb) => {
	return qb
		.select({
			eventId: registeredEvents.id,
			eventName: eventTypes.name,
			division: divisions.name,
			state: registeredEvents.state,
			timeCompleted: registeredEvents.timeCompleted,
			winner: registeredEvents.teamWinner,
			resultPreset: eventTypes.resultPreset
		})
		.from(registeredEvents)
		.innerJoin(eventTypes, eq(registeredEvents.eventType, eventTypes.id))
		.innerJoin(divisions, eq(registeredEvents.division, divisions.id));
});

export const registeredEventPlayersView = sqliteView('registeredEventPlayersView').as((qb) => {
	return qb
		.select({
			playerId: players.id,
			firstName: players.firstName,
			lastName: players.lastName,
			placement: registeredPlayers.placement,
			bracket: brackets.name,
			eventId: registeredEvents.id,
			eventName: eventTypes.name,
			teamId: teams.id,
			teamName: teams.name,
			teamColor: teams.color
		})
		.from(registeredPlayers)
		.innerJoin(registeredEvents, eq(registeredPlayers.registeredEventID, registeredEvents.id))
		.innerJoin(brackets, eq(registeredPlayers.bracket, brackets.id))
		.innerJoin(eventTypes, eq(registeredEvents.eventType, eventTypes.id))
		.innerJoin(players, eq(registeredPlayers.playerID, players.id))
		.innerJoin(teams, eq(players.team, teams.id));
});