/*
    * Copyright (C) 2007-2012 Argeo GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *         http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.argeo.slc.e4.parts;
  
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.SortedSet;
  import java.util.TreeSet;
  
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.Property;
  import javax.jcr.Repository;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.observation.Event;
  import javax.jcr.query.Query;
  import javax.jcr.query.QueryManager;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  import org.argeo.eclipse.ui.jcr.NodeElementComparer;
  import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  import org.argeo.eclipse.ui.specific.EclipseUiSpecificUtils;
  import org.argeo.jcr.JcrUtils;
  import org.argeo.slc.SlcException;
  import org.argeo.slc.SlcNames;
  import org.argeo.slc.SlcTypes;
  import org.argeo.slc.e4.SlcImages;
  import org.argeo.slc.execution.ExecutionModulesManager;
  import org.argeo.slc.jcr.SlcJcrConstants;
  import org.eclipse.jface.viewers.DoubleClickEvent;
  import org.eclipse.jface.viewers.IDoubleClickListener;
  import org.eclipse.jface.viewers.IStructuredSelection;
  import org.eclipse.jface.viewers.ITableLabelProvider;
  import org.eclipse.jface.viewers.TreeViewer;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.dnd.DND;
  import org.eclipse.swt.dnd.DragSourceAdapter;
  import org.eclipse.swt.dnd.DragSourceEvent;
  import org.eclipse.swt.dnd.TextTransfer;
  import org.eclipse.swt.dnd.Transfer;
  import org.eclipse.swt.graphics.Image;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Display;
  
  /** JCR based view of the execution modules. */
  public class JcrExecutionModulesView implements SlcTypes, SlcNames {
  	private final static Log log = LogFactory.getLog(JcrExecutionModulesView.class);
  
  //	public static final String ID = ClientUiPlugin.ID + ".jcrExecutionModulesView";
  
  	private TreeViewer viewer;
  
  //	private ServerPushSession pushSession;
  
  	/* DEPENDENCY INJECTION */
  	private Repository repository;
  	private Session session;
  	private ExecutionModulesManager modulesManager;
  
  	public void createPartControl(Composite parent) {
  //		pushSession = new ServerPushSession();
  //		pushSession.start();
  
  		try {
  			session = repository.login();
  		} catch (RepositoryException e1) {
  			throw new SlcException("Cannot log in to repository");
  		}
  
  		viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  		EclipseUiSpecificUtils.enableToolTipSupport(viewer);
  		ViewContentProvider contentProvider = new ViewContentProvider(session);
  		viewer.setContentProvider(contentProvider);
  		viewer.setComparer(new NodeElementComparer());
  		final ViewLabelProvider viewLabelProvider = new ViewLabelProvider();
  		viewer.setLabelProvider(viewLabelProvider);
  		viewer.setInput(modulesManager);
  //		viewer.setInput(getViewSite());
  		viewer.addDoubleClickListener(new ViewDoubleClickListener());
 		// context menu
 		// addContextMenu(viewer);
 
 //		getViewSite().setSelectionProvider(viewer);
 
 		Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
 		// Transfer[] tt = new Transfer[] { EditorInputTransfer.getInstance() };
 		int operations = DND.DROP_COPY | DND.DROP_MOVE;
 		viewer.addDragSupport(operations, tt, new ViewDragListener());
 
 		try {
 			String[] nodeTypes = { SlcTypes.SLC_AGENT, SlcTypes.SLC_AGENT_FACTORY, SlcTypes.SLC_EXECUTION_MODULE };
 			session.getWorkspace().getObservationManager().addEventListener(
 					new VmAgentObserver(viewer.getTree().getDisplay()),
 					Event.NODE_ADDED | Event.NODE_REMOVED | Event.NODE_MOVED, SlcJcrConstants.VM_AGENT_FACTORY_PATH,
 					true, null, nodeTypes, false);
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot add observer", e);
 		}
 	}
 
 	public void setFocus() {
 		viewer.getControl().setFocus();
 	}
 
 	public TreeViewer getViewer() {
 		return viewer;
 	}
 
 	public void refreshView() {
 //		viewer.setInput(getViewSite());
 		viewer.setInput(modulesManager);
 	}
 
 	// Controllers
 	class ViewContentProvider extends SimpleNodeContentProvider {
 		private static final long serialVersionUID = 5117887833174813672L;
 
 		public ViewContentProvider(Session session) {
 			super(session, new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
 		}
 
 		@Override
 		protected Object[] sort(Object parent, Object[] children) {
 			Object[] sorted = new Object[children.length];
 			System.arraycopy(children, 0, sorted, 0, children.length);
 			Arrays.sort(sorted, new ViewComparator());
 			return sorted;
 		}
 
 		@Override
 		protected List<Node> filterChildren(List<Node> children) throws RepositoryException {
 			for (Iterator<Node> it = children.iterator(); it.hasNext();) {
 				Node node = it.next();
 				// execution spec definitions
 				if (node.getName().equals(SLC_EXECUTION_SPECS))
 					it.remove();
 				// flow values
 				else if (node.getParent().isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 					it.remove();
 			}
 			return super.filterChildren(children);
 		}
 
 		@Override
 		public boolean hasChildren(Object element) {
 			if (element instanceof Node) {
 				Node node = (Node) element;
 				try {
 					if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 						return false;
 				} catch (RepositoryException e) {
 					throw new SlcException("Cannot check has children", e);
 				}
 			}
 			return super.hasChildren(element);
 		}
 	}
 
 	static class ViewComparator implements Comparator<Object> {
 
 		public int compare(Object o1, Object o2) {
 			try {
 				if (o1 instanceof Node && o2 instanceof Node) {
 					Node node1 = (Node) o1;
 					Node node2 = (Node) o2;
 
 					if (node1.getName().equals(SLC_EXECUTION_SPECS))
 						return -100;
 					if (node2.getName().equals(SLC_EXECUTION_SPECS))
 						return 100;
 
 					if (node1.isNodeType(SLC_EXECUTION_FLOW) && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 						return node1.getName().compareTo(node2.getName());
 					} else if (node1.isNodeType(SLC_EXECUTION_FLOW) && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 						return 1;
 					} else if (!node1.isNodeType(SLC_EXECUTION_FLOW) && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 						return -1;
 					} else {
 						// TODO: check title
 						return node1.getName().compareTo(node2.getName());
 					}
 				}
 			} catch (RepositoryException e) {
 				throw new SlcException("Cannot compare " + o1 + " and " + o2, e);
 			}
 			return 0;
 		}
 
 	}
 
 	// private void addContextMenu(TreeViewer flowsViewer) {
 	//
 	// final MenuManager menuMgr = new MenuManager();
 	// menuMgr.setRemoveAllWhenShown(true);
 	// menuMgr.addMenuListener(new IMenuListener() {
 	//
 	// public void menuAboutToShow(IMenuManager manager) {
 	// menuMgr.add(new Action("Test") {
 	// public void run() {
 	// log.debug("do something");
 	// }
 	// });
 	// }
 	// });
 	// Menu menu = menuMgr.createContextMenu(flowsViewer.getControl());
 	// flowsViewer.getTree().setMenu(menu);
 	// getSite().registerContextMenu(menuMgr, flowsViewer);
 	// }
 
 	class VmAgentObserver extends AsyncUiEventListener {
 
 		public VmAgentObserver(Display display) {
 			super(display);
 		}
 
 		protected void onEventInUiThread(List<Event> events) {
 			for (Event event : events) {
 				try {
 					String path = event.getPath();
 
 					if (session.itemExists(path)) {
 						Node parentNode = session.getNode(path);// .getParent();
 						if (log.isTraceEnabled())
 							log.trace("Refresh " + parentNode + " after event " + event);
 						viewer.refresh(parentNode);
 					}
 				} catch (RepositoryException e) {
 					log.warn("Cannot process event " + event + ": " + e);
 				}
 			}
 
 			// TODO: optimize based on event
 			viewer.refresh();
 		}
 	}
 
 	class ViewLabelProvider extends DefaultNodeLabelProvider implements ITableLabelProvider {
 		private static final long serialVersionUID = 2410754425574656399L;
 
 		@Override
 		protected String getText(Node node) throws RepositoryException {
 			if (node.isNodeType(NodeType.MIX_TITLE) && node.hasProperty(Property.JCR_TITLE))
 				return node.getProperty(Property.JCR_TITLE).getString();
 			else if (node.getName().equals(SLC_EXECUTION_SPECS))
 				return "Execution Specifications";
 			else if (node.getPath().equals(SlcJcrConstants.VM_AGENT_FACTORY_PATH))
 				return "Internal Agents";
 			return super.getText(node);
 		}
 
 		@Override
 		public Image getImage(Node node) throws RepositoryException {
 			// we try to optimize a bit by putting deeper nodes first
 			if (node.getParent().isNodeType(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 				return SlcImages.CHOICES;
 			else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 				return SlcImages.EXECUTION_SPEC_ATTRIBUTE;
 			else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC))
 				return SlcImages.EXECUTION_SPEC;
 			else if (node.getName().equals(SLC_EXECUTION_SPECS))
 				return SlcImages.EXECUTION_SPECS;
 			else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 				return SlcImages.FLOW;
 			else if (node.isNodeType(SlcTypes.SLC_MODULE)) {
 				if (node.getProperty(SLC_STARTED).getBoolean())
 					return SlcImages.MODULE;
 				else
 					return SlcImages.MODULE_STOPPED;
 			} else if (node.isNodeType(SlcTypes.SLC_AGENT))
 				return SlcImages.AGENT;
 			else if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY))
 				return SlcImages.AGENT_FACTORY;
 			else
 				return SlcImages.FOLDER;
 		}
 
 		public String getToolTipText(Node node) throws RepositoryException {
 			if (node.isNodeType(NodeType.MIX_TITLE) && node.hasProperty(Property.JCR_DESCRIPTION))
 				return node.getProperty(Property.JCR_DESCRIPTION).getString();
 			return super.getToolTipText(node);
 		}
 
 		public String getColumnText(Object obj, int index) {
 			return getText(obj);
 		}
 
 		public Image getColumnImage(Object obj, int index) {
 			return getImage(obj);
 		}
 
 	}
 
 	class ViewDoubleClickListener implements IDoubleClickListener {
 		public void doubleClick(DoubleClickEvent evt) {
 			Object obj = ((IStructuredSelection) evt.getSelection()).getFirstElement();
 			try {
 				if (obj instanceof Node) {
 					Node node = (Node) obj;
 					if (node.isNodeType(SLC_EXECUTION_MODULE)) {
 						//ClientUiPlugin.startStopExecutionModule(modulesManager, node);
 					} else {
 						String path = node.getPath();
 						// TODO factorize with editor
 						QueryManager qm = node.getSession().getWorkspace().getQueryManager();
 						String statement = "SELECT * FROM [" + SlcTypes.SLC_EXECUTION_FLOW
 								+ "] WHERE ISDESCENDANTNODE(['" + path + "']) OR ISSAMENODE(['" + path + "'])";
 						// log.debug(statement);
 						Query query = qm.createQuery(statement, Query.JCR_SQL2);
 
 						// order paths
 						SortedSet<String> paths = new TreeSet<String>();
 						for (NodeIterator nit = query.execute().getNodes(); nit.hasNext();) {
 							paths.add(nit.nextNode().getPath());
 						}
 
 //						IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
 //								.getActivePage();
 //						activePage.openEditor(new ProcessEditorInput(new ArrayList<String>(paths), true),
 //								ProcessEditor.ID);
 					}
 				}
 			} catch (Exception e) {
 				throw new SlcException("Cannot open " + obj, e);
 			}
 		}
 
 	}
 
 	/** Listen to drags */
 	class ViewDragListener extends DragSourceAdapter {
 		private static final long serialVersionUID = 250270504802674171L;
 
 		// Check if the drag action should start.
 		public void dragStart(DragSourceEvent event) {
 			// we only start drag if at least one of the selected elements is
 			// valid
 			boolean doIt = false;
 			IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
 			@SuppressWarnings("rawtypes")
 			Iterator it = selection.iterator();
 			try {
 				while (it.hasNext()) {
 					Object obj = it.next();
 					if (obj instanceof Node) {
 						Node node = (Node) obj;
 						if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW)
 								|| node.isNodeType(SlcTypes.SLC_EXECUTION_MODULE)) {
 							doIt = true;
 						}
 					}
 				}
 			} catch (RepositoryException e) {
 				throw new SlcException("Cannot read node to set drag data", e);
 			}
 			event.doit = doIt;
 		}
 
 		public void dragSetData(DragSourceEvent event) {
 			IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
 			StringBuilder buf = new StringBuilder();
 			@SuppressWarnings("rawtypes")
 			Iterator it = selection.iterator();
 			try {
 
 				while (it.hasNext()) {
 					Object obj = it.next();
 
 					if (obj instanceof Node) {
 						Node node = (Node) obj;
 						if ((node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW)
 								|| node.isNodeType(SlcTypes.SLC_EXECUTION_MODULE))
 								&& TextTransfer.getInstance().isSupportedType(event.dataType)) {
 							buf.append(node.getPath()).append('\n');
 						}
 					}
 				}
 			} catch (RepositoryException e) {
 				throw new SlcException("Cannot read node to set drag data", e);
 			}
 
 			if (buf.length() > 0) {
 				if (buf.charAt(buf.length() - 1) == '\n')
 					buf.deleteCharAt(buf.length() - 1);
 				event.data = buf.toString();
 				log.debug("data set to : " + buf.toString());
 			}
 		}
 	}
 
 	public void dispose() {
 		JcrUtils.logoutQuietly(session);
 //		if (pushSession != null)
 //			pushSession.stop();
 //		super.dispose();
 	}
 
 	// DEPENDENCY INJECTION
 
 	public void setModulesManager(ExecutionModulesManager modulesManager) {
 		this.modulesManager = modulesManager;
 	}
 
 	public void setRepository(Repository repository) {
 		this.repository = repository;
 	}
 }