daphnis/lib/api.ts

"use server";

import { getAuth } from "@/auth/queries/getauth";
import { artemis, daphnis } from "@/lib/prisma";
import type * as Prisma from '@prisma/client';

type ChuniScorePlaylog = Prisma.PrismaClient;
type ChuniStaticMusic = Prisma.PrismaClient;
type LinkSharingToken = {
  playlogId: number;
};

export async function getSongsWithTitles(userId: number) {
  try {
    const songs: ChuniScorePlaylog[] = await artemis.chuni_score_playlog.findMany({
      where: {
        user: userId,
      },
      orderBy: {
        userPlayDate: "desc",
      },
      select: {
        id: true,
        maxCombo: true,
        userPlayDate: true,
        isFullCombo: true,
        playerRating: true,
        isAllJustice: true,
        score: true,
        judgeHeaven: true,
        judgeGuilty: true,
        judgeJustice: true,
        judgeAttack: true,
        judgeCritical: true,
        isClear: true,
        skillId: true,
        skillEffect: true,
        skillLevel: true,
        isNewRecord: true,
        musicId: true,
        level: true,
        rateAir: true,
        rateHold: true,
        rateFlick: true,
        rateSlide: true,
        rateTap: true,
        romVersion: true,
        eventId: true,
        characterId: true,
        charaIllustId: true,
        track: true,
        isContinue: true,
        isFreeToPlay: true,
        playKind: true,
        playDate: true,
        orderId: true,
        sortNumber: true,
        user: true,
        placeId: true,
        ticketId: true,
      },
    });

    const musicIds = songs
      .map((song) => song.musicId)
      .filter((id) => id !== null) as number[];

    const staticMusicInfo: ChuniStaticMusic[] = await artemis.chuni_static_music.findMany({
      where: {
        songId: {
          in: musicIds,
        },
      },
      select: {
        songId: true,
        title: true,
        artist: true,
      },
    });

    const songsWithTitles = songs.map((song) => ({
      ...song,
      title:
        staticMusicInfo.find((title) => title.songId === song.musicId)?.title ||
        "Unknown Title",
      artist:
        staticMusicInfo.find((artist) => artist.songId === song.musicId)
          ?.artist || "Unknown Artist",
    }));

    return songsWithTitles;
  } catch (error) {
    console.error("Error fetching songs with titles:", error);
    throw error;
  }
}

export async function generatePlaylogId(playlogid: number) {
  try {
    const tokens = await daphnis.linkSharingToken.findMany({
      where: {
        playlogId: playlogid,
      },
      select: {
        playlogId: true,
      },
    }) as LinkSharingToken[];

    const playlogIds: number[] = tokens.map((token) => token.playlogId);

    return playlogIds;
  } catch (error) {
    console.error("Error fetching playlogIds:", error);
    throw error;
  }
}

export const getUsername = async () => {
  const { user } = await getAuth();
  if (user) {
    return await daphnis.user.findFirst({
      where: {
        id: user.id,
        username: user.username,
      },
    });
  }
  return null;
};

export async function getAllAimeCards() {
  const { user } = await getAuth();

  if (!user || !user.accessCode) {
    throw new Error("User is not authenticated or accessCode is missing");
  }

  const aimeUser = await daphnis.user.findMany({
    where: {
      accessCode: user.accessCode,
    },
  });
  return aimeUser;
}

export async function verifyAimeCodeAgainstArtemis() {
  const { user } = await getAuth();

  if (!user || !user.accessCode) {
    throw new Error("User is not authenticated or accessCode is missing");
  }

  const aimeUser = await artemis.aime_card.findFirst({
    where: {
      access_code: user.accessCode,
    },
  });
  return aimeUser;
}