import { databaseTimeToDate } from "$lib/Utility/time";
import sb from "../../sb";

export interface Badge {
	id: number;
	post: string;
	image: string;
	hidden: boolean;
	shadow_hidden: boolean;
	click_count: number;
	time?: string;
	description?: string | null;
	category?: string | null;
	source?: string | null;
	designer?: string | null;
}

export interface BadgeInput {
	post?: string;
	image?: string;
	description?: string | null;
	time?: string;
	category?: string | null;
	hidden?: boolean;
	source?: string | null;
	designer?: string | null;
}

const getPagination = (page: number, size: number) => {
	const from = page ? page * (size ? +size : 3) : 0;

	return { from, to: page ? from + size - 1 : size - 1 };
};

export const getUserBadges = async (
	userId: number,
	page = 0,
	size = -1,
): Promise<Badge[]> => {
	const { from, to } = getPagination(page, size);
	let query = sb.from("user_badges").select("*").eq("user_id", userId);

	if (size !== -1) query = query.range(from, to);

	const { data, error } = await query;

	if (error) return [];

	return data.sort((a, b) =>
		databaseTimeToDate((a as Badge).time ?? "").getTime() >
		databaseTimeToDate((b as Badge).time ?? "").getTime()
			? -1
			: 1,
	) as Badge[];
};

export const addUserBadge = async (userId: number, badge: BadgeInput) => {
	const { post, image, description, time, category, hidden, source, designer } =
		badge;

	if (post === undefined || image === undefined) return;

	if (time) {
		await sb.from("user_badges").insert({
			user_id: userId,
			post,
			image,
			description,
			time,
			category,
			hidden,
			source,
			designer,
		});
	} else {
		await sb.from("user_badges").insert({
			user_id: userId,
			post,
			image,
			description,
			category,
			hidden,
			source,
			designer,
		});
	}
};

export const removeUserBadge = async (userId: number, id: number) => {
	if (!isNaN(id))
		await sb.from("user_badges").delete().eq("id", id).eq("user_id", userId);
};

export const updateUserBadge = async (
	userId: number,
	id: number,
	badge: BadgeInput,
) => {
	if (badge.post === undefined || badge.image === undefined) return;

	await sb
		.from("user_badges")
		.update({
			post: badge.post,
			image: badge.image,
			description: badge.description,
			category: badge.category,
			time: badge.time,
			hidden: badge.hidden,
			source: badge.source,
			designer: badge.designer,
		})
		.eq("id", id)
		.eq("user_id", userId);
};

export const renameCategory = async (
	userId: number,
	oldName: string,
	newName: string,
) =>
	await sb
		.from("user_badges")
		.update({ category: newName })
		.eq("category", oldName)
		.eq("user_id", userId);

export const removeAllUserBadges = async (userId: number) =>
	await sb.from("user_badges").delete().eq("user_id", userId);

export const migrateCategory = async (
	userId: number,
	oldName: string,
	newName: string,
) =>
	await sb
		.from("user_badges")
		.update({ category: newName })
		.eq("category", oldName)
		.eq("user_id", userId);

export const setShadowHidden = async (userId: number, shadowHide: boolean) =>
	await sb
		.from("user_badges")
		.update({ shadow_hidden: shadowHide })
		.eq("user_id", userId);

export const setShadowHiddenBadge = async (id: number, shadowHide: boolean) =>
	await sb
		.from("user_badges")
		.update({ shadow_hidden: shadowHide })
		.eq("id", id);

export const incrementClickCount = async (id: number) =>
	await sb.rpc("user_badges_increment_click_count", { user_badge_id: id });