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

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

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.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ICellModifier;

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

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Table;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.term.TermBase;

import eu.etaxonomy.cdm.persistence.dto.ReferencingObjectDto;

import eu.etaxonomy.cdm.persistence.dto.TermDto;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

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

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

import eu.etaxonomy.taxeditor.editor.IReferencingObjectsView;

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 implements IReferencingObjectsView{

    private static final Logger logger = Logger.getLogger(ReferencingObjectsViewE4.class);

    public static final String IS_LOADING = "Loading ...";

//    public static final String CANCELED = "Canceled ...";

    private Label contentDescription;

    private String description;

//	private String referencedObjectTitleCache;

	private ConversationHolder conversation;

	private UUID actualUuid;

	private List<ReferencingObjectDto> referencingObjects = null;

	private Set<ReferencingObjectDto> referencingObjectsSet = null;

	private IProgressMonitor actualMonitor = null;

	private Job currentJob = null;

    @PostConstruct

    public void create(Composite parent, EMenuService menuService) {

        if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

        }

        else{

            return;

        }

        parent.setLayout(new GridLayout());

		contentDescription = new Label(parent, SWT.NONE);

		contentDescription.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));

		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.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

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

	}

	@Override

    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 for " + entityUUID) {

			@Override

			protected IStatus run(final IProgressMonitor monitor) {

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

				actualUuid = entityUUID;

				monitor.worked(2);

				ReferencingObjectDto loadDto = new ReferencingObjectDto();

				loadDto.setTitleCache(IS_LOADING);

				referencingObjects = Arrays.asList(loadDto);

				updateView();

				if(monitor.isCanceled()) {

//				    actualUuid = null;

                    return Status.CANCEL_STATUS;

                }

				if (actualMonitor != null){

				    actualMonitor.setCanceled(true);

				}

				actualMonitor = monitor;

				if (entityUUID != null){

				    monitor.subTask("Load data from server");

				    monitor.worked(1);

	                Set<ReferencingObjectDto> refObjectsFromServer = loadReferencingObjects(entityUUID, objectClass);

	                monitor.worked(25);

	                if(monitor.isCanceled()) {

//	                  actualUuid = null;

	                    return Status.CANCEL_STATUS;

	                }

	                referencingObjectsSet = refObjectsFromServer;

	                monitor.subTask("Show without description");

	                monitor.worked(1);//maybe this helps to update the subtask label

	                //TODO have a status line instead

	                updateDescriptionLabel(description + "(n="+referencingObjectsSet.size()+")"); //

	                List<ReferencingObjectDto> localDtos = sortToList(referencingObjectsSet, monitor);

	                monitor.worked(10);

	                if(monitor.isCanceled()) {

//	                    actualUuid = null;

	                    return Status.CANCEL_STATUS;

	                }

	                referencingObjects = localDtos;

	                updateView();

	                monitor.subTask("Initialize");

	                monitor.worked(1);//maybe this helps to update the subtask label

                    initializeDtos(localDtos, monitor, 50);

                    if (monitor.isCanceled()){

//                        actualUuid = null;

                        //TODO use status line instead

//                        referencingObjects = Arrays.asList(CANCELED);

                        updateView();

//                        monitor.done();

                        return Status.CANCEL_STATUS;

                    }

                    //not necessary anymore, we sort by type and

                    //id as this can be done immediately

//	                monitor.subTask("Sort");

//                    referencingObjects = sortReferencing();

//                    monitor.worked(5);

//	                if (referencingObjects == null){

//	                    if (monitor.isCanceled()){

////	                        actualUuid = null;

//	                        return Status.CANCEL_STATUS;

//	                    }

//	                }

	                if(monitor.isCanceled()) {

	                    return Status.CANCEL_STATUS;

	                }

	                monitor.subTask("Update View");

	                updateView();

	                monitor.worked(5);

				}

				monitor.done();

				actualMonitor = null;

				return Status.OK_STATUS;

			}

		};

		currentJob.setUser(true);

		currentJob.schedule();

	}

    private List<ReferencingObjectDto> sortToList(Set<ReferencingObjectDto> referencingObjectsSet, IProgressMonitor monitor) {

        List<ReferencingObjectDto> result = new ArrayList<>(referencingObjectsSet);

        //TODO make singleton

        Collections.sort(result, new RefObjectDtoComparator());

        return result;

    }

    protected boolean initializeDtos(List<ReferencingObjectDto> localDtos, IProgressMonitor monitor, int work) {

        IProgressMonitor subMonitor = AbstractUtility.getSubProgressMonitor(monitor, work);

        subMonitor.beginTask("Initialize DTOs", localDtos.size());

        int i = 100 - 20;  //the first run should only include 20 records

        Set<ReferencingObjectDto> toInitialize = new HashSet<>();

        for (ReferencingObjectDto dto : localDtos){

            toInitialize.add(dto);

//            dto.setTitleCache(ReferencingObjectFormatter.format(dto.getReferencedEntity(), CdmStore.getDefaultLanguage() ));

            if (monitor.isCanceled()){

                return false;

            }

            subMonitor.worked(1);

            if (++i == 100){

                initBulk(toInitialize);

                updateView();

                toInitialize = new HashSet<>();

                i = 0;

            }

        }

        initBulk(toInitialize);

        return true;

    }

    private void initBulk(Set<ReferencingObjectDto> toInitialize) {

        Set<ReferencingObjectDto> initialized = CdmStore.getCommonService().initializeReferencingObjectDtos(toInitialize, true, true, true, CdmStore.getDefaultLanguage());

        Map<UUID,ReferencingObjectDto> map = new HashMap<>();

        initialized.forEach(i->map.put(i.getUuid(), i));

        toInitialize.forEach(dto->merge(dto, map.get(dto.getUuid())));

        updateView();

    }

    private void merge(ReferencingObjectDto to, ReferencingObjectDto from) {

        to.setTitleCache(from.getTitleCache());

        to.setOpenInTarget(from.getOpenInTarget());

        to.setReferencedEntity(from.getReferencedEntity());

    }

    private Set<ReferencingObjectDto> loadReferencingObjects(UUID entity, Class objectClass) {

		//TODO why do we need to load the referenced object here

        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<ReferencingObjectDto> 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 = DescriptionHelper.getLabel(referencedObject);

//        	    }

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

        		return setOfReferencingObjects;

        	}

        } catch (Exception e) {

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

            e.printStackTrace();

            updateDescriptionLabel("The referencing objects view could not be loaded completely. Some problems occurred: " + e.getMessage());

        }

		return null;

	}

	class RefObjectDtoComparator implements Comparator<ReferencingObjectDto>{

        @Override

        public int compare(ReferencingObjectDto dto1, ReferencingObjectDto dto2) {

            int result = dto1.getType().getSimpleName().compareToIgnoreCase(dto2.getType().getSimpleName());

            if (result == 0) {

                result = Integer.compare(dto1.getId(),dto2.getId());

            }

            return result;

        }

	}

	private void updateView() {

	    Display.getDefault().asyncExec(()->{

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

                    updateDescriptionLabel("The referencing objects view could not be updated completely. Some Problems occurred: " + e.getMessage());

                }

            }

	    });

	}

	private void updateDescriptionLabel(final String description){

	    Display.getDefault().asyncExec(()->{

                if(contentDescription!=null && !contentDescription.isDisposed()) {

                    contentDescription.setText(description.replace("&", "&&"));

                }

            }

         );

	 }

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

        }

	}

	@Override

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

	//	this.part = part;

		Object firstElement = selection.getFirstElement();

		if (firstElement instanceof TermDto){

		   TermDto termDto = (TermDto) firstElement;

		   description = "'"+termDto.getRepresentation_L10n() + "' is referenced by:";

		   updateDescriptionLabel(description);

		   updateReferencingObjects(termDto.getUuid(), TermBase.class );

		   return;

		}

		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;

		    }

		    String referencedObjectTitleCache = 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 (CdmUtils.isBlank(referencedObjectTitleCache)){

	            referencedObjectTitleCache = "#"+referencedCdmObject.getId();

	        }

	        description = referencedCdmObject.getUserFriendlyTypeName() + " '" + referencedObjectTitleCache + "' is referenced by:";

	        updateDescriptionLabel(description);

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

		}else if  (firstElement instanceof UuidAndTitleCache<?>){

		    UuidAndTitleCache<?> element = (UuidAndTitleCache<?>) firstElement;

		    description = element.getType().getSimpleName() + " '" + element.getTitleCache() + "' is referenced by:";

	        updateDescriptionLabel(description);

            updateReferencingObjects(element.getUuid(),element.getType());

		}

		else if (firstElement != null){

		    updateView();

            description = "undefined:";

		    updateDescriptionLabel(description);

		}

	}

	@PreDestroy

	public void dispose() {

	    if(conversation!=null){

	        conversation.close();

	        conversation = null;

	    }

	}

	@Override

	public void changed(Object object) {

		// no editing in this view

	}

	@Override

	public boolean onComplete() {

		return false;

	}

	@Override

	protected String getViewName() {

		return "Referencing Objects";

	}

}