import type { ImagePack, QuickEntry } from './types';

export type DisabledPackImages = Record<string, string[]>;

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function setOwn<T>(record: Record<string, T>, key: string, value: T): void {
  Object.defineProperty(record, key, {
    configurable: true,
    enumerable: true,
    value,
    writable: true
  });
}

function hasOwn(record: object, key: string): boolean {
  return Object.prototype.hasOwnProperty.call(record, key);
}

export function parseDisabledPackImages(raw: unknown): DisabledPackImages {
  if (!isRecord(raw) || !isRecord(raw['disabled'])) return {};
  const disabled: DisabledPackImages = {};
  for (const [packId, rawShortcodes] of Object.entries(raw['disabled'])) {
    if (!Array.isArray(rawShortcodes)) continue;
    const seen = new Set<string>();
    const shortcodes = rawShortcodes.filter((value): value is string => {
      if (typeof value !== 'string' || value.length === 0 || seen.has(value)) return false;
      seen.add(value);
      return true;
    });
    if (shortcodes.length > 0) setOwn(disabled, packId, shortcodes);
  }
  return disabled;
}

export function imageEnabled(disabled: DisabledPackImages, packId: string, shortcode: string): boolean {
  return !hasOwn(disabled, packId) || !disabled[packId].includes(shortcode);
}

export function withImageEnabled(
  disabled: DisabledPackImages,
  packId: string,
  shortcode: string,
  enabled: boolean
): DisabledPackImages {
  const current = hasOwn(disabled, packId) ? disabled[packId] : [];
  const nextShortcodes = enabled
    ? current.filter((item) => item !== shortcode)
    : current.includes(shortcode) ? [...current] : [...current, shortcode];
  if (nextShortcodes.length === current.length && nextShortcodes.every((item, index) => item === current[index])) {
    return disabled;
  }
  const next = { ...disabled };
  if (nextShortcodes.length === 0) delete next[packId];
  else setOwn(next, packId, nextShortcodes);
  return next;
}

export function enabledPacks(packs: ImagePack[], disabled: DisabledPackImages): ImagePack[] {
  return packs.map((pack) => ({
    ...pack,
    images: pack.images.filter((image) => imageEnabled(disabled, pack.id, image.shortcode))
  }));
}

export function enabledQuickReactions(
  quick: QuickEntry[],
  packs: ImagePack[],
  disabled: DisabledPackImages
): QuickEntry[] {
  const hidden = new Set<string>();
  const enabled = new Set<string>();
  for (const pack of packs) {
    for (const image of pack.images) {
      (imageEnabled(disabled, pack.id, image.shortcode) ? enabled : hidden).add(image.reaction_key);
    }
  }
  return quick.filter((entry) => 'separator' in entry || !hidden.has(entry.key) || enabled.has(entry.key));
}