export const DEVICE_PUSH_APP_ID = 'dev.malice.device';
export const PUSH_CHANNEL = 'malice-push';
export const PUSH_CHANGED_MESSAGE = 'malice-push-changed';
export const PUSH_NOTIFY_PATH = '/_matrix/push/v1/notify';

export interface PushDisplay {
  title: string;
  body: string;
  tag: string;
  navigate: string | null;
  silent: boolean;
  badge: number | null;
  roomId: string | null;
  eventId: string | null;
  mention: boolean;
  encrypted: boolean;
}

export interface ResolvedPush {
  title: string;
  body: string;
}

export interface PushSubscriptionKeys {
  endpoint: string;
  p256dh: string;
  auth: string;
}

const FALLBACK_TITLE = 'New message';
const FALLBACK_TAG = 'malice';

function record(value: unknown): Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
}

function text(value: unknown): string | null {
  return typeof value === 'string' && value.length > 0 ? value : null;
}

function count(value: unknown): number | null {
  const n = typeof value === 'string' ? Number(value) : value;
  return typeof n === 'number' && Number.isInteger(n) && n >= 0 ? n : null;
}

function sameOrigin(url: string | null, origin: string): string | null {
  if (!url) return null;
  try {
    const parsed = new URL(url, origin);
    return parsed.origin === origin ? parsed.href : null;
  } catch {
    return null;
  }
}

export function roomFromTag(tag: string | null | undefined): string | null {
  return tag?.startsWith('room:') && tag.length > 5 ? tag.slice(5) : null;
}

/** Never throws, so the push handler can always show something. */
export function parsePush(raw: unknown, origin: string): PushDisplay {
  let value = raw;
  if (typeof raw === 'string') {
    try {
      value = JSON.parse(raw);
    } catch {
      value = null;
    }
  }
  const payload = record(value);
  const note = record(payload['notification']);
  const malice = record(payload['malice']);
  const roomId = text(malice['room_id']);
  const tag = text(note['tag']) ?? (roomId ? `room:${roomId}` : FALLBACK_TAG);
  const badge = count(note['app_badge']) ?? count(malice['unread']);
  return {
    title: text(note['title']) ?? FALLBACK_TITLE,
    body: text(note['body']) ?? '',
    tag,
    navigate: sameOrigin(text(note['navigate']), origin),
    silent: note['silent'] === true,
    badge,
    roomId: roomId ?? roomFromTag(tag),
    eventId: text(malice['event_id']),
    mention: malice['mention'] === true,
    encrypted: malice['encrypted'] === true
  };
}

export function roomTarget(roomId: string | null, navigate: string | null): string {
  if (navigate) return navigate;
  return roomId ? `/?room=${encodeURIComponent(roomId)}` : '/';
}

/** A visible focused window is already showing the app, so the banner stays but without sound or vibration. */
export function shouldSilence(display: PushDisplay, windowFocused: boolean): boolean {
  return display.silent || windowFocused;
}

/** The decrypted reply replaces the tier 1 notification only when it adds something. */
export function parseResolved(value: unknown, current: PushDisplay): ResolvedPush | null {
  const reply = record(value);
  const title = text(reply['title']);
  const body = text(reply['body']);
  if (!title && !body) return null;
  const next = { title: title ?? current.title, body: body ?? current.body };
  return next.title === current.title && next.body === current.body ? null : next;
}

export function urlBase64ToBytes(value: string): Uint8Array<ArrayBuffer> {
  const padded = value.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(value.length / 4) * 4, '=');
  const raw = atob(padded);
  const bytes = new Uint8Array(raw.length);
  for (let i = 0; i < raw.length; i++) bytes[i] = raw.charCodeAt(i);
  return bytes;
}

export function bytesToUrlBase64(bytes: Uint8Array): string {
  let raw = '';
  for (const byte of bytes) raw += String.fromCharCode(byte);
  return btoa(raw).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
}

export function subscriptionKeys(sub: { endpoint: string; getKey(name: 'p256dh' | 'auth'): ArrayBuffer | null }): PushSubscriptionKeys | null {
  const p256dh = sub.getKey('p256dh');
  const auth = sub.getKey('auth');
  if (!p256dh || !auth) return null;
  return { endpoint: sub.endpoint, p256dh: bytesToUrlBase64(new Uint8Array(p256dh)), auth: bytesToUrlBase64(new Uint8Array(auth)) };
}

export interface StoredPush {
  endpoint: string;
  pushkey: string | null;
}

export type SyncAction = 'none' | 'subscribe' | 'register';

/** What a launch check must repair, given whether the user wants push, the live subscription and what was last registered. */
export function syncAction(wanted: boolean, live: string | null, stored: StoredPush | null): SyncAction {
  if (!wanted) return 'none';
  if (!live) return 'subscribe';
  return stored?.endpoint === live ? 'none' : 'register';
}

export function parseStoredPush(raw: string | null): StoredPush | null {
  if (!raw) return null;
  try {
    const value = record(JSON.parse(raw));
    const endpoint = text(value['endpoint']);
    return endpoint ? { endpoint, pushkey: text(value['pushkey']) } : null;
  } catch {
    return null;
  }
}

export function devicePusherRequest(keys: PushSubscriptionKeys, origin: string, lang: string, browser: string) {
  return {
    op: 'set_pusher' as const,
    app_id: DEVICE_PUSH_APP_ID,
    pushkey: keys.p256dh,
    app_display_name: 'Malice',
    device_display_name: 'Malice web',
    lang,
    url: `${origin}${PUSH_NOTIFY_PATH}`,
    format: 'Full' as const,
    data: { endpoint: keys.endpoint, auth: keys.auth, browser }
  };
}

/** Pushers this browser registered under an endpoint it no longer holds. Other browsers on the account share the app id, so only its own id matches. */
export function stalePushers(reply: unknown, browser: string, endpoint: string): string[] {
  const list = record(reply)['pushers'];
  if (!Array.isArray(list)) return [];
  const stale: string[] = [];
  for (const entry of list) {
    const pusher = record(entry);
    const data = record(pusher['data']);
    const pushkey = text(pusher['pushkey']);
    if (pusher['app_id'] === DEVICE_PUSH_APP_ID && data['browser'] === browser && data['endpoint'] !== endpoint && pushkey) stale.push(pushkey);
  }
  return stale;
}