/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package sk.baka.ambient;
  
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.RejectedExecutionException;
  import java.util.concurrent.ThreadFactory;
  import java.util.concurrent.atomic.AtomicBoolean;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import sk.baka.ambient.commons.NullArgumentException;
  import android.util.Log;
  
  /***
   * <p>
   * Able to execute multiple long operations running simultaneously in the
   * background. Accepts {@link Runnable} task implementations. The tasks will run
   * in low-priority daemon thread. Thread-safe.
   * </p>
   * <p>
   * Tasks are differentiated based on a task type object. At most a single
   * instance of a task of given type may be submitted - multiple submissions of
   * tasks having the same task type will do nothing unless there is no such task
   * in executor's queue or already being executed. The task type object must
   * comply the contract for a {@link Map} key.
   * </p>
   * <p>
   * A task must periodically check for its {@link Thread#isInterrupted()
   * interrupt} status. If it is interrupted, it should terminate ASAP. It may do
   * so by throwing an Exception - exceptions are not reported when the process is
   * interrupted.
   * </p>
   * <p>
   * Uncaught exceptions thrown by tasks are reported using
   * {@link AmbientApplication#error(Class, boolean, String, Throwable)}.
   * </p>
   * <p>
   * The executor initially starts in offline mode. Use
   * {@link #setOffline(boolean)} to change the mode.
   * </p>
   * <p>
   * There is no support for mutually exclusive tasks. If you need this
   * functionality you have to implement it yourself, for example by synchronizing
   * on the same object instance.
   * </p>
   * 
   * @author Martin Vysny
   */
  public final class BackgroundOpExecutor implements ThreadFactory,
  		IBackgroundTask {
  	/***
  	 * Describes a single task.
  	 * 
  	 * @author mvy
  	 */
  	private static class TaskInfo {
  		/***
  		 * The current task name.
  		 */
  		public volatile String name;
  		/***
  		 * Current progress of the task.
  		 */
  		public volatile int progress = 0;
  		/***
  		 * The maximum progress.
  		 */
  		public volatile int maxProgress = 100;
  
  		/***
  		 * The thread the task is executed in. <code>null</code> if the task is
  		 * not currently being run.
  		 */
  		public volatile Thread thread;
  		
  		/***
  		 * <code>true</code> if the task was canceled using the {@link BackgroundOpExecutor#cancel(Object)} method.
 		 */
 		public volatile boolean canceled = false;
 	}
 
 	/***
 	 * Contains set of scheduled or executing tasks. Maps the task type to the
 	 * task name.
 	 */
 	private final ConcurrentMap<Object, TaskInfo> scheduledTasks = new ConcurrentHashMap<Object, TaskInfo>();
 
 	/***
 	 * <p>
 	 * Schedules given task for execution. Does nothing if the task is rejected
 	 * to be submitted. Task may be rejected for these reasons:
 	 * </p>
 	 * <ul>
 	 * <li>it is already scheduled for execution or executed</li>
 	 * <li>Processing of online task was requested while in offline mode</li>
 	 * </ul>
 	 * 
 	 * @param task
 	 *            the task to schedule, must not be <code>null</code>.
 	 * @param taskType
 	 *            the task type, must not be <code>null</code>.
 	 * @param online
 	 *            if <code>true</code> then this task processes some online
 	 *            content.
 	 * @param name
 	 *            the displayable task name. A grammar construct of <code>name +
 	 *            "failed"</code> should be a meaningful text.
 	 * @return <code>true</code> if the task was scheduled, <code>false</code>
 	 *         if it was rejected.
 	 */
 	public boolean schedule(final Runnable task, final Object taskType,
 			final boolean online, final String name) {
 		if (name == null) {
 			throw new NullArgumentException("name");
 		}
 		if (taskType == null) {
 			throw new NullArgumentException("taskType");
 		}
 		final TaskInfo info = new TaskInfo();
 		info.name = name;
 		if (scheduledTasks.putIfAbsent(taskType, info) != null) {
 			return false;
 		}
 		// okay, we have a new task. Schedule it.
 		boolean scheduled = false;
 		executorLock.readLock().lock();
 		try {
 			final ExecutorService executor;
 			if (online) {
 				executor = onlineExecutor;
 				if (executor == null) {
 					return false;
 				}
 			} else {
 				executor = offlineExecutor;
 			}
 			try {
 				executor.execute(new ProtectedRunnable(task, info, taskType));
 			} catch (RejectedExecutionException ex) {
 				// no luck. we are probably terminating, or someone switched to
 				// offline mode.
 				return false;
 			}
 			scheduled = true;
 			return true;
 		} finally {
 			if (!scheduled) {
 				scheduledTasks.remove(taskType);
 			}
 			executorLock.readLock().unlock();
 		}
 	}
 
 	private final AtomicBoolean offline = new AtomicBoolean(true);
 
 	/***
 	 * Checks if this task is already scheduled.
 	 * 
 	 * @param taskType
 	 *            the task handle to check, must not be <code>null</code>.
 	 * @return <code>true</code> if it is scheduled.
 	 */
 	public boolean isScheduledOrExecuted(final Object taskType) {
 		if (taskType == null) {
 			throw new NullArgumentException("taskType");
 		}
 		return scheduledTasks.containsKey(taskType);
 	}
 
 	private final ReadWriteLock executorLock = new ReentrantReadWriteLock();
 
 	/***
 	 * The online tasks executor.
 	 */
 	private ExecutorService onlineExecutor = null;
 
 	/***
 	 * Executes tasks that does not require Internet access.
 	 */
 	private ExecutorService offlineExecutor = Executors
 			.newCachedThreadPool(this);
 
 	/***
 	 * Sets the online/offline state of the executor. During the offline period
 	 * the executor rejects online tasks.
 	 * 
 	 * @param offline
 	 *            if <code>true</code> then the executor sets itself as offline
 	 *            and all pending online tasks are terminated.
 	 */
 	public void setOffline(final boolean offline) {
 		if (!this.offline.compareAndSet(!offline, offline)) {
 			return;
 		}
 		executorLock.writeLock().lock();
 		try {
 			if (offline) {
 				// terminate the online task executor
 				onlineExecutor.shutdownNow();
 				onlineExecutor = null;
 			} else {
 				if (offlineExecutor.isShutdown()) {
 					return;
 				}
 				onlineExecutor = Executors.newCachedThreadPool(this);
 			}
 		} finally {
 			executorLock.writeLock().unlock();
 		}
 	}
 
 	private final AtomicInteger threadId = new AtomicInteger();
 
 	public Thread newThread(Runnable r) {
 		final Thread result = new Thread(r, "backgroundOp-"
 				+ threadId.getAndIncrement());
 		result.setPriority(Thread.MIN_PRIORITY);
 		result.setDaemon(true);
 		return result;
 	}
 
 	/***
 	 * Immediately stops all running/pending tasks.
 	 */
 	public void stopAllTasks() {
 		executorLock.writeLock().lock();
 		try {
 			offlineExecutor.shutdownNow();
 			offlineExecutor = Executors.newCachedThreadPool(this);
 			if (onlineExecutor != null) {
 				onlineExecutor.shutdownNow();
 				onlineExecutor = Executors.newCachedThreadPool(this);
 			}
 		} finally {
 			executorLock.writeLock().unlock();
 		}
 	}
 
 	/***
 	 * Immediately terminates the executor and all pending tasks. The executor
 	 * will reject all submitted tasks from now on.
 	 */
 	public void terminate() {
 		executorLock.readLock().lock();
 		try {
 			offlineExecutor.shutdownNow();
 			if (onlineExecutor != null) {
 				onlineExecutor.shutdownNow();
 			}
 		} finally {
 			executorLock.readLock().unlock();
 		}
 	}
 
 	private final String failed = AmbientApplication.getInstance().getString(
 			R.string.failed);
 
 	/***
 	 * This class wraps given runnable and takes care of counting
 	 * scheduled/running tasks instances and handling exceptions.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private class ProtectedRunnable implements Runnable {
 		private final Runnable r;
 		private final TaskInfo task;
 		private final Object taskType;
 
 		/***
 		 * Creates new instance.
 		 * 
 		 * @param r
 		 *            the wrapped runnable.
 		 * @param task
 		 *            this task info.
 		 * @param taskType
 		 *            this task type.
 		 */
 		public ProtectedRunnable(final Runnable r, final TaskInfo task,
 				final Object taskType) {
 			this.r = r;
 			this.task = task;
 			this.taskType = taskType;
 		}
 
 		public void run() {
 			if (task.canceled) {
 				return;
 			}
 			// synchronize on the executor instance to prevent reporting
 			// decreasing numbers. This could happen when one thread increments
 			// the value and enters the fireEvent method after another thread
 			// incremented the value but still did not entered the fireEvent.
 			synchronized (BackgroundOpExecutor.this) {
 				taskInfo.set(task);
 				fireEvent();
 			}
 			try {
 				task.thread = Thread.currentThread();
 				try {
 					if (task.canceled) {
 						return;
 					}
 					r.run();
 				} finally {
 					task.thread = null;
 				}
 			} catch (final Throwable e) {
 				if (Thread.currentThread().isInterrupted()) {
 					Log.i(r.getClass().getSimpleName(), "Interrupted: "
 							+ e.getMessage(), e);
 				} else {
 					AmbientApplication.getInstance().error(r.getClass(), true,
 							task.name + " " + failed, e);
 				}
 			} finally {
 				scheduledTasks.remove(taskType);
 				taskInfo.set(null);
 				// synchronize on the executor instance to prevent reporting
 				// increasing numbers
 				fireEvent();
 			}
 		}
 	}
 
 	private final ThreadLocal<TaskInfo> taskInfo = new ThreadLocal<TaskInfo>();
 
 	private synchronized void fireEvent() {
 		String randomName = null;
 		int taskCount = 0;
 		int progress = 0;
 		int maxProgress = 0;
 		for (final TaskInfo info : scheduledTasks.values()) {
 			taskCount++;
 			if (randomName == null) {
 				randomName = info.name;
 			}
 			progress += info.progress;
 			maxProgress += info.maxProgress;
 		}
 		if (maxProgress <= 0) {
 			maxProgress = 100;
 		}
 		AmbientApplication.getInstance().getBus().getInvocator(
 				IBackgroundTask.class, true).backgroundTask(taskCount,
 				randomName, progress, maxProgress);
 	}
 
 	/***
 	 * Sets a progress of the current task. Must be invoked from a task
 	 * {@link Runnable}.
 	 * 
 	 * @param taskCount
 	 *            unused, ignored.
 	 * @param name
 	 *            a new name for the task.
 	 * @param progress
 	 *            current task progress.
 	 * @param maxProgress
 	 *            maximum progress.
 	 */
 	public void backgroundTask(int taskCount, String name, int progress,
 			int maxProgress) {
 		final TaskInfo info = taskInfo.get();
 		if (info == null) {
 			throw new IllegalStateException("Must be invoked from a task");
 		}
 		info.name = name;
 		info.progress = progress < 0 ? 0 : progress;
 		info.maxProgress = maxProgress < info.progress ? info.progress
 				: maxProgress;
 		fireEvent();
 	}
 
 	/***
 	 * Cancels given task. Does nothing if no such task is running.
 	 * 
 	 * @param taskType
 	 *            the task type, must not be <code>null</code>.
 	 */
 	public void cancel(final Object taskType) {
 		final TaskInfo info = scheduledTasks.get(taskType);
 		if (info == null) {
 			return;
 		}
 		info.canceled = true;
 		final Thread t = info.thread;
 		if (t != null) {
 			t.interrupt();
 		}
 	}
 }