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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

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

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

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.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.hibernate.HibernateProxyHelper;

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

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

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

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.dialog.selection.FeatureTreeSelectionDialog;

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

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

/**

 * @author pplitzner

 * @date 24.05.2017

 *

 */

public class CharacterEditor implements ICdmEntitySessionEnabled, IConversationEnabled, ISelectionChangedListener,

        ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData, IE4SavablePart,

        IDirtyMarkable {

    private FeatureTreeEditorComposite characterTreeEditorComposite;

    private FeatureTreeEditorComposite propertiesTreeEditorComposite;

    private FeatureTreeEditorComposite structuresTreeEditorComposite;

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

    private Button btnAddCharacter;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    private Composite composite;

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

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

        structuresTreeEditorComposite.getLabel_title().setText("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, null, null);

        propertiesTreeEditorComposite.getLabel_title().setText("Properties");

        //TODO: fix drag and drop

//        initFeatureTreeComposite(treeViewerProperties, new CharacterDragListener(treeViewerStructures.getViewer(), treeViewerProperties.getViewer()), null);

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

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

        btnAddCharacter.setText(">>");

        formToolkit.adapt(btnAddCharacter, true, true);

        characterTreeEditorComposite = addFeatureTreeEditor(composite_3);

        initFeatureTreeComposite(characterTreeEditorComposite, new FeatureNodeDragListener(characterTreeEditorComposite.getViewer()), new FeatureNodeDropAdapter(dirty, characterTreeEditorComposite.getViewer()));

        characterTreeEditorComposite.getLabel_title().setText("Characters");

        //add context menu to character viewer//create context menu

        menuService.registerContextMenu(characterTreeEditorComposite.getViewer().getControl(), "eu.etaxonomy.taxeditor.editor.popupmenu.characterEditor");

        init();

    }

    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, FeatureNodeDropAdapter featureNodeDropAdapter) {

        featureTreeEditorComposite.init(featureNodeDragListener, featureNodeDropAdapter, this,

                new FeatureTreeChooserListener(featureTreeEditorComposite), this);

    }

    @Focus

    public void focus(){

        if(characterTreeEditorComposite!=null){

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

        }

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

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    private void init(){

        btnAddCharacter.addSelectionListener(new SelectionAdapter() {

            /**

             * {@inheritDoc}

             */

            @Override

            public void widgetSelected(SelectionEvent e) {

                ISelection structureTreeSelection = structuresTreeEditorComposite.getViewer().getSelection();

                ISelection propertyTreeSelection = propertiesTreeEditorComposite.getViewer().getSelection();

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

                    MessagingUtils.warningDialog("Cannot perform action", CharacterEditor.this,

                            "You have to select a structure, a property and a feature tree to perform this action.");

                    return;

                }

                //get selected structures and properties

                Iterator<FeatureNode> structureIterator = ((TreeSelection)structureTreeSelection).iterator();

                //create all combinations of structures and properties

                while(structureIterator.hasNext()){

                    FeatureNode structureNode = structureIterator.next();

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

                    while(propertiesIterator.hasNext()){

                        FeatureNode propertyNode = propertiesIterator.next();

                        //create new Character

                        String label = structureNode.getFeature().generateTitle()+" "+propertyNode.getFeature().generateTitle();

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

                        character = HibernateProxyHelper.deproxy(CdmStore.getService(ITermService.class).merge(character), Character.class);

                        //add new Character to feature tree

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

                        CdmStore.getService(IFeatureNodeService.class).addChildFeatureNode(parent.getUuid(), character.getUuid());

                    }

                }

                setDirty();

                characterTreeEditorComposite.getViewer().refresh();

            }

        });

    }

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

    }

    @PreDestroy

    public void dispose(){

        if(conversation!=null){

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

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

    }

    /**

     * {@inheritDoc}

     */

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

        }

    }

    /** {@inheritDoc} */

    @Override

    public void selectionChanged(SelectionChangedEvent event) {

        //propagate selection

        selService.setSelection(AbstractUtility.getElementsFromSelectionChangedEvent(event));

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void modifyText(ModifyEvent e) {

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

        setDirty();

    }

    private void setDirty() {

        dirty.setDirty(true);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public IStructuredSelection getSelection() {

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

    }

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

            }

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void changed(Object element) {

        setDirty();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void forceDirty() {

        setDirty();

    }

}