EDIT

// $Id$

/**

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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

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

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

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

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

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

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

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

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.forms.widgets.FormToolkit;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.AppModelId;

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

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

import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;

import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeLabelProvider;

import eu.etaxonomy.taxeditor.featuretree.e4.AbstractTermTreeEditor;

import eu.etaxonomy.taxeditor.featuretree.e4.FeatureNodeDragListener;

import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDropAdapter;

import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditorComposite;

import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.ui.dialog.selection.FeatureTreeSelectionDialog;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TermVocabularySelectionDialog;

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

/**

 * Editor for combining structure and property terms to characters.

 * @author pplitzner

 * @date 24.05.2017

 *

 */

public class CharacterEditor implements IFeatureTreeEditor,IConversationEnabled, ISelectionChangedListener,

        ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData, IDirtyMarkable {

    private FeatureTreeEditorComposite<Character> characterTreeEditorComposite;

    private final FormToolkit formToolkit = new FormToolkit(Display.getDefault());

    @Inject

    private ESelectionService selService;

    @Inject

    private UISynchronize sync;

    @Inject

    private MDirtyable dirty;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    private TermVocabulary vocabulary;

    private TreeViewer structureViewer;

    private TreeViewer propertyViewer;

    public CharacterEditor() {

    }

    /**

     * Create contents of the view part.

     */

    @PostConstruct

    public void createControls(Composite parent, EMenuService menuService ) {

        if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

            if(cdmEntitySession==null){

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

            }

        }

        else{

            return;

        }

        parent.setLayout(new GridLayout(1, false));

        Composite vocChooserComposite = new Composite(parent, SWT.NONE);

        vocChooserComposite.setLayout(new GridLayout(4, false));

        vocChooserComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.FILL, false, false, 2, 1));

        Label lblVocImport = new Label(vocChooserComposite, SWT.NONE);

        lblVocImport.setText("Character vocabulary");

        Text txtVocabulary = new Text(vocChooserComposite, SWT.NONE);

        txtVocabulary.setEditable(false);

        Button btnChooseVoc = new Button(vocChooserComposite, SWT.PUSH);

        btnChooseVoc.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));

        btnChooseVoc.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                // hard-coded filter for "built-in" vocabularies Feature and Name Feature

                Set<TermVocabulary> vocabulariesToBeFiltered = new HashSet<>();

                vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.Feature.getUuid()));

                vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));

                if(vocabulary!=null){

                    vocabulariesToBeFiltered.add(vocabulary);

                }

                vocabulary = TermVocabularySelectionDialog.select("Select vocabulary for characters", btnChooseVoc.getShell(), vocabulariesToBeFiltered, TermType.Character);

                if(vocabulary!=null){

                    txtVocabulary.setText(vocabulary.getLabel());

                }

            }

        });

        SashForm sashForm = new SashForm(parent, SWT.NONE);

        sashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        formToolkit.adapt(sashForm);

        formToolkit.paintBordersFor(sashForm);

        Composite composite = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite);

        formToolkit.paintBordersFor(composite);

        GridLayout gl_composite = new GridLayout(1, false);

        gl_composite.marginWidth = 0;

        composite.setLayout(gl_composite);

        structureViewer = createTreeViewer(composite, TermType.Structure);

        Composite composite_1 = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite_1);

        formToolkit.paintBordersFor(composite_1);

        GridLayout gl_composite_1 = new GridLayout(1, false);

        gl_composite_1.marginWidth = 0;

        composite_1.setLayout(gl_composite_1);

        propertyViewer = createTreeViewer(composite_1, TermType.Property);

        int ops = DND.DROP_COPY | DND.DROP_MOVE;

        Transfer[] transfers = new Transfer[] {CharacterTransfer.getInstance()};

        propertyViewer.addDragSupport(ops, transfers, new CharacterDragListener(structureViewer, propertyViewer));

        Composite composite_3 = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite_3);

        formToolkit.paintBordersFor(composite_3);

        GridLayout gl_composite_3 = new GridLayout(2, false);

        gl_composite_3.marginWidth = 0;

        composite_3.setLayout(gl_composite_3);

        Button btnAddCharacter = new Button(composite_3, SWT.NONE);

        btnAddCharacter.setText(">>"); //$NON-NLS-1$

        formToolkit.adapt(btnAddCharacter, true, true);

        btnAddCharacter.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                if(!isVocabularySet()){

                    return;

                }

                ISelection structureTreeSelection = structureViewer.getSelection();

                ISelection propertyTreeSelection = propertyViewer.getSelection();

                if(structureTreeSelection==null || propertyTreeSelection==null || characterTreeEditorComposite.getFeatureTree()==null){

                    MessagingUtils.warningDialog(Messages.CharacterEditor_CANNOT_PERFORM_TITLE, CharacterEditor.this,

                            Messages.CharacterEditor_CANNOT_PERFORM_MESSAGE);

                    return;

                }

                Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);

                TermNode<Character> parent = ((TermTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();

                for (Character character : characters) {

                    //add new Character to feature tree

                    UpdateResult result = CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent.getUuid(), character, vocabulary.getUuid());

                    cdmEntitySession.load(result, true);

                }

                refresh();

            }

        });

        characterTreeEditorComposite = addFeatureTreeEditor(composite_3);

        initFeatureTreeComposite(TermType.Character, characterTreeEditorComposite, new FeatureNodeDragListener(characterTreeEditorComposite.getViewer()),

                new CharacterDropAdapter(this, characterTreeEditorComposite.getViewer(), sync),

                new Transfer[] {FeatureNodeTransfer.getInstance(), CharacterTransfer.getInstance()},

                this,

                this);

        characterTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_CHARACTERS);

        //add context menu to character viewer

        menuService.registerContextMenu(characterTreeEditorComposite.getViewer().getControl(),

                AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_EDITOR_POPUPMENU_CHARACTEREDITOR);

    }

    private TreeViewer createTreeViewer(Composite parent, TermType termType) {

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

        composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        composite.setLayout(new GridLayout(2, false));

        Label label = new Label(composite, SWT.NONE);

        label.setText(termType.getMessage());

        Button btnRefresh = new Button(composite, SWT.PUSH);

        btnRefresh.setImage(ImageResources.getImage(ImageResources.REFRESH));

        btnRefresh.setToolTipText("Refresh");

        TreeViewer viewer = new TreeViewer(composite);

        viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));

        viewer.setContentProvider(new FeatureTreeContentProvider());

        viewer.setLabelProvider(new FeatureTreeLabelProvider());

        viewer.setComparator(new FeatureTreeViewerComparator());

        viewer.addSelectionChangedListener(this);

        viewer.setInput(CdmStore.getService(ITermTreeService.class).list(termType, null, null, null, AbstractTermTreeEditor.TREE_PROPERTY_PATH));

        btnRefresh.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                refresh(viewer);

            }

        });

        return viewer;

    }

    private <T extends DefinedTermBase> FeatureTreeEditorComposite<T> addFeatureTreeEditor(Composite composite_3) {

        FeatureTreeEditorComposite<T> featureTreeEditorComposite = new FeatureTreeEditorComposite<>(composite_3, SWT.NONE);

        featureTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        return featureTreeEditorComposite;

    }

    private void initFeatureTreeComposite(

            TermType termType,

            FeatureTreeEditorComposite featureTreeEditorComposite,

            FeatureNodeDragListener featureNodeDragListener,

            FeatureTreeDropAdapter featureNodeDropAdapter,

            Transfer[] transfers,

            ISelectionChangedListener viewerSelectionChangedListener,

            ModifyListener modifyListener) {

        featureTreeEditorComposite.init(

                featureNodeDragListener,

                featureNodeDropAdapter,

                transfers,

                viewerSelectionChangedListener,

                new FeatureTreeChooserListener(featureTreeEditorComposite, termType),

                modifyListener);

    }

    @Focus

    public void focus(){

        if(characterTreeEditorComposite!=null){

            characterTreeEditorComposite.getViewer().getControl().setFocus();

        }

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

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){

        Set<Character> characters = new HashSet<>();

        //get selected structures and properties

        Iterator<TermNode<DefinedTerm>> structureIterator = structureTreeSelection.iterator();

        //create all combinations of structures and properties

        while(structureIterator.hasNext()){

            TermNode<DefinedTerm> structureNode = structureIterator.next();

            Iterator<TermNode<DefinedTerm>> propertiesIterator = propertyTreeSelection.iterator();

            while(propertiesIterator.hasNext()){

                TermNode<DefinedTerm> propertyNode = propertiesIterator.next();

                Character character = CharacterTransfer.createCharacter(structureNode, propertyNode);

                characters.add(character);

            }

        }

        return characters;

    }

    @Override

    @Persist

    public void save(IProgressMonitor monitor){

        if (!conversation.isBound()) {

            conversation.bind();

        }

        TermTree<Character> featureTree = characterTreeEditorComposite.getFeatureTree();

        CdmStore.getService(ITermTreeService.class).merge(featureTree, true);

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        initializeTrees();

        dirty.setDirty(false);

    }

    private void initializeTrees() {

        Object[] expandedElements = characterTreeEditorComposite.getViewer().getExpandedElements();

        characterTreeEditorComposite.getViewer().getTree().removeAll();

        TermTree tree = (TermTree) characterTreeEditorComposite.getViewer().getInput();

        cdmEntitySession.load(tree, true);

        characterTreeEditorComposite.getViewer().setInput(tree);

        characterTreeEditorComposite.getViewer().setExpandedElements(expandedElements);

    }

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

    }

    public boolean isVocabularySet() {

        if(vocabulary==null){

            MessagingUtils.warningDialog("Character creation not possible", this.getClass(), "Please select a vocabulary for the characters.");

        }

        return vocabulary!=null;

    }

    public TermVocabulary getVocabulary() {

        return vocabulary;

    }

    @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<TermTree<Character>> getRootEntities() {

        List<TermTree<Character>> root = new ArrayList<>();

        cdmEntitySession.load(characterTreeEditorComposite.getFeatureTree(), true);

        root.add(characterTreeEditorComposite.getFeatureTree());

        return root;

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Focus

    public void setFocus() {

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

            conversation.bind();

        }

    }

    @Override

    public void selectionChanged(SelectionChangedEvent event) {

        //propagate selection

        selService.setSelection(event.getSelection());

    }

    @Override

    public void modifyText(ModifyEvent e) {

        characterTreeEditorComposite.getFeatureTree().setTitleCache(((Text) e.widget).getText(), true);

        setDirty();

    }

    private void setDirty() {

        dirty.setDirty(true);

    }

    @Override

    public IStructuredSelection getSelection() {

        return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();

    }

    @Override

    public TermType getTermType() {

        return TermType.Character;

    }

    public TermTree<Character> getCharacterTree(){

        return characterTreeEditorComposite.getFeatureTree();

    }

    public void refresh(TreeViewer viewer){

        viewer.refresh();

        characterTreeEditorComposite.getViewer().setInput(characterTreeEditorComposite.getViewer().getInput());

    }

    private class FeatureTreeChooserListener extends SelectionAdapter{

        private FeatureTreeEditorComposite<Feature> featureTreeEditorComposite;

        private TermType termType;

        public FeatureTreeChooserListener(FeatureTreeEditorComposite<Feature> featureTreeEditorComposite, TermType termType) {

            super();

            this.featureTreeEditorComposite = featureTreeEditorComposite;

            this.termType = termType;

        }

        @Override

        public void widgetSelected(SelectionEvent e) {

            TermTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);

            if(tree!=null){

//                cdmEntitySession.load(tree, true);

                featureTreeEditorComposite.setSelectedTree(tree);

            }

        }

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        setDirty();

        characterTreeEditorComposite.getViewer().refresh();

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        characterTreeEditorComposite.getViewer().refresh();

        if(objectAffectedByOperation instanceof TermNode){

            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);

            characterTreeEditorComposite.getViewer().setSelection(selection);

        }

        return true;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

    @Override

    public void refresh() {

        structureViewer.refresh();

        propertyViewer.refresh();

        characterTreeEditorComposite.getViewer().setInput(characterTreeEditorComposite.getViewer().getInput());

    }

}