Study/src/services/deckService.ts

import { prisma } from "@/lib/db";
import type { FlashcardImportData } from "@/lib/validation/importSchemas";

export async function listDecksByClass(classId: string) {
  return prisma.deck.findMany({
    where: { classId },
    orderBy: { sortOrder: "asc" },
    include: {
      _count: { select: { cards: true } },
      progress: {
        select: {
          mode: true,
          currentIndex: true,
          orderJson: true,
          cardResultsJson: true,
        },
      },
    },
  });
}

export async function getDeckWithCards(deckId: string) {
  return prisma.deck.findUnique({
    where: { id: deckId },
    include: {
      cards: { orderBy: { sortOrder: "asc" } },
      class: { select: { slug: true, name: true } },
      progress: true,
    },
  });
}

export async function createDeckFromImport(
  classId: string,
  data: FlashcardImportData,
  overrideName?: string,
  groupId?: string | null
) {
  const maxOrder = await prisma.deck.aggregate({
    where: { classId, groupId: groupId || null },
    _max: { sortOrder: true },
  });
  const sortOrder = (maxOrder._max.sortOrder ?? -1) + 1;

  return prisma.deck.create({
    data: {
      classId,
      groupId: groupId || null,
      name: overrideName || data.deckName,
      description: data.description,
      sortOrder,
      cards: {
        create: data.cards.map((card, index) => ({
          front: card.front,
          back: card.back,
          sortOrder: index,
        })),
      },
    },
    include: {
      cards: true,
      _count: { select: { cards: true } },
    },
  });
}

export async function updateDeck(
  id: string,
  data: { name?: string; description?: string }
) {
  return prisma.deck.update({
    where: { id },
    data,
  });
}

export async function deleteDeck(id: string) {
  return prisma.deck.delete({
    where: { id },
  });
}