package org.warp.commonutils.concurrency.executor;

import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jetbrains.annotations.NotNull;

public abstract class ExecutorServiceDecorator implements ExecutorService {
	private ExecutorService executorService;

	public ExecutorServiceDecorator(ExecutorService executorService) {
		this.executorService = Objects.requireNonNull(executorService);
	}

	@Override
	public void shutdown() {
		executorService.shutdown();
	}

	@NotNull
	@Override
	public List<Runnable> shutdownNow() {
		return executorService.shutdownNow();
	}

	@Override
	public boolean isShutdown() {
		return executorService.isShutdown();
	}

	@Override
	public boolean isTerminated() {
		return executorService.isTerminated();
	}

	@Override
	public boolean awaitTermination(long l, @NotNull TimeUnit timeUnit) throws InterruptedException {
		return executorService.awaitTermination(l, timeUnit);
	}

	@NotNull
	@Override
	public <T> Future<T> submit(@NotNull Callable<T> callable) {
		return executorService.submit(callable);
	}

	@NotNull
	@Override
	public <T> Future<T> submit(@NotNull Runnable runnable, T t) {
		return executorService.submit(runnable, t);
	}

	@NotNull
	@Override
	public Future<?> submit(@NotNull Runnable runnable) {
		return executorService.submit(runnable);
	}

	@NotNull
	@Override
	public <T> List<Future<T>> invokeAll(@NotNull Collection<? extends Callable<T>> collection)
			throws InterruptedException {
		return executorService.invokeAll(collection);
	}

	@NotNull
	@Override
	public <T> List<Future<T>> invokeAll(@NotNull Collection<? extends Callable<T>> collection,
			long l,
			@NotNull TimeUnit timeUnit) throws InterruptedException {
		return executorService.invokeAll(collection, l, timeUnit);
	}

	@NotNull
	@Override
	public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> collection)
			throws InterruptedException, ExecutionException {
		return executorService.invokeAny(collection);
	}

	@Override
	public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> collection, long l, @NotNull TimeUnit timeUnit)
			throws InterruptedException, ExecutionException, TimeoutException {
		return executorService.invokeAny(collection, l, timeUnit);
	}

	@Override
	public void execute(@NotNull Runnable runnable) {
		executorService.execute(runnable);
	}
}