import type { InventoryTypeDefinition } from '../types'
import { inventoryDefinitions } from './inventories'

const registry = new Map<string, InventoryTypeDefinition>(
  Object.entries(inventoryDefinitions),
)

/** Built from each definition’s `aliases` field in `inventories.ts`. */
function buildAliasToNameMap(
  defs: Record<string, InventoryTypeDefinition>,
): Map<string, string> {
  const m = new Map<string, string>()
  for (const def of Object.values(defs)) {
    if (def.aliases) {
      for (const a of def.aliases) {
        m.set(a, def.name)
      }
    }
  }
  return m
}

const aliasToName = buildAliasToNameMap(inventoryDefinitions)

/** Runtime aliases from {@link registerTypeAlias} / {@link registerInventoryType}. */
const dynamicAliasToName = new Map<string, string>()

export function registerInventoryType(def: InventoryTypeDefinition): void {
  registry.set(def.name, def)
  def.aliases?.forEach((a) => dynamicAliasToName.set(a, def.name))
}

/**
 * Resolve an inventory type name or alias to its definition.
 * Handles:
 *  - Exact matches (e.g. "crafting_table")
 *  - `aliases` on each definition in `inventories.ts`
 *  - "minecraft:" namespace prefix (e.g. "minecraft:generic_9x3" → "generic_9x3")
 */
export function getInventoryType(name: string): InventoryTypeDefinition | undefined {
  const stripped = name.startsWith('minecraft:') ? name.slice('minecraft:'.length) : name
  const canonical =
    dynamicAliasToName.get(stripped) ?? aliasToName.get(stripped) ?? stripped
  return registry.get(canonical)
}

export function registerTypeAlias(alias: string, canonical: string): void {
  dynamicAliasToName.set(alias, canonical)
}

export function getAllInventoryTypes(): InventoryTypeDefinition[] {
  return Array.from(registry.values())
}

export { inventoryDefinitions }
export type { InventoryTypeDefinition }
export type WindowType = keyof typeof inventoryDefinitions