import { eq } from "drizzle-orm";
import { db } from "../db/db.controller.js";
import { notifications } from "../db/schema/notifications.schema.js";
import { prodQuery } from "../prodSql/prodSqlQuery.controller.js";
import {
	type SqlQuery,
	sqlQuerySelector,
} from "../prodSql/prodSqlQuerySelector.utils.js";
import { returnFunc } from "../utils/returnHelper.utils.js";
import { sendEmail } from "../utils/sendEmail.utils.js";
import { tryCatch } from "../utils/trycatch.utils.js";

/**
 *
 */
const func = async (data: any, emails: string) => {
	// get the actual notification as items will be updated between intervals if no one touches
	const { data: l, error: le } = (await tryCatch(
		db.select().from(notifications).where(eq(notifications.id, data.id)),
	)) as any;

	if (le) {
		return returnFunc({
			success: false,
			level: "error",
			module: "notification",
			subModule: "query",
			message: `${data.name} encountered an error while trying to get initial info`,
			data: [le],
			notify: true,
		});
	}

	// search the query db for the query by name
	const sqlQuery = sqlQuerySelector(`${data.name}`) as SqlQuery;
	// create the ignore audit logs ids
	const ignoreIds = l[0].options[0]?.auditId
		? `${l[0].options[0]?.auditId}`
		: "0";

	// run the check
	const { data: queryRun, error } = await tryCatch(
		prodQuery(
			sqlQuery.query
				.replace("[intervalCheck]", l[0].interval)
				.replace("[ignoreList]", ignoreIds),
			`Running notification query: ${l[0].name}`,
		),
	);

	if (error) {
		return returnFunc({
			success: false,
			level: "error",
			module: "notification",
			subModule: "query",
			message: `Data for: ${l[0].name} encountered an error while trying to get it`,
			data: [error],
			notify: true,
		});
	}

	if (queryRun.data.length > 0) {
		// update the latest audit id
		const { error: dbe } = await tryCatch(
			db
				.update(notifications)
				.set({ options: [{ auditId: `${queryRun.data[0].id}` }] })
				.where(eq(notifications.id, data.id)),
		);

		if (dbe) {
			return returnFunc({
				success: false,
				level: "error",
				module: "notification",
				subModule: "query",
				message: `Data for: ${l[0].name} encountered an error while trying to get it`,
				data: [dbe],
				notify: true,
			});
		}

		// send the email

		const sentEmail = await sendEmail({
			email: emails,
			subject: "Alert! Label Reprinted",
			template: "reprintLabels",
			context: {
				items: queryRun.data,
			},
		});

		if (!sentEmail?.success) {
			return returnFunc({
				success: false,
				level: "error",
				module: "email",
				subModule: "notification",
				message: `${l[0].name} failed to send the email`,
				data: [sentEmail],
				notify: true,
			});
		}
	} else {
		console.log("doing nothing as there is nothing to do.");
	}
	// TODO send the error to systemAdmin users so they do not always need to be on the notifications.
	// these errors are defined per notification.
};

export default func;
