"use server";
import { getAuth } from "@/auth/queries/getauth";
import { supportedVersionNumber } from "@/lib/helpers";
import { artemis } from "@/lib/prisma";

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

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

  try {
    const userRatingBaseList = await artemis.chuni_profile_rating.findMany({
      where: {
        user: user.UserId,
        type: "userRatingBaseList",
        version: supportedVersionNumber,
      },
      select: {
        musicId: true,
        score: true,
        difficultId: true,
        version: true,
        index: true,
      },
      orderBy: {
        index: "asc",
      },
    });

    const staticMusicInfo = await artemis.chuni_static_music.findMany({
      where: {
        songId: {
          in: userRatingBaseList.map((entry) => entry.musicId!),
        },
        version: supportedVersionNumber,
      },
      select: {
        songId: true,
        title: true,
        artist: true,
        chartId: true,
        level: true,
        genre: true,
        jacketPath: true,
      },
    });

    // Create a map
    const songIdtoChartId = new Map<string, (typeof staticMusicInfo)[0]>(
      staticMusicInfo.map((music) => [
        `${music.songId}-${music.chartId}`,
        music,
      ]),
    );

    //  user ratings
    const musicIdToDifficltId = userRatingBaseList.map((rating) => {
      const staticMusic = songIdtoChartId.get(
        `${rating.musicId}-${rating.difficultId}`,
      );

      const level = staticMusic?.level ?? 0;
      const score = rating.score ?? 0;

      const ratingChange = calculateRating(level, score);

      return {
        ...rating,
        chartId: staticMusic?.chartId || "Unknown chartId",
        title: staticMusic?.title || "Unknown Title",
        artist: staticMusic?.artist || "Unknown Artist",
        genre: staticMusic?.genre || "Unknown Genre",
        level: staticMusic?.level || "Unknown Level",
        jacketPath: staticMusic?.jacketPath || "",
        rating: ratingChange,
      };
    });

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

// calculate the rating
function calculateRating(level: number, score: number): number {
  if (score >= 1009000) {
    return level * 100 + 215;
  } else if (score >= 1007500) {
    return level * 100 + 200 + (score - 1007500) / 100;
  } else if (score >= 1005000) {
    return level * 100 + 150 + (score - 1005000) / 50;
  } else if (score >= 1000000) {
    return level * 100 + 100 + (score - 1000000) / 100;
  } else if (score >= 975000) {
    return level * 100 + (score - 975000) / 250;
  } else if (score >= 925000) {
    return level * 100 - 300 + ((score - 925000) * 3) / 500;
  } else if (score >= 900000) {
    return level * 100 - 500 + ((score - 900000) * 4) / 500;
  } else if (score >= 800000) {
    return (
      (level * 100 - 500) / 2 +
      ((score - 800000) * ((level - 500) / 2)) / 100000
    );
  } else {
    return 0;
  }
}