// @effect-diagnostics globalDate:off globalTimers:off -- Synchronous before-input-event handler; key events must be timed and the watchdog scheduled outside any Effect runtime.

// Chrome-style hold-to-quit. The quit accelerator is intercepted in
// before-input-event (which runs before the native menu accelerator), and the
// app only quits after the shortcut has been held for QUIT_HOLD_DURATION_MS
// and released.
// A quick tap just shows the renderer's "Hold to Quit" hint, and a second tap
// within QUIT_DOUBLE_TAP_MS quits immediately. Quitting from the application
// menu itself is untouched and quits immediately.
export const QUIT_HOLD_DURATION_MS = 1200;
// A second quick tap of the shortcut is the user insisting: quit immediately.
export const QUIT_DOUBLE_TAP_MS = 500;
// "Still held" is proven by auto-repeat keydowns, not by the absence of a
// release: macOS suppresses a letter keyUp while the command key is down, so a
// tap release can go completely unseen and a release-based timer would quit
// anyway. Once held, quitting waits for Q keyUp or a quiet grace period after
// modifier keyUp so repeats cannot reach the next app. Keyboards with
// auto-repeat disabled fall back to the application menu Quit action.
export const QUIT_HOLD_RELEASE_GRACE_MS = 600;

export type QuitHoldState = "down" | "up";

export interface QuitHoldKeyInput {
  readonly type: string;
  readonly key: string;
  readonly meta: boolean;
  readonly control: boolean;
  readonly alt: boolean;
  readonly shift: boolean;
  readonly isAutoRepeat: boolean;
}

export interface QuitHoldOptions {
  readonly platform: NodeJS.Platform;
  readonly isEnabled: () => Promise<boolean>;
  readonly notify: (state: QuitHoldState) => void;
  readonly quit: () => void;
}

export function makeQuitHoldHandler(
  options: QuitHoldOptions,
): (event: { preventDefault: () => void }, input: QuitHoldKeyInput) => void {
  const modifierKey = options.platform === "darwin" ? "meta" : "control";
  let watchdog: NodeJS.Timeout | undefined;
  let holding = false;
  // Set once isEnabled resolves true; auto-repeats may only complete the hold when armed.
  let armed = false;
  let quitOnRelease = false;
  let heldSince = 0;
  let lastPressAt = 0;
  // Incremented on every new press and every release/quit so a pending
  // isEnabled() resolution from a superseded press cannot arm (or quit for)
  // the current one.
  let generation = 0;

  const clearWatchdog = () => {
    if (watchdog !== undefined) {
      clearTimeout(watchdog);
      watchdog = undefined;
    }
  };

  const release = () => {
    if (!holding) return;
    const shouldNotify = armed || quitOnRelease;
    generation += 1;
    holding = false;
    armed = false;
    quitOnRelease = false;
    clearWatchdog();
    if (shouldNotify) options.notify("up");
  };

  // Dismisses any overlay first: if the quit is cancelled downstream the
  // renderer must not be left with a stuck "Hold to Quit" hint.
  const quitNow = () => {
    release();
    options.quit();
  };

  return (event, input) => {
    const key = input.key.toLowerCase();
    if (input.type === "keyUp") {
      if (key === "q") {
        const shouldQuit = quitOnRelease;
        release();
        if (shouldQuit) options.quit();
      } else if (key === modifierKey) {
        if (!quitOnRelease) {
          release();
        } else {
          watchdog = setTimeout(quitNow, QUIT_HOLD_RELEASE_GRACE_MS);
        }
      }
      return;
    }
    if (input.type !== "keyDown") return;

    if (quitOnRelease && input.isAutoRepeat && key === "q") {
      event.preventDefault();
      clearWatchdog();
      return;
    }

    const modifierDown = options.platform === "darwin" ? input.meta : input.control;
    if (!modifierDown || input.alt || input.shift || key !== "q") {
      // Any other key (or an extra modifier) pressed mid-hold breaks the
      // gesture; without this the hold timer keeps running through the
      // interruption and the next qualifying repeat would quit early. The
      // interrupted press also stops counting toward a double tap — but only
      // here, not in release(), which runs mid-restart on an unseen-release
      // re-press and must not wipe that press's own tap timestamp.
      if (holding && !input.isAutoRepeat) {
        lastPressAt = 0;
        release();
      }
      return;
    }

    event.preventDefault();

    if (input.isAutoRepeat) {
      if (armed && Date.now() - heldSince >= QUIT_HOLD_DURATION_MS) {
        armed = false;
        quitOnRelease = true;
        clearWatchdog();
      }
      return;
    }

    const now = Date.now();
    const previousPressAt = lastPressAt;
    lastPressAt = now;
    // A fresh keydown while "holding" means the key came back down after a
    // release macOS never delivered — so both branches below see real taps.
    if (previousPressAt !== 0 && now - previousPressAt <= QUIT_DOUBLE_TAP_MS) {
      quitNow();
      return;
    }
    if (holding) release();

    generation += 1;
    const pressGeneration = generation;
    holding = true;
    heldSince = now;
    void options.isEnabled().then(
      (enabled) => {
        if (generation !== pressGeneration) return;
        if (!enabled) {
          // Hold-to-quit disabled: a single press quits immediately.
          quitNow();
          return;
        }
        armed = true;
        options.notify("down");
        // No auto-repeat by then means the key was released (possibly with a
        // suppressed keyUp) or repeat is disabled; either way, don't quit.
        watchdog = setTimeout(() => {
          watchdog = undefined;
          release();
        }, QUIT_HOLD_DURATION_MS + QUIT_HOLD_RELEASE_GRACE_MS);
      },
      // A failed settings read must never strand the quit request.
      () => {
        if (generation !== pressGeneration) return;
        quitNow();
      },
    );
  };
}