import assert from 'node:assert/strict';
import { test } from 'node:test';
import { selfThread } from '../src/platforms/threads.ts';
import { fixture } from './helpers.ts';

type Post = Parameters<typeof selfThread>[0][number];

// A real capture of a two-post NASA thread. The page ships eighteen posts:
// the two that belong together, other people's replies to them, and a pile of
// unrelated recommendations. Only the first two may survive.
const page = () => fixture<Post[]>('threads/thread-chain.json');

test('the author\'s own follow-up is kept, in order', () => {
  const chain = selfThread(page(), 'DccGgKuEW-E');
  assert.equal(chain.length, 2);
  assert.deepEqual(chain.map((p) => p.code), ['DccGgKuEW-E', 'DccGhYSkXYY']);
  assert.match(chain[0]?.caption?.text ?? '', /Home improvement/);
  assert.match(chain[1]?.caption?.text ?? '', /where you can watch/);
});

test('every other author on the page is dropped', () => {
  const chain = selfThread(page(), 'DccGgKuEW-E');
  assert.ok(chain.every((p) => p.user?.username === 'nasa'),
    'a post by someone else survived the filter');
  assert.ok(page().length > chain.length + 10, 'the fixture should be mostly noise');
});

test('a reply from someone else to the same post is not a continuation', () => {
  // This one is the trap: it carries reply_to_author = nasa, exactly like a
  // real follow-up does. Only the author of the *post* separates them.
  const esa = page().find((p) => p.user?.username === 'europeanspaceagency');
  assert.ok(esa, 'fixture should contain a reply from another account');
  assert.equal(esa?.text_post_app_info?.reply_to_author?.username, 'nasa');
  assert.ok(!selfThread(page(), 'DccGgKuEW-E').includes(esa as Post));
});

test('linking the second post still returns the whole chain', () => {
  const chain = selfThread(page(), 'DccGhYSkXYY');
  assert.deepEqual(chain.map((p) => p.code), ['DccGgKuEW-E', 'DccGhYSkXYY']);
});

test('an unknown code yields nothing rather than guessing', () => {
  assert.deepEqual(selfThread(page(), 'NoSuchCode'), []);
});

test('a lone post is a chain of one', () => {
  const chain = selfThread(
    [
      { code: 'A', taken_at: 1, user: { username: 'me' }, caption: { text: 'only' } },
      { code: 'B', taken_at: 2, user: { username: 'you' }, caption: { text: 'reply' },
        text_post_app_info: { reply_to_author: { username: 'me' } } },
    ],
    'A',
  );
  assert.deepEqual(chain.map((p) => p.code), ['A']);
});

test('the chain is ordered by when each was posted, not by payload order', () => {
  const chain = selfThread(
    [
      { code: 'C', taken_at: 30, user: { username: 'me' },
        text_post_app_info: { reply_to_author: { username: 'me' } } },
      { code: 'A', taken_at: 10, user: { username: 'me' } },
      { code: 'B', taken_at: 20, user: { username: 'me' },
        text_post_app_info: { reply_to_author: { username: 'me' } } },
    ],
    'A',
  );
  assert.deepEqual(chain.map((p) => p.code), ['A', 'B', 'C']);
});