"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 chuniScorePlaylogMusicId = songs
      .map((song) => song.musicId)
      .filter((id): id is number => id !== null);

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

    // Fetch play count for each musicId specific to the user
    const playCounts = await artemis.chuni_score_playlog.groupBy({
      by: ['musicId'],
      _count: {
        musicId: true,
      },
      where: {
        user: userId,
        musicId: {
          in: chuniScorePlaylogMusicId,
        },
      },
    });

    // Create a map of musicId to play count
    const playCountMap = playCounts.reduce((map, item) => {
      if (item.musicId !== null) {
        map[item.musicId] = item._count.musicId;
      }
      return map;
    }, {} as Record<number, number>);

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

      // Return mapped song with title, artist, genre, correct level, and play count
      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 || "Unknown Level",
        playCount: song.musicId !== null ? playCountMap[song.musicId] || 0 : 0,
      };
    });

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