Event runner Big Idea

package nl.fhict.i400433.websocketservice.logic.events;

import nl.fhict.i400433.websocketservice.logic.Auction;
import nl.fhict.i400433.websocketservice.logic.LogicFactory;
import nl.fhict.i400433.websocketservice.logic.components.AuctionHolder;
import nl.fhict.i400433.websocketservice.logic.components.ItemHolder;
import nl.fhict.i400433.websocketservice.logic.components.MarketManager;
import nl.fhict.i400433.websocketservice.logic.item.Item;
import nl.fhict.i400433.websocketservice.websockets.WebSocketServer;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

public class EventRunner implements Runnable {

    private ScheduledExecutorService threadPool;
    private final Map<Future, IEvent> futureToEventMap;
    private boolean isRunning;


    public EventRunner(MarketManager marketManager) {
        threadPool = Executors.newScheduledThreadPool(10);
        ((ScheduledThreadPoolExecutor) threadPool).setRemoveOnCancelPolicy(true);
        futureToEventMap = new HashMap<>();

        // Test auction for startup
        Auction auction = new Auction.Builder(new Item.Builder("Cowboy hat").build(),
                100000, marketManager.getAuctionHolder().getAuctionMessageSender())
                .setStartingBid(100)
                .setMinIncrement(50).build();

        marketManager.getAuctionHolder().addAuction(auction);

        addEvent(new AuctionEvent(auction));
        addEvent(new CreateAuctionEvent(marketManager.getAuctionHolder(), marketManager.getItemHolder()));
        addEvent(new GiveBudgetEvent(marketManager));


    }

    public void addEvent(IEvent event){
        Future future = threadPool.scheduleWithFixedDelay(event, event.getInitialDelay(), event.getDelay(), TimeUnit.MILLISECONDS);
        synchronized (futureToEventMap){
            futureToEventMap.put(future, event);
        }
    }


    @Override
    public void run() {
        isRunning = true;
        while(isRunning) {
            try {
                Thread.sleep(60_000);
            } catch (InterruptedException ignored) {
                Thread.currentThread().interrupt();
            }

            for (Map.Entry<Future, IEvent> futureEvent : futureToEventMap.entrySet()) {
                if (futureEvent.getValue().shouldDelete()) {
                    futureEvent.getKey().cancel(false);
                    synchronized (futureToEventMap) {
                        futureToEventMap.remove(futureEvent.getKey());
                    }
                }
            }
        }
    }

    public void stop(){
        isRunning = false;
    }
}