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

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 javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

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.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.ISelectionChangedListener;

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

import org.eclipse.swt.widgets.Table;

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

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

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

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

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

import eu.etaxonomy.taxeditor.bulkeditor.referencingobjects.ReferencingObjectsContentProvider;

import eu.etaxonomy.taxeditor.bulkeditor.referencingobjects.ReferencingObjectsLabelProvider;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.DescriptionHelper;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.e4.AbstractCdmEditorPartE4;

/**

 *

 * @author pplitzner

 * @since Aug 16, 2017

 *

 */

public class ReferencingObjectsViewE4 extends AbstractCdmEditorPartE4 {

    private static final Logger logger = Logger

			.getLogger(ReferencingObjectsViewE4.class);

	private TableViewer viewer;

	private String referencedObjectTitleCache;

	private ConversationHolder conversation;

	private UUID actualUuid;

	List<CdmBase> referencingObjects = null;

	Set<CdmBase> referencingObjectsSet = null;

	IProgressMonitor actualMonitor = null;

	private Job currentJob = null;

    private ISelectionChangedListener selectionChangedListener;

    @Inject

    private ESelectionService selService;

    @PostConstruct

    public void create(Composite parent, EMenuService menuService) {

		conversation = CdmStore.createConversation();

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

				| SWT.V_SCROLL | SWT.FULL_SELECTION);

		createColumns(tableViewer);

		tableViewer.setContentProvider(new ReferencingObjectsContentProvider());

		tableViewer.setLabelProvider(new ReferencingObjectsLabelProvider());

		tableViewer.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(tableViewer.getLabelProvider() instanceof ITableLabelProvider){

                    tableLabelProvider = (ITableLabelProvider) tableViewer.getLabelProvider();

                }

                Object[] columnProperties = tableViewer.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;

            }

        });

		viewer = tableViewer;

        // Propagate selection from viewer

        selectionChangedListener = (event -> selService.setSelection(AbstractUtility.getElementsFromSelectionChangedEvent(event)));

        viewer.addSelectionChangedListener(selectionChangedListener);

        //create context menu

        menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.bulkeditor.popupmenu.referencingobjectsview");

	}

	/**

	 * 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);

	}

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

	    if (actualUuid == entityUUID){

	        return ;

	    }

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

	        while(!actualMonitor.isCanceled()){

	            actualMonitor.setCanceled(true);

	        }

	    }

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

			@Override

			protected IStatus run(final 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){

	                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()) {

	                    return Status.CANCEL_STATUS;

	                }

	                monitor.worked(80);

	                updateView();

				}

				monitor.done();

				actualMonitor = null;

				return Status.OK_STATUS;

			}

		};

		currentJob.setUser(true);

		currentJob.schedule();

	}

	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(TaxonName.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.debug("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);

        				viewer.refresh();

        				//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){

            	    //FIXME E4 implement

//                    setContentDescription(description);

                } else {

//                    setContentDescription(description);

                }

            }

         });

	 }

    @Override

    public void selectionChanged_internal(Object selection, MPart activePart, MPart thisPart) {

        if(activePart==thisPart){

            return;

        }

        IStructuredSelection structuredSelection = createSelection(selection);

        if(structuredSelection!=null){

        	//referencedObjectTitleCache = null;

        	showViewer(structuredSelection, activePart, viewer);

        }

	}

	/** {@inheritDoc} */

	@Override

	public void showViewer(IStructuredSelection selection, MPart activePart, Viewer viewer){

	//	this.part = part;

		Object firstElement = selection.getFirstElement();

		if(firstElement instanceof TreeNode){

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

		}

		if (firstElement instanceof TaxonNode && !((TaxonNode)firstElement).hasTaxon()){

			firstElement = ((TaxonNode)firstElement).getClassification();

		}

		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 if (referencedCdmObject.isInstanceOf(TaxonNode.class)){

                    referencedObjectTitleCache = "TaxonNode of "+(HibernateProxyHelper.deproxy(referencedCdmObject, TaxonNode.class)).getTaxon().getTitleCache();

                }

		    }

		    if (referencedObjectTitleCache != null){

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

		    } else{

		        updateDescription("");

		    }

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

		}

		else if (firstElement != null){

		    updateView();

            updateDescription("");

		}

	}

	/** {@inheritDoc} */

	@PreDestroy

	public void dispose() {

		conversation.close();

	}

	/** {@inheritDoc} */

	@Override

	public void changed(Object object) {

		// no editing in this view

	}

	/** {@inheritDoc} */

	@Override

	public boolean onComplete() {

		return false;

	}

	@Override

	protected String getViewName() {

		return "Referencing Objects";

	}

}