일시정지는 종료가 아니야

// A configurable pause key that never fights with typing, IME or focus.
interface KeyLike {
  code: string; altKey: boolean; ctrlKey: boolean; metaKey: boolean; shiftKey: boolean;
  isComposing: boolean; keyCode?: number; repeat: boolean; targetIsEditable: boolean;
}

/** "Space", "Alt+KeyP", "Meta+Shift+KeyM", or "disabled". Normalized on save. */
export function normalizePauseKey(raw: string | null | undefined): string {
  const parts = (raw ?? '').split('+').map((p) => p.trim()).filter(Boolean);
  if (!parts.length) return 'Space';
  if (parts.length === 1 && parts[0].toLowerCase() === 'disabled') return 'disabled';
  const order = ['Ctrl', 'Alt', 'Shift', 'Meta'];
  const mods = order.filter((m) => parts.slice(0, -1).some((p) => p.toLowerCase() === m.toLowerCase()));
  return [...mods, parts[parts.length - 1]].join('+');
}

export function matchesPauseKey(event: KeyLike, setting: string): boolean {
  if (setting === 'disabled') return false;
  if (event.targetIsEditable) return false;                   // typing in a field
  if (event.isComposing || event.keyCode === 229) return false; // Hangul IME mid-syllable
  const parts = setting.split('+');
  const code = parts[parts.length - 1];
  const want = new Set(parts.slice(0, -1));
  return event.code === code
    && event.ctrlKey === want.has('Ctrl') && event.altKey === want.has('Alt')
    && event.shiftKey === want.has('Shift') && event.metaKey === want.has('Meta');
}

// Swallow the matching keyup too, so a focused button can't read the same
// key as a click and toggle pause a second time. Only THAT key's keyup:
// an unrelated key released in between is none of our business.
let swallowKeyUp: string | null = null;
let paused = false;
function onKeyDown(event: KeyLike, setting: string) {
  if (!matchesPauseKey(event, setting)) return;
  swallowKeyUp = event.code;
  if (event.repeat) return;              // a held key is one press, not a drumroll
  paused = !paused;
  console.log(paused ? 'Paused. The microphone is off.' : 'Listening again.');
}
function onKeyUp(event: KeyLike) {
  if (swallowKeyUp !== event.code) return;
  swallowKeyUp = null;
  console.log(`  (keyup ${event.code} swallowed)`);
}

const key = (code: string, extra: Partial<KeyLike> = {}): KeyLike => ({
  code, altKey: false, ctrlKey: false, metaKey: false, shiftKey: false,
  isComposing: false, repeat: false, targetIsEditable: false, ...extra,
});

const setting = normalizePauseKey('Space');   // Admin's house setting
onKeyDown(key('Space'), setting); onKeyUp(key('Space'));
onKeyDown(key('Space', { isComposing: true }), setting);      // ignored: composing
onKeyDown(key('Space', { targetIsEditable: true }), setting); // ignored: typing
onKeyDown(key('Space'), setting);
onKeyDown(key('Space', { repeat: true }), setting);          // held: no second toggle
onKeyUp(key('KeyA'));                                         // not ours: passes through
onKeyUp(key('Space'));
console.log(normalizePauseKey('shift + alt + KeyP'), normalizePauseKey('DISABLED'));