/**
 * @copyright nhcarrigan
 * @license Naomi's Public License
 * @author Naomi Carrigan
 */

import type { DatabasePath } from "../interfaces/databasePath.js";
import type {
  Appeals,
  Commissions,
  Contacts,
  Events,
  Meetings,
  Mentorships,
  PrismaClient,
  Staff,
} from "@prisma/client";

/**
 * Generic wrapper to list all unreviewed submissions of a given type.
 * @param database - The Prisma client.
 * @param route - The type of data to list.
 * @returns An array of unreviewed submissions.
 */
const listUnreviewedSubmissions = async(
  database: PrismaClient,
  route: DatabasePath,
): Promise<
  Array<
    Appeals | Commissions | Contacts | Events | Meetings | Mentorships | Staff
  >
> => {
  const query = { };
  switch (route) {
    case "appeals":
      return await database.appeals.findMany(query);
    case "commissions":
      return await database.commissions.findMany(query);
    case "contacts":
      return await database.contacts.findMany(query);
    case "events":
      return await database.events.findMany(query);
    case "meetings":
      return await database.meetings.findMany(query);
    case "mentorships":
      return await database.mentorships.findMany(query);
    case "staff":
      return await database.staff.findMany(query);
    default:
      return [];
  }
};

/**
 * Checks if a submission exists in the database.
 * @param database - The Prisma client.
 * @param route - The type of data to check.
 * @param id - The ID of the submission to check.
 * @returns A boolean indicating if the submission exists.
 */
const checkSubmissionExists = async(
  database: PrismaClient,
  route: DatabasePath,
  id: string,
): Promise<boolean> => {
  const query = { where: { id } };
  switch (route) {
    case "appeals":
      return Boolean(await database.appeals.findUnique(query));
    case "commissions":
      return Boolean(await database.commissions.findUnique(query));
    case "contacts":
      return Boolean(await database.contacts.findUnique(query));
    case "events":
      return Boolean(await database.events.findUnique(query));
    case "meetings":
      return Boolean(await database.meetings.findUnique(query));
    case "mentorships":
      return Boolean(await database.mentorships.findUnique(query));
    case "staff":
      return Boolean(await database.staff.findUnique(query));
    default:
      return false;
  }
};

/**
 * Marks a submission as reviewed in the database.
 * @param database - The Prisma client.
 * @param route - The type of data to mark.
 * @param id - The ID of the submission to mark.
 */
const markSubmissionReviewed = async(
  database: PrismaClient,
  route: DatabasePath,
  id: string,
): Promise<void> => {
  const update = {
    where: {
      id,
    },
  };
  switch (route) {
    case "appeals":
      await database.appeals.delete(update);
      break;
    case "commissions":
      await database.commissions.delete(update);
      break;
    case "contacts":
      await database.contacts.delete(update);
      break;
    case "events":
      await database.events.delete(update);
      break;
    case "meetings":
      await database.meetings.delete(update);
      break;
    case "mentorships":
      await database.mentorships.delete(update);
      break;
    case "staff":
      await database.staff.delete(update);
      break;
    default:
      break;
  }
};

export {
  listUnreviewedSubmissions,
  checkSubmissionExists,
  markSubmissionReviewed,
};