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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.core.di.annotations.Optional;

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

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

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

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

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.workbench.modeling.EPartService;

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

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.KeyAdapter;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IMemento;

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.definedterm.FeatureTreeViewerComparator;

import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.featuretree.FeatureNodeDtoTransfer;

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeLabelProvider;

import eu.etaxonomy.taxeditor.featuretree.e4.operation.AddFeatureOperation;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IContextListener;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.AppModelId;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

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

/**

 *

 * @author pplitzner

 * @date 06.06.2017

 *

 */

public class TermTreeEditor<T extends DefinedTermBase> implements IFeatureTreeEditor, ISelectionChangedListener,

        IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData,

        IContextListener, IConversationEnabled, IDirtyMarkable {

    public static final List<String> TREE_PROPERTY_PATH = Arrays.asList(new String[] {

            "root", //$NON-NLS-1$

            "root.children", //$NON-NLS-1$

            "root.children.inapplicableIf", //$NON-NLS-1$

            "root.children.inapplicableIf.feature", //$NON-NLS-1$

            "root.children.inapplicableIf.state", //$NON-NLS-1$

            "root.children.onlyApplicableIf", //$NON-NLS-1$

            "root.children.onlyApplicableIf.feature", //$NON-NLS-1$

            "root.children.onlyApplicableIf.state", //$NON-NLS-1$

    });

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private UISynchronize sync;

    @Inject

    private MPart thisPart;

    private TreeViewer viewer;

    Map<UUID,TermTreeDto> trees;

    Map<UUID, TermNodeDto> uuidTermMap = new HashMap<>();

    List<AbstractPostOperation<TermNode>> operationList = new ArrayList<>();

    List<TermNodeDto> listToUpdate = new ArrayList<>();

    TermType termType;

    @Inject

    public TermTreeEditor() {

        CdmStore.getContextManager().addContextListener(this);

    }

    @PostConstruct

    public void createControl(Composite parent, EMenuService menuService){

        if (CdmStore.isActive()){

            initSession();

        }

        else{

            return;

        }

        parent.setLayout(new FillLayout());

        viewer = new TreeViewer(parent);

        FeatureTreeContentProvider contentProvider = new FeatureTreeContentProvider();

        viewer.setContentProvider(contentProvider);

        viewer.setLabelProvider(new FeatureTreeLabelProvider());

        int ops = DND.DROP_COPY | DND.DROP_MOVE;

        Transfer[] transfers = new Transfer[] {

                FeatureNodeDtoTransfer.getInstance(),

                TermTransfer.getInstance(),

                LocalSelectionTransfer.getTransfer()};

        viewer.addDragSupport(ops, transfers, new FeatureNodeDtoDragListener(viewer));

        viewer.addDropSupport(ops, transfers, new FeatureTreeDtoDropAdapter(this, viewer, sync));

        viewer.addSelectionChangedListener(this);

        viewer.getTree().addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if(e.stateMask == SWT.MOD1 && e.keyCode == 'c'){

                    copy(viewer.getStructuredSelection());

                }

                else if(e.stateMask == SWT.MOD1 && e.keyCode == 'v'){

                    paste(viewer.getStructuredSelection());

                }

            }

        });

        updateTrees();

        viewer.setComparator(new FeatureTreeViewerComparator());

        viewer.setInput(getTrees());

        contentProvider.setUuidTermMap(uuidTermMap);

        //create context menu

        menuService.registerContextMenu(viewer.getControl(), AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_STORE_POPUPMENU_FEATURETREEEDITOR);

    }

    public void init(TermType type, String label){

        this.termType = type;

        updateTrees();

        viewer.setComparator(new FeatureTreeViewerComparator());

        viewer.setInput(getTrees());

        ((FeatureTreeContentProvider)viewer.getContentProvider()).setUuidTermMap(uuidTermMap);

        thisPart.setLabel(label);

    }

//    protected abstract List<TermTreeDto> getTrees();

    public void paste(IStructuredSelection selection) {

        if (StoreUtil.promptCheckIsDirty(this)) {

            return;

        }

        ISelection clipBoardSelection = LocalSelectionTransfer.getTransfer().getSelection();

        Object firstElement = selection.getFirstElement();

        TermNodeDto parentNode = null;

        if(firstElement instanceof TermNodeDto){

            parentNode = (TermNodeDto) firstElement;

        }

        else if(firstElement instanceof TermTreeDto){

            parentNode = ((TermTreeDto)firstElement).getRoot();

        }

        if(parentNode!=null){

        	TermNodeDto copiedNode = (TermNodeDto) ((IStructuredSelection)clipBoardSelection).getFirstElement();

            AddFeatureOperation operation = new AddFeatureOperation(copiedNode.getUuid(), parentNode, this, this);

//            AbstractUtility.executeOperation(operation, sync);

            this.addOperation(operation);

        }

    }

    public void copy(IStructuredSelection selection) {

        LocalSelectionTransfer.getTransfer().setSelection(selection);

    }

    private void initSession(){

        if(conversation == null){

            conversation = CdmStore.createConversation();

        }

        if(cdmEntitySession==null){

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

        }

    }

    private void clearSession() {

        if(conversation!=null){

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

	public void setDirty(boolean isDirty){

	    this.dirty.setDirty(isDirty);

	}

	@Override

    public void setDirty(){

        this.dirty.setDirty(true);

    }

	@Override

    public boolean isDirty(){

	    return dirty.isDirty();

	}

	@Override

	public void selectionChanged(SelectionChangedEvent event) {

		//propagate selection

		selService.setSelection(event.getSelection());

	}

	@Focus

	public void focus(){

	    if(viewer!=null){

	        viewer.getControl().setFocus();

	    }

        if(conversation!=null && !conversation.isBound()){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

	}

	@Override

    public void refresh(){

	    viewer.refresh();

	}

	@Override

    public TreeViewer getViewer(){

	    return viewer;

	}

	@Override

	public IStructuredSelection getSelection() {

	    return (IStructuredSelection) viewer.getSelection();

	}

	@Override

	public ConversationHolder getConversationHolder() {

	    return conversation;

	}

	@Override

    @Persist

	public void save(IProgressMonitor monitor){

        if (!conversation.isBound()) {

            conversation.bind();

        }

        // commit the conversation and start a new transaction immediately

        Object[] expandedElements = this.viewer.getExpandedElements();

        conversation.commit(true);

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

            for (AbstractPostOperation<TermNode> operation: operationList){

                AbstractUtility.executeOperation(operation, sync);

            }

            operationList.clear();

        }

        CdmStore.getService(ITermNodeService.class).saveTermNodeDtoList(listToUpdate);

        listToUpdate.clear();

        List<TermTreeDto> rootEntities = getRootEntities();

        CdmStore.getService(ITermTreeService.class).saveOrUpdateTermTreeDtoList(rootEntities);

        initializeTrees();

        conversation.commit(true);

        this.setDirty(false);

//        this.viewer.setExpandedElements(expandedElements);

	}

    private void initializeTrees() {

        Object[] expandedElements = viewer.getExpandedElements();

        viewer.getTree().removeAll();

        updateTrees();

        viewer.setInput(getTrees());

        viewer.setExpandedElements(expandedElements);

    }

	@PreDestroy

	public void dispose(){

	    selService.setSelection(null);

	    clearSession();

	}

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Override

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

        List<String> propertyPaths = Arrays.asList(new String[] {

                "children", //$NON-NLS-1$

                "feature", //$NON-NLS-1$

                "featureTree", //$NON-NLS-1$

        });

        Map<Object, List<String>> propertyPathMap =

                new HashMap<Object, List<String>>();

        propertyPathMap.put(TermNode.class,propertyPaths);

        return propertyPathMap;

    }

    @Override

    public List<TermTreeDto> getRootEntities() {

        return (List<TermTreeDto>) viewer.getInput();

    }

    @Override

    public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public void contextStop(IMemento memento, IProgressMonitor monitor) {

        //close view when workbench closes

        try{

            thisPart.getContext().get(EPartService.class).hidePart(thisPart);

        }

        catch(Exception e){

            //nothing

        }

    }

    @Override

    public void contextStart(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public void contextRefresh(IProgressMonitor monitor) {

    }

    @Override

    public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public void changed(Object element) {

        dirty.setDirty(true);

        viewer.refresh();

    }

    @Override

    public void forceDirty() {

        dirty.setDirty(true);

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        initializeTrees();

        viewer.refresh();

        if(objectAffectedByOperation instanceof TermNodeDto){

        	TermNodeDto node = (TermNodeDto)objectAffectedByOperation;

//            viewer.expandToLevel(((TermRelationBase) node).getGraph(), 1); find a solution for dto editor

        }

        if(objectAffectedByOperation!=null){

            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);

            viewer.setSelection(selection);

        }

        return true;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

    @Override

    public TermNodeDto getNodeDtoForUuid(UUID nodeUuid){

        return uuidTermMap.get(nodeUuid);

    }

    protected void addAllNodesToMap(TermNodeDto root){

        if (!uuidTermMap.containsKey(root.getUuid())){

            uuidTermMap.put(root.getUuid(), root);

            if (root.getTerm() != null){

                getTreeDtoForUuid(root.getTree().getUuid()).addTerm(root.getTerm());

            }

        }

        for (TermNodeDto child: root.getChildren()){

            uuidTermMap.put(child.getUuid(), child);

            if (child.getTerm() != null){

                getTreeDtoForUuid(child.getTree().getUuid()).addTerm(child.getTerm());

            }

            if (child.getChildren() != null && !child.getChildren().isEmpty()){

                addAllNodesToMap(child);

            }

        }

    }

    /**

     * @param term

     * @param treeUuid

     */

    @Override

    public boolean checkDuplicates(UUID termUuid, UUID treeUuid) {

        TermTreeDto tree = this.getTreeDtoForUuid(treeUuid);

        for (TermDto dto: tree.getTerms()){

            if (dto.getUuid().equals(termUuid)) {

                return true;

            }

        }

        return false;

    }

    protected void updateTrees(){

        uuidTermMap.clear();

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

            trees.clear();

        }

        if (trees == null){

            trees = new HashMap<>();

        }

        List<TermTreeDto> treeList = CdmStore.getService(ITermTreeService.class).listTermTreeDtosByTermType(getTermType());

        treeList.stream().forEach(tree -> trees.put(tree.getUuid(), tree));

//        trees.addAll(CdmStore.getService(ITermTreeService.class).listTermTreeDtosByTermType(getTermType()));

        for (TermTreeDto tree: trees.values()){

            addAllNodesToMap(tree.getRoot());

        }

        ((FeatureTreeContentProvider<T>)viewer.getContentProvider()).setUuidTermMap(uuidTermMap);

//        viewer.refresh();

    }

    public List<TermTreeDto> getTrees(){

        List<TermTreeDto> treeList = new ArrayList<>(trees.values());

        return treeList;

    }

    public void putTree(TermTreeDto tree){

       trees.put(tree.getUuid(), tree);

    }

    public void removeTree(TermTreeDto tree){

        trees.remove(tree.getUuid());

     }

    @Override

    public TermTreeDto getTreeDtoForUuid(UUID treeUuid){

        return trees.get(treeUuid);

    }

    @Override

    public void setTreeDtoForUuid(TermTreeDto tree){

        trees.put(tree.getUuid(), tree);

    }

    @Override

    public void setNodeDtoForUuid(TermNodeDto node){

        this.uuidTermMap.put(node.getUuid(), node);

    }

    @Override

    public void addOperation(AbstractPostOperation operation) {

        operationList.add(operation);

    }

    @Inject

    @Optional

    private void addSaveCandidate(@UIEventTopic(WorkbenchEventConstants.ADD_SAVE_CANDIDATE) UUID cdmbaseUuid) {

        for (UUID uuid: uuidTermMap.keySet()) {

            if (uuid.equals(cdmbaseUuid)){

                listToUpdate.add(uuidTermMap.get(uuid));

            }

        }

    }

    @Override

    public TermType getTermType() {

        return termType;

    }

}