EDIT

// $Id$

/**

* 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 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.IReferenceService;

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

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

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

		final Display display = Display.getCurrent();

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

			@Override

			protected IStatus run(IProgressMonitor monitor) {

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

				monitor.worked(3);

				display.asyncExec(new Runnable() {

					@Override

					public void run() {

						if (entityUUID != null){

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

						    cdmEntitySession.bind();

							List<CdmBase> referencingObjects = getReferencingObjects(entityUUID, objectClass);

							if(previousCdmEntitySession != null) {

							    previousCdmEntitySession.bind();

							}

							updateView(referencingObjects);

						}

					}

				});

				monitor.done();

				return Status.OK_STATUS;

			}

		};

		job.setPriority(Job.DECORATE);

		job.schedule();

	}

	private List<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 (EventBase.class.isAssignableFrom(objectClass)){

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

            }

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

        	        referencedObjectTitleCache = null;

        	    }

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

        	}

	        if (setOfReferencingObjects != null){

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

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

		    	return referencingObjects;

        	}

        } catch (Exception e) {

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

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

        }

		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 classCompare = string1.compareToIgnoreCase(string2);

			if (classCompare == 0) {

				string1 = DescriptionHelper.getObjectDescription(o1);

				string2 = DescriptionHelper.getObjectDescription(o2);

				return string1.compareToIgnoreCase(string2);

			} else {

				return classCompare;

			}

		}

	}

	private void updateView(List<CdmBase> referencingObjects) {

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

			try{

				viewer.setInput(referencingObjects);

				if (referencedObjectTitleCache != null){

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

				} else {

					setContentDescription("");

				}

				showViewer();

			}catch(Exception e){

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

			}

		}

	}

	/** {@inheritDoc} */

	@Override

    public void selectionChanged(IWorkbenchPart part, ISelection selection) {

        if(part == this){

            return;

        }

        if(selection instanceof IStructuredSelection){

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

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

		}

		else{

		    updateView(null);

            setContentDescription("");

		}

	}

	/** {@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);

	}

}