import { configuration } from "./configuration.js";

function findInPossible(entryList, entry) {
  switch (entry.type) {
    case "legacy_block":
      return entryList.find(v => v.name === entry.name
          && v.metadata === entry.metadata);

    case "oredict":
      return entryList.find(v => v.oredict === entry.oredict);

    default:
      console.warn("unknown type", entry.type);
  }
  return null;
}

export function resolveBlockName(block, { configurationHint }) {

  if (block.type === "module") {
    switch (block.name) {
      case "nuclearcraft:overhaul_sfr:fuel_cell":
        return "Fuel Cell";

      case "nuclearcraft:overhaul_sfr:moderator":
        return "Moderator";

      case "nuclearcraft:overhaul_sfr:casing":
        return "Casing";

      case "nuclearcraft:overhaul_sfr:reflector":
        return "Reflector";

      case "nuclearcraft:overhaul_sfr:neutron_shield":
        return "Neutron Shield";

      case "nuclearcraft:overhaul_sfr:irradiator":
        return "Irradiator";

      default:
        console.warn("unknown module", block);
        return null;
    }
  }

  const possibleBlocks = [
    ...Object.entries(configuration.configuration),
    ...configuration.addons.flatMap(a => Object.entries(a.configuration)),
  ]
      .filter(([k, v]) => (!configurationHint || k === configurationHint) && "blocks" in v)
      .flatMap(([, v]) => v.blocks);

  const entry = findInPossible(possibleBlocks, block);
  if (!entry) return null;

  return entry.modules["plannerator:display_name"].display_name;
}

export function lookupFromMetadata(metadata) {
  if (!metadata.configuration || !metadata.configurationList || !metadata.type)
    return null;

  const possibleEntries = [
    ...Object.entries(configuration.configuration),
    ...configuration.addons.flatMap(a => Object.entries(a.configuration)),
  ]
      .filter(([k, v]) => k === metadata.configuration && metadata.configurationList in v)
      .flatMap(([, v]) => v[metadata.configurationList])
      .filter(v => v.type === metadata.type);

  return findInPossible(possibleEntries, metadata);
}