import { CorporateUser, Type, User } from "@/interfaces/user";
import { getGroupsForUser, getParticipantGroups, getUserGroups, getUsersGroups } from "./groups.be";
import { uniq } from "lodash";
import { getUserCodes } from "./codes.be";
import client from "@/lib/mongodb";
import { EntityWithRoles, WithEntities } from "@/interfaces/entity";
import { getEntity } from "./entities.be";
import { getRole } from "./roles.be";
import { findAllowedEntities } from "./permissions";
import { mapBy } from ".";

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

export async function getUsers(filter?: object, limit = 0, sort = {}, projection = {}) {
	return await db
		.collection("users")
		.find<User>(filter || {}, { projection: { _id: 0, ...projection } })
		.limit(limit)
		.sort(sort)
		.toArray();
}

export async function searchUsers(searchInput?: string, limit = 50, page = 0, sort: object = { "name": 1 }, projection = {}, filter?: object) {
	const compoundFilter = {
		"compound": {
			"should": [...(searchInput != "" ? [{
				"autocomplete": {
					"query": searchInput,
					"path": "name",
				}
			}, {
				"autocomplete": {
					"query": searchInput,
					"path": "email",
				}
			}] : [{ exists: { path: "name" } }])],
			"minimumShouldMatch": 1,

		}
	}
	
	const [{ users, totalUsers }] = await db
		.collection("users").aggregate([
			{
				"$search": {
					"index": "UsersByNameEmail",
					...compoundFilter
				}
			},
			...(filter ? [{
				"$match": Object.entries(filter).reduce((accm, [key, value]) => {
					if (value.length === 0) return accm
					accm[key] = Array.isArray(value) ? { $in: value } : value
					return accm;
				}, {} as any)
			}] : []),
			{
				$facet: {
					totalUsers: [{ $count: "count" }],
					users: [
						{ $sort: sort },
						{ $skip: limit * page },
						{ $limit: limit },
						{ "$project": { _id: 0, label: { $concat: ["$name", " - ", "$email"] }, value: "$id", ...projection } }
					]
				}
			}
		]).toArray();
	return { users, total: totalUsers[0]?.count || 0 };
}

export async function countUsers(filter?: object) {
	return await db
		.collection("users")
		.countDocuments(filter || {})
}

export async function getUserWithEntity(id: string): Promise<WithEntities<User> | undefined> {
	const user = await db.collection("users").findOne<User>({ id: id }, { projection: { _id: 0 } });
	if (!user) return undefined;

	const entities = await Promise.all(
		user.entities.map(async (e) => {
			const entity = await getEntity(e.id);
			const role = await getRole(e.role);

			return { entity, role };
		}),
	);

	return { ...user, entities };
}

export async function getUser(id: string): Promise<User | undefined> {
	const user = await db.collection("users").findOne<User>({ id: id }, { projection: { _id: 0 } });
	return !!user ? user : undefined;
}

export async function getSpecificUsers(ids: string[]) {
	if (ids.length === 0) return [];

	return await db
		.collection("users")
		.find<User>({ id: { $in: ids } }, { projection: { _id: 0 } })
		.toArray();
}

export async function getEntityUsers(id: string, limit?: number, filter?: object) {
	return await db
		.collection("users")
		.find<User>({ "entities.id": id, ...(filter || {}) })
		.limit(limit || 0)
		.toArray();
}

export async function countEntityUsers(id: string, filter?: object) {
	return await db.collection("users").countDocuments({ "entities.id": id, ...(filter || {}) });
}

export async function getEntitiesUsers(ids: string[], filter?: object, limit?: number, projection = {}) {
	return await db
		.collection("users")
		.find<User>({ "entities.id": { $in: ids }, ...(filter || {}) }, projection)
		.limit(limit || 0)
		.toArray();
}

export async function countEntitiesUsers(ids: string[], filter?: object) {
	return await db.collection("users").countDocuments({ "entities.id": { $in: ids }, ...(filter || {}) });
}

export async function getLinkedUsers(
	userID?: string,
	userType?: Type,
	type?: Type,
	page?: number,
	size?: number,
	sort?: string,
	direction?: "asc" | "desc",
) {
	const filters = {
		...(!!type ? { type } : {}),
	};

	if (!userID || userType === "admin" || userType === "developer") {
		const users = await db
			.collection("users")
			.find<User>(filters)
			.sort(sort ? { [sort]: direction === "desc" ? -1 : 1 } : {})
			.skip(page && size ? page * size : 0)
			.limit(size || 0)
			.toArray();

		const total = await db.collection("users").countDocuments(filters);
		return { users, total };
	}

	const adminGroups = await getUserGroups(userID);
	const groups = await getUsersGroups(adminGroups.flatMap((x) => x.participants));
	const belongingGroups = await getParticipantGroups(userID);

	const participants = uniq([
		...adminGroups.flatMap((x) => x.participants),
		...(userType === "mastercorporate" ? groups.flat().flatMap((x) => x.participants) : []),
		...(userType === "teacher" ? belongingGroups.flatMap((x) => x.participants) : []),
	]);

	//  ⨯ [FirebaseError: Invalid Query. A non-empty array is required for 'in' filters.] {
	if (participants.length === 0) return { users: [], total: 0 };

	const users = await db
		.collection("users")
		.find<User>({ ...filters, id: { $in: participants } })
		.skip(page && size ? page * size : 0)
		.limit(size || 0)
		.toArray();
	const total = await db.collection("users").countDocuments({ ...filters, id: { $in: participants } });

	return { users, total };
}

export async function getUserBalance(user: User) {
	const codes = await getUserCodes(user.id);
	if (user.type !== "corporate" && user.type !== "mastercorporate") return codes.length;

	const groups = await getGroupsForUser(user.id);
	const participants = uniq(groups.flatMap((x) => x.participants));

	if (user.type === "corporate") return participants.length + codes.filter((x) => !participants.includes(x.userId || "")).length;

	const participantUsers = await Promise.all(participants.map(getUser));
	const corporateUsers = participantUsers.filter((x) => x?.type === "corporate") as CorporateUser[];

	return (
		corporateUsers.reduce((acc, curr) => acc + 0, 0) +
		corporateUsers.length +
		codes.filter((x) => !participants.includes(x.userId || "") && !corporateUsers.map((u) => u.id).includes(x.userId || "")).length
	);
}

export const filterAllowedUsers = async (user: User, entities: EntityWithRoles[]) => {
	const studentsAllowedEntities = findAllowedEntities(user, entities, 'view_students')
	const teachersAllowedEntities = findAllowedEntities(user, entities, 'view_teachers')
	const corporateAllowedEntities = findAllowedEntities(user, entities, 'view_corporates')
	const masterCorporateAllowedEntities = findAllowedEntities(user, entities, 'view_mastercorporates')

	const students = await getEntitiesUsers(mapBy(studentsAllowedEntities, 'id'), { type: "student" })
	const teachers = await getEntitiesUsers(mapBy(teachersAllowedEntities, 'id'), { type: "teacher" })
	const corporates = await getEntitiesUsers(mapBy(corporateAllowedEntities, 'id'), { type: "corporate" })
	const masterCorporates = await getEntitiesUsers(mapBy(masterCorporateAllowedEntities, 'id'), { type: "mastercorporate" })

	return [...students, ...teachers, ...corporates, ...masterCorporates]
}

export const countAllowedUsers = async (user: User, entities: EntityWithRoles[]) => {
	const studentsAllowedEntities = findAllowedEntities(user, entities, 'view_students')
	const teachersAllowedEntities = findAllowedEntities(user, entities, 'view_teachers')
	const corporateAllowedEntities = findAllowedEntities(user, entities, 'view_corporates')
	const masterCorporateAllowedEntities = findAllowedEntities(user, entities, 'view_mastercorporates')

	const student = await countEntitiesUsers(mapBy(studentsAllowedEntities, 'id'), { type: "student" })
	const teacher = await countEntitiesUsers(mapBy(teachersAllowedEntities, 'id'), { type: "teacher" })
	const corporate = await countEntitiesUsers(mapBy(corporateAllowedEntities, 'id'), { type: "corporate" })
	const mastercorporate = await countEntitiesUsers(mapBy(masterCorporateAllowedEntities, 'id'), { type: "mastercorporate" })

	return { student, teacher, corporate, mastercorporate }
}