EDIT

/**

* Copyright (C) 2017 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.editor.descriptiveDataSet;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import javax.inject.Named;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.core.contexts.ContextInjectionFactory;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

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

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

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

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.window.Window;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.KeyAdapter;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.IDescriptiveDataSetEditor;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 * Editor for configuring DescriptiveDataSets

 * @author pplitzner

 * @since Nov 21, 2017

 *

 */

public class DescriptiveDataSetEditor implements IE4SavablePart, IConversationEnabled, ICdmEntitySessionEnabled,

IPartContentHasDetails, IPartContentHasSupplementalData, IDirtyMarkable, IDescriptiveDataSetEditor {

    private DescriptiveDataSetComposite composite;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    private DescriptiveDataSet descriptiveDataSet;

    private final int dndOperations = DND.DROP_MOVE;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    @Inject

    private ESelectionService selectionService;

    private ModifyListener labelModifyListener;

    @PostConstruct

    public void create(Composite parent, IEclipseContext context, @Named(IServiceConstants.ACTIVE_SHELL)Shell shell,

            EMenuService menuService){

        if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

            if(cdmEntitySession == null){

                cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

            }

        }

        else{

            return;

        }

        CdmFormFactory cdmFormFactory = new CdmFormFactory(Display.getCurrent());

        ContextInjectionFactory.inject(cdmFormFactory, context);

        composite = new DescriptiveDataSetComposite(parent, SWT.NONE);

        labelModifyListener = new ModifyListener() {

            @Override

            public void modifyText(ModifyEvent e) {

                descriptiveDataSet.setLabel(composite.getTxt_label().getText());

                EventUtility.postSyncEvent(WorkbenchEventConstants.REFRESH_DATASET_NAVIGATOR, descriptiveDataSet);

                dirty.setDirty(true);

            }

        };

        composite.getRankMin().addSelectionChangedListener(event->dirty.setDirty(true));

        composite.getRankMin().setText("Select min rank...");

        composite.getRankMax().addSelectionChangedListener(event->dirty.setDirty(true));

        composite.getRankMax().setText("Select max rank...");

        composite.getBtnRemoveRankMin().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {

             composite.getRankMin().setElement(null);

             dirty.setDirty(true);

            }

        });

        composite.getBtnRemoveRankMax().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {

                composite.getRankMax().setElement(null);

                dirty.setDirty(true);

            }

        });

        composite.getBtnChooseArea().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {

                AreasSelectionDialog areasSelectionDialog = new AreasSelectionDialog(composite.getShell(), composite.getAreas());

                if(areasSelectionDialog.open()==Window.OK){

                    List<TermDto> selectedAreas = areasSelectionDialog.getSelectedAreas();

                    if(selectedAreas!=null){

                        composite.setAreas(selectedAreas);

                        dirty.setDirty(true);

                    }

                }

            }

        });

        composite.getFeatureTreeEditorComposite().init("Character Tree",

                TermType.Character,

                null,

                null,

                e->selectionService.setSelection(e.getSelection()),

                this,

                null);

        //add drag'n'drop support

        Transfer[] transfers = new Transfer[] {LocalSelectionTransfer.getTransfer()};

        composite.getTaxonNodeTree().addDropSupport(dndOperations, transfers, new TaxonNodeDropAdapter(this));

        composite.getTaxonNodeTree().getTree().addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if(e.character==SWT.DEL){

                    removeSelectedTaxonNodes();

                }

            }

        });

        //create context menu

        menuService.registerContextMenu(composite.getTaxonNodeTree().getControl(), "eu.etaxonomy.taxeditor.editor.descriptiveDataSet.DescriptiveDataSetEditor.popupmenu.specimeneditor");

    }

    public void init(UUID descriptiveDataSetUuid) {

        this.descriptiveDataSet = cdmEntitySession.remoteLoad(CdmStore.getService(IDescriptiveDataSetService.class), descriptiveDataSetUuid);

        if(descriptiveDataSet.getLabel()!=null){

            composite.getTxt_label().setText(descriptiveDataSet.getLabel());

        }

        if(descriptiveDataSet.getDescriptiveSystem()!=null){

            composite.setCharacters(descriptiveDataSet.getDescriptiveSystem());

        }

        Rank maxRank = descriptiveDataSet.getMaxRank();

        if(maxRank!=null){

            composite.setRankMax(maxRank);

        }

        Rank minRank = descriptiveDataSet.getMinRank();

        if(minRank!=null){

            composite.setRankMin(minRank);

        }

        Set<NamedArea> geoFilter = descriptiveDataSet.getGeoFilter();

        if(geoFilter!=null && !geoFilter.isEmpty()){

            Set<TermDto> terms = geoFilter.stream().map(filter->TermDto.fromTerm(filter, true)).collect(Collectors.toSet());

            composite.setAreas(new ArrayList<>(terms));

        }

        Set<TaxonNode> taxonSubtreeFilter = descriptiveDataSet.getTaxonSubtreeFilter();

        if(taxonSubtreeFilter!=null){

            composite.getTaxonNodeTree().setInput(taxonSubtreeFilter);

        }

        composite.getTxt_label().addModifyListener(labelModifyListener);

        composite.getTxt_label().addFocusListener(new FocusAdapter() {

            @Override

            public void focusGained(FocusEvent e) {

                super.focusGained(e);

                selectionService.setSelection(new StructuredSelection(descriptiveDataSet));

            }

        });

        selectionService.setSelection(new StructuredSelection(descriptiveDataSet));

        thisPart.setLabel(descriptiveDataSet.getLabel());

    }

    public void addTaxonNode(TaxonNodeDto taxonNodeDto){

        TaxonNode taxonNode = cdmEntitySession.remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNodeDto.getUuid());

        //check if node belongs to same classification

        Set<TaxonNode> taxonSubtreeFilter = descriptiveDataSet.getTaxonSubtreeFilter();

        if(taxonSubtreeFilter!=null && !taxonSubtreeFilter.isEmpty()){

            if(!taxonSubtreeFilter.iterator().next().getClassification().equals(taxonNode.getClassification())){

                MessagingUtils.warningDialog(Messages.TaxonNodeDropAdapter_CLASSIFICATIONS_NO_MATCH, this.getClass(),

                        Messages.TaxonNodeDropAdapter_CLASSIFICATIONS_NO_MATCH_MESSAGE);

                return;

            }

        }

        Viewer taxonTreeViewer = getTaxonTreeViewer();

        Object input = taxonTreeViewer.getInput();

        Collection<TaxonNodeDto> treeNodes;

        if(input==null){

            treeNodes = new ArrayList<>();

        }

        else{

            treeNodes = (Collection<TaxonNodeDto>) input;

        }

        treeNodes.add(taxonNodeDto);

        taxonTreeViewer.setInput(treeNodes);

        dirty.setDirty(true);

    }

    public void removeSelectedTaxonNodes(){

        IStructuredSelection selection = (IStructuredSelection) composite.getTaxonNodeTree().getSelection();

        if(selection.toList().stream().anyMatch(object->!(object instanceof TaxonNodeDto))){

            MessagingUtils.warningDialog(Messages.DescriptiveDataSetEditor_DELETE_FAIL_TITLE, this.getClass(), Messages.DescriptiveDataSetEditor_DELETE_FAIL_MESSAGE);

            return;

        }

        Iterator<Object> iterator = selection.iterator();

        Viewer taxonTreeViewer = getTaxonTreeViewer();

        Collection<TaxonNodeDto> input = (Collection<TaxonNodeDto>) taxonTreeViewer.getInput();

        while(iterator.hasNext()){

            Object next = iterator.next();

            TaxonNodeDto taxonNode = (TaxonNodeDto) next;

            input.remove(taxonNode);

            TaxonNode node = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid());

            descriptiveDataSet.removeTaxonSubtree(node);

        }

        taxonTreeViewer.setInput(input);

        dirty.setDirty(true);

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        if (!conversation.isBound()) {

            conversation.bind();

        }

        conversation.commit(true);

        Collection<TermDto> areas = composite.getAreas();

        Object input = composite.getTaxonNodeTree().getInput();

        if(input!=null){

            descriptiveDataSet.setTaxonSubtreeFilter(new HashSet<>());//clear existing filter

            Collection<TaxonNode> taxonNodes = (Collection<TaxonNode>) input;

            for (TaxonNode taxonTreeNode : taxonNodes) {

//                TaxonNode taxonNode =  CdmStore.getService(ITaxonNodeService.class).load(taxonTreeNode.getUuid());

                descriptiveDataSet.addTaxonSubtree(taxonTreeNode);

            }

        }

        TermTree<Feature> characters = composite.getCharacters();

        if(characters!=null){

            //save characters because they can be modified in this editor

            characters.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));

        }

        DefinedTermBase rankMaxSelection = composite.getRankMax().getSelection();

        Rank rankMax = null;

        if(rankMaxSelection instanceof Rank){

            rankMax = (Rank) rankMaxSelection;

        }

        DefinedTermBase rankMinSelection = composite.getRankMin().getSelection();

        Rank rankMin = null;

        if(rankMinSelection instanceof Rank){

            rankMin = (Rank) rankMinSelection;

        }

        descriptiveDataSet.setMaxRank(rankMax);

        descriptiveDataSet.setMinRank(rankMin);

        descriptiveDataSet.setDescriptiveSystem(characters);

        List<DefinedTermBase> terms = CdmStore.getService(ITermService.class)

                .load(areas.stream().map(area -> area.getUuid()).collect(Collectors.toList()), null);

        Set<NamedArea> areaTerms = new HashSet<>();

        terms.forEach(term->areaTerms.add((NamedArea) term));

        descriptiveDataSet.setGeoFilter(areaTerms);

//        conversation.commit();

        CdmStore.getService(IDescriptiveDataSetService.class).merge(descriptiveDataSet, true);

        //event for updating matrix

        EventUtility.postEvent(WorkbenchEventConstants.REFRESH_DESCRIPTIVE_DATASET, descriptiveDataSet.getUuid());

        dirty.setDirty(false);

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    @PreDestroy

    public void dispose() {

        if (conversation != null) {

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

        selectionService.setSelection(null);

    }

    @Focus

    public void setFocus() {

        if(composite!=null){

            composite.setFocus();

        }

        if (getConversationHolder() != null) {

            getConversationHolder().bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    public Viewer getTaxonTreeViewer() {

        return composite.getTaxonNodeTree();

    }

    public DescriptiveDataSet getDescriptiveDataSet() {

        return descriptiveDataSet;

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Override

    public Collection<DescriptiveDataSet> getRootEntities() {

        return Collections.singleton(descriptiveDataSet);

    }

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        return null;

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        dirty.setDirty(true);

    }

    @Override

    public void forceDirty() {

        dirty.setDirty(true);

    }

}