package org.warp.commonutils.concurrency.executor;

import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import org.jetbrains.annotations.Nullable;

public interface BoundedExecutorService extends ExecutorService {

	@Deprecated
	static ExecutorService createUnbounded(
			boolean resizable,
			int corePoolSize,
			int maxPoolSize,
			long keepAliveTime,
			TimeUnit unit,
			@Nullable BiConsumer<Boolean, Integer> queueSizeStatus) {
		return create(0, corePoolSize, maxPoolSize, keepAliveTime, unit, Executors.defaultThreadFactory(), queueSizeStatus);
	}

	static ExecutorService createUnbounded(
			boolean resizable,
			int corePoolSize,
			int maxPoolSize,
			long keepAliveTime,
			TimeUnit unit,
			ThreadFactory threadFactory,
			@Nullable BiConsumer<Boolean, Integer> queueSizeStatus) {
		return create(0, corePoolSize, maxPoolSize, keepAliveTime, unit, threadFactory, Duration.ofDays(100000), queueSizeStatus);
	}

	@Deprecated
	static BoundedExecutorService create(
			int maxQueueSize,
			int corePoolSize,
			int maxPoolSize,
			long keepAliveTime,
			TimeUnit unit,
			@Nullable BiConsumer<Boolean, Integer> queueSizeStatus) {
		return create(maxQueueSize, corePoolSize, maxPoolSize, keepAliveTime, unit, Executors.defaultThreadFactory(), queueSizeStatus);
	}

	static BoundedExecutorService create(
			int maxQueueSize,
			int corePoolSize,
			int maxPoolSize,
			long keepAliveTime,
			TimeUnit unit,
			ThreadFactory threadFactory,
			@Nullable BiConsumer<Boolean, Integer> queueSizeStatus) {
		return create(maxQueueSize, corePoolSize, maxPoolSize, keepAliveTime, unit, threadFactory, Duration.ofDays(100000), queueSizeStatus);
	}

	static BoundedExecutorService create(
			int maxQueueSize,
			int corePoolSize,
			int maxPoolSize,
			long keepAliveTime,
			TimeUnit unit,
			ThreadFactory threadFactory,
			Duration queueItemTtl,
			@Nullable BiConsumer<Boolean, Integer> queueSizeStatus) {
		var queue = new LinkedBlockingQueue<Runnable>();
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,
				maxPoolSize,
				keepAliveTime,
				unit,
				queue,
				threadFactory
		);
		return new BlockingOnFullQueueExecutorServiceDecorator(threadPoolExecutor,
				maxQueueSize,
				queueItemTtl,
				queue::size,
				queueSizeStatus
		);
	}
}