package br.com.leonardoz.features.executors;

import java.util.LinkedList;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * Thread creation is expensive and difficult to manage.
 * 
 * Executors help us to decouple task submission from execution.
 * 
 * We have 6 types of executors:
 * 
 * - Single Thread Executor: Uses a single worker to process tasks.
 * 
 * - Cached Thread Pool: Unbounded thread limit, good performance for long
 * running tasks.
 * 
 * - Fixed Thread Pool: Bounded thread limit, maintains the same thread pool
 * size.
 * 
 * - Scheduled Thread Pool: Bounded thread limit, used for delayed tasks.
 * 
 * - Single-Thread Scheduled Pool: Similar to the scheduled thread pool, but 
 * single-threaded, with only one active task at the time. 
 * 
 * - Work-Stealing Thread Pool: Based on Fork/Join Framework, applies the
 * work-stealing algorithm for balancing tasks, with available processors as a
 * paralellism level.
 * 
 * And 2 types of tasks:
 * 
 * - execute: Executes without giving feedback. Fire-and-forget.
 * 
 * - submit: Returns a FutureTask.
 * 
 * ThreadPools: Used by the executors described above. ThreadPoolExecutor can be
 * used to create custom Executors.
 * 
 * shutdown() -> Waits for tasks to terminate and release resources.
 * shutdownNow() -> Try to stops all executing tasks and returns a list of not
 * executed tasks.
 *
 */
public class UsingExecutors {

	public static void usingSingleThreadExecutor() {
		System.out.println("=== SingleThreadExecutor ===");
		var singleThreadExecutor = Executors.newSingleThreadExecutor();
		singleThreadExecutor.execute(() -> System.out.println("Print this."));
		singleThreadExecutor.execute(() -> System.out.println("and this one to."));
		singleThreadExecutor.shutdown();
		try {
			singleThreadExecutor.awaitTermination(4, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");
	}

	public static void usingCachedThreadPool() {
		System.out.println("=== CachedThreadPool ===");
		var cachedThreadPool = Executors.newCachedThreadPool();
		var uuids = new LinkedList<Future<UUID>>();
		for (int i = 0; i < 10; i++) {
			var submittedUUID = cachedThreadPool.submit(() -> {
				var randomUUID = UUID.randomUUID();
				System.out.println("UUID " + randomUUID + " from " + Thread.currentThread().getName());
				return randomUUID;
			});
			uuids.add(submittedUUID);
		}
		cachedThreadPool.execute(() -> uuids.forEach((f) -> {
			try {
				System.out.println("Result " + f.get() + " from thread " + Thread.currentThread().getName());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}));
		cachedThreadPool.shutdown();
		try {
			cachedThreadPool.awaitTermination(4, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");

	}

	public static void usingFixedThreadPool() {
		System.out.println("=== FixedThreadPool ===");
		var fixedPool = Executors.newFixedThreadPool(4);
		var uuids = new LinkedList<Future<UUID>>();
		for (int i = 0; i < 20; i++) {
			var submitted = fixedPool.submit(() -> {
				var randomUUID = UUID.randomUUID();
				System.out.println("UUID " + randomUUID + " from " + Thread.currentThread().getName());
				return randomUUID;
			});
			uuids.add(submitted);
		}
		fixedPool.execute(() -> uuids.forEach((f) -> {
			try {
				System.out.println("Result " + f.get() + " from " + Thread.currentThread().getName());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}));
		fixedPool.shutdown();
		try {
			fixedPool.awaitTermination(4, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");
	}

	public static void usingScheduledThreadPool() {
		System.out.println("=== ScheduledThreadPool ===");
		var scheduledThreadPool = Executors.newScheduledThreadPool(4);
		scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
		scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("2) Print every 2s"), 0, 2, TimeUnit.SECONDS);
		scheduledThreadPool.scheduleWithFixedDelay(() -> System.out.println("3) Print every 2s delay"), 0, 2,
				TimeUnit.SECONDS);

		try {
			scheduledThreadPool.awaitTermination(6, TimeUnit.SECONDS);
			scheduledThreadPool.shutdown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");
	}
	
	public static void usingSingleTreadScheduledExecutor() {
		System.out.println("=== SingleThreadScheduledThreadPool ===");
		var singleThreadScheduler = Executors.newSingleThreadScheduledExecutor();
		singleThreadScheduler.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
		singleThreadScheduler.scheduleWithFixedDelay(() -> System.out.println("2) Print every 2s delay"), 0, 2,
				TimeUnit.SECONDS);

		try {
			singleThreadScheduler.awaitTermination(6, TimeUnit.SECONDS);
			singleThreadScheduler.shutdown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");
		
	}

	public static void usingWorkStealingThreadPool() {
		System.out.println("=== WorkStealingThreadPool ===");
		var workStealingPool = Executors.newWorkStealingPool();

		workStealingPool.execute(() -> System.out.println("Prints normally"));

		Callable<UUID> generatesUUID = UUID::randomUUID;
		var severalUUIDsTasks = new LinkedList<Callable<UUID>>();
		for (int i = 0; i < 20; i++) {
			severalUUIDsTasks.add(generatesUUID);
		}

		try {
			var futureUUIDs = workStealingPool.invokeAll(severalUUIDsTasks);
			for (var future : futureUUIDs) {
				if (future.isDone()) {
					var uuid = future.get();
					System.out.println("New UUID :" + uuid);
				}
			}
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
		try {
			workStealingPool.awaitTermination(6, TimeUnit.SECONDS);
			workStealingPool.shutdown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("\n\n");
	}

	

	public static void main(String[] args) {
		usingSingleThreadExecutor();
		usingCachedThreadPool();
		usingFixedThreadPool();
		usingScheduledThreadPool();
		usingSingleTreadScheduledExecutor();
		usingWorkStealingThreadPool();
	}
}