/*******************************************************************************
 * Copyright (c) 2000, 2018 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Eugene Ostroukhov <eugeneo@symbian.org> -  Bug 287887 [Wizards] [api] Cancel button has two distinct roles
 *     Lars Vogel <Lars.Vogel@vogella.com> - Bug 440270
 *     Jan-Ove Weichel <janove.weichel@vogella.com> - Bug 475879
 *     Karsten Thoms <karsten.thoms@itemis.de> - Bug 520720 Asynchronous, throttled label update
 *******************************************************************************/
package org.eclipse.jface.wizard;

import static org.eclipse.swt.events.SelectionListener.widgetSelectedAdapter;

import java.time.Duration;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IProgressMonitorWithBlocking;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.ProgressIndicator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.Throttler;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;

/**
 * A standard implementation of an IProgressMonitor. It consists
 * of a label displaying the task and subtask name, and a
 * progress indicator to show progress. In contrast to
 * <code>ProgressMonitorDialog</code> this class only implements
 * <code>IProgressMonitor</code>.
 */
public class ProgressMonitorPart extends Composite implements
        IProgressMonitorWithBlocking {

	/** the label */
    protected Label fLabel;

    /** the current task name */
    protected String fTaskName;

    /** the current sub task name */
    protected String fSubTaskName;

    /** the progress indicator */
    protected ProgressIndicator fProgressIndicator;

    /** the cancel component */
    protected Control fCancelComponent;

    /** true if canceled */
    protected volatile boolean fIsCanceled;

    /** current blocked status */
    protected IStatus blockedStatus;

    /** the cancel lister attached to the cancel component */
    protected Listener fCancelListener = e -> {
	    setCanceled(true);
	    if (fCancelComponent != null) {
			fCancelComponent.setEnabled(false);
		}
	};

    /** toolbar for managing stop button **/
    private ToolBar fToolBar;

    /** default tool item for canceling tasks **/
	private ToolItem fStopButton;

	/** <code>true</code> if this monitor part should show stop button **/
	private boolean fHasStopButton = false;

	private Throttler throttledUpdate;

	/**
	 * Creates a <code>ProgressMonitorPart</code> that does not provide a stop button.
	 *
	 * @param parent The SWT parent of the part.
	 * @param layout The SWT grid layout used by the part. A client can supply the layout to control
	 *            how the progress monitor part is laid out. If <code>null</code> is passed the part
	 *            uses its default layout.
	 */
	public ProgressMonitorPart(Composite parent, Layout layout) {
		this(parent, layout, false);
	}

	/**
	 * Creates a <code>ProgressMonitorPart</code> that does not provide a stop button.
	 *
	 * @param parent The SWT parent of the part.
	 * @param layout The SWT grid layout used by the part. A client can supply the layout to control
	 *            how the progress monitor part is laid out. If <code>null</code> is passed the part
	 *            uses its default layout.
	 * @param progressIndicatorHeight The height of the progress indicator in pixels. This value may
	 *            be SWT.DEFAULT in order to get the default height as calculated by the widget and
	 *            its layout.
	 */
	public ProgressMonitorPart(Composite parent, Layout layout, int progressIndicatorHeight) {
		super(parent, SWT.NONE);
		initialize(layout, progressIndicatorHeight);
	}

	/**
	 * Creates a <code>ProgressMonitorPart</code>.
	 *
	 * @param parent the SWT parent of the part
	 * @param layout the SWT grid layout used by the part. A client can supply the layout to control
	 *            how the progress monitor part is laid out. If <code>null</code> is passed the part
	 *            uses its default layout.
	 * @param createStopButton <code>true</code> if the progress indicator should include a stop
	 *            button that can be used to cancel any currently running task, and
	 *            <code>false</code> if no such stop button should be created.
	 *
	 * @since 3.6
	 */
	public ProgressMonitorPart(Composite parent, Layout layout, boolean createStopButton) {
		super(parent, SWT.NONE);
		fHasStopButton= createStopButton;
		initialize(layout, SWT.DEFAULT);
	}

	/**
	 * Attaches the progress monitor part to the given cancel component.
	 *
	 * @param cancelComponent the control whose selection will trigger a cancel. This parameter will
	 *            be ignored and hence can be <code>null</code> if a stop button was requested upon
	 *            construction and instead the stop button will enabled and serve as the cancel
	 *            component.
	 * @see #ProgressMonitorPart(Composite, Layout, boolean)
	 */
	public void attachToCancelComponent(Control cancelComponent) {
		if (fHasStopButton)
			setCancelEnabled(true);
		else {
			fCancelComponent = cancelComponent;
			fCancelComponent.addListener(SWT.Selection, fCancelListener);
		}
	}

    @Override
	public void beginTask(String name, int totalWork) {
        fTaskName = name;
        fSubTaskName = ""; //$NON-NLS-1$
		queueUpdateLabel();
		if (!fProgressIndicator.isDisposed()) {
			if (totalWork == IProgressMonitor.UNKNOWN || totalWork == 0) {
				fProgressIndicator.beginAnimatedTask();
			} else {
				fProgressIndicator.beginTask(totalWork);
			}
        }
        if (fToolBar != null && !fToolBar.isDisposed()) {
        	fToolBar.setVisible(true);
        	fToolBar.setFocus();
        }
    }

    @Override
	public void done() {
		if (!fLabel.isDisposed()) {
			fLabel.setText("");//$NON-NLS-1$
		}
        fSubTaskName = ""; //$NON-NLS-1$
		if (!fProgressIndicator.isDisposed()) {
			fProgressIndicator.sendRemainingWork();
			fProgressIndicator.done();
		}
        if (fToolBar != null && !fToolBar.isDisposed())
        	fToolBar.setVisible(false);
    }

    /**
     * Escapes any occurrence of '&' in the given String so that
     * it is not considered as a mnemonic
     * character in SWT ToolItems, MenuItems, Button and Labels.
     * @param in the original String
     * @return The converted String
     */
    protected static String escapeMetaCharacters(String in) {
        if (in == null || in.indexOf('&') < 0) {
			return in;
		}
        int length = in.length();
        StringBuilder out = new StringBuilder(length + 1);
        for (int i = 0; i < length; i++) {
            char c = in.charAt(i);
            if (c == '&') {
				out.append("&&");//$NON-NLS-1$
			} else {
				out.append(c);
			}
        }
        return out.toString();
    }

    /**
     * Creates the progress monitor's UI parts and layouts them
     * according to the given layout. If the layout is <code>null</code>
     * the part's default layout is used.
     * @param layout The layout for the receiver.
     * @param progressIndicatorHeight The suggested height of the indicator
     */
    protected void initialize(Layout layout, int progressIndicatorHeight) {
        if (layout == null) {
            GridLayout l = new GridLayout();
            l.marginWidth = 0;
            l.marginHeight = 0;
            layout = l;
        }
        int numColumns = 1;
        if (fHasStopButton)
        	numColumns++;
        setLayout(layout);

        if (layout instanceof GridLayout)
        	((GridLayout)layout).numColumns = numColumns;

        fLabel = new Label(this, SWT.LEFT);
        fLabel.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false, numColumns, 1));

        if (progressIndicatorHeight == SWT.DEFAULT) {
            GC gc = new GC(fLabel);
            FontMetrics fm = gc.getFontMetrics();
            gc.dispose();
            progressIndicatorHeight = fm.getHeight();
        }

        fProgressIndicator = new ProgressIndicator(this);
        GridData gd = new GridData();
        gd.horizontalAlignment = GridData.FILL;
        gd.grabExcessHorizontalSpace = true;
        gd.grabExcessVerticalSpace = false;
    	gd.verticalAlignment = GridData.CENTER;
    	gd.heightHint = progressIndicatorHeight;
        fProgressIndicator.setLayoutData(gd);

        if (fHasStopButton) {
        	fToolBar = new ToolBar(this, SWT.FLAT);

        	gd = new GridData();
            gd.grabExcessHorizontalSpace = false;
            gd.grabExcessVerticalSpace = false;
        	gd.verticalAlignment = GridData.CENTER;
        	fToolBar.setLayoutData(gd);
        	fStopButton = new ToolItem(fToolBar, SWT.PUSH);
        	// It would have been nice to use the fCancelListener, but that
        	// listener operates on the fCancelComponent which must be a control.
        	fStopButton.addSelectionListener(widgetSelectedAdapter(e -> {
				setCanceled(true);
				if (fStopButton != null) {
					fStopButton.setEnabled(false);
				}
			}));
        	final Image stopImage = ImageDescriptor.createFromFile(
        			ProgressMonitorPart.class, "images/stop.png").createImage(getDisplay()); //$NON-NLS-1$
			fToolBar.setCursor(this.getDisplay().getSystemCursor(SWT.CURSOR_ARROW));
        	fStopButton.setImage(stopImage);
        	fStopButton.addDisposeListener(e -> {
				stopImage.dispose();
			});
        	fStopButton.setEnabled(false);
			fStopButton.setToolTipText(JFaceResources.getString("ProgressMonitorPart.cancelToolTip")); //$NON-NLS-1$
        }

		throttledUpdate = new Throttler(fLabel.getDisplay(), Duration.ofMillis(100), this::updateLabel);
    }

    @Override
	public void internalWorked(double work) {
		if (!fProgressIndicator.isDisposed()) {
			fProgressIndicator.worked(work);
		}
    }

    @Override
	public boolean isCanceled() {
        return fIsCanceled;
    }

	/**
	 * Detach the progress monitor part from the given cancel component.
	 *
	 * @param cancelComponent the control that was previously used as a cancel component. This
	 *            parameter will be ignored and hence can be <code>null</code> if a stop button was
	 *            requested upon construction and instead the stop button will be disabled.
	 * @see #ProgressMonitorPart(Composite, Layout, boolean)
	 */
	public void removeFromCancelComponent(Control cancelComponent) {
		if (fHasStopButton) {
			setCancelEnabled(false);
		} else {
			Assert.isTrue(fCancelComponent == cancelComponent && fCancelComponent != null);
			fCancelComponent.removeListener(SWT.Selection, fCancelListener);
			fCancelComponent = null;
		}
	}

    @Override
	public void setCanceled(boolean b) {
        fIsCanceled = b;
    }

    @Override
	public void setFont(Font font) {
        super.setFont(font);
        fLabel.setFont(font);
        fProgressIndicator.setFont(font);
    }

    @Override
	public void setTaskName(String name) {
        fTaskName = name;
		queueUpdateLabel();
    }

    @Override
	public void subTask(String name) {
        fSubTaskName = name;
		queueUpdateLabel();
    }

	/**
	 * Enqueues a label update for asynchronous execution. The update is performed
	 * throttled to 100ms, i.e. updates within the throttle range are not displayed.
	 *
	 * @since 3.14
	 */
	protected void queueUpdateLabel() {
		throttledUpdate.throttledExec();
	}

    /**
     * Updates the label with the current task and subtask names.
     */
    protected void updateLabel() {
		if (fLabel.isDisposed() || fLabel.isAutoDirection()) {
			return;
		}
		if (blockedStatus == null) {
			String text = taskLabel();
			fLabel.setText(text);
		} else {
			fLabel.setText(blockedStatus.getMessage());
		}

		// Force an update as we are in the UI Thread
		fLabel.update();
	}

    /**
     * Return the label for showing tasks
     * @return String
     */
    private String taskLabel() {
    	boolean hasTask= fTaskName != null && fTaskName.length() > 0;
    	boolean hasSubtask= fSubTaskName != null && fSubTaskName.length() > 0;

		if (hasTask) {
			if (hasSubtask)
				return escapeMetaCharacters(JFaceResources.format("Set_SubTask", fTaskName, fSubTaskName));//$NON-NLS-1$
   			return escapeMetaCharacters(fTaskName);

    	} else if (hasSubtask) {
    		return escapeMetaCharacters(fSubTaskName);

    	} else {
    		return ""; //$NON-NLS-1$
    	}
    }

    @Override
	public void worked(int work) {
        internalWorked(work);
    }

    @Override
	public void clearBlocked() {
        blockedStatus = null;
		queueUpdateLabel();
    }

    @Override
	public void setBlocked(IStatus reason) {
        blockedStatus = reason;
		queueUpdateLabel();
    }

   private void setCancelEnabled(boolean enabled) {
    	if (fStopButton != null && !fStopButton.isDisposed()) {
    		fStopButton.setEnabled(enabled);
    		if (enabled)
    			fToolBar.setFocus();
    	}
    }
}
