import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MaxMain {
    static final int ARRAY_SIZE = 100000000;
    //Try 1, 2, 4, 10, 100
    static final int NR_OF_THREADS = 2;
    static final int NR_OF_TASKS = NR_OF_THREADS;

    public static void main(String[] args){
        System.out.println("Maximum number");
        System.out.println(" ARRAY_SIZE " + ARRAY_SIZE);
        System.out.println(" NR_OF_THREADS " + NR_OF_THREADS);
        System.out.println(" NR_OF_TASKS " + NR_OF_TASKS);

       /*
        * Generating random numbers
        */
        System.out.println("(Generating random numbers, please wait)");
        double[] arr = new double[ARRAY_SIZE];
        for(int i=0; i<arr.length; i++){
            arr[i] = Math.random();
        }

        /*
         * Find the maximum with one thread
         */
        System.out.println("Find the maximum with main thread");
        long singleThreadStart = System.nanoTime();
        double max = Double.MIN_VALUE;
        for(int i=0; i<arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        long singleThreadTime = System.nanoTime() - singleThreadStart;
        System.out.println(" Single thread max: " + max);
        System.out.println(" Single thread time: " + singleThreadTime + " ns");
        System.out.println(" Single thread time: " + singleThreadTime/1000000 + " ms");

        /*
         * Find the maximum with multiple Threads
         */
        System.out.println("Find the maximum with multiple Threads");
        long multipleThreadsStart = System.nanoTime();
        ArrayList<FindMaxThread> findMaxThreads = new ArrayList<>();
        for(int i=0; i<NR_OF_THREADS; i++){
            int from = i*(arr.length/NR_OF_THREADS);
            int to = (i+1)*(arr.length/NR_OF_THREADS);
            FindMaxThread findMaxThread = new FindMaxThread(arr, from, to);
            findMaxThreads.add(findMaxThread);
            findMaxThread.start();
        }

        double multipleThreadsMax = Double.MIN_VALUE;
        for(FindMaxThread findMaxThread : findMaxThreads){
            try {
                findMaxThread.join();
                if(findMaxThread.localMax > multipleThreadsMax){
                    multipleThreadsMax = findMaxThread.localMax;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long multipleThreadsTime = System.nanoTime() - multipleThreadsStart;
        System.out.println(" Multiple thread max: " + multipleThreadsMax + (max==multipleThreadsMax ? " (same)" : " (different)"));
        System.out.println(" Multiple thread time: " + multipleThreadsTime + " ns");
        System.out.println(" Multiple thread time: " + multipleThreadsTime/1000000 + " ms");

        /*
         * Find the maximum with ExecutorService
         */
        System.out.println("Find the maximum with ExecutorService");
        //int nrOfThreads = Runtime.getRuntime().availableProcessors();
        ExecutorService executorService = Executors.newFixedThreadPool(NR_OF_THREADS);

        long executorServiceStart = System.nanoTime();
        ArrayList<Future<Double>> findMaxFutures = new ArrayList<>();
        for(int i = 0; i< NR_OF_TASKS; i++){
            int from = i*(arr.length/NR_OF_TASKS);
            int to = (i+1)*(arr.length/NR_OF_TASKS);
            FindMaxCallable findMaxCallable = new FindMaxCallable(arr, from, to);
            Future<Double> findMaxFuture = executorService.submit(findMaxCallable);
            findMaxFutures.add(findMaxFuture);
        }
        //findMaxCallables = executorService.invokeAll( ... )
        double executorServiceMax = Double.MIN_VALUE;
        for(Future<Double> findMaxFuture : findMaxFutures){
            try {
                if( findMaxFuture.get() > executorServiceMax){
                    executorServiceMax = findMaxFuture.get();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        long executorServiceTime = System.nanoTime() - executorServiceStart;
        System.out.println(" ExecutorService max: " + executorServiceMax + (max==executorServiceMax ? " (same)" : " (different)"));
        System.out.println(" ExecutorService time: " + executorServiceTime + " ns");
        System.out.println(" ExecutorService time: " + executorServiceTime/1000000 + " ms");

        executorService.shutdownNow();
    }

}