// Loudness normalization math for the web player (M464 #4999). Pure, so the
// rules are tested without an <audio> element or an AudioContext.

import type { NormalizationPrefs, ReplayGain } from '#lib/api/normalization.js';
import type { TrackRef } from '#lib/api/types.js';

// The server's gains are to the ReplayGain 2.0 reference.
const REFERENCE_LUFS = -18;
// Headroom mode raises a quiet track only until its true peak reaches this.
export const PEAK_CEILING_DBTP = -1;
// No track is raised more than this, whatever its measurement says: a
// near-silent track would otherwise come out as amplified noise.
export const MAX_BOOST_DB = 12;

/**
 * Whether the track at `index` is being played as part of its album, in
 * order: a neighbour in the queue is from the same album and sits on the
 * right side of it. That is when album gain keeps the album's own dynamics
 * (a quiet intro stays quiet); anywhere else track gain levels the mix.
 */
export function playingAsAlbum(queue: TrackRef[], index: number): boolean {
  const cur = queue[index];
  const curOrder = cur ? order(cur) : null;
  if (!cur || curOrder === null) return false;
  const inOrder = (n: TrackRef | undefined, before: boolean): boolean => {
    if (!n || n.album_id !== cur.album_id) return false;
    const o = order(n);
    if (o === null) return false;
    return before ? o < curOrder : o > curOrder;
  };
  return inOrder(queue[index - 1], true) || inOrder(queue[index + 1], false);
}

// Disc-major track order. A track with no number has no place in the order
// and is never evidence of album play.
function order(t: TrackRef): number | null {
  if (t.track_number == null) return null;
  return (t.disc_number ?? 1) * 1000 + t.track_number;
}

/**
 * The gain to apply, in dB, for one track. 0 when leveling is off or the
 * track has not been measured yet: an unmeasured track plays as mastered.
 */
export function gainDb(
  prefs: NormalizationPrefs,
  g: ReplayGain | undefined,
  asAlbum: boolean
): number {
  if (prefs.mode === 'off' || !g) return 0;
  const wantAlbum = prefs.mode === 'album' || (prefs.mode === 'auto' && asAlbum);
  // Album gain falls back to track gain while the album is still being
  // measured; track gain never falls back to album gain.
  const useAlbum = wantAlbum && g.album_gain !== undefined;
  const gain = useAlbum ? g.album_gain : g.track_gain;
  const peak = useAlbum ? g.album_peak : g.track_peak;
  if (gain === undefined) return 0;

  let db = gain + (prefs.target_lufs - REFERENCE_LUFS);
  if (prefs.boost === 'headroom' && peak !== undefined && peak > 0) {
    db = Math.min(db, PEAK_CEILING_DBTP - 20 * Math.log10(peak));
  }
  return Math.min(db, MAX_BOOST_DB);
}

export function dbToLinear(db: number): number {
  return Math.pow(10, db / 20);
}