/******************************************************************************
 * Copyright (c) 2011, 2012, EBM WebSourcing
 * All rights reserved. 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:
 *     EBM WebSourcing - initial API and implementation
 *******************************************************************************/

package org.eclipse.bpel.ui.wizards;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import javax.xml.namespace.QName;

import org.eclipse.bpel.common.ui.details.viewers.ComboViewer;
import org.eclipse.bpel.common.wsdl.helpers.UriAndUrlHelper;
import org.eclipse.bpel.common.wsdl.parsers.WsdlParser;
import org.eclipse.bpel.ui.BPELUIPlugin;
import org.eclipse.bpel.ui.IBPELUIConstants;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Fault;
import org.eclipse.wst.wsdl.Input;
import org.eclipse.wst.wsdl.Operation;
import org.eclipse.wst.wsdl.Output;
import org.eclipse.wst.wsdl.PortType;

/**
 * The page of the wizard to select the contract to implement.
 * <p>
 * This page could have to deal with several contracts to implement.
 * </p>
 * <p>
 * Notice that this class uses WSDL4j to parse WSDL files, and not EMF.
 * The reason is that EMF does not cross file inclusions and thus results in incomplete
 * parsing or in failures with valid WSDL definitions.
 * </p>
 *
 * @author Michal Chmielewski - Oracle
 * @author Vincent Zurczak - EBM WebSourcing
 */
public class NewBpelFilePortTypePage extends WizardPage {

	/**
	 * The page's name, so that it can be referenced from other pages.
	 */
	public static final String PAGE_NAME = "port-type-page";

	/**
	 * The WSDL URL.
	 */
	private String wsdlUrl;

	/**
	 * The selected port type in the WSDL.
	 */
	private PortType portType;

	/**
	 * True to import the selected WSDL at the end.
	 */
	private boolean importWsdl = true;

	/**
	 * The images used by this page.
	 */
	private final Image workspaceImg, fileSystemImg, parseImg;


	/**
	 * Constructor.
	 */
	public NewBpelFilePortTypePage() {
		super( PAGE_NAME );

		setTitle( "Service Contract" );
		setDescription( "Select the service contract the BPEL process must implement." );
		setImageDescriptor( BPELUIPlugin.INSTANCE.getImageDescriptor( IBPELUIConstants.ICON_WIZARD_BANNER ));

		this.workspaceImg = BPELUIPlugin.createImage( "icons/obj16/workspace.gif" );
		this.fileSystemImg = BPELUIPlugin.createImage( "icons/obj16/file_system.gif" );
		this.parseImg = BPELUIPlugin.createImage( "icons/obj16/parse.gif" );
	}


	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.DialogPage
	 * #dispose()
	 */
	@Override
	public void dispose() {

		if( this.fileSystemImg != null && ! this.fileSystemImg.isDisposed())
			this.fileSystemImg.dispose();

		if( this.workspaceImg != null && ! this.workspaceImg.isDisposed())
			this.workspaceImg.dispose();

		if( this.parseImg != null && ! this.parseImg.isDisposed())
			this.parseImg.dispose();

		super.dispose();
	}


	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jface.wizard.WizardPage
	 * #getNextPage()
	 */
	@Override
	public IWizardPage getNextPage() {

		// We need to do that since the page order depends on user choices
		IWizardPage nextPage = getWizard().getPage( NewBpelFileLocationPage.PAGE_NAME );
		nextPage.setPreviousPage( this );
		return nextPage;
	}


	/**
	 * @return the wsdlUrl
	 */
	public String getWsdlUrl() {
		return this.wsdlUrl;
	}


	/**
	 * @return the importWsdl
	 */
	public boolean isImportWsdl() {
		return this.importWsdl;
	}


	/**
	 * @return the portType
	 */
	public PortType getPortType() {
		return this.portType;
	}


	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage
	 * #createControl(org.eclipse.swt.widgets.Composite)
	 */
	@Override
	public void createControl( Composite parent ) {

		// Create the container
		final Composite container = new Composite( parent, SWT.NONE );
		container.setFont( parent.getFont());
		initializeDialogUnits( parent );
		container.setLayout( new GridLayout( 2, false ));
		container.setLayoutData( new GridData( GridData.FILL_BOTH ));
		setControl( container );


		// WSDL location (as an URL)
		Label l = new Label( container, SWT.NONE );
		l.setText( "WSDL URL:" );
		l.setToolTipText( "The URL of the service description (WSDL)" );
		l.setLayoutData( new GridData( SWT.TOP, SWT.DEFAULT, false, false ));

		final Text wsdlUrlText = new Text( container, SWT.SINGLE | SWT.BORDER );
		wsdlUrlText.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ));
		wsdlUrlText.setToolTipText( "Press the 'Tab' key to parse this WSDL" );
		if( this.wsdlUrl != null )
			wsdlUrlText.setText( this.wsdlUrl );

		wsdlUrlText.addModifyListener( new ModifyListener() {
			@Override
			public void modifyText( ModifyEvent e ) {
				NewBpelFilePortTypePage.this.wsdlUrl = ((Text) e.widget).getText();
				updateStatus();
			}
		});

		final ControlDecoration wsdlTextDecoration = new ControlDecoration( wsdlUrlText, SWT.LEFT | SWT.BOTTOM );
		wsdlTextDecoration.setImage( PlatformUI.getWorkbench().getSharedImages().getImage( ISharedImages.IMG_OBJS_INFO_TSK ));
		wsdlTextDecoration.setDescriptionText( wsdlUrlText.getToolTipText());
		wsdlTextDecoration.hide();


		// Helpers to browse for WSDL files
		new Label( container, SWT.NONE );	// Bad but so convenient!
		Composite subContainer = new Composite( container, SWT.NONE );
		GridLayout layout = new GridLayout( 2, false );
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		layout.marginBottom = 13;
		subContainer.setLayout( layout );
		subContainer.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ));

		new Label( subContainer, SWT.NONE ).setImage( this.fileSystemImg );
		Link browseFileSystemLink = new Link( subContainer, SWT.NONE );
		browseFileSystemLink.setText( "<A>Browse the file system...</A>" );

		new Label( subContainer, SWT.NONE ).setImage( this.workspaceImg );
		Link browseWorkspaceLink = new Link( subContainer, SWT.NONE );
		browseWorkspaceLink.setText( "<A>Browse the workspace...</A>" );

		new Label( subContainer, SWT.NONE ).setImage( this.parseImg );
		Link parseWsdlLink = new Link( subContainer, SWT.NONE );
		parseWsdlLink.setText( "<A>Parse the given WSDL</A>" );


		// Port type to use for the generation
		l = new Label( container, SWT.NONE );
		l.setText( "Service Contract:" );
		l.setToolTipText( "The port type (service contract) to implement with BPEL" );

		final ComboViewer portTypeCombo = new ComboViewer( container, SWT.BORDER | SWT.DROP_DOWN | SWT.READ_ONLY );
		portTypeCombo.getCombo().setLayoutData( new GridData( GridData.FILL_HORIZONTAL ));
		portTypeCombo.setContentProvider( new ArrayContentProvider());
		portTypeCombo.setLabelProvider( new LabelProvider() {
			@Override
			public String getText( Object element ) {
				QName name = ((PortType) element).getQName();
				return name.getLocalPart() + " - " + name.getNamespaceURI();
			}
		});


		// The button to import the WSDL
		new Label( container, SWT.NONE );
		Button importButton = new Button( container, SWT.CHECK );
		importButton.setText( "Import the WSDL file with its dependencies" );
		importButton.setSelection( this.importWsdl );
		importButton.addSelectionListener( new SelectionListener() {
			@Override
			public void widgetSelected( SelectionEvent e ) {
				widgetDefaultSelected( e );
			}

			@Override
			public void widgetDefaultSelected( SelectionEvent e ) {
				NewBpelFilePortTypePage.this.importWsdl = ((Button) e.widget).getSelection();
			}
		});


		// The viewer for a quick overview of the operations
		subContainer = new Composite( container, SWT.NONE );
		layout = new GridLayout();
		layout.marginWidth = 0;
		layout.marginTop = 11;
		subContainer.setLayout( layout );
		GridData layoutData = new GridData( GridData.FILL_BOTH );
		layoutData.horizontalSpan = 2;
		subContainer.setLayoutData( layoutData );

		l = new Label( subContainer, SWT.NONE );
		l.setText( "Select a service contract (port type) and see its operations below." );

		final TreeViewer operationsViewer = new TreeViewer( subContainer, SWT.BORDER );
		operationsViewer.getTree().setLayoutData( new GridData( GridData.FILL_BOTH ));
		operationsViewer.setLabelProvider( new LabelProvider () {
			@Override
			public Image getImage( Object element ) {

				Image result = null;
				if( element instanceof Operation )
					result = BPELUIPlugin.INSTANCE.getImage( IBPELUIConstants.ICON_OPERATION_16 );
				else if( element instanceof Input )
					result = BPELUIPlugin.INSTANCE.getImage( IBPELUIConstants.ICON_INPUT_16 );
				else if( element instanceof Output )
					result = BPELUIPlugin.INSTANCE.getImage( IBPELUIConstants.ICON_OUTPUT_16 );
				else if( element instanceof Fault )
					result = BPELUIPlugin.INSTANCE.getImage( IBPELUIConstants.ICON_FAULT_16 );

				return result;
			}

			@Override
			public String getText( Object element ) {

				String result = "";
				if( element instanceof Operation ) {
					result = ((Operation) element).getName();
					result = result == null || result.trim().length() == 0 ? "?" : result;

				} else if( element instanceof Input ) {
					result = ((Input) element).getName();
					result = result == null || result.trim().length() == 0 ? "Input" : result;

				} else if( element instanceof Output ) {
					result = ((Output) element).getName();
					result = result == null || result.trim().length() == 0 ? "Output" : result;

				} else if( element instanceof Fault ) {
					result = ((Fault) element).getName();
					result = result == null || result.trim().length() == 0 ? "Fault" : result;
				}

				return result;
			}
		});

		operationsViewer.setContentProvider( new ITreeContentProvider() {
			@Override
			public void dispose() {
				// nothing
			}

			@Override
			public void inputChanged( Viewer viewer, Object oldInput, Object newInput ) {
				// nothing
			}

			@Override
			public Object[] getElements( Object inputElement ) {
				return ((PortType) inputElement).getOperations().toArray();
			}

			@SuppressWarnings( "unchecked" )
			@Override
			public Object[] getChildren( Object pa ) {

				List<Object> result = new ArrayList<Object> ();
				if( pa instanceof Operation ) {
					Operation op = (Operation) pa;
					if( op.getInput() != null )
						result.add( op.getInput());

					if( op.getOutput() != null )
						result.add( op.getOutput());

					if( op.getFaults() != null )
						result.addAll( op.getFaults().values());
				}

				return result.toArray();
			}

			@Override
			public Object getParent( Object element ) {
				return null;
			}

			@Override
			public boolean hasChildren( Object element ) {
				return element instanceof Operation;
			}
		});


		// Listeners
		portTypeCombo.addSelectionChangedListener( new ISelectionChangedListener() {
			@Override
			public void selectionChanged( SelectionChangedEvent event ) {
				NewBpelFilePortTypePage.this.portType = (PortType) ((IStructuredSelection) portTypeCombo.getSelection()).getFirstElement();
				operationsViewer.setInput( NewBpelFilePortTypePage.this.portType );
				operationsViewer.refresh();

				if( NewBpelFilePortTypePage.this.portType != null ) {
					if( NewBpelFilePortTypePage.this.portType.getOperations().size() < 4 )
						operationsViewer.expandAll();
					else
						operationsViewer.expandToLevel( 2 );
				}

				updateStatus();
			}
		});


		// WSDL parsing
		final List<PortType> portTypes = new ArrayList<PortType> ();
		final IRunnableWithProgress wsdlParsingOperation = new IRunnableWithProgress() {
			@Override
			public void run( IProgressMonitor monitor )
			throws InvocationTargetException, InterruptedException {

				monitor.beginTask( "Parsing the WSDL...", 5 );
				try {
					portTypes.clear();
					monitor.worked( 1 );

					URI emfUri = URI.createURI( NewBpelFilePortTypePage.this.wsdlUrl );
					Collection<Definition> definitions = WsdlParser.loadAllWsdlDefinitions( emfUri, WsdlParser.createBasicResourceSetForWsdl());
					for( Definition def : definitions ) {
						for( Object o : def.getPortTypes().values())
							portTypes.add((PortType) o );
					}

					monitor.worked( 3 );

				} finally {
					monitor.done();
				}
			}
		};

		wsdlUrlText.addTraverseListener( new TraverseListener() {
			@Override
			public void keyTraversed( TraverseEvent e ) {

				if( NewBpelFilePortTypePage.this.wsdlUrl == null )
					return;

				try {
					// Parse
					getContainer().run( true, false, wsdlParsingOperation );

					// Update the UI
					portTypeCombo.setInput( portTypes );
					portTypeCombo.refresh();
					if( portTypes.size() > 0 )
						portTypeCombo.getCombo().select( 0 );
					portTypeCombo.getCombo().notifyListeners( SWT.Selection, new Event());

				} catch( InvocationTargetException e1 ) {
					BPELUIPlugin.log( e1 );

				} catch( InterruptedException e1 ) {
					BPELUIPlugin.log( e1 );
				}
			}
		});

		wsdlUrlText.addFocusListener( new FocusListener() {
			@Override
			public void focusLost( FocusEvent e ) {
				wsdlTextDecoration.hide();
			}

			@Override
			public void focusGained( FocusEvent e ) {
				wsdlTextDecoration.show();
			}
		});


		// "Browse" call-backs
		browseFileSystemLink.addSelectionListener( new SelectionListener() {
			@Override
			public void widgetSelected( SelectionEvent e ) {
				widgetDefaultSelected( e );
			}

			@Override
			public void widgetDefaultSelected( SelectionEvent e ) {
				FileDialog dlg = new FileDialog( getShell());
				dlg.setFilterExtensions( new String[] { "*.wsdl" });
				dlg.setFilterNames( new String[] { "WSDL (*.wsdl)" });
				dlg.setText( "Select a service description (WSDL)." );

				String path = dlg.open();
				if( path != null ) {
					File f = new File( path );
					wsdlUrlText.setText( f.toURI().toString());
					wsdlUrlText.notifyListeners( SWT.Traverse, new Event());
				}
			}
		});

		parseWsdlLink.addSelectionListener( new SelectionListener() {
			@Override
			public void widgetSelected( SelectionEvent e ) {
				wsdlUrlText.notifyListeners( SWT.Traverse, new Event());
			}

			@Override
			public void widgetDefaultSelected( SelectionEvent e ) {
				wsdlUrlText.notifyListeners( SWT.Traverse, new Event());
			}
		});

		browseWorkspaceLink.addSelectionListener( new SelectionListener() {
			@Override
			public void widgetSelected( SelectionEvent e ) {
				widgetDefaultSelected( e );
			}

			@Override
			public void widgetDefaultSelected( SelectionEvent e ) {

				// Prepare the initial selection
				IFile currentWsdl = null;
				if( NewBpelFilePortTypePage.this.wsdlUrl != null ) {
					try {
						java.net.URI uri = UriAndUrlHelper.urlToUri( NewBpelFilePortTypePage.this.wsdlUrl );
						File f = new File( uri );
						IPath path = new Path( f.getAbsolutePath());
						currentWsdl = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation( path );

					} catch( Exception e1 ) {
						BPELUIPlugin.log( e1, IStatus.WARNING );
					}
				}

				// Open a dialog that only shows the WSDL files in the workspace - and their ancestors/containers
				final List<IFile> workspaceWsdlFiles = getFiles( "wsdl", Arrays.asList( ResourcesPlugin.getWorkspace().getRoot()));
				ElementTreeSelectionDialog dlg = new ElementTreeSelectionDialog(
						getShell(),
						new WorkbenchLabelProvider(),
						new WorkbenchContentProvider() {

							@Override
							public Object[] getChildren( Object element ) {

								Object[] result = super.getChildren( element );
								if( result == null )
									result = new Object[ 0 ];

								List<Object> filteredResult = new ArrayList<Object>();
								for( Object o : result ) {
									if( o instanceof IFile
											&& workspaceWsdlFiles.contains( o ))
										filteredResult.add( o );

									else if( o instanceof IContainer ) {
										IPath containerPath = ((IContainer) o).getFullPath();
										for( IFile wsdlFile : workspaceWsdlFiles ) {
											if( containerPath.isPrefixOf( wsdlFile.getFullPath())) {
												filteredResult.add( o );
												break;
											}
										}
									}
								}

								return filteredResult.toArray();
							}
				});

				dlg.setInput( ResourcesPlugin.getWorkspace().getRoot());
				dlg.setTitle( "WSDL Selection" );
				dlg.setMessage( "Select a WSDL file located in the workspace." );
				if( currentWsdl != null )
					dlg.setInitialElementSelections( Arrays.asList( currentWsdl ));

				// Open it and update the text widget if necessary
				if( dlg.open() == Window.OK ) {
					IFile selectedFile = (IFile) dlg.getResult()[ 0 ];
					wsdlUrlText.setText( selectedFile.getLocation().toFile().toURI().toString());
					wsdlUrlText.notifyListeners( SWT.Traverse, new Event());
				}
			}
		});


		// Initialize the port type...
		if( this.portType != null )
			portTypeCombo.setSelection( new StructuredSelection( this.portType ));

		else if( portTypeCombo.getCombo().getItemCount() > 0 ) {
			portTypeCombo.getCombo().select( 0 );
			portTypeCombo.getCombo().notifyListeners( SWT.Selection, new Event());
		}


		// ... and the page's state
		updateStatus();
		if( getErrorMessage() != null ) {
			setPageComplete( false );
			setErrorMessage( null );
		}
	}


	/**
	 * Validates the page data and updates the page state in consequence.
	 */
	private void updateStatus() {
		String errorMsg = validatePage();
		setPageComplete( errorMsg == null );
		setErrorMessage( errorMsg );
	}


	/**
	 * Validates the page data and stores valid values for further use.
	 * @return an error message or null if everything is right
	 */
	private String validatePage() {

		String errorMsg = null;

		// Validate the page fields
		if( this.wsdlUrl == null || this.wsdlUrl.trim().length() == 0 )
			errorMsg = "You must specify the URL of a service description (WSDL).";
		else if( this.portType == null )
			errorMsg = "You must select a port type (contract) to implement in the BPEL process.";

		return errorMsg;
	}


	/**
	 * Gets all the files whose extension is <b>extension</b> and present in <b>containers</b>.
	 * @param extension the file extension. Use "*" for any extension. Not null.
	 * @param containers the containers to explore
	 * @return all the IFile contained into this container (with no limit in the level).
	 */
	private static List<IFile> getFiles( String extension, Collection<? extends IContainer> containers ) {

		List<IFile> result = new ArrayList<IFile> ();
		if( containers == null )
			return result;

		for( IContainer container : containers ) {
			try {
				IResource[] resources = container.members();
				for( IResource resource : resources ) {
					switch( resource.getType()) {

					case IResource.FILE:
						if( "*".equals( extension )
									|| extension.equalsIgnoreCase( resource.getFileExtension()))
							result.add((IFile) resource);
						break;

					case IResource.FOLDER:
						IFolder subFolder = (IFolder) resource;
						result.addAll( getFiles( extension, Arrays.asList( subFolder )));
						break;

					case IResource.PROJECT:
						IProject project = (IProject) resource;
						if( project.isAccessible())
							result.addAll( getFiles( extension, Arrays.asList( project )));
						break;

					default:
						break;
					}
				}

			} catch( CoreException e ) {
				BPELUIPlugin.log( e, IStatus.ERROR );
			}
		}

		return result;
	}
}