package org.eparapher.rcp.views.documents;
   
   import java.util.ArrayList;
   
   import org.apache.log4j.Logger;
   import org.eclipse.core.runtime.IAdaptable;
   import org.eclipse.jface.action.Action;
   import org.eclipse.jface.action.IMenuListener;
   import org.eclipse.jface.action.IMenuManager;
  import org.eclipse.jface.action.IToolBarManager;
  import org.eclipse.jface.action.MenuManager;
  import org.eclipse.jface.action.Separator;
  import org.eclipse.jface.viewers.DoubleClickEvent;
  import org.eclipse.jface.viewers.IDoubleClickListener;
  import org.eclipse.jface.viewers.ISelectionProvider;
  import org.eclipse.jface.viewers.IStructuredContentProvider;
  import org.eclipse.jface.viewers.ITreeContentProvider;
  import org.eclipse.jface.viewers.LabelProvider;
  import org.eclipse.jface.viewers.TreeViewer;
  import org.eclipse.jface.viewers.Viewer;
  import org.eclipse.jface.viewers.ViewerSorter;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.graphics.Image;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Menu;
  import org.eclipse.ui.IActionBars;
  import org.eclipse.ui.IWorkbenchActionConstants;
  import org.eclipse.ui.dialogs.PropertyDialogAction;
  import org.eclipse.ui.part.DrillDownAdapter;
  import org.eclipse.ui.part.ViewPart;
  import org.eparapher.core.tools.JVMSettings;
  import org.eparapher.rcp.EPReferences;
  import org.eparapher.rcp.actions.CMSSignDocumentAction;
  import org.eparapher.rcp.actions.DecryptAction;
  import org.eparapher.rcp.actions.EncryptAction;
  import org.eparapher.rcp.actions.OpenEditorAction;
  import org.eparapher.rcp.actions.ToPDFAndSignDocumentAction;
  import org.eparapher.rcp.actions.XMLSignDocumentAction;
  import org.eparapher.rcp.tools.GUIIcons;
  import org.eparapher.rcp.tools.RCPSettings;
  
  /**
   * This sample class demonstrates how to plug-in a new
   * workbench view. The view shows data obtained from the
   * model. The sample creates a dummy model on the fly,
   * but a real implementation would connect to the model
   * available either in this or another plug-in (e.g. the workspace).
   * The view is connected to the model using a content provider.
   * <p>
   * The view uses a label provider to define how model
   * objects should be presented in the view. Each
   * view can present the same model objects using
   * different labels and icons, if needed. Alternatively,
   * a single label provider can be shared between views
   * in order to ensure that objects of the same type are
   * presented in the same way everywhere.
   * <p>
   */
  
  public class SecuredDocumentsView extends ViewPart {
  	
  	public static final String ID = "org.eparapher.rcp.views.documents.SecuredDocumentsView";
  	private static Logger log = Logger.getLogger(SecuredDocumentsView.class);
  	
  	private TreeViewer viewer;
  	private DrillDownAdapter drillDownAdapter;
  	
  	private Action cmsSignAction;
  	private Action cmsSignActionwithwizard;
  
  	private Action xmlSignAction;
  	private Action xmlSignActionwithwizard;
  	
  	private Action convertAndSignPDFAction;
  	private Action convertAndSignPDFActionwithwizard;
  	
  	//private Action verifsignatureAction;
  	
  	private Action refreshAction;
  	
  	private Action encryptAction;
  	private Action encryptwithwizardAction;
  	private Action decryptAction;
  	private Action decryptwithwizardAction;
  
  	private Action doubleClickAction;
  	
  	private Action propertyAction;
  
  	/*
  	 * The content provider class is responsible for
  	 * providing objects to the view. It can wrap
  	 * existing objects in adapters or simply return
  	 * objects as-is. These objects may be sensitive
  	 * to the current input of the view, or ignore
  	 * it and always show the same content 
  	 * (like Task List, for example).
  	 */
  	 
 	public class TreeObject implements IAdaptable {
 		
 		protected String   name;
 		private TreeParent parent;
 		private boolean    isReadableDir;
 		
 		public TreeObject(String name) {
 			this.name = name;
 			this.isReadableDir = false;
 		}
 
 		public TreeObject(String name,boolean misReadableDir) {
 			this.name = name;
 			this.isReadableDir = false;
 		}
 		public String getName() {
 			return name;
 		}
 		public void setParent(TreeParent parent) {
 			this.parent = parent;
 		}
 		public TreeParent getParent() {
 			return parent;
 		}
 		public String getFilePath() {
 			String fp = getName();
 			TreeParent tp = getParent();
 			//Stop when got root parent
 			while (!tp.getParent().getName().equals("")) {
 				fp = tp.getName() + java.io.File.separator + fp;
 				tp = tp.getParent();
 			}
 			//Correct a bug on Windows
 			if (fp.endsWith(java.io.File.separator))
 				fp = tp.getName() + fp;
 			else 
 				fp = tp.getName() + java.io.File.separator + fp;
 			return fp;
 		}
 		public String toString() {
 			return getName();
 		}
 		public Object getAdapter(Class key) {
 			return null;
 		}
 	}
 	
 	public class TreeParent extends TreeObject {
 		private ArrayList<TreeObject> children;
 		private boolean isRoot;
 		private int     rootnb;
 		public TreeParent(String name) {
 			super(name);
 			children = new ArrayList<TreeObject>();
 			isRoot = false;
 		}
 		public void addChild(TreeObject child) {
 			children.add(child);
 			child.setParent(this);
 		}
 		public void removeChild(TreeObject child) {
 			children.remove(child);
 			child.setParent(null);
 		}
 		public TreeObject [] getChildren() {
 			return (TreeObject [])children.toArray(new TreeObject[children.size()]);
 		}
 		public boolean hasChildren() {
 			return children.size()>0;
 		}
 		public boolean isRoot() {
 			return isRoot;
 		}
 		public void setRoot(boolean misroot, String mpath) {
 			isRoot = misroot;
 			if (isRoot)
 				this.name = mpath;
 		}
 		/*public String getFilePath() {
 			if (isRoot())
 				return EPConfig.getSecureDocumentPath();
 			else
 				return super.getFilePath();
 		}*/
 	}
 
 	class ViewLabelProvider extends LabelProvider {
 
 		public String getText(Object obj) {
 			return obj.toString();
 		}
 		public Image getImage(Object obj) {
 			//String imageKey = ISharedImages.IMG_OBJ_FILE;
 			if (obj instanceof TreeParent) {
 				TreeParent tp = (TreeParent) obj;
 				if (tp.isRoot()) {
 					return GUIIcons.HOME_LOCAL_FILE_ICON;
 				}
 				else 
 					return GUIIcons.FILE_ICON_FOLDER; //imageKey = ISharedImages.IMG_OBJ_FOLDER;
 			}
 			if (obj instanceof TreeObject) {
 				TreeObject to = (TreeObject) obj;
 				return GUIIcons.getIconFromFileExt(to);
 			}
 			return GUIIcons.FILE_ICON_DEFAULT;
 			//return PlatformUI.getWorkbench().getSharedImages().getImage(imageKey);
 		}
 	}
 	class NameSorter extends ViewerSorter {
 	}
 	class DocViewContentProvider implements IStructuredContentProvider, ITreeContentProvider {
 		
 		private TreeParent   invisibleRoot;
 		private TreeParent[] localDocsRoot;
 		private String[]     localDocsPath;
 		
 		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
 		}
 		public void dispose() {
 		}
 		public Object[] getElements(Object parent) {
 			if (parent.equals(getViewSite())) {
 				if ( (invisibleRoot==null) || (isRootPathsChanged()) )
 					initialize();
 				else refresh();
 				return getChildren(invisibleRoot);
 			}
 			return getChildren(parent);
 		}
 		
 		private boolean isRootPathsChanged() {
 			boolean returnvalue=false;
 			String[] docpathsconfig = RCPSettings.getSecureDocumentPath();
 			if (localDocsPath.length!=docpathsconfig.length)
 				return true;
 			for (int i = 0; i < localDocsPath.length; i++) {
 				if (!localDocsPath[i].equals(docpathsconfig[i]))
 					returnvalue=true;
 			}
 			
 			return returnvalue;
 		}
 		private void refresh() {
 			for (int i = 0; i < localDocsPath.length; i++) {
 				log.debug("Refreshing directory " + localDocsRoot[i]);
 				recursiveupdate(localDocsRoot[i], new java.io.File(localDocsPath[i]));
 			}
 			log.debug("Refreshing directories finished");
 		}
 		public Object getParent(Object child) {
 			if (child instanceof TreeObject) {
 				return ((TreeObject)child).getParent();
 			}
 			return null;
 		}
 		public Object [] getChildren(Object parent) {
 			if (parent instanceof TreeParent) {
 				return ((TreeParent)parent).getChildren();
 			}
 			return new Object[0];
 		}
 		public boolean hasChildren(Object parent) {
 			if (parent instanceof TreeParent)
 				return ((TreeParent)parent).hasChildren();
 			return false;
 		}
 		/*
 		 * We set up a dummy model to initialize tree heararchy.
 		 * In a real code, you will connect to a real model and
 		 * expose its hierarchy.
 		 */
 		private void initialize() {
 
 			localDocsPath = RCPSettings.getSecureDocumentPath();
 			localDocsRoot = new TreeParent[localDocsPath.length];
 			invisibleRoot = new TreeParent("");
 			
 			for (int i = 0; i < localDocsPath.length; i++) {
 				java.io.File rootpath = new java.io.File(localDocsPath[i]);
 				localDocsRoot[i] = recursiveinit(rootpath);
 				localDocsRoot[i].setRoot(true,localDocsPath[i]);
 				invisibleRoot.addChild(localDocsRoot[i]);
 			}
 		}
 		private TreeParent recursiveinit(java.io.File pathToDo) {
 
 			java.io.File[] files = pathToDo.listFiles();
 			TreeParent tp = new TreeParent(pathToDo.getName());
 			try {
 			for (int i = 0; i < files.length; i++) {
 				java.io.File file = files[i];
 				if (!file.isHidden()&& file.canRead()) {
 					if (file.isFile()) {
 						TreeObject to = new TreeObject(file.getName());
 						tp.addChild(to);
 					}
 					if (file.isDirectory()) {
 						TreeParent subtp = recursiveinit(file);
 						tp.addChild(subtp);
 					}
 				}
 			}
 			} catch (Exception e) {
 				log.debug("Error while creating doc tree for " + pathToDo.getAbsolutePath(),e);
 			}
 			return tp;
 		}
 
 		private void recursiveupdate(TreeParent tp, java.io.File pathToCheck) {
 			
 			java.io.File[] files = pathToCheck.listFiles();
 			TreeObject[]   tos    = tp.getChildren();
 			
 			//Add check : List files in the directory and check if exists in the tree
 			for (int i = 0; i < files.length; i++) {
 				java.io.File file = files[i];
 				int  corresponding_index = -1;
 				//search for corresponding object
 				for (int j = 0; j < tos.length; j++)
 					if (file.getName().equals(tos[j].getName()))
 						corresponding_index = j;
 				//Not found : new file on FS that is not in the treeview, so add it ...
 				if (corresponding_index == -1) {
 					if (!file.isHidden() && file.canRead()) {
 						if (file.isFile()) {
 							// New File
 							TreeObject to = new TreeObject(file.getName());
 							tp.addChild(to);
 						}
 						if (file.isDirectory()) {
 							//New Directory
 							TreeParent subtp = recursiveinit(file);
 							tp.addChild(subtp);
 						}
 					}
 				}
 			}
 			
 			//Delete check : List tree and check if the file or directory exists
 			for (int i = 0; i < tos.length; i++) {
 				TreeObject to  = tos[i];
 				java.io.File file = new java.io.File(to.getFilePath());
 				if ( !file.exists() )
 					tp.removeChild(tos[i]);
 				else {
 					if ( file.isDirectory() && (to instanceof TreeParent)) {
 						TreeParent tp_subdir = (TreeParent) to;
 						recursiveupdate(tp_subdir,file);
 					}
 					//Directory change to file or vice versa
 					if ( file.isDirectory() && !(to instanceof TreeParent)) {
 						
 					}
 				}
 			}
 			
 		}
 	}
 	
 	/**
 	 * The constructor.
 	 */
 	public SecuredDocumentsView() {
 	}
 
 	/**
 	 * This is a callback that will allow us
 	 * to create the viewer and initialize it.
 	 */
 	public void createPartControl(Composite parent) {
 		viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 		drillDownAdapter = new DrillDownAdapter(viewer);
 		viewer.setContentProvider(new DocViewContentProvider());
 		viewer.setLabelProvider(new ViewLabelProvider());
 		viewer.setSorter(new NameSorter());
 		viewer.setInput(getViewSite());
 		makeActions();
 		hookContextMenu();
 		hookDoubleClickAction();
 		contributeToActionBars();
 		EPReferences.getInstance().setDocviews(this);
 		//Send the change selection notification to the selection service
 		getSite().setSelectionProvider(viewer);
 	}
 
 	private void hookContextMenu() {
 		MenuManager menuMgr = new MenuManager("#PopupMenu");
 		menuMgr.setRemoveAllWhenShown(true);
 		menuMgr.addMenuListener(new IMenuListener() {
 			public void menuAboutToShow(IMenuManager manager) {
 				SecuredDocumentsView.this.fillContextMenu(manager);
 			}
 		});
 		Menu menu = menuMgr.createContextMenu(viewer.getControl());
 		viewer.getControl().setMenu(menu);
 		getSite().registerContextMenu(menuMgr, viewer);
 	}
 
 	private void contributeToActionBars() {
 		IActionBars bars = getViewSite().getActionBars();
 		fillLocalPullDown(bars.getMenuManager());
 		fillLocalToolBar(bars.getToolBarManager());
 	}
 	
 	private void fillLocalToolBar(IToolBarManager manager) {
 		manager.add(refreshAction);
 		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 		drillDownAdapter.addNavigationActions(manager);
 	}
 
 	private void fillLocalPullDown(IMenuManager manager) {
 		manager.add(convertAndSignPDFActionwithwizard);
 		manager.add(cmsSignActionwithwizard);
 		if (JVMSettings.isJava16Min())
 			manager.add(xmlSignActionwithwizard);
 		manager.add(new Separator());
 		//manager.add(verifsignatureAction);
 		//drillDownAdapter.addNavigationActions(manager);
 	}
 
 	private void fillContextMenu(IMenuManager manager) {
 		
 		MenuManager signMenu = new MenuManager("Signature");
 		signMenu.add(convertAndSignPDFAction);
 		signMenu.add(convertAndSignPDFActionwithwizard);
 		signMenu.add(new Separator());
 		signMenu.add(cmsSignAction);
 		signMenu.add(cmsSignActionwithwizard);
 
 		if (JVMSettings.isJava16Min()) {
 			signMenu.add(new Separator());
 			signMenu.add(xmlSignAction);
 			signMenu.add(xmlSignActionwithwizard);
 		}
 		manager.add(signMenu);
 
 		MenuManager encryptMenu = new MenuManager("Encryption");
 		encryptMenu.add(encryptAction);
 		encryptMenu.add(encryptwithwizardAction);
 		encryptMenu.add(decryptAction);
 		manager.add(encryptMenu);
 
 		//manager.add(new Separator());
 		//manager.add(verifsignatureAction);
 		manager.add(new Separator());
 		manager.add(refreshAction);
 		//drillDownAdapter.addNavigationActions(manager);
 		// Other plug-ins can contribute there actions here
 		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 		
 		manager.add(new Separator());
         manager.add(propertyAction);
 
 	}
 
 	private void makeActions() {
 		cmsSignAction             = new CMSSignDocumentAction(viewer, false);
 		cmsSignActionwithwizard   = new CMSSignDocumentAction(viewer, true);
 		
 		convertAndSignPDFAction   = new ToPDFAndSignDocumentAction(viewer, false);
 		convertAndSignPDFActionwithwizard = new ToPDFAndSignDocumentAction(viewer, true);
 
 		if (JVMSettings.isJava16Min()) {
 			xmlSignAction             = new XMLSignDocumentAction(viewer, false);
 			xmlSignActionwithwizard   = new XMLSignDocumentAction(viewer, true);
 			//verifsignatureAction = new SignatureVerificationAction();
 		}
 		
 		refreshAction =  new Action() {
 			public void run() {viewer.refresh();}
 		};
 		refreshAction.setText("Re&fresh");
 		refreshAction.setToolTipText("Refresh the Tree for added/removed files");
 		refreshAction.setImageDescriptor(GUIIcons.REFRESH_ICON);
 		refreshAction.setAccelerator(SWT.F5);
 
 		encryptAction           = new EncryptAction(viewer, false);
 		encryptwithwizardAction = new EncryptAction(viewer, true);
 		decryptAction           = new DecryptAction(viewer);
 		encryptAction.setEnabled(false);
 		encryptwithwizardAction.setEnabled(false);
 		decryptAction.setEnabled(false);
 
 		propertyAction = new PropertyDialogAction(getSite(), viewer);
 		propertyAction.setImageDescriptor(GUIIcons.INFO_ICON);
 		
 		doubleClickAction = new OpenEditorAction(viewer);
 	}
 
 	private void hookDoubleClickAction() {
 		viewer.addDoubleClickListener(new IDoubleClickListener() {
 			public void doubleClick(DoubleClickEvent event) {
 				doubleClickAction.run();
 			}
 		});
 	}
 
 	/**
 	 * Passing the focus request to the viewer's control.
 	 */
 	public void setFocus() {
 		viewer.getControl().setFocus();
 	}
 	/*
 	 *   IActionBars bars = getViewSite().getActionBars();
      *   IStatusLineManager statusLine = bars.getStatusLineManager();
      *  IProgressMonitor pm = statusLine.getProgressMonitor();
      */
 	public void refreshView() {
 		//refresh the view
 		if (viewer!=null)
 			viewer.refresh();
 	}
 }