package org.eparapher.rcp.actions;
   
   import java.io.File;
   import java.security.KeyStoreException;
   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.cert.CertificateManager;
  import org.eparapher.core.crypto.keystore.IUserKeystore;
  import org.eparapher.core.signature.PDFSignatureParameters;
  import org.eparapher.core.signature.PDFSigner;
  import org.eparapher.core.tools.PDFConverterWrapper;
  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.PDFSigningWizard;
  
  
  public class ToPDFAndSignDocumentAction extends Action implements IWorkbenchAction {
  
  	private static Logger log = Logger.getLogger(ToPDFAndSignDocumentAction.class);
  	
  	private TreeViewer viewer;
  	private boolean usewizard;
  	private IWorkbenchWindow window;
  
  	public ToPDFAndSignDocumentAction() {
  		this(null,true);
  	}
  
  	public ToPDFAndSignDocumentAction(TreeViewer mviewer, boolean museWizard) {
  		super();
  		viewer = mviewer;
  		usewizard = museWizard;
  		window = null;
  		this.setId("ToPDFAndSignDocumentAction");
  		this.setImageDescriptor(GUIIcons.PDF_ICON);
  		if (!usewizard) {
  			this.setText("Convert to PDF and Sign");
  			this.setToolTipText("Convert to PDF and Sign CMS with default parameters");
  			this.setAccelerator(SWT.CTRL | 'G');
  		} else {
  			this.setText("Convert to PDF and Sign (wizard)");
  			this.setToolTipText("Convert to PDF and Sign using a wizard");
  			this.setAccelerator(SWT.CTRL | 'H');
  		}
  	}
  
  	public ToPDFAndSignDocumentAction(IWorkbenchWindow mwindow) {
  		this();
  		window=mwindow;
  	}
  
  	public void run() {
  		PDFConvertAndSignJob job = new PDFConvertAndSignJob();
  		job.setUser(true);
  		job.schedule();
  	}
  
  	private PDFSignatureParameters getSignatureParameters() {
  		
  		PDFSignatureParameters pdfsignparams = new PDFSignatureParameters();
  		pdfsignparams.setPdfsignatureParamsFromPreferences();
  		if (viewer !=null)
  			pdfsignparams.setFileSelectiontoSign(getFileSelectionFromView());
  
  		if (usewizard) {
  			//Launch Wizard to get PDF Signature Parameters
  			PDFSigningWizard pdfWizard = new PDFSigningWizard(pdfsignparams);
  			if (window==null)
  				window=PlatformUI.getWorkbench().getActiveWorkbenchWindow();
  			WizardDialog dialog = new WizardDialog(window.getShell(), pdfWizard);
  			if ( dialog.open() != Window.OK ) {
  				log.info("PDF converter ans signature option wizard cancelled");
  				return null;
  			}
  			//recover params from wizard
  			pdfsignparams = pdfWizard.getPdfsignatureparams();
  		}
 		return pdfsignparams;
 	}
 
 	private File[] getFileSelectionFromView() {
 
 		ArrayList<File> fileList = new ArrayList<File>();
 		
 		if (viewer.getSelection()!=null && !viewer.getSelection().isEmpty()) {
 			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 PDFConvertAndSignJob extends Job {
 		
 		private PDFSignatureParameters pdfsignatureparams;
 		private PDFSigner pdfsigner;
 		private PDFConverterWrapper pdfconverter;
 
 		private String originalAlias;
 		protected boolean isSigningPrivateKeyLoaded;
 
 		protected PDFConvertAndSignJob() {
 			
 			super("Converting to PDF and Sign");
 
 			// Getting signature settings (with wizard if needed)
 			pdfsignatureparams = getSignatureParameters();
 
 			IUserKeystore uk = EPKeystoreManager.getInstance().getUserkeystore();
 
 			try {
 				
 				//Load private key for the coming signing operation
 				if (pdfsignatureparams!=null) {
 					
 					// Set the alias keystore to use
 					originalAlias = uk.getDefaultAlias();
 					if (pdfsignatureparams.getSignatureAlias()!=null
 						&& uk.containsAlias(pdfsignatureparams.getSignatureAlias()) )
 						uk.setDefaultAlias(pdfsignatureparams.getSignatureAlias());
 
 					//Verify if algorithm is supported (Elliptic curve not supported yet)
 					if (CertificateManager.isECCertificate(uk.getX509Certificate())) {
 						pdfsignatureparams=null;
 						eParapherTools.errorMessage("Elliptic curve keys are not supported yet for PDF Signing.\r\n Please use a RSA or DSA Keypair & Certificate.");
 					}
 					//Load the private key (Ask PIN or Passphrase)
 					isSigningPrivateKeyLoaded = uk.loadPrivateKey();
 					
 					if (isSigningPrivateKeyLoaded) {
 						pdfsigner = new PDFSigner();
 						//Start OpenOffice if needed
 						pdfconverter = new PDFConverterWrapper();
 						
 						//End Job Listener
 						this.addJobChangeListener(new JobChangeAdapter() {
 							public void done(IJobChangeEvent event) {
 								if (event.getResult().isOK())
 									log.info("PDF convertion and signing job completed successfully");
 								else
 									log.error("PDF convertion and signing job did not complete successfully");
 							}
 						});
 					}
 				}
 			} catch (KeyStoreException e) {
 				log.error("Error in PDFConvertAndSignJob",e);
 			} catch (Throwable t) {
 				log.error("Error in PDFConvertAndSignJob",t);
 			}
 		}
 
 		@SuppressWarnings("unchecked")
 		@Override
 		protected IStatus run(IProgressMonitor monitor) {
 			if (pdfsignatureparams!=null && isSigningPrivateKeyLoaded) {
 
 				monitor.beginTask("Converting to PDF and Sign", pdfsignatureparams.getFileSelectiontoSign().length*2 );
 				File[] f2s = pdfsignatureparams.getFileSelectiontoSign();
 				for (int i = 0; i < f2s.length; i++) {
 
 					if (f2s[i].getName().toLowerCase().endsWith(".pdf")) {
 						monitor.subTask("Signing "+f2s[i].getName());
 						pdfsigner.sign(f2s[i].getAbsolutePath(), pdfsignatureparams, false);
 						monitor.worked(2);
 					} else {
 						monitor.subTask("Converting "+f2s[i].getName()+" to PDF");
 						String converted_unsigned_pdf = null;
 						try {
 							converted_unsigned_pdf = pdfconverter.convert(f2s[i].getAbsolutePath());
 							monitor.worked(1);
 							if (converted_unsigned_pdf!=null) {
 								monitor.subTask("Signing "+converted_unsigned_pdf);
 								pdfsigner.sign( converted_unsigned_pdf, pdfsignatureparams, true );
 							}
 							monitor.worked(1);
 						} catch (Exception e) {
 							final String eLabel = e.getLocalizedMessage();
 							Display.getDefault().asyncExec( new Runnable() {
 								public void run() {	eParapherTools.errorMessage( eLabel ); }
 							});
 						}
 					}
 					//refresh the view
 					refreshView();
 				}
 				monitor.done();
 
 			}
 			if (originalAlias!=null)
 				EPKeystoreManager.getInstance().getUserkeystore().setDefaultAlias(originalAlias);
 			return Status.OK_STATUS;
 		}
 
 		private void refreshView() {
 			Display.getDefault().asyncExec(
 				new Runnable() {
 					public void run() {	viewer.refresh(); }
 				}
 			);			
 		}
 	}
 }