Design a multi-timer using single underlying timer

You are given a Timer class that has access to a single underlying system timer API that can only keep one active timer at a time.

Underlying single-timer primitives (already available)

class Timer {
 // Schedule ONE timer to fire at `timestamp` (absolute time).
 // If called again, it overrides/cancels the previously scheduled system timer.
 private void setTimer(long timestamp);

 // Called automatically when the currently scheduled system timer expires.
 private void handleTimer();

 // Returns current time as an absolute timestamp (same unit as setTimer).
 private long getCurrentTime();

 // Public API: users can call this to schedule MANY timers.
 public void setNewTimer(long timestamp);
}

Requirements

• Users can only call setNewTimer(timestamp).
• setNewTimer must support multiple outstanding timers.
• When any user timer expires, handleTimer() should be invoked (once per expired user timer).
• You must implement the logic of the four methods so that multiple user timers are correctly managed on top of the single underlying setTimer.

Clarifications you may assume

• timestamp is an absolute time value (e.g., epoch milliseconds) comparable to getCurrentTime().
• Multiple user timers may share the same timestamp.
• If a timer is set for a time ≤ getCurrentTime(), it should fire “immediately” (as soon as the system can schedule it).

Discuss data structures, time/space complexity, and important edge cases (e.g., overrides, duplicate timestamps, and concurrency if relevant).