interface Entry<T> {
  signature: string;
  item: T;
}

export interface ShareCache<T> {
  byKey: Map<string, Entry<T>>;
  list: T[];
}

export function newShareCache<T>(): ShareCache<T> {
  return { byKey: new Map(), list: [] };
}

function signature(text: string): string {
  let a = 0x811c9dc5;
  let b = 0x9747b28c;
  for (let i = 0; i < text.length; i += 1) {
    const c = text.charCodeAt(i);
    a = Math.imul(a ^ c, 0x01000193);
    b = Math.imul(b + c, 0x85ebca6b) ^ (b >>> 13);
  }
  return `${text.length}.${(a >>> 0).toString(36)}.${(b >>> 0).toString(36)}`;
}

/**
 * Parses `raw` while reusing the objects from the previous call whose serialised form is unchanged.
 * Entries are matched by `identify` and compared by a hash of their JSON, so only the latest list is retained.
 * Returns the previous array itself when every element was reused and the length matches.
 */
export function parseShared<T>(
  cache: ShareCache<T>,
  raw: unknown,
  parse: (entry: unknown) => T | null,
  identify: (entry: unknown) => string | null = () => null
): T[] {
  if (!Array.isArray(raw)) {
    cache.byKey = new Map();
    cache.list = cache.list.length ? [] : cache.list;
    return cache.list;
  }
  const byKey = new Map<string, Entry<T>>();
  const out: T[] = [];
  for (const entry of raw) {
    const sig = signature(JSON.stringify(entry));
    const base = identify(entry) ?? `~${sig}`;
    let key = base;
    for (let n = 1; byKey.has(key); n += 1) key = `${base}#${n}`;
    const previous = cache.byKey.get(key);
    const item = previous && previous.signature === sig ? previous.item : parse(entry);
    if (item === null) continue;
    byKey.set(key, { signature: sig, item });
    out.push(item);
  }
  cache.byKey = byKey;
  if (out.length === cache.list.length && out.every((item, index) => item === cache.list[index])) return cache.list;
  cache.list = out;
  return out;
}

export function sameList<T>(a: readonly T[], b: readonly T[]): boolean {
  return a === b || (a.length === b.length && a.every((item, index) => item === b[index]));
}