import time


class TimerEvent:

    __slots__ = ('time', 'callback', 'args')

    def __init__(self, delay, callback, args):
        self.time = time.time() + delay
        self.callback = callback
        self.args = args

    def execute(self):
        self.callback(*self.args)

    def __lt__(self, other):
        return self.time < other.time

    def __str__(self):
        return '{:.2f}s {} {}'.format(
            self.time - time.time(), self.callback, self.args)


class Timer:

    def __init__(self):
        #: Each timeout
        self.events = []

    def add_timeout(self, delay, callback, *args):
        """Register `callback` to be called after `delay` seconds."""
        self.events.append(TimerEvent(delay, callback, args))
        self.events.sort(reverse=True)

    def remove_timeout(self, callback, *args):
        """Unregister callback previously registered with add_timeout.

        Removes all timeouts with the `callback` and `args`.

        """
        for event in self.events[:]:
            if event.callback == callback and event.args == args:
                self.events.remove(event)

    def nearest_timeout(self):
        """Get interval in seconds when next timeout expires.

        Returns None when no timeout is registered.

        """
        if not len(self.events):
            return None
        timeout = self.events[-1].time - time.time()
        return max(0, timeout)

    def process_timeouts(self):
        """Execute all expired timeouts."""
        now = time.time()
        while len(self.events) and self.events[-1].time <= now:
            self.events[-1].execute()
            self.events.pop()

    def __str__(self):
        return '\n'.join(str(event) for event in self.events)


if __name__ == '__main__':
    # Self Test
    t = Timer()
    t.process_timeouts()
    t.add_timeout(1, print, 'timeout 1')
    t.add_timeout(3, print, 'timeout 3')
    t.add_timeout(2, print, 'timeout 2')
    print(t)
    print('Nearest: %.2f' % t.nearest_timeout())
    t.process_timeouts()
    time.sleep(1)
    t.process_timeouts()
    print(t)
    time.sleep(2)
    t.process_timeouts()