// will move to https://github.com/felixroos/zyklus

// TODO: started flag

function createClock(

  getTime,

  callback, // called slightly before each cycle

  duration = 0.05, // duration of each cycle

  interval = 0.1, // interval between callbacks

  overlap = 0.1, // overlap between callbacks

  setInterval = globalThis.setInterval,

  clearInterval = globalThis.clearInterval,

  round = true,

) {

  let tick = 0; // counts callbacks

  let phase = 0; // next callback time

  let precision = 10 ** 4; // used to round phase

  let minLatency = 0.01;

  const setDuration = (setter) => (duration = setter(duration));

  overlap = overlap || interval / 2;

  const onTick = () => {

    const t = getTime();

    const lookahead = t + interval + overlap; // the time window for this tick

    if (phase === 0) {

      phase = t + minLatency;

    }

    // callback as long as we're inside the lookahead

    while (phase < lookahead) {

      phase = round ? Math.round(phase * precision) / precision : phase;

      callback(phase, duration, tick, t); // callback has to skip / handle phase < t!

      phase += duration; // increment phase by duration

      tick++;

    }

  };

  let intervalID;

  const start = () => {

    clear(); // just in case start was called more than once

    onTick();

    intervalID = setInterval(onTick, interval * 1000);

  };

  const clear = () => {

    intervalID !== undefined && clearInterval(intervalID);

    intervalID = undefined;

  };

  const pause = () => clear();

  const stop = () => {

    tick = 0;

    phase = 0;

    clear();

  };

  const getPhase = () => phase;

  // setCallback

  return { setDuration, start, stop, pause, duration, interval, getPhase, minLatency };

}

export default createClock;