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

export const VerificationTokenRepository = (ctx: RepositoryContext) => {
  const { datastore } = new BaseRepository(ctx);

  const CreateToken = async (entry: {
    userId: string;
    kind: string;
    expiresInDays?: number;
    expiresInMinutes?: number;
  }) => {
    try {
      const token = nanoid(32);
      const expires = new Date();
      if (entry.expiresInMinutes) {
        expires.setMinutes(expires.getMinutes() + entry.expiresInMinutes);
      } else {
        expires.setDate(expires.getDate() + (entry.expiresInDays ?? 7));
      }

      const newEntry = await datastore
        .insertInto("verification_tokens")
        .values({
          token,
          user_id: entry.userId as any,
          kind: entry.kind,
          expires: expires.toISOString(),
        })
        .returningAll()
        .executeTakeFirstOrThrow();

      return newEntry;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to create verification token",
      });
    }
  };

  const FindToken = async (token: string, kind: string) => {
    try {
      const record = await datastore
        .selectFrom("verification_tokens")
        .selectAll()
        .where("token", "=", token)
        .where("kind", "=", kind)
        .executeTakeFirst();
      return record;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to fetch verification token",
      });
    }
  };

  const ConsumeToken = async (token: string, kind: string) => {
    try {
      const record = await datastore
        .deleteFrom("verification_tokens")
        .where("token", "=", token)
        .where("kind", "=", kind)
        .returningAll()
        .executeTakeFirst();
      return record;
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to consume verification token",
      });
    }
  };

  const DeleteToken = async (id: string) => {
    try {
      await datastore
        .deleteFrom("verification_tokens")
        .where("id", "=", id as any)
        .execute();
    } catch (err) {
      logError(err);
      throw new DatabaseError({
        error: err,
        message: "Failed to delete verification token",
      });
    }
  };

  return {
    CreateToken,
    FindToken,
    ConsumeToken,
    DeleteToken,
  };
};

export type TVerificationTokenRepository = ReturnType<typeof VerificationTokenRepository>;
