/** Browser tabs share credentials only while a page session is available. */
interface AuthSnapshot {
  revision: string;
  value: null | string;
}

interface ValueStorage {
  getItem: (key: string) => null | string;
  setItem: (key: string, value: string) => void;
}

interface SessionAuthOptions {
  channel?: BroadcastChannel;
  events: Window;
  key: string;
  onRemoteChange: () => void;
  persistent: ValueStorage;
  session: ValueStorage;
}

function tokenOf(value: null | string): null | string {
  if (!value) return null;
  try {
    return JSON.parse(value).accessToken || null;
  } catch {
    return null;
  }
}

export function createSessionAuthStorage(options: SessionAuthOptions) {
  const { channel, events, key, onRemoteChange, persistent, session } = options;
  // Only an opaque revision is persistent; it cannot restore authentication.
  const revisionKey = `${key}-revision`;
  const snapshotKey = `${key}-session`;
  const revision = () => persistent.getItem(revisionKey) || '';
  let current: AuthSnapshot = { revision: revision(), value: null };
  try {
    const saved = JSON.parse(session.getItem(snapshotKey) || 'null');
    if (saved && saved.revision === current.revision && typeof saved.value === 'string') current = saved;
  } catch {
    // Unreadable session data must never prevent the login page from opening.
  }
  let started = false;
  let disposed = false;
  let timer: ReturnType<typeof setTimeout> | undefined;
  let finishDiscovery: (() => void) | undefined;

  function save(snapshot: AuthSnapshot) {
    current = snapshot;
    session.setItem(snapshotKey, JSON.stringify(current));
  }

  function requestSession() {
    channel?.postMessage({ type: 'request' });
  }

  function reconcile() {
    if (disposed || current.revision === revision()) return;
    const hadToken = !!tokenOf(current.value);
    save({ revision: revision(), value: null });
    if (started && hadToken) onRemoteChange();
  }

  function checkRevision() {
    if (current.revision === revision()) return;
    requestSession();
    // Let the peer's snapshot arrive before reinitializing the application.
    clearTimeout(timer);
    timer = setTimeout(reconcile, 250);
  }

  function receive(event: MessageEvent) {
    const message = event.data;
    if (message?.type === 'request') {
      if (current.revision === revision() && tokenOf(current.value)) {
        channel?.postMessage({ type: 'snapshot', snapshot: current });
      }
      return;
    }
    const snapshot = message?.snapshot as AuthSnapshot | undefined;
    if (
      message?.type !== 'snapshot' ||
      !snapshot ||
      typeof snapshot.revision !== 'string' ||
      (snapshot.value !== null && typeof snapshot.value !== 'string') ||
      snapshot.revision !== revision()
    )
      return;
    const changed = tokenOf(current.value) !== tokenOf(snapshot.value);
    save(snapshot);
    finishDiscovery?.();
    if (started && changed) onRemoteChange();
  }

  function storageChanged(event: StorageEvent) {
    if (event.key === revisionKey || event.key === null) checkRevision();
  }
  channel?.addEventListener('message', receive);
  events.addEventListener('storage', storageChanged);
  events.addEventListener('pageshow', checkRevision);
  events.addEventListener('focus', checkRevision);
  events.document?.addEventListener('visibilitychange', checkRevision);

  return {
    async start() {
      if ((!tokenOf(current.value) || current.revision !== revision()) && channel) {
        await new Promise<void>((resolve) => {
          const timeout = setTimeout(() => {
            finishDiscovery = undefined;
            resolve();
          }, 350);
          finishDiscovery = () => {
            clearTimeout(timeout);
            finishDiscovery = undefined;
            resolve();
          };
          requestSession();
        });
      }
      reconcile();
      started = true;
    },
    getAccessToken() {
      return current.revision === revision() ? tokenOf(current.value) : null;
    },
    getItem() {
      // A sleeping tab must not hydrate a credential revoked by another tab.
      return current.revision === revision() ? current.value : null;
    },
    setItem(_key: string, value: string) {
      if (current.revision !== revision()) {
        checkRevision();
        return;
      }
      if (value === current.value) return;
      const changed = tokenOf(current.value) !== tokenOf(value);
      let nextRevision = current.revision;
      if (changed) {
        nextRevision = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
        persistent.setItem(revisionKey, nextRevision);
      }
      save({ revision: nextRevision, value });
      if (changed) channel?.postMessage({ type: 'snapshot', snapshot: current });
    },
    dispose() {
      disposed = true;
      clearTimeout(timer);
      finishDiscovery?.();
      channel?.removeEventListener('message', receive);
      channel?.close();
      events.removeEventListener('storage', storageChanged);
      events.removeEventListener('pageshow', checkRevision);
      events.removeEventListener('focus', checkRevision);
      events.document?.removeEventListener('visibilitychange', checkRevision);
    },
  };
}