/*

 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package org.netbeans.jemmy;

import java.util.Optional;

/**

 *

 * Runs actions with or without waiting.

 *

 * <BR><BR>Timeouts used: <BR>

 * ActionProducer.MaxActionTime - time action should be finished in. <BR>

 *

 * @see Action

 * @see Timeouts

 *

 * @author Alexandre Iline (alexandre.iline@oracle.com)

 */

public class ActionProducer<R, P> extends Thread

        implements Action<R, P>, Waitable<Optional<R>, P>, Timeoutable {

    private final static long ACTION_TIMEOUT = 10000;

    private Action<R, P> action;

    private boolean needWait = true;

    private P parameter;

    private boolean finished;

    private R result = null;

    private Timeouts timeouts;

    private Waiter<Optional<R>, P> waiter;

    private TestOut output;

    private Throwable exception;

    /**

     * Creates a producer for an action.

     *

     * @param a Action implementation.

     */

    public ActionProducer(Action<R, P> a) {

        super();

        waiter = new Waiter<>(this);

        action = a;

        setTimeouts(JemmyProperties.getProperties().getTimeouts());

        setOutput(JemmyProperties.getProperties().getOutput());

        finished = false;

        exception = null;

    }

    /**

     * Creates a producer for an action.

     *

     * @param a Action implementation.

     * @param nw Defines if {@code produceAction} method should wait for

     * the end of action.

     */

    public ActionProducer(Action<R, P> a, boolean nw) {

        super();

        waiter = new Waiter<>(this);

        action = a;

        needWait = nw;

        setTimeouts(JemmyProperties.getProperties().getTimeouts());

        setOutput(JemmyProperties.getProperties().getOutput());

        finished = false;

        exception = null;

    }

    /**

     * Creates a producer. {@code produceAction} must be overridden.

     */

    protected ActionProducer() {

        super();

        waiter = new Waiter<>(this);

        setTimeouts(JemmyProperties.getProperties().getTimeouts());

        setOutput(JemmyProperties.getProperties().getOutput());

        finished = false;

        exception = null;

    }

    /**

     * Creates a producer. {@code produceAction} must be overridden.

     *

     * @param nw Defines if {@code produceAction} method should wait for

     * the end of action.

     */

    protected ActionProducer(boolean nw) {

        super();

        waiter = new Waiter<>(this);

        needWait = nw;

        setTimeouts(JemmyProperties.getProperties().getTimeouts());

        setOutput(JemmyProperties.getProperties().getOutput());

        finished = false;

        exception = null;

    }

    static {

        Timeouts.initDefault("ActionProducer.MaxActionTime", ACTION_TIMEOUT);

    }

    /**

     * Set all the time outs used by sleeps or waits used by the launched

     * action.

     *

     * @param ts An object containing timeout information.

     * @see org.netbeans.jemmy.Timeouts

     * @see org.netbeans.jemmy.Timeoutable

     * @see #getTimeouts

     */

    @Override

    public void setTimeouts(Timeouts ts) {

        timeouts = ts;

    }

    /**

     * Get all the time outs used by sleeps or waits used by the launched

     * action.

     *

     * @return an object containing information about timeouts.

     * @see org.netbeans.jemmy.Timeouts

     * @see org.netbeans.jemmy.Timeoutable

     * @see #setTimeouts

     */

    @Override

    public Timeouts getTimeouts() {

        return timeouts;

    }

    /**

     * Identity of the streams or writers used for print output.

     *

     * @param out An object containing print output assignments for output and

     * error streams.

     * @see org.netbeans.jemmy.TestOut

     * @see org.netbeans.jemmy.Outputable

     */

    public void setOutput(TestOut out) {

        output = out;

        waiter.setOutput(output);

    }

    /**

     * Returns the exception value.

     *

     * @return a Throwable object representing the exception value

     */

    public Throwable getException() {

        return exception;

    }

    /**

     * Defines action priority in terms of thread priority. Increase (decrease)

     * parameter value to Thread.MIN_PRIORITY(MAX_PRIORITY) in case if it is

     * less(more) then it.

     *

     * @param newPriority New thread priority.

     */

    public void setActionPriority(int newPriority) {

        int priority;

        if (newPriority < Thread.MIN_PRIORITY) {

            priority = MIN_PRIORITY;

        } else if (newPriority > Thread.MAX_PRIORITY) {

            priority = MAX_PRIORITY;

        } else {

            priority = newPriority;

        }

        try {

            setPriority(priority);

        } catch (IllegalArgumentException | SecurityException e) {

            e.printStackTrace();

        }

    }

    /**

     * Get the result of a launched action.

     *

     * @return a launched action's result. without waiting in case if

     * {@code getFinished()}

     * @see #getFinished()

     */

    public R getResult() {

        return result;

    }

    /**

     * Check if a launched action has finished.

     *

     * @return {@code true} if the launched action has completed, either

     * normally or with an exception;  {@code false} otherwise.

     */

    public boolean getFinished() {

        synchronized (this) {

            return finished;

        }

    }

    /**

     * Does nothing; the method should be overridden by inheritors.

     *

     * @param obj An object used to modify execution. This might be a

     * {@code java.lang.String[]} that lists a test's command line

     * arguments.

     * @return An object - result of the action.

     * @see org.netbeans.jemmy.Action

     */

    @Override

    public R launch(P obj) {

        return null;

    }

    /**

     * @return this {@code ActionProducer}'s description.

     * @see Action

     */

    @Override

    public String getDescription() {

        if (action != null) {

            return action.getDescription();

        } else {

            return "Unknown action";

        }

    }

    /**

     * Starts execution. Uses ActionProducer.MaxActionTime timeout.

     *

     * @param obj Parameter to be passed into action's

     * {@code launch(Object)} method. This parameter might be a

     * {@code java.lang.String[]} that lists a test's command line

     * arguments.

     * @param actionTimeOrigin is used for timeout reporting, if non-null.

     * @return        {@code launch(Object)} result.

     * @throws TimeoutExpiredException

     * @exception InterruptedException

     */

    public R produceAction(P obj, String actionTimeOrigin) throws InterruptedException {

        parameter = obj;

        synchronized (this) {

            finished = false;

        }

        start();

        if (needWait) {

            waiter.setTimeoutsToCloneOf(timeouts, "ActionProducer.MaxActionTime", actionTimeOrigin);

            try {

                waiter.waitAction(null);

            } catch (TimeoutExpiredException e) {

                output.printError("Timeout for \"" + getDescription()

                        + "\" action has been expired. Thread has been interrupted.");

                interrupt();

                throw (e);

            }

        }

        return result;

    }

    /**

     * Launch an action in a separate thread of execution. When the action

     * finishes, record that fact. If the action finishes normally, store it's

     * result. Use {@code getFinished()} and {@code getResult} to

     * answer questions about test completion and return value, respectively.

     *

     * @see #getFinished()

     * @see #getResult()

     * @see java.lang.Runnable

     */

    @Override

    public final void run() {

        result = null;

        try {

            result = launchAction(parameter);

        } catch (Throwable e) {

            exception = e;

        }

        synchronized (this) {

            finished = true;

        }

    }

    /**

     * Inquire for a reference to the object returned by a launched action.

     *

     * @param obj Not used.

     * @return the result returned when a launched action finishes normally.

     * @see org.netbeans.jemmy.Waitable

     */

    @Override

    public final Optional<R> actionProduced(P obj) {

        synchronized (this) {

            if (finished) {

                return Optional.ofNullable(result);

            } else {

                return null;

            }

        }

    }

    /**

     * Launch some action. Pass the action parameters and get it's return value,

     * too.

     *

     * @param obj Parameter used to configure the execution of whatever this

     * {@code ActionProducer} puts into execution.

     * @return the return value of the action.

     */

    private R launchAction(P obj) {

        if (action != null) {

            return action.launch(obj);

        } else {

            return launch(obj);

        }

    }

    @Override

    public String toString() {

        return "ActionProducer{" + "action=" + action + ", needWait=" + needWait + ", parameter=" + parameter + ", finished=" + finished + ", result=" + result + ", exception=" + exception + '}';

    }

}