/*
    *  
    *  Fosstrak LLRP Commander (www.fosstrak.org)
    * 
    *  Copyright (C) 2008 ETH Zurich
    *
    *  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 org.fosstrak.llrp.commander.wizards;
  
  import org.eclipse.jface.viewers.IStructuredSelection;
  import org.eclipse.jface.wizard.Wizard;
  import org.eclipse.ui.INewWizard;
  import org.eclipse.ui.IWorkbench;
  import org.eclipse.core.runtime.*;
  import org.eclipse.jface.operation.*;
  import java.lang.reflect.InvocationTargetException;
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.jface.viewers.ISelection;
  import org.eclipse.core.resources.*;
  import org.eclipse.core.runtime.CoreException;
  import java.io.*;
  import org.eclipse.ui.*;
  import org.eclipse.ui.ide.IDE;
  import org.fosstrak.llrp.commander.util.LLRPFactory;
  import org.llrp.ltk.types.LLRPMessage;
  
  /**
   * This wizard lets the user create a new LLRP message with all mandatory parameters set.
   * 
   * The implementation is based on Eclipse's "New File Wizard" template (see plug-in development environment).
   *
   * @author Ulrich Etter, ETHZ
   *
   */
  public class NewLLRPMessageWizard extends Wizard implements INewWizard {
  	
  	private final String PLUGIN_ID = "llrp";
  	
  	private NewLLRPMessageWizardPage page;
  	private ISelection selection;
  
  	/**
  	 * Constructor for NewLLRPMessageWizard.
  	 */
  	public NewLLRPMessageWizard() {
  		super();
  		setNeedsProgressMonitor(true);
  	}
  	
  	/**
  	 * Adding the page to the wizard.
  	 */
  	public void addPages() {
  		page = new NewLLRPMessageWizardPage(selection);
  		addPage(page);
  	}
  
  	/**
  	 * This method is called when 'Finish' button is pressed in
  	 * the wizard. We will create an operation and run it
  	 * using wizard as execution context.
  	 */
  	public boolean performFinish() {
  		final String folderName = page.getFolderName();
  		final String fileName = page.getFileName();
  		final String messageType = page.getLLRPMessageType();
  		IRunnableWithProgress op = new IRunnableWithProgress() {
  			public void run(IProgressMonitor monitor) throws InvocationTargetException {
  				try {
  					doFinish(folderName, fileName, messageType, monitor);
  				} catch (CoreException e) {
  					throw new InvocationTargetException(e);
  				} finally {
  					monitor.done();
  				}
  			}
  		};
  		try {
  			getContainer().run(true, false, op);
  		} catch (InterruptedException e) {
  			return false;
  		} catch (InvocationTargetException e) {
  			Throwable realException = e.getTargetException();
  			MessageDialog.openError(getShell(), "Error", realException.getMessage());
  			return false;
 		}
 		return true;
 	}
 	
 	/**
 	 * The worker method. It will find the container, create the
 	 * file if missing or just replace its contents, and open
 	 * the editor on the newly created file.
 	 */
 	private void doFinish(
 		String folderName,
 		String fileName,
 		String messageType, 
 		IProgressMonitor monitor)
 		throws CoreException {
 		monitor.beginTask("Creating " + fileName, 2);
 		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 		IResource resource = root.findMember(new Path(folderName));
 		if (!resource.exists() || !(resource instanceof IContainer)) {
 			throwCoreException("Container \"" + folderName + "\" does not exist.");
 		}
 		IContainer container = (IContainer) resource;
 		final IFile file = container.getFile(new Path(fileName));
 		try {
 			InputStream stream = openContentStream(messageType);
 			if (file.exists()) {
 				file.setContents(stream, true, true, monitor);
 			} else {
 				file.create(stream, true, monitor);
 			}
 			stream.close();
 		} catch (IOException e) {
 		}
 		monitor.worked(1);
 		monitor.setTaskName("Opening file for editing...");
 		getShell().getDisplay().asyncExec(new Runnable() {
 			public void run() {
 				IWorkbenchPage page =
 					PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
 				try {
 					IDE.openEditor(page, file, true);
 				} catch (PartInitException e) {
 				}
 			}
 		});
 		monitor.worked(1);
 	}
 	
 	/**
 	 * Initializes file contents with a default LLRP message.
 	 */
 	private InputStream openContentStream(String messageType) {
 		String contents = "";
 		try {
 			LLRPMessage message = LLRPFactory.createLLRPMessage(messageType);
 			contents = message.toXMLString();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return new ByteArrayInputStream(contents.getBytes());
 	}
 
 	private void throwCoreException(String message) throws CoreException {
 		IStatus status =
 			new Status(IStatus.ERROR, PLUGIN_ID, IStatus.OK, message, null);
 		throw new CoreException(status);
 	}
 
 	/**
 	 * We will accept the selection in the workbench to see if
 	 * we can initialize from it.
 	 * @see IWorkbenchWizard#init(IWorkbench, IStructuredSelection)
 	 */
 	public void init(IWorkbench workbench, IStructuredSelection selection) {
 		this.selection = selection;
 	}
 }