/**
 * Posts a runnable to the Main Server Thread.
 * <p/>
 *
 * @param runnable The runnable that should be executed.
 * @return a Listenable Future.
 */
public ListenableFuture postToMainThread(Runnable runnable, boolean noThreadCheck, int delay) {
	Callable callable = Executors.callable(runnable);
	ListenableFuture listenableFuture = ListenableFutureTask.create(callable);
	if (noThreadCheck || delay > 0 || !The5zigMod.getVars().isMainThread()) {
		synchronized (jobs) {
			jobs.add(new Task(listenableFuture, delay));
			return listenableFuture;
		}
	} else {
		try {
			return Futures.immediateFuture(callable.call());
		} catch (Exception e) {
			return Futures.immediateFailedCheckedFuture(e);
		}
	}
}
 

/**
 * Posts a runnable to the Main Server Thread.
 * <p/>
 *
 * @param runnable The runnable that should be executed.
 * @return a Listenable Future.
 */
public ListenableFuture postToMainThread(Runnable runnable, boolean noThreadCheck, int delay) {
	Callable callable = Executors.callable(runnable);
	ListenableFuture listenableFuture = ListenableFutureTask.create(callable);
	if (noThreadCheck || delay > 0 || !The5zigMod.getVars().isMainThread()) {
		synchronized (jobs) {
			jobs.add(new Task(listenableFuture, delay));
			return listenableFuture;
		}
	} else {
		try {
			return Futures.immediateFuture(callable.call());
		} catch (Exception e) {
			return Futures.immediateFailedCheckedFuture(e);
		}
	}
}
 

public AbstractJobInstance(Config config) {
    Assert.notNull(config.parameters, "parameters is null");
    Assert.notNull(config.job, "job is null");
    Assert.notNull(config.jobsManager, "jobsManager is null");
    Assert.notNull(config.info, "info is null");
    this.jobContext = new JobContext(this, config.parameters);
    this.infoRef = new AtomicReference<>(config.info);
    this.manager = config.jobsManager;
    // create wait future with stub
    this.atEndFuture = SettableFuture.create();
    this.job = config.job;
    this.authentication = config.authentication;
    this.watcher = config.watcher;
    this.cancelFuture = ListenableFutureTask.create(this::innerCancel);
    this.startFuture = ListenableFutureTask.create(this::innerStart);
}
 

/**
 * Returns a future whose result is the state of the wavelet after it has been
 * loaded from storage. Any failure is reported as a
 * {@link PersistenceException}.
 */
@VisibleForTesting
static ListenableFuture<DeltaStoreBasedWaveletState> loadWaveletState(Executor executor,
    final DeltaStore deltaStore, final DeltaStoreTransient transientDeltaStore,
    final WaveletName waveletName, final Executor persistExecutor,
    final int persistSnapshotOnDeltasCount) {
  ListenableFutureTask<DeltaStoreBasedWaveletState> task = ListenableFutureTask
      .create(new Callable<DeltaStoreBasedWaveletState>() {
        @Override
        public DeltaStoreBasedWaveletState call() throws PersistenceException {

          DeltasAccess deltasAccess = null;
          if (waveletName.waveletId.isTransientWavelet())
            deltasAccess = transientDeltaStore.open(waveletName);
          else
            deltasAccess = deltaStore.open(waveletName);

          return DeltaStoreBasedWaveletState.create(deltasAccess, persistExecutor,
              persistSnapshotOnDeltasCount);
        }
      });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onParticipantAdded(final WaveletName waveletName,
    ParticipantId participant) {
  Preconditions.checkNotNull(waveletName);
  Preconditions.checkNotNull(participant);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to update index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onWaveInit(final WaveletName waveletName) {
  Preconditions.checkNotNull(waveletName);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to initialize index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onWaveInit(final WaveletName waveletName) {

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletDataProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to initialize index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public void waveletCommitted(final WaveletName waveletName, final HashedVersion version) {

  Preconditions.checkNotNull(waveletName);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletDataProvider.getReadableWaveletData(waveletName);
        LOG.fine("commit " + version + " " + waveletData.getVersion());
        if (waveletData.getVersion() == version.getVersion()) {
          updateIndex(waveletData);
        }
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to update index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
}
 

private static void testOneSlice(final String id, final NavigableSet<Integer> test, final NavigableSet<Integer> canon, List<ListenableFuture<?>> results)
{
    ListenableFutureTask<?> f = ListenableFutureTask.create(new Runnable()
    {

        @Override
        public void run()
        {
            test(id + " Count", test.size(), canon.size());
            testEqual(id, test.iterator(), canon.iterator());
            testEqual(id + "->DSCI", test.descendingIterator(), canon.descendingIterator());
            testEqual(id + "->DSCS", test.descendingSet().iterator(), canon.descendingSet().iterator());
            testEqual(id + "->DSCS->DSCI", test.descendingSet().descendingIterator(), canon.descendingSet().descendingIterator());
        }
    }, null);
    results.add(f);
    COMPARE.execute(f);
}
 

@Override
public ListenableFuture<GuidePostsInfo> reload(
        final GuidePostsKey key,
        GuidePostsInfo prevGuidepostInfo)
{
    if (statsLoader.needsLoad()) {
        // schedule asynchronous task
        ListenableFutureTask<GuidePostsInfo> task =
                ListenableFutureTask.create(new Callable<GuidePostsInfo>() {
                    public GuidePostsInfo call() {
                        try {
                            return statsLoader.loadStats(key, prevGuidepostInfo);
                        } catch (Exception e) {
                            LOGGER.warn("Unable to load stats from table: " + key.toString(), e);
                            return prevGuidepostInfo;
                        }
                    }
                });
        executor.execute(task);
        return task;
    }
    else {
        return Futures.immediateFuture(prevGuidepostInfo);
    }
}
 

/**
 * Returns a future whose result is the state of the wavelet after it has been
 * loaded from storage. Any failure is reported as a
 * {@link PersistenceException}.
 */
@VisibleForTesting
static ListenableFuture<DeltaStoreBasedWaveletState> loadWaveletState(Executor executor,
    final DeltaStore deltaStore, final WaveletName waveletName, final Executor persistExecutor) {
  ListenableFutureTask<DeltaStoreBasedWaveletState> task =
      ListenableFutureTask.create(
         new Callable<DeltaStoreBasedWaveletState>() {
           @Override
           public DeltaStoreBasedWaveletState call() throws PersistenceException {
             return DeltaStoreBasedWaveletState.create(deltaStore.open(waveletName),
                                                              persistExecutor);
           }
         });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onParticipantAdded(final WaveletName waveletName,
    ParticipantId participant) {
  Preconditions.checkNotNull(waveletName);
  Preconditions.checkNotNull(participant);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to update index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onWaveInit(final WaveletName waveletName) {
  Preconditions.checkNotNull(waveletName);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to initialize index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public ListenableFuture<Void> onWaveInit(final WaveletName waveletName) {

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletDataProvider.getReadableWaveletData(waveletName);
        updateIndex(waveletData);
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to initialize index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
  return task;
}
 

@Override
public void waveletCommitted(final WaveletName waveletName, final HashedVersion version) {

  Preconditions.checkNotNull(waveletName);

  ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

    @Override
    public Void call() throws Exception {
      ReadableWaveletData waveletData;
      try {
        waveletData = waveletDataProvider.getReadableWaveletData(waveletName);
        LOG.fine("commit " + version + " " + waveletData.getVersion());
        if (waveletData.getVersion() == version.getVersion()) {
          updateIndex(waveletData);
        }
      } catch (WaveServerException e) {
        LOG.log(Level.SEVERE, "Failed to update index for " + waveletName, e);
        throw e;
      }
      return null;
    }
  });
  executor.execute(task);
}
 

public ListenableFuture<?> acquireRequestPermit()
{
    long delayNanos = backoff.getBackoffDelayNanos();

    if (delayNanos == 0) {
        return Futures.immediateFuture(null);
    }

    ListenableFutureTask<Object> futureTask = ListenableFutureTask.create(() -> null);
    scheduledExecutor.schedule(futureTask, delayNanos, NANOSECONDS);
    return futureTask;
}
 

@Override
public ListenableFuture<V> reload(final K key, final V oldValue) {
    
    if (log.isTraceEnabled())
        log.trace("Reload the cache");
    
    ListenableFutureTask<V> task = null;
    if (!lazy) {
        if (log.isTraceEnabled())
            log.trace("Reloading synchronously");
        try {
            build(null);
            
            return Futures.immediateCheckedFuture(load(key));
            
        } catch (Exception e) {
            log.error(e);
        }
    } else {
        
        task = ListenableFutureTask.create(() -> {
            build(null);
            return load(key);
        });
        
        executor.execute(task);
    }
    
    return task;
    
}
 

public ListenableFuture<Object> uploadChunkBlocks(final BlockRenderLayer layer, final BufferBuilder buffer,
        final RenderChunkSchematicVbo renderChunk, final CompiledChunk compiledChunk, final double distanceSq)
{
    if (Minecraft.getMinecraft().isCallingFromMinecraftThread())
    {
        //if (GuiBase.isCtrlDown()) System.out.printf("uploadChunkBlocks()\n");
        if (OpenGlHelper.useVbo())
        {
            this.uploadVertexBuffer(buffer, renderChunk.getVertexBufferByLayer(layer.ordinal()));
        }
        else
        {
            this.uploadDisplayList(buffer, ((RenderChunkSchematicList) renderChunk).getDisplayList(layer, compiledChunk), renderChunk);
        }

        buffer.setTranslation(0.0D, 0.0D, 0.0D);

        return Futures.<Object>immediateFuture(null);
    }
    else
    {
        ListenableFutureTask<Object> futureTask = ListenableFutureTask.<Object>create(new Runnable()
        {
            @Override
            public void run()
            {
                ChunkRenderDispatcherLitematica.this.uploadChunkBlocks(layer, buffer, renderChunk, compiledChunk, distanceSq);
            }
        }, null);

        synchronized (this.queueChunkUploads)
        {
            this.queueChunkUploads.add(new ChunkRenderDispatcherLitematica.PendingUpload(futureTask, distanceSq));
            return futureTask;
        }
    }
}
 

public ListenableFuture<Object> uploadChunkOverlay(final OverlayRenderType type, final BufferBuilder buffer,
        final RenderChunkSchematicVbo renderChunk, final CompiledChunkSchematic compiledChunk, final double distanceSq)
{
    if (Minecraft.getMinecraft().isCallingFromMinecraftThread())
    {
        //if (GuiBase.isCtrlDown()) System.out.printf("uploadChunkOverlay()\n");
        if (OpenGlHelper.useVbo())
        {
            this.uploadVertexBuffer(buffer, renderChunk.getOverlayVertexBuffer(type));
        }
        else
        {
            this.uploadDisplayList(buffer, ((RenderChunkSchematicList) renderChunk).getOverlayDisplayList(type, compiledChunk), renderChunk);
        }

        buffer.setTranslation(0.0D, 0.0D, 0.0D);

        return Futures.<Object>immediateFuture(null);
    }
    else
    {
        ListenableFutureTask<Object> futureTask = ListenableFutureTask.<Object>create(new Runnable()
        {
            @Override
            public void run()
            {
                ChunkRenderDispatcherLitematica.this.uploadChunkOverlay(type, buffer, renderChunk, compiledChunk, distanceSq);
            }
        }, null);

        synchronized (this.queueChunkUploads)
        {
            this.queueChunkUploads.add(new ChunkRenderDispatcherLitematica.PendingUpload(futureTask, distanceSq));
            return futureTask;
        }
    }
}
 

/**
 * @reason Replaces the vanilla F3 + C logic to immediately crash rather than requiring
 * that the buttons are pressed for 6 seconds and add more crash types:
 * F3 + C - Client crash
 * Alt + F3 + C - Integrated server crash
 * Shift + F3 + C - Scheduled client task exception
 * Alt + Shift + F3 + C - Scheduled server task exception
 * <p>
 * Note: Left Shift + F3 + C doesn't work on most keyboards, see http://keyboardchecker.com/
 * Use the right shift instead.
 * <p>
 * TODO: Make this work outside the game too (for example on the main menu).
 */
@Redirect(method = "runTickKeyboard", at = @At(value = "FIELD", target = "Lnet/minecraft/client/Minecraft;debugCrashKeyPressTime:J", ordinal = 0))
private long checkForF3C(Minecraft mc) {
    // Fix: Check if keys are down before checking time pressed
    if (Keyboard.isKeyDown(Keyboard.KEY_F3) && Keyboard.isKeyDown(Keyboard.KEY_C)) {
        debugCrashKeyPressTime = getSystemTime();
        actionKeyF3 = true;
    } else {
        debugCrashKeyPressTime = -1L;
    }

    if (debugCrashKeyPressTime > 0L) {
        if (getSystemTime() - debugCrashKeyPressTime >= 0) {
            if (GuiScreen.isShiftKeyDown()) {
                if (GuiScreen.isAltKeyDown()) {
                    if (integratedServerIsRunning) integratedServer.addScheduledTask(() -> {
                        throw new ReportedException(new CrashReport("Manually triggered server-side scheduled task exception", new Throwable()));
                    });
                } else {
                    scheduledTasks.add(ListenableFutureTask.create(() -> {
                        throw new ReportedException(new CrashReport("Manually triggered client-side scheduled task exception", new Throwable()));
                    }));
                }
            } else {
                if (GuiScreen.isAltKeyDown()) {
                    if (integratedServerIsRunning) crashIntegratedServerNextTick = true;
                } else {
                    throw new ReportedException(new CrashReport("Manually triggered client-side debug crash", new Throwable()));
                }
            }
        }
    }
    return -1;
}
 

public static final PhotosLibraryUploadApiFuture create(
    PhotosLibraryUploadCallable uploadCallable, ClientContext clientContext) {
  PhotosLibraryUploadApiFuture future =
      new PhotosLibraryUploadApiFuture(ListenableFutureTask.create(uploadCallable));
  clientContext.getExecutor().execute(future.futureTask);
  return future;
}
 

protected synchronized ListenableFuture<Void> performAddConnection ( final String id, final ConnectionConfiguration configuration )
{
    logger.debug ( "adding connection - id: {}, cfg: {}", id, configuration );

    if ( this.executor == null )
    {
        logger.debug ( "Hive is not started" );
        return Futures.immediateFailedFuture ( new IllegalStateException ( "Hive is not started" ) );
    }

    final ListenableFutureTask<Void> task = ListenableFutureTask.create ( new Callable<Void> () {

        @Override
        public Void call () throws Exception
        {
            try
            {
                handleAddConnection ( id, configuration );
            }
            catch ( final Exception e )
            {
                logger.warn ( "Failed to create connection", e );
                throw new InvocationTargetException ( e );
            }
            return null;
        }
    } );
    this.executor.execute ( task );
    return task;
}
 

@Override
public ListenableFuture<DocumentHolder> reload(final String key, DocumentHolder oldValue) throws Exception {
    URL url = SERVLET_CONTEXT.getResource(key);
    if (oldValue.isValid(url)) {
        LOGGER.debug("Keeping {} in cache", url);
        return Futures.immediateFuture(oldValue);
    }
    ListenableFutureTask<DocumentHolder> task = ListenableFutureTask.create(() -> load(key));
    executor.execute(task);
    return task;
}
 

@Override
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    ListenableFutureTask<T> ret = impl instanceof SubThreadPoolExecutor
            ? (ListenableFutureTask) ((SubThreadPoolExecutor) impl).newTaskFor(runnable, value)
            : ListenableFutureTask.create(runnable, value);
    ret.addListener(new Runnable() {
        @Override
        public void run() {
            releaseThread();
        }
    }, MoreExecutors.sameThreadExecutor());
    return ret;
}
 

@Override
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    ListenableFutureTask<T> ret = impl instanceof SubThreadPoolExecutor
            ? (ListenableFutureTask) ((SubThreadPoolExecutor) impl).newTaskFor(callable)
            : ListenableFutureTask.create(callable);
    ret.addListener(new Runnable() {
        @Override
        public void run() {
            releaseThread();
        }
    }, MoreExecutors.sameThreadExecutor());
    return ret;
}
 

/**
 * Loops the main thread until the app goes idle.
 *
 * <p>Same as {@link Espresso#onIdle()}, but takes an additional {@link Callable} as parameter,
 * which is executed after the app goes idle.
 *
 * @param action callable executed when the app goes idle.
 * @return the computed result of the action callable
 * @throws AppNotIdleException when app does not go Idle within the master policies timeout
 */
public static <T> T onIdle(Callable<T> action) {
  Executor mainThreadExecutor = BASE.mainThreadExecutor();
  ListenableFutureTask<Void> idleFuture =
      ListenableFutureTask.create(
          new Runnable() {
            @Override
            public void run() {
              BASE.uiController().loopMainThreadUntilIdle();
            }
          },
          null);
  FutureTask<T> actionTask = new FutureTask<>(action);
  idleFuture.addListener(actionTask, mainThreadExecutor);
  mainThreadExecutor.execute(idleFuture);
  BASE.controlledLooper().drainMainThreadUntilIdle();

  try {
    idleFuture.get();
    return actionTask.get();
  } catch (InterruptedException ie) {
    throw new RuntimeException(ie);
  } catch (ExecutionException ee) {
    if (ee.getCause() instanceof AppNotIdleException) {
      throw (AppNotIdleException) ee.getCause();
    } else {
      throw new RuntimeException(ee);
    }
  }
}
 

@Override
public ListenableFuture<Void> persist(final HashedVersion version) {
  Preconditions.checkArgument(version.getVersion() > 0,
      "Cannot persist non-positive version %s", version);
  Preconditions.checkArgument(isDeltaBoundary(version),
      "Version to persist %s matches no delta", version);
  synchronized (persistLock) {
    if (latestVersionToPersist != null) {
      // There's a persist task in flight.
      if (version.getVersion() <= latestVersionToPersist.getVersion()) {
        LOG.info("Attempt to persist version " + version
            + " smaller than last version requested " + latestVersionToPersist);
      } else {
        latestVersionToPersist = version;
      }
      if (nextPersistTask == null) {
        nextPersistTask = ListenableFutureTask.<Void>create(persisterTask);
      }
      return nextPersistTask;
    } else {
      latestVersionToPersist = version;
      ListenableFutureTask<Void> resultTask = ListenableFutureTask.<Void>create(persisterTask);
      persistExecutor.execute(resultTask);
      return resultTask;
    }
  }
}
 

/**
 * Returns a future whose result is the ids of stored wavelets in the given wave.
 * Any failure is reported as a {@link PersistenceException}.
 */
private static ListenableFuture<ImmutableSet<WaveletId>> lookupWavelets(
    final WaveId waveId, final WaveletStore<?> waveletStore, Executor lookupExecutor) {
  ListenableFutureTask<ImmutableSet<WaveletId>> task =
      ListenableFutureTask.create(
         new Callable<ImmutableSet<WaveletId>>() {
           @Override
           public ImmutableSet<WaveletId> call() throws PersistenceException {
             return waveletStore.lookup(waveId);
           }
         });
  lookupExecutor.execute(task);
  return task;
}
 

@Nonnull
@Override
public ListenableFuture<byte[]> submit(@Nonnull ServerQueryRequest queryRequest) {
  if (!isRunning) {
    return immediateErrorResponse(queryRequest, QueryException.SERVER_SCHEDULER_DOWN_ERROR);
  }
  queryRequest.getTimerContext().startNewPhaseTimer(ServerQueryPhase.SCHEDULER_WAIT);
  QueryExecutorService queryExecutorService = resourceManager.getExecutorService(queryRequest, null);
  ListenableFutureTask<byte[]> queryTask = createQueryFutureTask(queryRequest, queryExecutorService);
  resourceManager.getQueryRunners().submit(queryTask);
  return queryTask;
}
 

@Override
public ListenableFuture<Long> reload(final String dataset, Long preMaxDataTime) {
  ListenableFutureTask<Long> reloadTask = ListenableFutureTask.create(new Callable<Long>() {
    @Override public Long call() throws Exception {
      return DatasetMaxDataTimeCacheLoader.this.load(dataset);
    }
  });
  reloadExecutor.execute(reloadTask);
  LOGGER.info("Passively refreshing max data time of collection: {}", dataset);
  return reloadTask;
}