import assert from 'node:assert/strict';
import { test } from 'node:test';
import {
  arrivalIn,
  badgeTotal,
  isRoomWatched,
  notifyingCount,
  planNotification,
  sourceFromTimeline,
  type NotificationSource
} from '../src/lib/notification-model.ts';
import type { RoomSummary, TimelineItem } from '../src/lib/types.ts';

const NOW = 1_000_000_000;

function room(extra: Partial<RoomSummary> = {}): RoomSummary {
  return {
    room_id: '!r:x',
    name: 'General',
    membership: 'Joined',
    unread_messages: 0,
    unread_mentions: 0,
    unread_notifications: 0,
    space: false,
    direct: false,
    notification_mode: null,
    latest_event_timestamp_ms: NOW - 1000,
    avatar: 'mxc://x/room',
    ...extra
  } as RoomSummary;
}

function source(extra: Partial<NotificationSource> = {}): NotificationSource {
  return { senderId: '@bob:x', senderName: 'Bob', senderAvatar: 'mxc://x/bob', kind: 'Text', body: 'hi', undecryptable: false, highlight: false, ...extra };
}

test('counts only notifying unread per mode', () => {
  assert.equal(notifyingCount(room({ unread_notifications: 0, unread_messages: 9 })), 9);
  assert.equal(notifyingCount(room({ direct: true, unread_messages: 2, unread_mentions: 1 })), 3);
  assert.equal(notifyingCount(room({ notification_mode: 'Mute', unread_mentions: 4 })), 0);
  assert.equal(notifyingCount(room({ notification_mode: 'MentionsAndKeywordsOnly', unread_notifications: 5, unread_mentions: 1 })), 1);
  assert.equal(notifyingCount(room({ space: true, unread_mentions: 1 })), 0);
  assert.equal(notifyingCount(room({ membership: 'Invited', unread_mentions: 1 })), 0);
});

test('badge sums notifying counts across rooms', () => {
  const rooms = [room({ unread_messages: 2 }), room({ direct: true, unread_messages: 1 }), room({ notification_mode: 'Mute', unread_messages: 9 })];
  assert.equal(badgeTotal(rooms), 3);
  assert.equal(badgeTotal([]), 0);
});

test('arrival needs a known previous room and a count increase', () => {
  const before = room({ unread_messages: 1 });
  assert.equal(arrivalIn(undefined, before, NOW), null);
  assert.equal(arrivalIn(before, before, NOW), null);
  assert.equal(arrivalIn(before, room({ unread_messages: 0 }), NOW), null);
  assert.deepEqual(arrivalIn(before, room({ unread_messages: 2 }), NOW), { mention: false });
  assert.deepEqual(arrivalIn(before, room({ unread_messages: 2, unread_mentions: 1 }), NOW), { mention: true });
});

test('arrival ignores stale backfill', () => {
  const next = room({ unread_messages: 1, latest_event_timestamp_ms: NOW - 10 * 60 * 1000 });
  assert.equal(arrivalIn(room(), next, NOW), null);
});

test('only the focused open room is watched', () => {
  assert.equal(isRoomWatched('!a', '!a', true, true), true);
  assert.equal(isRoomWatched('!a', '!a', false, true), false);
  assert.equal(isRoomWatched('!a', '!a', true, false), false);
  assert.equal(isRoomWatched('!a', '!b', true, true), false);
});

test('group notification prefixes the sender and tags per room', () => {
  const plan = planNotification(room(), source(), { mention: false });
  assert.equal(plan.title, 'General');
  assert.equal(plan.body, 'Bob: hi');
  assert.equal(plan.tag, 'room:!r:x');
  assert.equal(plan.renotify, false);
  assert.equal(plan.iconMxc, 'mxc://x/room');
});

test('direct notification titles the sender and uses their avatar', () => {
  const plan = planNotification(room({ direct: true, name: 'Bob' }), source(), { mention: false });
  assert.equal(plan.title, 'Bob');
  assert.equal(plan.body, 'hi');
  assert.equal(plan.iconMxc, 'mxc://x/bob');
});

test('mentions and keyword highlights renotify', () => {
  assert.equal(planNotification(room(), source(), { mention: true }).renotify, true);
  assert.equal(planNotification(room(), source({ highlight: true }), { mention: false }).renotify, true);
});

test('undecryptable and missing content get a generic body', () => {
  assert.equal(planNotification(room(), source({ undecryptable: true, body: null }), { mention: false }).body, 'Bob: New messages');
  assert.equal(planNotification(room({ direct: true }), null, { mention: false }).body, 'New message');
});

test('media and emotes get readable previews', () => {
  assert.equal(planNotification(room({ direct: true }), source({ kind: 'Image', body: 'cat.png' }), { mention: false }).body, 'Sent an image');
  assert.equal(planNotification(room(), source({ kind: 'Emote', body: 'waves' }), { mention: false }).body, 'Bob waves');
});

test('falls back to the user id local part when no display name is known', () => {
  assert.equal(planNotification(room(), source({ senderName: null }), { mention: false }).body, 'bob: hi');
});

test('timeline source skips own newest and non-message items', () => {
  const message = (own: boolean, body: string): TimelineItem =>
    ({
      kind: 'event',
      event: {
        own,
        sender: { user_id: '@bob:x', display_name: 'Bob', avatar: null, name_ambiguous: false },
        content: { kind: 'Message', message: { kind: 'Text', body } }
      }
    }) as TimelineItem;
  const membership = { kind: 'event', event: { own: false, sender: { user_id: '@c:x' }, content: { kind: 'RoomCreated' } } } as TimelineItem;
  assert.equal(sourceFromTimeline([message(false, 'a'), membership])?.body, 'a');
  assert.equal(sourceFromTimeline([message(false, 'a'), message(true, 'b')]), null);
  assert.equal(sourceFromTimeline(undefined), null);
});