import { eq, and } from "drizzle-orm";
import db, { actors, sessions, users, guilds, tickets, type Ticket } from "..";

export async function getUser(id: number) {
	const [result] = await db.select().from(users).where(eq(users.id, id));
	return result;
}

export async function getUserByDiscordId(discordId: string) {
	const [result] = await db.select().from(users).where(eq(users.discordId, discordId));
	return result;
}

export async function getActor(id: number) {
	const [result] = await db.select().from(actors).where(eq(actors.id, id));
	return result;
}

export async function getActorByDiscordId(discordId: string, guildId: number) {
	const [result] = await db
		.select()
		.from(actors)
		.where(and(eq(actors.discordId, discordId), eq(actors.guildId, guildId)));
	return result;
}

export async function getActorByDiscordIdAndGuildDiscordId(
	discordId: string,
	guildDiscordId: string,
) {
	const [guild] = await db.select().from(guilds).where(eq(guilds.discordId, guildDiscordId));
	if (!guild) return null;
	return getActorByDiscordId(discordId, guild.id);
}

export async function getUserSessions(id: number) {
	const result = await db.select().from(sessions).where(eq(sessions.userId, id));
	return result;
}

export async function getSession(id: string) {
	const [result] = await db.select().from(sessions).where(eq(sessions.id, id));
	return result;
}

export async function upsertGuild(guild: { discordId: string; name: string; icon: string | null }) {
	const [upsertedGuild] = await db
		.insert(guilds)
		.values({
			discordId: guild.discordId,
			name: guild.name,
			icon: guild.icon,
			createdAt: new Date(),
			updatedAt: new Date(),
		})
		.onConflictDoUpdate({
			target: guilds.discordId,
			set: {
				name: guild.name,
				icon: guild.icon,
				updatedAt: new Date(),
			},
		})
		.returning();

	return upsertedGuild;
}

export async function upsertUser(user: {
	username: string;
	displayName: string | null;
	id: string;
	avatar: string | null;
}) {
	const [upsertedUser] = await db
		.insert(users)
		.values({
			discordId: user.id,
			username: user.username,
			displayName: user.displayName,
			avatar: user.avatar,
			createdAt: new Date(),
			updatedAt: new Date(),
		})
		.onConflictDoUpdate({
			target: users.discordId,
			set: {
				username: user.username,
				displayName: user.displayName,
				avatar: user.avatar,
				updatedAt: new Date(),
			},
		})
		.returning();

	return upsertedUser;
}

export async function upsertActor(data: {
	guild: {
		discordId: string;
		name: string;
		icon: string | null;
	};
	user: {
		discordId: string;
		username: string;
		displayName: string | null;
		avatar: string | null;
	};
	moderator: boolean;
}) {
	const dbGuild = await upsertGuild(data.guild);
	const dbUser = await upsertUser({
		id: data.user.discordId,
		username: data.user.username,
		displayName: data.user.displayName,
		avatar: data.user.avatar,
	});

	if (!dbGuild || !dbUser) {
		throw new Error("Failed to upsert guild or user");
	}

	const [actor] = await db
		.insert(actors)
		.values({
			guildId: dbGuild.id,
			userId: dbUser.id,
			discordId: data.user.discordId,
			username: data.user.username,
			displayName: data.user.displayName,
			avatar: data.user.avatar,
			moderator: data.moderator,
			createdAt: new Date(),
			updatedAt: new Date(),
		})
		.onConflictDoUpdate({
			target: [actors.guildId, actors.userId],
			set: {
				username: data.user.username,
				displayName: data.user.displayName,
				avatar: data.user.avatar,
				moderator: data.moderator,
				updatedAt: new Date(),
			},
		})
		.returning();

	return actor;
}

export async function anonymiseUser(id: number) {
	const result = await db
		.update(actors)
		.set({
			username: `Anonymised User`,
			displayName: null,
			avatar: null,
			updatedAt: new Date(),
		})
		.where(eq(actors.id, id))
		.returning();

	return result;
}

export async function getGuild(id: number) {
	const [result] = await db.select().from(guilds).where(eq(guilds.id, id));
	return result;
}

export async function getGuildByDiscordId(discordId: string) {
	const [result] = await db.select().from(guilds).where(eq(guilds.discordId, discordId));
	return result;
}

export async function getTicket(ticketId: string): Promise<Ticket | undefined>;
export async function getTicket(guildId: number, ticketId: number): Promise<Ticket | undefined>;

export async function getTicket(
	idOrGuildId: string | number,
	ticketId?: number,
): Promise<Ticket | undefined> {
	return typeof idOrGuildId === "string"
		? getTicketById(idOrGuildId)
		: getTicketByGuild(idOrGuildId, ticketId);
}
async function getTicketById(id: string) {
	const [ticket] = await db.select().from(tickets).where(eq(tickets.id, id));
	return ticket;
}
async function getTicketByGuild(guildId: number, localId?: number) {
	if (localId === undefined) return undefined;
	const [ticket] = await db
		.select()
		.from(tickets)
		.where(and(eq(tickets.guildId, guildId), eq(tickets.localId, localId)));
	return ticket;
}

export async function editTicket(ticketId: string, data: Partial<Ticket>) {
	const [result] = await db.update(tickets).set(data).where(eq(tickets.id, ticketId)).returning();
	return result;
}