added local score fetching

src/store/playerScoresStore.ts

@@ -0,0 +1,160 @@
+"use client";
+
+import { ScoresaberPlayerScore } from "@/schemas/scoresaber/playerScore";
+import { fetchAllScores, fetchScores } from "@/utils/scoresaber/api";
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+type Player = {
+  lastUpdated: Date;
+  id: string;
+  scores: ScoresaberPlayerScore[];
+};
+
+interface PlayerScoresStore {
+  players: Player[];
+
+  exists: (playerId: string) => boolean;
+  get(playerId: string): Player | undefined;
+
+  addPlayer: (
+    playerId: string,
+    callback?: (page: number, totalPages: number) => void,
+  ) => Promise<{
+    error: boolean;
+    message: string;
+  }>;
+  updatePlayerScores: () => void;
+}
+
+const UPDATE_INTERVAL = 1000 * 60 * 60; // 1 hour
+
+export const usePlayerScoresStore = create<PlayerScoresStore>()(
+  persist(
+    (set) => ({
+      players: [],
+
+      exists: (playerId: string) => {
+        const players: Player[] = usePlayerScoresStore.getState().players;
+        return players.some((player) => player.id == playerId);
+      },
+
+      get: (playerId: string) => {
+        const players: Player[] = usePlayerScoresStore.getState().players;
+        return players.find((player) => player.id == playerId);
+      },
+
+      addPlayer: async (
+        playerId: string,
+        callback?: (page: number, totalPages: number) => void,
+      ) => {
+        const players = usePlayerScoresStore.getState().players;
+
+        // Check if the player already exists
+        if (usePlayerScoresStore.getState().exists(playerId)) {
+          return {
+            error: true,
+            message: "Player already exists",
+          };
+        }
+
+        // Get all of the players scores
+        const scores = await fetchAllScores(
+          playerId,
+          "recent",
+          (page, totalPages) => {
+            if (callback) callback(page, totalPages);
+          },
+        );
+
+        if (scores == undefined) {
+          return {
+            error: true,
+            message: "Could not fetch scores for player",
+          };
+        }
+
+        console.log(scores);
+
+        set({
+          players: [
+            ...players,
+            {
+              id: playerId,
+              lastUpdated: new Date(),
+              scores: scores,
+            },
+          ],
+        });
+        return {
+          error: false,
+          message: "Player added successfully",
+        };
+      },
+
+      updatePlayerScores: async () => {
+        const players = usePlayerScoresStore.getState().players;
+
+        for (const player of players) {
+          if (player == undefined) continue;
+
+          // Skip if the player was already updated recently
+          if (player.lastUpdated > new Date(Date.now() - UPDATE_INTERVAL))
+            continue;
+
+          console.log(`Updating scores for ${player.id}...`);
+
+          let oldScores = player.scores;
+
+          // Sort the scores by id, so we know when to stop searching for new scores
+          oldScores = oldScores.sort((a, b) => b.score.id - a.score.id);
+
+          const mostRecentScore = oldScores?.[0].score;
+          if (mostRecentScore == undefined) continue;
+          let search = true;
+
+          let page = 0;
+          let newScoresCount = 0;
+          while (search) {
+            page++;
+            const newScores = await fetchScores(player.id, page);
+            if (newScores == undefined) continue;
+
+            for (const newScore of newScores.scores) {
+              if (newScore.score.id == mostRecentScore.id) {
+                search = false;
+                break;
+              }
+
+              // remove the old score
+              const oldScoreIndex = oldScores.findIndex(
+                (score) => score.score.id == newScore.score.id,
+              );
+              if (oldScoreIndex != -1) {
+                oldScores = oldScores.splice(oldScoreIndex, 1);
+              }
+              oldScores.push(newScore);
+              newScoresCount++;
+            }
+          }
+
+          let newPlayers = players;
+          // Remove the player if it already exists
+          newPlayers = newPlayers.filter((playerr) => playerr.id != player.id);
+          // Add the player
+          newPlayers.push({
+            lastUpdated: new Date(),
+            id: player.id,
+            scores: oldScores,
+          });
+
+          console.log(`Found ${newScoresCount} new scores for ${player.id}`);
+        }
+      },
+    }),
+    {
+      name: "playerScores",
+      storage: createJSONStorage(() => localStorage),
+    },
+  ),
+);

src/store/settingsStore.ts

@@ -22,7 +22,9 @@ export const useSettingsStore = create<SettingsStore>()(
       setUserId: (userId: string) => {
         set({ userId });
       },
+
       setProfilePicture: (profilePicture: string) => set({ profilePicture }),
+
       async refreshProfile() {
         const id = useSettingsStore.getState().userId;
         if (!id) return;