package org.eparapher.rcp.actions;
   
   import java.io.File;
   import java.util.ArrayList;
   import java.util.Iterator;
   
   import org.apache.log4j.Logger;
   import org.eclipse.core.runtime.IProgressMonitor;
   import org.eclipse.core.runtime.IStatus;
  import org.eclipse.core.runtime.Status;
  import org.eclipse.core.runtime.jobs.IJobChangeEvent;
  import org.eclipse.core.runtime.jobs.Job;
  import org.eclipse.core.runtime.jobs.JobChangeAdapter;
  import org.eclipse.jface.action.Action;
  import org.eclipse.jface.viewers.ISelection;
  import org.eclipse.jface.viewers.IStructuredSelection;
  import org.eclipse.jface.viewers.TreeViewer;
  import org.eclipse.jface.window.Window;
  import org.eclipse.jface.wizard.WizardDialog;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.widgets.Display;
  import org.eclipse.ui.IWorkbenchWindow;
  import org.eclipse.ui.PlatformUI;
  import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
  import org.eparapher.core.crypto.EPKeystoreManager;
  import org.eparapher.core.crypto.keystore.IUserKeystore;
  import org.eparapher.core.signature.XMLSignatureParameters;
  import org.eparapher.core.signature.XMLSigner;
  import org.eparapher.rcp.tools.GUIIcons;
  import org.eparapher.rcp.tools.eParapherTools;
  import org.eparapher.rcp.views.documents.SecuredDocumentsView.TreeObject;
  import org.eparapher.rcp.views.documents.SecuredDocumentsView.TreeParent;
  import org.eparapher.rcp.wizards.XMLSigningWizard;
  
  public class XMLSignDocumentAction extends Action implements IWorkbenchAction {
  
  	private static Logger log = Logger.getLogger(ToPDFAndSignDocumentAction.class);
  	
  	private TreeViewer viewer;
  	
  	private boolean usewizard;
  	private IWorkbenchWindow window;
  
  	public XMLSignDocumentAction() {
  		this(null,true);
  	}
  
  	public XMLSignDocumentAction(TreeViewer mviewer, boolean museWizard) {
  		viewer = mviewer;
  		usewizard = museWizard;
  		window = null;
  		this.setId("XMLSignDocumentAction");
  		this.setImageDescriptor(GUIIcons.XML_ICON);
  		if (!usewizard) {
  			this.setText("XML DSig Signature");
  			this.setToolTipText("Digitally sign XML file(s) with default parameters");
  			this.setAccelerator(SWT.CTRL | 'J');
  		} else {
  			this.setText("XML DSig Signature (wizard)");
  			this.setToolTipText("Digitally sign XML file(s) using a wizard");
  			this.setAccelerator(SWT.CTRL | 'K');
  		}
  	}
  
  	public XMLSignDocumentAction(IWorkbenchWindow mwindow) {
  		this();
  		window=mwindow;
  	}
  
  	public void run() {
  		XMLSignJob job = new XMLSignJob();
  		job.setUser(true);
  		job.schedule();
  	}
  
  	private XMLSignatureParameters getSignatureParameters() {
  		
  		XMLSignatureParameters xmlsignparams = new XMLSignatureParameters();
  		xmlsignparams.setXMLSignatureParamsFromPreferences();
  		if (viewer != null)
  			xmlsignparams.setFileSelectiontoSign(getFileSelectionFromView());
  
  		if (usewizard) {
  			//Launch Wizard to get PDF Signature Parameters
  			XMLSigningWizard xmlWizard = new XMLSigningWizard(xmlsignparams);
  			if (window==null)
  				window=PlatformUI.getWorkbench().getActiveWorkbenchWindow();
  			WizardDialog dialog = new WizardDialog(window.getShell(), xmlWizard );
  			if ( dialog.open() != Window.OK ) {
  				log.info("XML DSig signature options wizard cancelled");
  				return null;
  			}
  			//recover params from wizard
  			xmlsignparams = xmlWizard.getXMLSignatureParams();
  		}
  		return xmlsignparams;
  	}
  
  	private File[] getFileSelectionFromView() {
 
 		ArrayList<File> fileList = new ArrayList<File>();
 		
 		if (viewer.getSelection()!=null && !viewer.getSelection().isEmpty()) {
 			// Iterate over selected file in view
 			ISelection selection = viewer.getSelection();
 			IStructuredSelection structselection = (IStructuredSelection) selection;
 			
 			//Build File Array from Table Selection
 			for (Iterator<Object> iterator = structselection.iterator(); iterator.hasNext();) {
 				Object obj =  iterator.next();
 				if (obj instanceof TreeParent)
 					//TODO : sign all files in a directory (if confirm?)
 					eParapherTools.debugMessage("Cannot sign a directory!");
 				else {
 					TreeObject to = (TreeObject) obj;
 					File f = new File(to.getFilePath());
 					if (!f.exists())
 						log.error("file " + to.getFilePath() + " has been deleted");
 					else
 						fileList.add(f);
 				}
 			}
 		}
 		return fileList.toArray(new File[] {});
 	}
 
 	public void dispose() {
 	}
 
 	class XMLSignJob extends Job {
 		
 		private XMLSignatureParameters xmlsignatureparams;
 		private XMLSigner xmlsigner;
 
 		private String originalAlias;
 		protected boolean isSigningPrivateKeyLoaded;
 
 		protected XMLSignJob() {
 			
 			super("XML DSig Signer Job");
 			
 			// Use Wizard if needed for signature parameters
 			xmlsignatureparams = getSignatureParameters();
 			
 			//Verify if algorithm is supported (Elliptic curve not supported yet)
 			IUserKeystore uk = EPKeystoreManager.getInstance().getUserkeystore();
 				
 			if (xmlsignatureparams!=null) {
 				
 				// Set the alias keystore to use
 				originalAlias = uk.getDefaultAlias();
 				if (xmlsignatureparams.getSignatureAlias()!=null
 					&& uk.containsAlias(xmlsignatureparams.getSignatureAlias()) )
 					uk.setDefaultAlias(xmlsignatureparams.getSignatureAlias());
 				
 				//Ask PIN or Passphrase with CMSSigner Constructor
 				isSigningPrivateKeyLoaded = EPKeystoreManager.getInstance().getUserkeystore().loadPrivateKey();
 				
 				if (isSigningPrivateKeyLoaded) {
 					xmlsigner = new XMLSigner();
 					
 					//End Job Listener
 					this.addJobChangeListener(new JobChangeAdapter() {
 						public void done(IJobChangeEvent event) {
 							if (event.getResult().isOK())
 								log.info("XML DSig signing job completed successfully");
 							else
 								log.warn("XML DSig signing job did not complete successfully");
 						}
 					});
 				}
 			}
 		}
 
 		@SuppressWarnings("unchecked")
 		@Override
 		protected IStatus run(IProgressMonitor monitor) {
 			if (xmlsignatureparams!=null && isSigningPrivateKeyLoaded) {
 
 				monitor.beginTask("XML DSig Signer", xmlsignatureparams.getFileSelectiontoSign().length );
 				
 				File[] f2s = xmlsignatureparams.getFileSelectiontoSign();
 				
 				for (int i = 0; i < f2s.length; i++) {
 					if (isXMLFile(f2s[i].getName().toLowerCase())) {
 						monitor.subTask("Signing "+f2s[i].getName());
 						xmlsigner.sign( f2s[i].getAbsolutePath(), xmlsignatureparams);
 						monitor.worked(1);
 					} else {
 						log.warn("Cannot apply XML signature on : " + f2s[i].getAbsolutePath() );
 					}
 
 					//refresh the view
 					Display.getDefault().asyncExec(new Runnable() {
 						public void run() {	viewer.refresh(); }
 					});
 				}
 				monitor.done();
 			}
 			if (originalAlias!=null)
 				EPKeystoreManager.getInstance().getUserkeystore().setDefaultAlias(originalAlias);
 			return Status.OK_STATUS;
 		}
 
 		private boolean isXMLFile(String lowerCaseFileName) {
 			for (int i = 0; i < xmlsignatureparams.XMLExtentions.length; i++) {
 				if (lowerCaseFileName.endsWith(xmlsignatureparams.XMLExtentions[i]))
 					return true;
 				break;
 			}
 			//TODO : XML Detection : read file Header to detect "<?xml ..."
 			return false;
 		}
 
 		private void refreshView() {
 			Display.getDefault().asyncExec(
 				new Runnable() {
 					public void run() {	viewer.refresh(); }
 				}
 			);
 		}
 	}
 
 }