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;

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.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.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.ui.forms.widgets.FormToolkit;

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

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

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

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

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;

/**

 * @author pplitzner

 * @date 24.05.2017

 *

 */

public class CharacterEditor implements ICdmEntitySessionEnabled, ISelectionChangedListener, ModifyListener{

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

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

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

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

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

        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_2 = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite_2);

        formToolkit.paintBordersFor(composite_2);

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

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

        btnAddCharacter.setText(">>");

        btnAddCharacter.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, true, 1, 1));

        formToolkit.adapt(btnAddCharacter, true, true);

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

        formToolkit.adapt(composite_3);

        formToolkit.paintBordersFor(composite_3);

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

        characterTreeEditorComposite = addFeatureTreeEditor(composite_3);

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

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

        sashForm.setWeights(new int[] {3, 3, 1, 3});

        init();

    }

    private FeatureTreeEditorComposite addFeatureTreeEditor(Composite composite_3) {

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

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

    }

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

                characterTreeEditorComposite.getViewer().refresh();

            }

        });

    }

    @Persist

    public void save(){

        if (!conversation.isBound()) {

            conversation.bind();

        }

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(characterTreeEditorComposite.getFeatureTree());

        this.setDirty(false);

    }

    @PreDestroy

    public void dispose(){

        if(conversation!=null){

            conversation.close();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

        }

    }

    @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

        IStructuredSelection isel = (IStructuredSelection) event.getSelection();

        selService.setSelection((isel.size() == 1 ? isel.getFirstElement() : isel.toArray()));

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void modifyText(ModifyEvent e) {

        characterTreeEditorComposite.getFeatureTree().setTitleCache(characterTreeEditorComposite.getText_title().getText(), true);

        setDirty(true);

    }

    public void setDirty(boolean isDirty) {

        dirty.setDirty(isDirty);

    }

    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, CharacterEditor.this);

                featureTreeEditorComposite.getText_title().setEnabled(false);

            }

        }

    }

}