malice

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

export function isSeparator(entry: QuickEntry): entry is QuickSeparator {

  return 'separator' in entry;

}

export function normaliseQuick(entries: readonly QuickEntry[]): QuickEntry[] {

  const seen = new Set<string>();

  const out: QuickEntry[] = [];

  for (const entry of entries) {

    if (isSeparator(entry)) {

      const last = out[out.length - 1];

      if (last && !isSeparator(last)) out.push(entry);

      continue;

    }

    if (seen.has(entry.key)) continue;

    seen.add(entry.key);

    out.push(entry);

  }

  const last = out[out.length - 1];

  if (last && isSeparator(last)) out.pop();

  return out;

}

export function parseQuickReactions(raw: unknown): QuickEntry[] | null {

  if (typeof raw !== 'object' || raw === null) return null;

  const list = (raw as Record<string, unknown>)['reactions'];

  if (!Array.isArray(list)) return null;

  const entries: QuickEntry[] = [];

  for (const item of list) {

    if (typeof item !== 'object' || item === null) continue;

    const { key, shortcode, separator } = item as Record<string, unknown>;

    if (separator === true) {

      entries.push({ separator: true });

      continue;

    }

    if (typeof key !== 'string' || !key) continue;

    entries.push({ key, shortcode: typeof shortcode === 'string' ? shortcode : null });

  }

  return normaliseQuick(entries);

}

export function quickGroups(entries: readonly QuickEntry[]): QuickReaction[][] {

  const groups: QuickReaction[][] = [];

  let group: QuickReaction[] = [];

  for (const entry of entries) {

    if (!isSeparator(entry)) {

      group.push(entry);

      continue;

    }

    if (group.length > 0) groups.push(group);

    group = [];

  }

  if (group.length > 0) groups.push(group);

  return groups;

}

export function quickColumns(groups: readonly QuickReaction[][], perRow: number): number {

  return groups.reduce((cols, group) => Math.max(cols, Math.min(group.length, perRow)), 0);

}

export function sameQuick(a: readonly QuickEntry[], b: readonly QuickEntry[]): boolean {

  return (

    a.length === b.length &&

    a.every((entry, i) => {

      const other = b[i];

      return isSeparator(entry) ? isSeparator(other) : !isSeparator(other) && entry.key === other.key;

    })

  );

}