export function registerIcons(iconSubset: IIconSubset, options?: Partial<IIconOptions>): void {
  let subset = {
    ...iconSubset,
    isRegistered: false,
    className: undefined
  };
  let { icons } = iconSubset;

  // Grab options, optionally mix user provided ones on top.
  options = options ? { ..._iconSettings.__options, ...options } : _iconSettings.__options;

  for (const iconName in icons) {
    if (icons.hasOwnProperty(iconName)) {
      const code = icons[iconName];
      const normalizedIconName = iconName.toLowerCase();

      if (_iconSettings[normalizedIconName]) {
        if (!options.disableWarnings) {
          warn(`Icon '${iconName} being re-registered. Ignoring duplicate registration.`);
        }
      } else {
        _iconSettings[normalizedIconName] = {
          code,
          subset
        };
      }
    }
  }
}

export function getIcon(name?: string): IIconRecord | undefined {
  let icon: IIconRecord | undefined = undefined;
  const options = _iconSettings.__options;

  name = name ? normalizeIconName(name) : '';
  name = _iconSettings.__remapped[name] || name;

  if (name) {
    icon = _iconSettings[name!] as IIconRecord;

    if (icon) {
      let { subset } = icon;
      if (subset && subset.fontFace) {
        if (!subset.isRegistered) {
          fontFace(subset.fontFace);
          subset.isRegistered = true;
        }

        if (!subset.className) {
          subset.className = mergeStyles(subset.style, {
            fontFamily: subset.fontFace.fontFamily,
            fontWeight: subset.fontFace.fontWeight || 'normal',
            fontStyle: subset.fontFace.fontStyle || 'normal'
          });
        }
      }
    } else {
      if (!options.disableWarnings && options.warnOnMissingIcons) {
        warn(`The icon "${name}" was used but not registered. See http://aka.ms/fabric-icon-usage for more information.`);
      }
    }
  }

  return icon;
}

export function unregisterIcons(iconNames: string[]): void {
  const options = _iconSettings.__options;

  for (const iconName of iconNames) {
    const normalizedIconName = normalizeIconName(iconName);
    if (_iconSettings[normalizedIconName]) {
      delete _iconSettings[normalizedIconName];
    } else {
      // Warn that we are trying to delete an icon that doesn't exist
      if (!options.disableWarnings) {
        warn(`The icon "${iconName}" tried to unregister but was not registered.`);
      }
    }

    // Delete any aliases for this iconName
    if (_iconSettings.__remapped[normalizedIconName]) {
      delete _iconSettings.__remapped[normalizedIconName];
    }

    // Delete any items that were an alias for this iconName
    Object.keys(_iconSettings.__remapped).forEach((key: string) => {
      if (_iconSettings.__remapped[key] === normalizedIconName) {
        delete _iconSettings.__remapped[key];
      }
    });
  }
}

 _missingIconsTimer = setTimeout(() => {
   warn(
     `Some icons were re-registered. Applications should only call registerIcons for any given ` +
       `icon once. Redefining what an icon is may have unintended consequences. Duplicates ` +
       `include: \n` +
       _missingIcons.slice(0, maxIconsInMessage).join(', ') +
       (_missingIcons.length > maxIconsInMessage ? ` (+ ${_missingIcons.length - maxIconsInMessage} more)` : '')
   );
   _missingIconsTimer = undefined;
   _missingIcons = [];
 }, warningDelay);