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

import org.eclipse.swt.custom.SashForm;

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

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

import eu.etaxonomy.cdm.model.common.Representation;

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.AppModelId;

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

import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;

import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;

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

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

    private FeatureTreeEditorComposite propertiesTreeEditorComposite;

    private FeatureTreeEditorComposite structuresTreeEditorComposite;

    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 Composite composite;

    private TermVocabulary vocabulary;

    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(3, 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) {

                vocabulary = TermVocabularySelectionDialog.select("Select vocabulary for characters", btnChooseVoc.getShell(), null);

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

        structuresTreeEditorComposite = addFeatureTreeEditor(composite);

        initFeatureTreeComposite(structuresTreeEditorComposite,

                new FeatureNodeDragListener(structuresTreeEditorComposite.getViewer()), null, null, null, null);

        structuresTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_STRUCTURES);

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

        propertiesTreeEditorComposite = addFeatureTreeEditor(composite_1);

        initFeatureTreeComposite(propertiesTreeEditorComposite,

                new CharacterDragListener(structuresTreeEditorComposite.getViewer(), propertiesTreeEditorComposite.getViewer()),

                null,

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

                null,

                null

        );

        propertiesTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_PROPERTIES);

        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 = structuresTreeEditorComposite.getViewer().getSelection();

                ISelection propertyTreeSelection = propertiesTreeEditorComposite.getViewer().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);

                for (Character character : characters) {

                    //add new Character to feature tree

                    FeatureNode parent = ((FeatureTree) characterTreeEditorComposite.getViewer().getInput()).getRoot();

                    vocabulary.addTerm(character);

                    CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent, character);

                }

                characterTreeEditorComposite.getViewer().refresh();

            }

        });

        characterTreeEditorComposite = addFeatureTreeEditor(composite_3);

        initFeatureTreeComposite(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 FeatureTreeEditorComposite addFeatureTreeEditor(Composite composite_3) {

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

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

        return featureTreeEditorComposite;

    }

    private void initFeatureTreeComposite(

            FeatureTreeEditorComposite featureTreeEditorComposite,

            FeatureNodeDragListener featureNodeDragListener,

            FeatureTreeDropAdapter featureNodeDropAdapter,

            Transfer[] transfers,

            ISelectionChangedListener viewerSelectionChangedListener,

            ModifyListener modifyListener) {

        featureTreeEditorComposite.init(

                featureNodeDragListener,

                featureNodeDropAdapter,

                transfers,

                viewerSelectionChangedListener,

                new FeatureTreeChooserListener(featureTreeEditorComposite),

                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<FeatureNode> structureIterator = structureTreeSelection.iterator();

        //create all combinations of structures and properties

        while(structureIterator.hasNext()){

            FeatureNode structureNode = structureIterator.next();

            Iterator<FeatureNode> propertiesIterator = propertyTreeSelection.iterator();

            while(propertiesIterator.hasNext()){

                FeatureNode propertyNode = propertiesIterator.next();

                Representation structureRepresentation = structureNode.getFeature().getRepresentation(PreferencesUtil.getGlobalLanguage());

                Representation propertyRepresentation = propertyNode.getFeature().getRepresentation(PreferencesUtil.getGlobalLanguage());

                String label = null;

                String abbrevLabel = null;

                if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){

                    label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();

                }

                if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){

                    abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();

                }

                //create new Character

                Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);

                characters.add(character);

            }

        }

        return characters;

    }

    @Override

    @Persist

    public void save(IProgressMonitor monitor){

        if (!conversation.isBound()) {

            conversation.bind();

        }

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        FeatureTree featureTree = characterTreeEditorComposite.getFeatureTree();

        if(featureTree!=null){

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

            featureTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));

        }

        CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);

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

    }

    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(FeatureNode.class,propertyPaths);

        return propertyPathMap;

    }

    @Override

    public List<FeatureTree> getRootEntities() {

        List<FeatureTree> root = new ArrayList<>();

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

    }

    public FeatureTree getCharacterTree(){

        return characterTreeEditorComposite.getFeatureTree();

    }

    @Override

    public void refresh(){

        structuresTreeEditorComposite.getViewer().refresh();

        propertiesTreeEditorComposite.getViewer().refresh();

        characterTreeEditorComposite.getViewer().refresh();

    }

    private class FeatureTreeChooserListener extends SelectionAdapter{

        FeatureTreeEditorComposite featureTreeEditorComposite;

        public FeatureTreeChooserListener(FeatureTreeEditorComposite featureTreeEditorComposite) {

            super();

            this.featureTreeEditorComposite = featureTreeEditorComposite;

        }

        @Override

        public void widgetSelected(SelectionEvent e) {

            FeatureTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), //conversation,

                    null);

            if(tree!=null){

                featureTreeEditorComposite.setSelectedTree(tree);

                featureTreeEditorComposite.getText_title().setEnabled(false);

            }

        }

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        setDirty();

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        characterTreeEditorComposite.getViewer().refresh();

        if(objectAffectedByOperation instanceof FeatureNode){

            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);

            characterTreeEditorComposite.getViewer().setSelection(selection);

        }

        return true;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

}