import assert from 'node:assert/strict';
import { test } from 'node:test';
import { enabledQuickReactions } from '../src/lib/pack-preferences-model.ts';
import {
  isSeparator,
  normaliseQuick,
  parseQuickReactions,
  quickColumns,
  quickGroups,
  sameQuick
} from '../src/lib/quick-reactions-model.ts';
import type { QuickEntry } from '../src/lib/types.ts';

const r = (key: string): QuickEntry => ({ key, shortcode: null });
const sep = (): QuickEntry => ({ separator: true });
const shape = (list: QuickEntry[]) => list.map((e) => (isSeparator(e) ? '|' : e.key)).join(' ');

test('normalising drops leading, trailing and doubled separators', () => {
  assert.equal(shape(normaliseQuick([sep(), r('a'), sep(), sep(), r('b'), sep()])), 'a | b');
  assert.equal(shape(normaliseQuick([sep(), sep()])), '');
  assert.equal(shape(normaliseQuick([])), '');
});

test('normalising dedupes keys and keeps the break between survivors', () => {
  assert.equal(shape(normaliseQuick([r('a'), sep(), r('a'), sep(), r('b')])), 'a | b');
  assert.equal(shape(normaliseQuick([r('a'), r('b'), sep(), r('a'), sep(), r('c')])), 'a b | c');
});

test('normalising keeps separator identity and leaves the input alone', () => {
  const middle = sep();
  const input = [r('a'), middle, r('b'), sep()];
  const out = normaliseQuick(input);
  assert.equal(out[1], middle);
  assert.equal(input.length, 4);
});

test('parsing keeps separators and tolerates what older builds wrote', () => {
  const parsed = parseQuickReactions({
    reactions: [{ key: 'a', shortcode: 'x' }, { separator: true }, { key: 'b' }, 7, null, { key: '' }, { key: 'a' }, { separator: true }]
  });
  assert.deepEqual(parsed, [{ key: 'a', shortcode: 'x' }, { separator: true }, { key: 'b', shortcode: null }]);
});

test('parsing rejects data without a reactions list', () => {
  assert.equal(parseQuickReactions(null), null);
  assert.equal(parseQuickReactions({ reactions: 'a' }), null);
  assert.equal(parseQuickReactions('a'), null);
  assert.deepEqual(parseQuickReactions({ reactions: [] }), []);
});

test('only a literal true makes a separator', () => {
  assert.deepEqual(parseQuickReactions({ reactions: [{ separator: 'yes' }, { separator: false, key: 'a' }] }), [{ key: 'a', shortcode: null }]);
});

test('groups split at separators and skip empty runs', () => {
  const groups = quickGroups([r('a'), r('b'), sep(), sep(), r('c'), sep()]);
  assert.deepEqual(groups.map((g) => g.map((e) => e.key)), [['a', 'b'], ['c']]);
  assert.deepEqual(quickGroups([]), []);
  assert.deepEqual(quickGroups([sep()]), []);
});

test('the toolbar is as wide as its widest group up to the row limit', () => {
  const groups = quickGroups([r('a'), r('b'), r('c'), sep(), r('d')]);
  assert.equal(quickColumns(groups, 8), 3);
  assert.equal(quickColumns(groups, 2), 2);
  assert.equal(quickColumns([], 8), 0);
});

test('comparison looks at order, keys and separator positions', () => {
  assert.ok(sameQuick([r('a'), sep(), r('b')], [r('a'), sep(), r('b')]));
  assert.ok(!sameQuick([r('a'), sep(), r('b')], [r('a'), r('b')]));
  assert.ok(!sameQuick([r('a'), r('b')], [r('b'), r('a')]));
  assert.ok(!sameQuick([sep()], [r('a')]));
});

test('a hidden pack image leaves no empty group or doubled break', () => {
  const pack = {
    id: 'p',
    display_name: null,
    avatar: null,
    attribution: 'source',
    source: 'User' as const,
    images: [{ shortcode: 'one', media_id: 'mxc://x/one', reaction_key: 'mxc://x/one', body: null, mimetype: null, width: null, height: null, usage: ['Emoticon' as const] }],
    editable: true,
    enabled_everywhere: false
  };
  const list = [r('a'), sep(), r('mxc://x/one'), sep(), r('b')];
  const visible = normaliseQuick(enabledQuickReactions(list, [pack], { p: ['one'] }));
  assert.equal(shape(visible), 'a | b');
  assert.equal(shape(normaliseQuick(enabledQuickReactions([r('mxc://x/one'), sep(), r('a')], [pack], { p: ['one'] }))), 'a');
});