import type {
  ContentPack,
  CreatureDefinition,
  ItemDefinition,
  RoomTemplate,
  TableDefinition,
} from "@/types/content";
import type { TableLookupResult } from "@/rules/tables";

export function findTableByCode(content: ContentPack, code: string): TableDefinition {
  const table = content.tables.find((entry) => entry.code === code);

  if (!table) {
    throw new Error(`Unknown table code: ${code}`);
  }

  return table;
}

export function findRoomTemplateById(
  content: ContentPack,
  roomTemplateId: string,
): RoomTemplate {
  const roomTemplate = content.roomTemplates.find((entry) => entry.id === roomTemplateId);

  if (!roomTemplate) {
    throw new Error(`Unknown room template id: ${roomTemplateId}`);
  }

  return roomTemplate;
}

export function findRoomTemplateForLookup(
  content: ContentPack,
  lookup: TableLookupResult,
): RoomTemplate {
  const roomReference = lookup.entry.references?.find((reference) => reference.type === "room");

  if (!roomReference) {
    throw new Error(`Lookup result ${lookup.tableId}:${lookup.entryKey} does not point to a room.`);
  }

  return findRoomTemplateById(content, roomReference.id);
}

function normalizeName(value: string) {
  return value.trim().toLowerCase().replace(/\s+/g, " ");
}

export function findCreatureByName(
  content: ContentPack,
  creatureName: string,
): CreatureDefinition {
  const normalizedTarget = normalizeName(creatureName);
  const creature = content.creatures.find(
    (entry) => normalizeName(entry.name) === normalizedTarget,
  );

  if (!creature) {
    throw new Error(`Unknown creature name: ${creatureName}`);
  }

  return creature;
}

export function findCreatureById(
  content: ContentPack,
  creatureId: string,
): CreatureDefinition {
  const creature = content.creatures.find((entry) => entry.id === creatureId);

  if (!creature) {
    throw new Error(`Unknown creature id: ${creatureId}`);
  }

  return creature;
}

export function findItemById(content: ContentPack, itemId: string): ItemDefinition {
  const item = content.items.find((entry) => entry.id === itemId);

  if (!item) {
    throw new Error(`Unknown item id: ${itemId}`);
  }

  return item;
}