import { PUSH_CHANGED_MESSAGE, PUSH_CHANNEL, parsePush, parseResolved, shouldSilence, subscriptionKeys, type PushDisplay } from './lib/push-model';

const RESOLVE_TIMEOUT_MS = 3000;

declare const __MALICE_DEVICE__: boolean;

interface BadgeNavigator {
  setAppBadge?: (n: number) => Promise<void>;
  clearAppBadge?: () => Promise<void>;
}

let channel: BroadcastChannel | undefined;
let nextRequestId = 0;
const pending = new Map<string, (reply: { json?: unknown; error?: unknown }) => void>();

function resolveChannel(): BroadcastChannel {
  if (!channel) {
    channel = new BroadcastChannel(PUSH_CHANNEL);
    channel.onmessage = (ev: MessageEvent) => {
      const msg = ev.data as { id?: unknown; json?: unknown; error?: unknown } | null;
      if (typeof msg?.id !== 'string') return;
      const done = pending.get(msg.id);
      if (!done) return;
      pending.delete(msg.id);
      done(msg);
    };
  }
  return channel;
}

function requestResolve(roomId: string, eventId: string): Promise<unknown | null> {
  const id = `${Date.now()}-${nextRequestId++}`;
  return new Promise((resolve) => {
    const timer = setTimeout(() => {
      pending.delete(id);
      resolve(null);
    }, RESOLVE_TIMEOUT_MS);
    pending.set(id, (reply) => {
      clearTimeout(timer);
      resolve(reply.error ? null : (reply.json ?? null));
    });
    resolveChannel().postMessage({ id, kind: 'resolve', room_id: roomId, event_id: eventId });
  });
}

function show(sw: ServiceWorkerGlobalScope, display: PushDisplay, title: string, body: string, silent: boolean): Promise<void> {
  const options: NotificationOptions & { renotify?: boolean } = {
    body,
    tag: display.tag,
    silent,
    renotify: display.mention && !silent,
    data: { roomId: display.roomId, navigate: display.navigate, eventId: display.eventId }
  };
  return sw.registration.showNotification(title, options);
}

function setBadge(sw: ServiceWorkerGlobalScope, count: number | null): void {
  if (count === null) return;
  const nav = sw.navigator as unknown as BadgeNavigator;
  const call = count > 0 ? nav.setAppBadge?.(count) : nav.clearAppBadge?.();
  void call?.catch(() => undefined);
}

async function handle(sw: ServiceWorkerGlobalScope, event: PushEvent): Promise<void> {
  const display = parsePush(event.data?.text() ?? null, sw.location.origin);
  const windows = await sw.clients.matchAll({ type: 'window', includeUncontrolled: true });
  const focused = windows.some((client) => client.focused && client.visibilityState === 'visible');
  await show(sw, display, display.title, display.body, shouldSilence(display, focused));
  setBadge(sw, display.badge);
  if (!__MALICE_DEVICE__ || windows.length === 0 || !display.roomId || !display.eventId) return;
  const resolved = parseResolved(await requestResolve(display.roomId, display.eventId), display);
  if (resolved) await show(sw, display, resolved.title, resolved.body, true);
}

/** Browsers revoke the subscription when a push shows nothing, so every failure still shows a generic notification. */
export function onPush(sw: ServiceWorkerGlobalScope, event: PushEvent): void {
  event.waitUntil(
    handle(sw, event).catch(() =>
      sw.registration.showNotification('New message', { tag: 'malice', data: {} }).catch(() => undefined)
    )
  );
}

export function onSubscriptionChange(sw: ServiceWorkerGlobalScope, event: Event): void {
  const change = event as Event & { oldSubscription?: PushSubscription | null; newSubscription?: PushSubscription | null };
  (event as ExtendableEvent).waitUntil(
    (async () => {
      let sub = change.newSubscription ?? (await sw.registration.pushManager.getSubscription());
      const key = change.oldSubscription?.options.applicationServerKey;
      if (!sub && key) sub = await sw.registration.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: key });
      const keys = sub ? subscriptionKeys(sub) : null;
      if (keys && !__MALICE_DEVICE__) {
        await fetch('/api/push/subscribe', {
          method: 'POST',
          credentials: 'same-origin',
          headers: { 'content-type': 'application/json' },
          body: JSON.stringify({ endpoint: keys.endpoint, keys: { p256dh: keys.p256dh, auth: keys.auth } })
        }).catch(() => undefined);
      }
      for (const client of await sw.clients.matchAll({ type: 'window', includeUncontrolled: true })) {
        client.postMessage({ type: PUSH_CHANGED_MESSAGE });
      }
    })().catch(() => undefined)
  );
}