import client from "@/lib/mongodb";
import {Permission, PermissionType, permissions, PermissionTopic} from "@/interfaces/permissions";
import {v4} from "uuid";

const db = client.db(process.env.MONGODB_DB);

async function createPermission(topic: string, type: string) {
	/*const permData = doc(db, "permissions", v4());
	const permDoc = await getDoc(permData);

	if (permDoc.exists()) {
		return true;
	}*/

	await db.collection("permissions").insertOne({
		id: v4(),
		type,
		topic,
		users: [],
	});
}
interface PermissionsHelperList {
	topic: string;
	type: string;
}
export function getPermissions(userId: string | undefined, docs: Permission[]) {
	if (!userId) {
		return [];
	}
	// the concept is like a blacklist
	// if the user exists in the list, he can't access this permission
	// even if his profile allows
	const permissions = docs.reduce((acc: PermissionType[], doc: Permission) => {
		//  typescript was complaining even with the validation on the top
		if (doc.users.includes(userId)) {
			return acc;
		}

		return [...acc, doc.type];
	}, []) as PermissionType[];
	return permissions;
}

export async function getUserPermissions(id: string) {
	const permissions = await getPermissionDocs();
	return getPermissions(id, permissions);
}

export async function bootstrap() {
	permissions
		.reduce((accm: PermissionsHelperList[], permissionData) => {
			return [
				...accm,
				...permissionData.list.map((type) => ({
					topic: permissionData.topic,
					type,
				})),
			];
		}, [])
		.forEach(async ({topic, type}) => {
			await createPermission(topic, type);
		});
}

export async function getPermissionDoc(id: string) {
	const perm = await db.collection("permissions").findOne<Permission>({ id: id });

	if (perm) {
		return perm;
	}

	throw new Error("Permission not found");
}

export async function getPermissionDocs() {
	// TODO: Don't know if this was finished
	// firebase is missing something like array-not-contains

	return await db.collection("permissions").find<Permission>({}).toArray();
}