malice

import { get, writable } from 'svelte/store';

import { getAccountData, messageMediaUrl, setAccountData, uploadMedia } from './api';

import {

  DEFAULT_MESSAGE_SOUND,

  SOUND_MAX_BYTES,

  parseMessageSound,

  type MessageSoundSettings

} from './message-sound-model';

const EVENT_TYPE = 'dev.malice.message_sound';

const DEFAULT_URL = '/sounds/message.wav';

const CACHE_NAME = 'malice-sounds';

export const messageSound = writable<MessageSoundSettings>(DEFAULT_MESSAGE_SOUND);

const resolved = new Map<string, Promise<string>>();

export async function loadMessageSound(): Promise<void> {

  try {

    messageSound.set(parseMessageSound(await getAccountData(EVENT_TYPE)));

  } catch {

    messageSound.set(DEFAULT_MESSAGE_SOUND);

  }

}

export async function saveMessageSound(settings: MessageSoundSettings): Promise<void> {

  await setAccountData(EVENT_TYPE, { mode: settings.mode, sound: settings.sound });

  messageSound.set(settings);

}

export function resetMessageSound(): void {

  messageSound.set(DEFAULT_MESSAGE_SOUND);

  for (const url of resolved.values()) void url.then((u) => URL.revokeObjectURL(u), () => undefined);

  resolved.clear();

}

const cacheKey = (mxc: string) => `/__sounds/${encodeURIComponent(mxc)}`;

async function remember(mxc: string, blob: Blob): Promise<void> {

  try {

    await (await caches.open(CACHE_NAME)).put(cacheKey(mxc), new Response(blob, { headers: { 'content-type': blob.type } }));

  } catch {}

}

async function fetchSound(mxc: string): Promise<Blob> {

  try {

    const hit = await (await caches.open(CACHE_NAME)).match(cacheKey(mxc));

    if (hit) return await hit.blob();

  } catch {}

  const res = await fetch(messageMediaUrl(mxc, 'Full'), { credentials: 'same-origin' });

  if (!res.ok) throw new Error('Sound unavailable');

  const blob = await res.blob();

  await remember(mxc, blob);

  return blob;

}

function resolve(mxc: string | null): Promise<string> {

  if (!mxc) return Promise.resolve(DEFAULT_URL);

  let url = resolved.get(mxc);

  if (!url) {

    url = fetchSound(mxc).then(

      (blob) => URL.createObjectURL(blob),

      () => DEFAULT_URL

    );

    resolved.set(mxc, url);

  }

  return url;

}

export async function playMessageSound(): Promise<void> {

  try {

    const audio = new Audio(await resolve(get(messageSound).sound));

    await audio.play();

  } catch {}

}

function decodes(file: File): Promise<boolean> {

  return new Promise((done) => {

    const url = URL.createObjectURL(file);

    const audio = new Audio();

    const finish = (ok: boolean) => {

      clearTimeout(timer);

      URL.revokeObjectURL(url);

      done(ok);

    };

    const timer = setTimeout(() => finish(false), 5000);

    audio.oncanplaythrough = () => finish(true);

    audio.onerror = () => finish(false);

    audio.preload = 'auto';

    audio.src = url;

  });

}

export async function uploadMessageSound(file: File): Promise<void> {

  if (!file.type.startsWith('audio/')) throw new Error('Choose an audio file.');

  if (file.size > SOUND_MAX_BYTES) throw new Error('Sounds must be smaller than 1 MB.');

  if (!(await decodes(file))) throw new Error('That audio file could not be played.');

  const { mxc } = await uploadMedia(file);

  await remember(mxc, file);

  await saveMessageSound({ ...get(messageSound), sound: mxc });

}