/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache 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.apache.org/licenses/LICENSE-2.0
 *
 * 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.apache.wicket.util.thread;

import java.time.Duration;
import java.time.Instant;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Runs a block of code periodically. A <code>Task</code> can be started at a given time in the
 * future and can be a daemon. The block of code will be passed a <code>Log</code> object each time
 * it is run through its <code>ICode</code> interface.
 * <p>
 * If the code block takes longer than the period to run, the next task invocation will occur
 * immediately. In this case, tasks will not occur at precise multiples of the period. For example,
 * if you run a task every 30 seconds, and the first run takes 40 seconds but the second takes 20
 * seconds, your task will be invoked at 0 seconds, 40 seconds and 70 seconds (40 seconds + 30
 * seconds), which is not an even multiple of 30 seconds.
 * <p>
 * In general, this is a simple task class designed for polling activities. If you need precise
 * guarantees, you probably should be using a different task class.
 * 
 * @author Jonathan Locke
 * @since 1.2.6
 */
public final class Task
{
	/** <code>true</code> if the task's thread should be a daemon */
	private boolean isDaemon = true;

	/** <code>true</code> if the task's thread has already started executing */
	private boolean isStarted = false;

	/** the <code>log</code> to give to the user's code */
	private Logger log = null;

	/** the name of this <code>Task</code> */
	private final String name;

	/** the <code>Instant</code> at which the task should start */
	private Instant startTime = Instant.now();

	/** When set the task will stop as soon as possible */
	private boolean stop;

	/** each <code>Task</code> has an associated <code>Thread</code> */
	private Thread thread;

	/**
	 * Constructor.
	 * 
	 * @param name
	 *            the name of this <code>Task</code>
	 */
	public Task(final String name)
	{
		this.name = name;
	}

	/**
	 * Runs this <code>Task</code> at the given frequency. You may only call this method if the task
	 * has not yet been started. If the task is already running, an
	 * <code>IllegalStateException</code> will be thrown.
	 * 
	 * @param frequency
	 *            the frequency at which to run the code
	 * @param code
	 *            the code to run
	 * @throws IllegalStateException
	 *             thrown if task is already running
	 */
	public synchronized final void run(final Duration frequency, final ICode code)
	{
		if (!isStarted)
		{
			final Runnable runnable = new Runnable()
			{
				@Override
				public void run()
				{
					// Sleep until start time
					Duration untilStart = Duration.between(startTime, Instant.now());

					final Logger log = getLog();

					if (!untilStart.isNegative())
					{
						try
						{
							Thread.sleep(untilStart.toMillis());
						}
						catch (InterruptedException e)
						{
							log.error("An error occurred during sleeping phase.", e);
						}
					}

					try
					{
						while (!stop)
						{
							// Get the start of the current period
							final Instant startOfPeriod = Instant.now();

							if (log.isTraceEnabled())
							{
								log.trace("Run the job: '{}'", code);
							}

							try
							{
								// Run the user's code
								code.run(getLog());
							}
							catch (Exception e)
							{
								log.error(
									"Unhandled exception thrown by user code in task " + name, e);
							}

							if (log.isTraceEnabled())
							{
								log.trace("Finished with job: '{}'", code);
							}

							// Sleep until the period is over (or not at all if it's
							// already passed)
							Instant nextExecution = startOfPeriod.plus(frequency);
							
							Duration timeToNextExecution = Duration.between(Instant.now(), nextExecution);

							if (!timeToNextExecution.isNegative())
							{
								try {
									Thread.sleep(timeToNextExecution.toMillis());
								}
								catch (InterruptedException e) {
									Thread.currentThread().interrupt();
								}
							}
						}
						log.trace("Task '{}' stopped", name);
					}
					catch (Exception x)
					{
						log.error("Task '{}' terminated", name, x);
					}
					finally
					{
						isStarted = false;
					}
				}
			};

			// Start the thread
			thread = new Thread(runnable, name + " Task");
			thread.setDaemon(isDaemon);
			thread.start();

			// We're started all right!
			isStarted = true;
		}
		else
		{
			throw new IllegalStateException("Attempt to start task that has already been started");
		}
	}

	/**
	 * Sets daemon or not. For obvious reasons, this value can only be set before the task starts
	 * running. If you attempt to set this value after the task starts running, an
	 * <code>IllegalStateException</code> will be thrown.
	 * 
	 * @param daemon
	 *            <code>true</code> if this <code>Task</code>'s <code>Thread</code> should be a
	 *            daemon
	 * @throws IllegalStateException
	 *             thrown if task is already running
	 */
	public synchronized void setDaemon(final boolean daemon)
	{
		if (isStarted)
		{
			throw new IllegalStateException(
				"Attempt to set daemon state of a task that has already been started");
		}

		isDaemon = daemon;
	}

	/**
	 * Sets log for user code to log to when task runs.
	 * 
	 * @param log
	 *            the log
	 */
	public synchronized void setLog(final Logger log)
	{
		this.log = log;
	}

	/**
	 * Sets start time for this task. You cannot set the start time for a task which is already
	 * running. If you attempt to, an IllegalStateException will be thrown.
	 * 
	 * @param startTime
	 *            The time this task should start running
	 * @throws IllegalStateException
	 *             Thrown if task is already running
	 */
	public synchronized void setStartTime(final Instant startTime)
	{
		if (isStarted)
		{
			throw new IllegalStateException(
				"Attempt to set start time of task that has already been started");
		}

		this.startTime = startTime;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString()
	{
		return "[name=" + name + ", startTime=" + startTime + ", isDaemon=" + isDaemon +
			", isStarted=" + isStarted + ", codeListener=" + log + "]";
	}

	/**
	 * Gets the log for this <code>Task</code>.
	 * 
	 * @return the log
	 */
	protected synchronized Logger getLog()
	{
		if (log == null)
		{
			log = LoggerFactory.getLogger(Task.class);
		}
		return log;
	}

	/**
	 * Stops this <code>Task</code> as soon as it has the opportunity.
	 */
	public void stop()
	{
		stop = true;
	}

	/**
	 * Interrupts the <code>Task</code> as soon as it has the opportunity.
	 */
	public void interrupt()
	{
		stop();
		if (thread != null)
		{
			thread.interrupt();
		}
	}

	/**
	 * Sets the priority of the thread
	 * 
	 * @param prio
	 */
	public void setPriority(int prio)
	{
		if (prio < Thread.MIN_PRIORITY)
		{
			prio = Thread.MIN_PRIORITY;
		}
		else if (prio > Thread.MAX_PRIORITY)
		{
			prio = Thread.MAX_PRIORITY;
		}
		thread.setPriority(prio);
	}

	/**
	 * Gets the thread priority
	 * 
	 * @return priority
	 */
	public int getPriority()
	{
		return thread.getPriority();
	}
}
