EDIT

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.bulkeditor.referencingobjects;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Set;

import java.util.UUID;

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.Job;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.jface.viewers.TreeNode;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Table;

import org.eclipse.ui.IWorkbenchPart;

import org.springframework.remoting.RemoteAccessException;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.IAgentService;

import eu.etaxonomy.cdm.api.service.IDescriptionService;

import eu.etaxonomy.cdm.api.service.IEventBaseService;

import eu.etaxonomy.cdm.api.service.IGroupService;

import eu.etaxonomy.cdm.api.service.IMediaService;

import eu.etaxonomy.cdm.api.service.INameService;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;

import eu.etaxonomy.cdm.api.service.IReferenceService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IUserService;

import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.cdm.model.common.EventBase;

import eu.etaxonomy.cdm.model.common.Group;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.common.User;

import eu.etaxonomy.cdm.model.description.DescriptionBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.PolytomousKey;

import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.molecular.Sequence;

import eu.etaxonomy.cdm.model.name.NonViralName;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.taxeditor.model.DescriptionHelper;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.AbstractCdmViewPart;

/**

 * @author p.ciardelli

 * @created 08.07.2009

 * @version 1.0

 */

public class ReferencingObjectsView extends AbstractCdmViewPart {

	private static final Logger logger = Logger

			.getLogger(ReferencingObjectsView.class);

	public static final String ID = "eu.etaxonomy.taxeditor.bulkeditor.view.referencingobjects";

	private TableViewer viewer;

	private String referencedObjectTitleCache;

	private ConversationHolder conversation;

	private final ICdmEntitySession cdmEntitySession;

	private UUID actualUuid;

	List<CdmBase> referencingObjects = null;

	Set<CdmBase> referencingObjectsSet = null;

	IProgressMonitor actualMonitor = null;

	private Job currentJob = null;

	public ReferencingObjectsView() {

	    cdmEntitySession = CdmStore.getCurrentSessionManager().bindNullSession();

	}

	/** {@inheritDoc} */

	@Override

	public void createViewer(Composite parent) {

		selectionService.addSelectionListener(this);

		conversation = CdmStore.createConversation();

		viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL

				| SWT.V_SCROLL | SWT.FULL_SELECTION);

		createColumns(viewer);

		viewer.setContentProvider(new ReferencingObjectsContentProvider());

		viewer.setLabelProvider(new ReferencingObjectsLabelProvider());

		viewer.setCellModifier(new ICellModifier() {

            @Override

            public void modify(Object element, String property, Object value) {

            }

            @Override

            public Object getValue(Object element, String property) {

                ITableLabelProvider tableLabelProvider = null;

                if(viewer.getLabelProvider() instanceof ITableLabelProvider){

                    tableLabelProvider = (ITableLabelProvider) viewer.getLabelProvider();

                }

                Object[] columnProperties = viewer.getColumnProperties();

                for (int i=0;i<columnProperties.length;i++) {

                    if(columnProperties[i].equals(property) && tableLabelProvider!=null){

                        return tableLabelProvider.getColumnText(element, i);

                    }

                }

                return "";

            }

            @Override

            public boolean canModify(Object element, String property) {

                return true;

            }

        });

        //create context menu

        MenuManager menuManager = new MenuManager();

        getSite().registerContextMenu(menuManager, viewer);

        Control control = viewer.getControl();

        Menu menu = menuManager.createContextMenu(control);

        control.setMenu(menu);

        // Propagate selection from viewer

        getSite().setSelectionProvider(viewer);

	}

	/**

	 * Create the columns for the table

	 * @param viewer

	 */

	private void createColumns(TableViewer viewer) {

		Table table = viewer.getTable();

		String[] titles = {"Class", "Description", "UUID", "Object ID" };

		int[] bounds = { 100, 200, 100, 70};

        CellEditor[] editors = new CellEditor[titles.length];

		for (int i = 0; i < titles.length; i++) {

			TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);

			editors[i] = new TextCellEditor(table);

			column.getColumn().setText(titles[i]);

			column.getColumn().setWidth(bounds[i]);

			column.getColumn().setResizable(true);

			column.getColumn().setMoveable(true);

		}

		table.setHeaderVisible(true);

		table.setLinesVisible(true);

		viewer.setCellEditors(editors);

		viewer.setColumnProperties(titles);

	}

	@Override

	public void setFocus() {

	    cdmEntitySession.bind();

	}

	public void updateReferencingObjects(final UUID entityUUID, final Class objectClass) {

	    if (actualUuid == entityUUID){

	        return ;

	    }

	    showEmptyPage();

	    if(actualMonitor!=null && !actualMonitor.isCanceled()){

//	        boolean success = false;

//	        //wait for cancel to be done

//	        while(!success){

//	            success = currentJob.cancel();

//	        }

//	        currentJob = null;

	        while(!actualMonitor.isCanceled()){

	            actualMonitor.setCanceled(true);

	        }

	    }

		currentJob = new Job("Update Referencing Objects " + entityUUID) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				monitor.beginTask("Calculating referencing objects", 100);

				actualUuid = entityUUID;

				monitor.worked(5);

				referencingObjects = new ArrayList<>();

				if(monitor.isCanceled()) {

				    actualUuid = null;

                    return Status.CANCEL_STATUS;

                }

				if (actualMonitor != null){

				    actualMonitor.setCanceled(true);

				}

				actualMonitor = monitor;

				if (entityUUID != null){

				    ICdmEntitySession previousCdmEntitySession = CdmStore.getCurrentSessionManager().getActiveSession();

	                cdmEntitySession.bind();

	                referencingObjectsSet = getReferencingObjects(entityUUID, objectClass);

	                if(monitor.isCanceled()) {

	                    actualUuid = null;

	                    return Status.CANCEL_STATUS;

	                }

	                monitor.worked(30);

	                referencingObjects = sortReferencing();

	                if (referencingObjects == null){

	                    if (monitor.isCanceled()){

	                        actualUuid = null;

	                        return Status.CANCEL_STATUS;

	                    }

	                }

	                if(monitor.isCanceled()) {

	                    if(previousCdmEntitySession != null) {

	                        previousCdmEntitySession.bind();

	                    }

	                    return Status.CANCEL_STATUS;

	                }

	                monitor.worked(80);

                    updateView();

	                if(previousCdmEntitySession != null) {

	                    previousCdmEntitySession.bind();

	                }

	               // actualUuid = entityUUID;

				}

				monitor.done();

				return Status.OK_STATUS;

			}

		};

		currentJob.setUser(true);

		currentJob.schedule();

//		final IJobChangeListener listener;

//		listener =  new JobChangeAdapter() {

//            @Override

//            public void done(IJobChangeEvent event) {

//                System.err.println("Job is done" + entityUUID);

//                //event.getJob().cancel();

//            }

//

//        };

//        currentJob.addJobChangeListener(listener);

	}

	private Set<CdmBase> getReferencingObjects(UUID entity, Class objectClass) {

		CdmBase referencedObject = null;

        try {

        	if (objectClass.getSuperclass().equals(TeamOrPersonBase.class) ){

	        	referencedObject = CdmStore.getService(IAgentService.class).load(entity);

        	} else if (objectClass.getSuperclass().equals(NonViralName.class)){

        		referencedObject = CdmStore.getService(INameService.class).load(entity);

        	} else if (objectClass.getSuperclass().equals(TaxonBase.class)){

        		referencedObject = CdmStore.getService(ITaxonService.class).load(entity);

        	} else if (objectClass.equals(Reference.class)){

        		referencedObject = CdmStore.getService(IReferenceService.class).load(entity);

        	} else if (objectClass.getSuperclass().equals(SpecimenOrObservationBase.class)){

        		referencedObject = CdmStore.getService(IOccurrenceService.class).load(entity);

        	} else if (objectClass.isAssignableFrom(User.class)){

        		referencedObject = CdmStore.getService(IUserService.class).load(entity);

        	} else if (objectClass.isAssignableFrom(Group.class)){

        		referencedObject = CdmStore.getService(IGroupService.class).load(entity);

        	} else if (objectClass.isAssignableFrom(Media.class)){

        	    referencedObject = CdmStore.getService(IMediaService.class).load(entity);

        	} else if (DescriptionBase.class.isAssignableFrom(objectClass)){

        	    referencedObject = CdmStore.getService(IDescriptionService.class).load(entity);

        	} else if (DescriptionElementBase.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IDescriptionService.class).loadDescriptionElement(entity, null);

            } else if (objectClass.equals(Sequence.class)){

                referencedObject = CdmStore.getService(ISequenceService.class).load(entity, null);

            } else if (PolytomousKey.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IPolytomousKeyService.class).load(entity, null);

            } else if (PolytomousKeyNode.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IPolytomousKeyNodeService.class).load(entity, null);

            } else if (DefinedTermBase.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(ITermService.class).load(entity, null);

            } else if (EventBase.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IEventBaseService.class).load(entity, null);

            } else if (User.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IUserService.class).load(entity, null);

            } else if (Group.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getService(IGroupService.class).load(entity, null);

            }

            else if(CdmBase.class.isAssignableFrom(objectClass)){

                referencedObject = CdmStore.getCommonService().find(objectClass, entity);

            }

	        	//referencedObject =(CdmBase) CdmStore.getService(IIdentifiableEntityService.class).load(referencedObject.getUuid());

        	Set<CdmBase> setOfReferencingObjects = null;

        	if (referencedObject != null){

        	    if(referencedObject.isInstanceOf(IdentifiableEntity.class)){

        	        referencedObjectTitleCache = (HibernateProxyHelper.deproxy(referencedObject, IdentifiableEntity.class)).getTitleCache();

        	    }

        	    else if(referencedObject.isInstanceOf(DescriptionElementBase.class)){

        	        referencedObjectTitleCache = DescriptionHelper.getLabel(referencedObject);

        	    }

        	    else if (referencedObject.isInstanceOf(User.class)){

        	        referencedObjectTitleCache = ((User)referencedObject).getUsername();

        	    }else{

        	        referencedObjectTitleCache = null;

        	    }

        		setOfReferencingObjects = CdmStore.getCommonService().getReferencingObjects(referencedObject);

        		return setOfReferencingObjects;

        	}

        } catch (Exception e) {

            logger.error("Error retrieving referencing objects", e);

            e.printStackTrace();

            updateDescription("The referencing objects view could not be loaded completely. Some Problems occured.");

        }

		return null;

	}

	private List<CdmBase> sortReferencing(){

	    if (referencingObjectsSet != null){

            List<CdmBase> referencingObjects = new ArrayList<CdmBase>(referencingObjectsSet);

            try{

                Collections.sort(referencingObjects, new ReferencingClassComparator());

            }catch (RemoteAccessException e){

                logger.debug(e.getStackTrace());

                return null;

            }

            return referencingObjects;

        }

	    return null;

	}

	class ReferencingClassComparator implements Comparator<CdmBase>   {

		@Override

        public int compare(CdmBase o1, CdmBase o2) {

			String string1 = o1.getClass().getSimpleName();

			String string2 = o2.getClass().getSimpleName();

			int result = string1.compareToIgnoreCase(string2);

			if (result == 0) {

				string1 = DescriptionHelper.getObjectDescription(o1);

				string2 = DescriptionHelper.getObjectDescription(o2);

				result = string1.compareToIgnoreCase(string2);

				if (result == 0){

				    return o1.getUuid().compareTo(o2.getUuid());

				}

			}

				return result;

		}

	}

	private void updateView() {

	    Display.getDefault().asyncExec(new Runnable() {

            @Override

            public void run() {

        		if (viewer != null && !viewer.getControl().isDisposed()){

        			try{

        				viewer.setInput(referencingObjects);

        				showViewer();

        				//enable/disable table

        				viewer.getControl().setEnabled(referencingObjects!=null);

        			}catch(Exception e){

        			    e.printStackTrace();

        			    logger.debug(e.getStackTrace());

        			    updateDescription("The referencing objects view could not be loaded completely. Some Problems occured.");

        			}

        		}

            }

            });

	}

	private void updateDescription(final String description){

	    Display.getDefault().asyncExec(new Runnable() {

            @Override

            public void run() {

        	    if (referencedObjectTitleCache != null){

                    setContentDescription(description);

                } else {

                    setContentDescription(description);

                }

            }

         });

	 }

	/** {@inheritDoc} */

	@Override

    public void selectionChanged(IWorkbenchPart part, ISelection selection) {

        if(part == this){

            return;

        }

        if(selection instanceof IStructuredSelection){

        	//referencedObjectTitleCache = null;

        	showViewer(part, (IStructuredSelection) selection);

        }

	}

	/** {@inheritDoc} */

	@Override

	public void showViewer(IWorkbenchPart part, IStructuredSelection selection) {

	//	this.part = part;

		Object firstElement = selection.getFirstElement();

		if(firstElement instanceof TreeNode){

		    firstElement = ((TreeNode) firstElement).getValue();

		}

		if(firstElement instanceof CdmBase){

		    CdmBase referencedCdmObject = (CdmBase) firstElement;

		    if (referencedCdmObject.getUuid() == actualUuid){

		        return;

		    }

		    if (referencedCdmObject != null){

                if(referencedCdmObject.isInstanceOf(IdentifiableEntity.class)){

                    referencedObjectTitleCache = (HibernateProxyHelper.deproxy(referencedCdmObject, IdentifiableEntity.class)).getTitleCache();

                }

                else if(referencedCdmObject.isInstanceOf(DescriptionElementBase.class)){

                    referencedObjectTitleCache = DescriptionHelper.getLabel(referencedCdmObject);

                }

                else if (referencedCdmObject.isInstanceOf(User.class)){

                    referencedObjectTitleCache = ((User)referencedCdmObject).getUsername();

                }else{

                    referencedObjectTitleCache = null;

                }

		    }

		    if (referencedObjectTitleCache != null){

		        updateDescription("'" + referencedObjectTitleCache + "' is referenced by:");

		    } else{

		        updateDescription("");

		    }

		    updateReferencingObjects(referencedCdmObject.getUuid(),firstElement.getClass() );

		}

		else if (firstElement != null){

		    updateView();

            updateDescription("");

		}

	}

	/** {@inheritDoc} */

	@Override

	public void dispose() {

		conversation.close();

		selectionService.removePostSelectionListener(this);

		selectionService.removeSelectionListener(this);

		cdmEntitySession.dispose();

		super.dispose();

	}

	/** {@inheritDoc} */

	@Override

	public Viewer getViewer() {

		return viewer;

	}

	/** {@inheritDoc} */

	@Override

	public void changed(Object object) {

		// no editing in this view

	}

	/** {@inheritDoc} */

	@Override

	public boolean onComplete() {

		return false;

	}

	public void refresh(){

		selectionService.removePostSelectionListener(this);

		selectionService.removeSelectionListener(this);

		selectionService.addPostSelectionListener(this);

		selectionService.addSelectionListener(this);

	}

	@Override

	protected String getViewName() {

		return "Referencing Objects";

	}

}