drop/server/internal/gamesize/index.ts

import { sum } from "~/utils/array";
import cacheHandler from "../cache";
import prisma from "../db/database";
import manifestGenerator from "../downloads/manifest";
import type { Game, Version } from "~~/prisma/client/client";

export type GameSize = {
  gameName: string;
  size: number;
  gameId: string;
};

export type VersionSize = GameSize & {
  latest: boolean;
};

type VersionsSizes = {
  [versionId: string]: VersionSize;
};

type GameVersionsSize = {
  [gameId: string]: VersionsSizes;
};

class GameSizeManager {
  private gameVersionsSizesCache =
    cacheHandler.createCache<GameVersionsSize>("gameVersionsSizes");
  // All versions sizes combined
  private gameSizesCache = cacheHandler.createCache<GameSize>("gameSizes");

  private async clearGameVersionsSizesCache() {
    (await this.gameVersionsSizesCache.getKeys()).map((key) =>
      this.gameVersionsSizesCache.remove(key),
    );
  }

  private async clearGameSizesCache() {
    (await this.gameSizesCache.getKeys()).map((key) =>
      this.gameSizesCache.remove(key),
    );
  }

  // All versions of a game combined
  async getCombinedGameSize(gameId: string) {
    const versions = await prisma.version.findMany({
      where: { gameId },
    });
    const sizes = await Promise.all(
      versions.map((version) =>
        manifestGenerator.calculateManifestSize(
          JSON.parse(version.dropletManifest as string),
        ),
      ),
    );
    return sum(sizes);
  }

  async getGameVersionSize(
    gameId: string,
    versionId?: string,
  ): Promise<number | null> {
    if (!versionId) {
      const version = await prisma.version.findFirst({
        where: { gameId },
        orderBy: {
          versionIndex: "desc",
        },
      });
      if (!version) {
        return null;
      }
      versionId = version.versionId;
    }

    const manifest = await manifestGenerator.generateManifest(versionId);
    if (!manifest) {
      return null;
    }

    return manifestGenerator.calculateManifestSize(manifest);
  }

  private async isLatestVersion(
    gameVersions: Version[],
    version: Version,
  ): Promise<boolean> {
    return gameVersions.length > 0
      ? gameVersions[0].versionId === version.versionId
      : false;
  }

  async getBiggestGamesLatestVersion(top: number): Promise<VersionSize[]> {
    const gameIds = await this.gameVersionsSizesCache.getKeys();
    const latestGames = await Promise.all(
      gameIds.map(async (gameId) => {
        const versionsSizes = await this.gameVersionsSizesCache.get(gameId);
        if (!versionsSizes) {
          return null;
        }
        const latestVersionName = Object.keys(versionsSizes).find(
          (versionId) => versionsSizes[versionId].latest,
        );
        if (!latestVersionName) {
          return null;
        }
        return versionsSizes[latestVersionName] || null;
      }),
    );
    return latestGames
      .filter((game) => game !== null)
      .sort((gameA, gameB) => gameB.size - gameA.size)
      .slice(0, top);
  }

  async isGameVersionsSizesCacheEmpty() {
    return (await this.gameVersionsSizesCache.getKeys()).length === 0;
  }

  async isGameSizesCacheEmpty() {
    return (await this.gameSizesCache.getKeys()).length === 0;
  }

  async cacheAllCombinedGames() {
    await this.clearGameSizesCache();
    const games = await prisma.game.findMany({ include: { versions: true } });

    await Promise.all(games.map((game) => this.cacheCombinedGame(game)));
  }

  async cacheCombinedGame(game: Game) {
    const size = await this.getCombinedGameSize(game.id);
    if (!size) {
      this.gameSizesCache.remove(game.id);
      return;
    }
    const gameSize = {
      size,
      gameName: game.mName,
      gameId: game.id,
    };
    await this.gameSizesCache.set(game.id, gameSize);
  }

  async cacheAllGameVersions() {
    await this.clearGameVersionsSizesCache();
    const games = await prisma.game.findMany({
      include: {
        versions: {
          orderBy: {
            versionIndex: "desc",
          },
          take: 1,
        },
      },
    });

    await Promise.all(games.map((game) => this.cacheGameVersion(game)));
  }

  async cacheGameVersion(
    game: Game & { versions: Version[] },
    versionId?: string,
  ) {
    const cacheVersion = async (version: Version) => {
      const size = await this.getGameVersionSize(game.id, version.versionId);
      if (!version.versionId || !size) {
        return;
      }

      const versionsSizes = {
        [version.versionId]: {
          size,
          gameName: game.mName,
          gameId: game.id,
          latest: await this.isLatestVersion(game.versions, version),
        },
      };
      const allVersionsSizes =
        (await this.gameVersionsSizesCache.get(game.id)) || {};
      await this.gameVersionsSizesCache.set(game.id, {
        ...allVersionsSizes,
        ...versionsSizes,
      });
    };

    if (versionId) {
      const version = await prisma.version.findFirst({
        where: { gameId: game.id, versionId },
      });
      if (!version) {
        return;
      }
      cacheVersion(version);
      return;
    }
    if ("versions" in game) {
      await Promise.all(game.versions.map(cacheVersion));
    }
  }

  async getBiggestGamesAllVersions(top: number): Promise<GameSize[]> {
    const gameIds = await this.gameSizesCache.getKeys();
    const allGames = await Promise.all(
      gameIds.map(async (gameId) => await this.gameSizesCache.get(gameId)),
    );
    return allGames
      .filter((game) => game !== null)
      .sort((gameA, gameB) => gameB.size - gameA.size)
      .slice(0, top);
  }

  async deleteGameVersion(gameId: string, versionId: string) {
    const game = await prisma.game.findFirst({ where: { id: gameId } });
    if (game) {
      await this.cacheCombinedGame(game);
    }
    const versionsSizes = await this.gameVersionsSizesCache.get(gameId);
    if (!versionsSizes) {
      return;
    }
    // Remove the version from the VersionsSizes object
    const { [versionId]: _, ...updatedVersionsSizes } = versionsSizes;
    await this.gameVersionsSizesCache.set(gameId, updatedVersionsSizes);
  }

  async deleteGame(gameId: string) {
    this.gameSizesCache.remove(gameId);
    this.gameVersionsSizesCache.remove(gameId);
  }
}

export const gameSizeManager = new GameSizeManager();
export default gameSizeManager;