package org.eparapher.rcp.views;

import java.security.Provider;
import java.security.Security;
import java.security.Provider.Service;
import java.util.ArrayList;
import java.util.Set;

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.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
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.EParapherManager;
import org.eparapher.rcp.tools.GUIIcons;

public class CryptoProvidersView extends ViewPart {

	public static final String ID = "org.eparapher.rcp.views.CryptoProvidersView";
	private static Logger log = Logger.getLogger(CryptoProvidersView.class);
	
	private TreeViewer viewer;
	private DrillDownAdapter drillDownAdapter;

	private Action refreshAction;

	private Action doubleClickAction;
	
	private Action propertyAction;
	 
	public class TreeObject implements IAdaptable {
		
		protected Service serv;
		
		private TreeParent parent;
		
		public TreeObject(Service name) {
			this.serv = name;
		}
		public String getName() {
			return toString();
		}
		public void setParent(TreeParent parent) {
			this.parent = parent;
		}
		public TreeParent getParent() {
			return parent;
		}
		public Service getService() {
			return serv;
		}
		public String getType() {
			return serv.getType();
		}
		public String toString() {
			return serv.getType() + " - " +serv.getAlgorithm();
		}
		public Object getAdapter(Class key) {
			return null;
		}
	}
	
	public class TreeParent extends TreeObject {
		
		private ArrayList<TreeObject> children;

		protected Provider prov;
		protected int order;
		protected String serviceType;

		public TreeParent(Provider p, int i) {
			super(null);
			children = new ArrayList<TreeObject>();
			prov = p;
			order = i;
			serviceType=null;
		}
		
		public TreeParent(Provider p, String srvType) {
			super(null);
			prov = p;
			serviceType = srvType;
			children = new ArrayList<TreeObject>();
		}
		
		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 Provider getProvider() {
			return this.prov;
		}
		public boolean hasChildren() {
			return children.size()>0;
		}
		public String toString() {
			if (serviceType == null)
				return "n°" + order + " - " + prov.getName() + " - " + prov.getVersion();
			else
				return serviceType;
		}
	}

	class ViewLabelProvider extends LabelProvider {

		public String getText(Object obj) {
			return obj.toString();
		}
		public Image getImage(Object obj) {
			if (obj instanceof TreeParent) {
				return GUIIcons.FILE_ICON_ENC;
			} else {
				return GUIIcons.INFO_ICON_IMAGE;
			}
		}
	}

	class NameSorter extends ViewerSorter {
	}

	class DocViewContentProvider implements IStructuredContentProvider, ITreeContentProvider {
		
		private TreeParent   invisibleRoot;
		
		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
		}
		public void dispose() {
		}
		public Object[] getElements(Object parent) {
			if (parent.equals(getViewSite())) {
				if ( invisibleRoot==null )
					initialize();
				else refresh();
				return getChildren(invisibleRoot);
			}
			return getChildren(parent);
		}

		private void refresh() {
			log.debug("Reloading Java Security Providers");
			initialize();
			/*
			try {
				EPCryptoProviderManager.getTerminals();
			} catch (CardException e) {
				log.error(e.getLocalizedMessage(),e);
			}
			*/
		}
		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() {
			
			invisibleRoot = new TreeParent(null,0);

			Provider[] providers = Security.getProviders();
			for (int i= 0; i< providers.length; i++) {
				Provider prov = providers[i];
				TreeParent tp = new TreeParent(prov,i+1);
				invisibleRoot.addChild(tp);
				
				Set<Service> services = prov.getServices();
				for (Service service : services) {
					TreeObject to = new TreeObject(service);
					tp.addChild(to);
				}
			}
		}
	}
	
	/**
	 * The constructor.
	 */
	public CryptoProvidersView() {
	}

	/**
	 * 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();
	}

	private void hookContextMenu() {
		MenuManager menuMgr = new MenuManager("#PopupMenu");
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				CryptoProvidersView.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) {
	}

	private void fillContextMenu(IMenuManager manager) {
		
		//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() {
		
		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);

		propertyAction = new PropertyDialogAction(getSite(), viewer);
		propertyAction.setImageDescriptor(GUIIcons.INFO_ICON);
		
		doubleClickAction = new Action() {
			public void run() {
				TreeObject to = (TreeObject) ((IStructuredSelection) viewer.getSelection()).getFirstElement();
				if (to instanceof TreeParent) {
					TreeParent tp = (TreeParent) to;
					Provider prov = tp.getProvider();
					String msg = prov.getInfo();
					EParapherManager.getInstance().getUI().infoMessage(msg);
				} else {
					Service srv = to.getService();
					String msg = "Security Provider : " + srv.getProvider();
					msg += "\r\n Type      : " + srv.getType();
					msg += "\r\n Algorithm : " + srv.getAlgorithm();
					msg += "\r\n Class     : " + srv.getClassName();
					EParapherManager.getInstance().getUI().infoMessage(msg);
				}
			}
		};
	}

	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();
	}

}