import type { AllergyView, DietView, IngredientView } from "@batch-cooking/shared";
import { prisma } from "../../db/prisma.js";

/** All reference dietary regimes, alphabetically — small, static list (see prisma/seed.ts). */
export async function getDiets(): Promise<DietView[]> {
  return prisma.diet.findMany({ orderBy: { name: "asc" } });
}

/**
 * All reference allergens, alphabetically. `Allergy` carries no `name` of
 * its own — it's the selectable instance of a named `Category` (see
 * schema.prisma) — so this resolves each allergen's display name from its
 * category and flattens the split away for callers.
 */
export async function getAllergies(): Promise<AllergyView[]> {
  const allergies = await prisma.allergy.findMany({
    include: { category: { select: { name: true, kind: true } } },
    orderBy: { category: { name: "asc" } },
  });
  return allergies.map((allergy) => ({
    id: allergy.id,
    name: allergy.category.name,
    kind: allergy.category.kind,
  }));
}

/**
 * All reference ingredients, alphabetically, each resolved to its allergens
 * (see `IngredientAllergy` in schema.prisma) and compatible diet regimes
 * (see `IngredientDiet`) — same aplattening approach as {@link getAllergies}.
 * Ingredients with no linked allergen/diet come back with `allergens: []`/
 * `diets: []`.
 */
export async function getIngredients(): Promise<IngredientView[]> {
  const ingredients = await prisma.ingredient.findMany({
    include: {
      allergies: { include: { allergy: { include: { category: true } } } },
      diets: { include: { diet: true } },
    },
    orderBy: { name: "asc" },
  });
  return ingredients.map((ingredient) => ({
    id: ingredient.id,
    name: ingredient.name,
    icon: ingredient.icon,
    category: ingredient.category,
    allergens: ingredient.allergies.map(({ allergy }) => ({
      id: allergy.id,
      name: allergy.category.name,
      kind: allergy.category.kind,
    })),
    diets: ingredient.diets.map(({ diet }) => ({ id: diet.id, name: diet.name })),
  }));
}