import { DatabaseError } from "@/lib/error";
import { logError } from "@/lib/logger";
import { BaseRepository, RepositoryContext } from "../datastore/repository";

export const ConsoleUserRolesRepository = (ctx: RepositoryContext) => {
  const { datastore } = new BaseRepository(ctx);
  const CreateEntries = async (entry: { userId: string; roleId: string }[]) => {
    try {
      const newUserRoles = await datastore
        .insertInto("console_user_roles")
        .values(
          entry.map((e) => ({
            console_user_id: e.userId,
            console_role_id: e.roleId,
          })),
        )
        .returningAll()
        .execute();
      return newUserRoles;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to create user roles",
      });
    }
  };

  const FindEntriesByUserIdAndRoleId = async (
    userId: string,
    roleId: string,
  ) => {
    try {
      const record = await datastore
        .selectFrom("console_user_roles")
        .where("console_user_id", "=", userId)
        .where("console_role_id", "=", roleId)
        .selectAll()
        .executeTakeFirst();
      return record;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to fetching user role",
      });
    }
  };

  const DeleteEntriesByUserId = async (userId: string) => {
    try {
      const records = await datastore
        .deleteFrom("console_user_roles")
        .where("console_user_id", "=", userId)
        .returningAll()
        .execute();
      return records;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to delete user roles",
      });
    }
  };

  const FindEntriesByUserId = async (userId: string) => {
    try {
      const records = await datastore
        .selectFrom("console_user_roles")
        .where("console_user_id", "=", userId)
        .selectAll()
        .execute();
      return records;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to fetching user role",
      });
    }
  };

  const FindEntriesByRoleId = async (roleId: string) => {
    try {
      const records = await datastore
        .selectFrom("console_user_roles")
        .where("console_role_id", "=", roleId)
        .selectAll()
        .execute();
      return records;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to fetching user roles by role id",
      });
    }
  };

  return {
    CreateEntries,
    FindEntriesByUserIdAndRoleId,
    DeleteEntriesByUserId,
    FindEntriesByUserId,
    FindEntriesByRoleId,
  };
};
export type TConsoleUserRolesRepository = ReturnType<
  typeof ConsoleUserRolesRepository
>;