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 {
    // Fetch songs played by the user
    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,
        },
      });

    // Extract unique musicIds from the fetched songs
    const musicIds = songs
      .map((song) => song.musicId)
      .filter((id) => id !== null) as number[];

    // Fetch static music information for the extrcted musicIds
    const staticMusicInfo: ChuniStaticMusic[] =
      await artemis.chuni_static_music.findMany({
        where: {
          songId: {
            in: musicIds,
          },
        },
        select: {
          songId: true,
          title: true,
          artist: true,
          chartId: true,
          level: true,
          genre: true,
          worldsEndTag: true,
        },
      });

    // Map each song with its corresponding static music information
    const songsWithTitles = songs.map((song) => {
      // Find static info corresponding to the song's musicId and level (chartId)
      const staticInfo = staticMusicInfo.find(
        (chuniStatiMusic) =>
          chuniStatiMusic.songId === song.musicId &&
          chuniStatiMusic.chartId === song.level
      );

      // Return mapped song with title, artist, genre, and correct level
      return {
        ...song,
        title: staticInfo?.title || "Unknown Title",
        artist: staticInfo?.artist || "Unknown Artist",
        genre: staticInfo?.genre || "Unknown Genre",
        level: staticInfo?.level || "Unknown Level",
        chartlevel: song.level || "unkownlevel",
      };
    });

    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;
}