import { configuration } from "./configuration.js";
import { objectKeepKeys } from "./js-utils.js";

export function checkEquivalence(a, b) {
  if (!a.type || !b.type || a.type !== b.type) return false;
  switch (a.type) {
    case "legacy_block":
      return a.name === b.name
          && a.metadata === b.metadata
          && (a.blockstate === undefined && b.blockstate === undefined
              || JSON.stringify(a.blockstate) === JSON.stringify(b.blockstate));

    case "legacy_fluid":
      return a.name === b.name;

    case "oredict":
      return a.oredict === b.oredict;

    case "list":
      return a.elements.length === b.elements.length &&
          a.elements.every((aE, i) => checkEquivalence(aE, b.elements[i]));

    default:
      console.warn("unknown type", a.type, a, b);
  }
  return false;
}

export function stripEntryToMinimums(entry) {
  if (!entry.type) throw new Error("must have a type");
  switch (entry.type) {
    case "legacy_block":
      return objectKeepKeys(entry, "type", "name", "metadata", "blockstate");

    case "legacy_fluid":
      return objectKeepKeys(entry, "type", "name");

    case "oredict":
      return objectKeepKeys(entry, "type", "oredict");

    case "list":
      return {
        type: entry.type,
        elements: entry.elements.map(stripEntryToMinimums),
      };
  }
  throw new Error(`unknown entry type ${entry.type}`);
}

export function findFullEntry(type, entry, { configurationHint }) {
  const possibleEntries = [
    ...Object.entries(configuration.configuration),
    ...configuration.addons.flatMap(a => Object.entries(a.configuration)),
  ]
      .filter(([k, v]) => (!configurationHint || k === configurationHint) && type in v)
      .flatMap(([, v]) => v[type]);
  return possibleEntries.find(other => checkEquivalence(entry, other));
}

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 = possibleBlocks.find(other => checkEquivalence(block, other));
  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 possibleEntries.find(other => checkEquivalence(metadata, other));
}