/**
    * Copyright 2010-2014 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.opensource.org/licenses/ecl2.php
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.common.util.execute.impl;
  
  import static com.google.common.base.Optional.absent;
  import static com.google.common.base.Stopwatch.createStarted;
  import static com.google.common.collect.Lists.newArrayList;
  import static java.lang.Math.ceil;
  import static java.lang.Math.max;
  import static org.kuali.common.util.FormatUtils.getTime;
  import static org.kuali.common.util.base.Precondition.checkNotNull;
  import static org.kuali.common.util.log.Loggers.newLogger;
  
  import java.lang.Thread.UncaughtExceptionHandler;
  import java.util.List;
  
  import org.kuali.common.util.base.Threads;
  import org.kuali.common.util.execute.Executable;
  import org.slf4j.Logger;
  
  import com.google.common.base.Optional;
  import com.google.common.base.Stopwatch;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.Lists;
  
  /**
   * Create a new thread for each executable in the list and run them all concurrently.
   */
  public final class ConcurrentExecutables implements Executable, UncaughtExceptionHandler {
  
  	private static final Logger logger = newLogger();
  
  	private final ImmutableList<Executable> executables;
  	private final boolean skip;
  	private final boolean timed;
  	private final Optional<Integer> maxThreads;
  
  	// If any thread throws an exception, this gets filled in
  	private Optional<IllegalStateException> uncaughtException = absent();
  
  	public static void execute(Executable... executables) {
  		create(executables).execute();
  	}
  
  	public static void execute(List<Executable> executables) {
  		create(executables).execute();
  	}
  
  	public static void executeConcurrently(List<Executable> executables, int maxThreads) {
  		builder(executables).withMaxThreads(maxThreads).build().execute();
  	}
  
  	public static ConcurrentExecutables create(Executable... executables) {
  		return builder(executables).build();
  	}
  
  	public static ConcurrentExecutables create(List<Executable> executables) {
  		return builder(executables).build();
  	}
  
  	public static Builder builder(Executable... executables) {
  		return new Builder(executables);
  	}
  
  	public static Builder builder(List<Executable> executables) {
  		return new Builder(executables);
  	}
  
  	public static class Builder implements org.apache.commons.lang3.builder.Builder<ConcurrentExecutables> {
  
  		// Required
  		private final List<Executable> executables;
  
  		// Optional
  		private boolean skip = false;
  		private boolean timed = false;
  		private Optional<Integer> maxThreads = absent();
  
  		public Builder(Executable... executables) {
  			this(ImmutableList.copyOf(executables));
  		}
  
  		public Builder(List<Executable> executables) {
  			this.executables = ImmutableList.copyOf(executables);
  		}
  
 		public Builder timed(boolean timed) {
 			this.timed = timed;
 			return this;
 		}
 
 		public Builder skip(boolean skip) {
 			this.skip = skip;
 			return this;
 		}
 
 		public Builder withMaxThreads(int maxThreads) {
 			this.maxThreads = Optional.of(maxThreads);
 			return this;
 		}
 
 		@Override
 		public ConcurrentExecutables build() {
 			ConcurrentExecutables instance = new ConcurrentExecutables(this);
 			validate(instance);
 			return instance;
 		}
 
 		private static void validate(ConcurrentExecutables instance) {
 			checkNotNull(instance.executables, "executables");
 			checkNotNull(instance.uncaughtException, "uncaughtException");
 		}
 	}
 
 	private ConcurrentExecutables(Builder builder) {
 		this.executables = ImmutableList.copyOf(builder.executables);
 		this.skip = builder.skip;
 		this.timed = builder.timed;
 		this.maxThreads = builder.maxThreads;
 	}
 
 	@Override
 	public void execute() {
 		if (skip) {
 			logger.info("Skipping execution of {} executables", executables.size());
 			return;
 		}
 		List<Thread> threads = getThreads(executables, maxThreads);
 		Stopwatch stopwatch = createStarted();
 		Threads.start(threads);
 		Threads.join(threads);
 		if (uncaughtException.isPresent()) {
 			throw uncaughtException.get();
 		}
 		if (timed) {
 			logger.info("------------------------------------------------------------------------");
 			logger.info("Total Time: {} (Wall Clock)", getTime(stopwatch));
 			logger.info("------------------------------------------------------------------------");
 		}
 	}
 
 	protected List<Thread> getThreads(List<Executable> executables, Optional<Integer> maxThreads) {
 		int max = maxThreads.isPresent() ? maxThreads.get() : executables.size();
 		int size = (int) max(ceil(executables.size() / (max * 1D)), 1);
 		List<List<Executable>> partitions = Lists.partition(executables, size);
 		List<Thread> threads = newArrayList();
 		for (List<Executable> partition : partitions) {
 			Runnable runnable = new ExecutablesRunner(partition);
 			Thread thread = new Thread(runnable, "Executable");
 			thread.setUncaughtExceptionHandler(this);
 			threads.add(thread);
 		}
 		return threads;
 	}
 
 	@Override
 	public synchronized void uncaughtException(Thread thread, Throwable uncaughtException) {
 		// Only report back on the first uncaught exception reported by any thread
 		// Any exceptions after the first one get ignored
 		if (!this.uncaughtException.isPresent()) {
 			String context = "Exception in thread [" + thread.getId() + ":" + thread.getName() + "]";
 			this.uncaughtException = Optional.of(new IllegalStateException(context, uncaughtException));
 		}
 	}
 
 	public ImmutableList<Executable> getExecutables() {
 		return executables;
 	}
 
 	public boolean isSkip() {
 		return skip;
 	}
 
 	public boolean isTimed() {
 		return timed;
 	}
 
 	public Optional<IllegalStateException> getUncaughtException() {
 		return uncaughtException;
 	}
 
 }