/*
    * 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.cms.e4.jcr;
  
  import java.util.List;
  
  import javax.annotation.PostConstruct;
  import javax.annotation.PreDestroy;
  import javax.inject.Inject;
  import javax.jcr.Property;
  import javax.jcr.PropertyType;
  import javax.jcr.Repository;
  import javax.jcr.RepositoryException;
  import javax.jcr.RepositoryFactory;
  import javax.jcr.Session;
  import javax.jcr.Value;
  import javax.jcr.observation.Event;
  import javax.jcr.observation.EventListener;
  import javax.jcr.observation.ObservationManager;
  
  import org.argeo.api.NodeConstants;
  import org.argeo.api.security.CryptoKeyring;
  import org.argeo.api.security.Keyring;
  import org.argeo.cms.CmsException;
  import org.argeo.cms.ui.jcr.JcrBrowserUtils;
  import org.argeo.cms.ui.jcr.NodeContentProvider;
  import org.argeo.cms.ui.jcr.NodeLabelProvider;
  import org.argeo.cms.ui.jcr.OsgiRepositoryRegister;
  import org.argeo.cms.ui.jcr.PropertiesContentProvider;
  import org.argeo.cms.ui.jcr.model.SingleJcrNodeElem;
  import org.argeo.cms.ui.util.CmsUiUtils;
  import org.argeo.eclipse.ui.EclipseUiException;
  import org.argeo.eclipse.ui.TreeParent;
  import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  import org.argeo.eclipse.ui.jcr.util.NodeViewerComparer;
  import org.argeo.jcr.JcrUtils;
  import org.eclipse.e4.core.contexts.IEclipseContext;
  import org.eclipse.e4.core.di.annotations.Optional;
  import org.eclipse.e4.ui.services.EMenuService;
  import org.eclipse.e4.ui.workbench.modeling.EPartService;
  import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
  import org.eclipse.jface.viewers.ColumnLabelProvider;
  import org.eclipse.jface.viewers.IBaseLabelProvider;
  import org.eclipse.jface.viewers.ISelectionChangedListener;
  import org.eclipse.jface.viewers.IStructuredSelection;
  import org.eclipse.jface.viewers.ITreeContentProvider;
  import org.eclipse.jface.viewers.SelectionChangedEvent;
  import org.eclipse.jface.viewers.StructuredSelection;
  import org.eclipse.jface.viewers.TableViewer;
  import org.eclipse.jface.viewers.TableViewerColumn;
  import org.eclipse.jface.viewers.TreeViewer;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.custom.SashForm;
  import org.eclipse.swt.layout.FillLayout;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Display;
  
  /**
   * Basic View to display a sash form to browse a JCR compliant multiple
   * repository environment
   */
  public class JcrBrowserView {
  	final static String ID = "org.argeo.cms.e4.jcrbrowser";
  	final static String NODE_VIEWER_POPUP_MENU_ID = "org.argeo.cms.e4.popupmenu.nodeViewer";
  
  	private boolean sortChildNodes = true;
  
  	/* DEPENDENCY INJECTION */
  	@Inject
  	@Optional
  	private Keyring keyring;
  	@Inject
  	private RepositoryFactory repositoryFactory;
  	@Inject
  	private Repository nodeRepository;
  
  	// Current user session on the home repository default workspace
  	private Session userSession;
  
  	private OsgiRepositoryRegister repositoryRegister = new OsgiRepositoryRegister();
  
  	// This page widgets
  	private TreeViewer nodesViewer;
  	private NodeContentProvider nodeContentProvider;
  	private TableViewer propertiesViewer;
 	private EventListener resultsObserver;
 
 	@PostConstruct
 	public void createPartControl(Composite parent, IEclipseContext context, EPartService partService,
 			ESelectionService selectionService, EMenuService menuService) {
 		repositoryRegister.init();
 
 		parent.setLayout(new FillLayout());
 		SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
 		// sashForm.setSashWidth(4);
 		// sashForm.setLayout(new FillLayout());
 
 		// Create the tree on top of the view
 		Composite top = new Composite(sashForm, SWT.NONE);
 		// GridLayout gl = new GridLayout(1, false);
 		top.setLayout(CmsUiUtils.noSpaceGridLayout());
 
 		try {
 			this.userSession = this.nodeRepository.login(NodeConstants.HOME_WORKSPACE);
 		} catch (RepositoryException e) {
 			throw new CmsException("Cannot open user session", e);
 		}
 
 		nodeContentProvider = new NodeContentProvider(userSession, keyring, repositoryRegister, repositoryFactory,
 				sortChildNodes);
 
 		// nodes viewer
 		nodesViewer = createNodeViewer(top, nodeContentProvider);
 
 		// context menu : it is completely defined in the plugin.xml file.
 		// MenuManager menuManager = new MenuManager();
 		// Menu menu = menuManager.createContextMenu(nodesViewer.getTree());
 
 		// nodesViewer.getTree().setMenu(menu);
 
 		nodesViewer.setInput("");
 
 		// Create the property viewer on the bottom
 		Composite bottom = new Composite(sashForm, SWT.NONE);
 		bottom.setLayout(CmsUiUtils.noSpaceGridLayout());
 		propertiesViewer = createPropertiesViewer(bottom);
 
 		sashForm.setWeights(getWeights());
 		nodesViewer.setComparer(new NodeViewerComparer());
 		nodesViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 			public void selectionChanged(SelectionChangedEvent event) {
 				IStructuredSelection selection = (IStructuredSelection) event.getSelection();
 				selectionService.setSelection(selection.toList());
 			}
 		});
 		nodesViewer.addDoubleClickListener(new JcrE4DClickListener(nodesViewer, partService));
 		menuService.registerContextMenu(nodesViewer.getControl(), NODE_VIEWER_POPUP_MENU_ID);
 		// getSite().registerContextMenu(menuManager, nodesViewer);
 		// getSite().setSelectionProvider(nodesViewer);
 	}
 
 	@PreDestroy
 	public void dispose() {
 		JcrUtils.logoutQuietly(userSession);
 		repositoryRegister.destroy();
 	}
 
 	public void refresh(Object obj) {
 		// Enable full refresh from a command when no element of the tree is
 		// selected
 		if (obj == null) {
 			Object[] elements = nodeContentProvider.getElements(null);
 			for (Object el : elements) {
 				if (el instanceof TreeParent)
 					JcrBrowserUtils.forceRefreshIfNeeded((TreeParent) el);
 				getNodeViewer().refresh(el);
 			}
 		} else
 			getNodeViewer().refresh(obj);
 	}
 
 	/**
 	 * To be overridden to adapt size of form and result frames.
 	 */
 	protected int[] getWeights() {
 		return new int[] { 70, 30 };
 	}
 
 	protected TreeViewer createNodeViewer(Composite parent, final ITreeContentProvider nodeContentProvider) {
 
 		final TreeViewer tmpNodeViewer = new TreeViewer(parent, SWT.MULTI);
 
 		tmpNodeViewer.getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 
 		tmpNodeViewer.setContentProvider(nodeContentProvider);
 		tmpNodeViewer.setLabelProvider((IBaseLabelProvider) new NodeLabelProvider());
 		tmpNodeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 			public void selectionChanged(SelectionChangedEvent event) {
 				if (!event.getSelection().isEmpty()) {
 					IStructuredSelection sel = (IStructuredSelection) event.getSelection();
 					Object firstItem = sel.getFirstElement();
 					if (firstItem instanceof SingleJcrNodeElem)
 						propertiesViewer.setInput(((SingleJcrNodeElem) firstItem).getNode());
 				} else {
 					propertiesViewer.setInput("");
 				}
 			}
 		});
 
 		resultsObserver = new TreeObserver(tmpNodeViewer.getTree().getDisplay());
 		if (keyring != null)
 			try {
 				ObservationManager observationManager = userSession.getWorkspace().getObservationManager();
 				observationManager.addEventListener(resultsObserver, Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED, "/",
 						true, null, null, false);
 			} catch (RepositoryException e) {
 				throw new EclipseUiException("Cannot register listeners", e);
 			}
 
 		// tmpNodeViewer.addDoubleClickListener(new JcrDClickListener(tmpNodeViewer));
 		return tmpNodeViewer;
 	}
 
 	protected TableViewer createPropertiesViewer(Composite parent) {
 		propertiesViewer = new TableViewer(parent, SWT.NONE);
 		propertiesViewer.getTable().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 		propertiesViewer.getTable().setHeaderVisible(true);
 		propertiesViewer.setContentProvider(new PropertiesContentProvider());
 		TableViewerColumn col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 		col.getColumn().setText("Name");
 		col.getColumn().setWidth(200);
 		col.setLabelProvider(new ColumnLabelProvider() {
 			private static final long serialVersionUID = -6684361063107478595L;
 
 			public String getText(Object element) {
 				try {
 					return ((Property) element).getName();
 				} catch (RepositoryException e) {
 					throw new EclipseUiException("Unexpected exception in label provider", e);
 				}
 			}
 		});
 		col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 		col.getColumn().setText("Value");
 		col.getColumn().setWidth(400);
 		col.setLabelProvider(new ColumnLabelProvider() {
 			private static final long serialVersionUID = -8201994187693336657L;
 
 			public String getText(Object element) {
 				try {
 					Property property = (Property) element;
 					if (property.getType() == PropertyType.BINARY)
 						return "<binary>";
 					else if (property.isMultiple()) {
 						StringBuffer buf = new StringBuffer("[");
 						Value[] values = property.getValues();
 						for (int i = 0; i < values.length; i++) {
 							if (i != 0)
 								buf.append(", ");
 							buf.append(values[i].getString());
 						}
 						buf.append(']');
 						return buf.toString();
 					} else
 						return property.getValue().getString();
 				} catch (RepositoryException e) {
 					throw new EclipseUiException("Unexpected exception in label provider", e);
 				}
 			}
 		});
 		col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 		col.getColumn().setText("Type");
 		col.getColumn().setWidth(200);
 		col.setLabelProvider(new ColumnLabelProvider() {
 			private static final long serialVersionUID = -6009599998150286070L;
 
 			public String getText(Object element) {
 				return JcrBrowserUtils.getPropertyTypeAsString((Property) element);
 			}
 		});
 		propertiesViewer.setInput("");
 		return propertiesViewer;
 	}
 
 	protected TreeViewer getNodeViewer() {
 		return nodesViewer;
 	}
 
 	/**
 	 * Resets the tree content provider
 	 * 
 	 * @param sortChildNodes if true the content provider will use a comparer to
 	 *                       sort nodes that might slow down the display
 	 */
 	public void setSortChildNodes(boolean sortChildNodes) {
 		this.sortChildNodes = sortChildNodes;
 		((NodeContentProvider) nodesViewer.getContentProvider()).setSortChildren(sortChildNodes);
 		nodesViewer.setInput("");
 	}
 
 	/** Notifies the current view that a node has been added */
 	public void nodeAdded(TreeParent parentNode) {
 		// insure that Ui objects have been correctly created:
 		JcrBrowserUtils.forceRefreshIfNeeded(parentNode);
 		getNodeViewer().refresh(parentNode);
 		getNodeViewer().expandToLevel(parentNode, 1);
 	}
 
 	/** Notifies the current view that a node has been removed */
 	public void nodeRemoved(TreeParent parentNode) {
 		IStructuredSelection newSel = new StructuredSelection(parentNode);
 		getNodeViewer().setSelection(newSel, true);
 		// Force refresh
 		IStructuredSelection tmpSel = (IStructuredSelection) getNodeViewer().getSelection();
 		getNodeViewer().refresh(tmpSel.getFirstElement());
 	}
 
 	class TreeObserver extends AsyncUiEventListener {
 
 		public TreeObserver(Display display) {
 			super(display);
 		}
 
 		@Override
 		protected Boolean willProcessInUiThread(List<Event> events) throws RepositoryException {
 			for (Event event : events) {
 				if (getLog().isTraceEnabled())
 					getLog().debug("Received event " + event);
 				String path = event.getPath();
 				int index = path.lastIndexOf('/');
 				String propertyName = path.substring(index + 1);
 				if (getLog().isTraceEnabled())
 					getLog().debug("Concerned property " + propertyName);
 			}
 			return false;
 		}
 
 		protected void onEventInUiThread(List<Event> events) throws RepositoryException {
 			if (getLog().isTraceEnabled())
 				getLog().trace("Refresh result list");
 			nodesViewer.refresh();
 		}
 
 	}
 
 	public boolean getSortChildNodes() {
 		return sortChildNodes;
 	}
 
 	public void setFocus() {
 		getNodeViewer().getTree().setFocus();
 	}
 
 	/* DEPENDENCY INJECTION */
 	// public void setRepositoryRegister(RepositoryRegister repositoryRegister) {
 	// this.repositoryRegister = repositoryRegister;
 	// }
 
 	public void setKeyring(CryptoKeyring keyring) {
 		this.keyring = keyring;
 	}
 
 	public void setRepositoryFactory(RepositoryFactory repositoryFactory) {
 		this.repositoryFactory = repositoryFactory;
 	}
 
 	public void setNodeRepository(Repository nodeRepository) {
 		this.nodeRepository = nodeRepository;
 	}
 }