EDIT

package eu.etaxonomy.taxeditor.editor.view.checklist.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedSet;

import java.util.UUID;

import javax.inject.Inject;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

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

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ComboBoxViewerCellEditor;

import org.eclipse.jface.viewers.EditingSupport;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.TableColumn;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

public final class DistributionEditingSupportE4 extends EditingSupport {

    private ComboBoxViewerCellEditor cellEditor = null;

    //private final TableViewer viewer;

    private final ChecklistEditorE4 editor;

//    private final IDescriptionService descriptionService;

    private final int columnIndex;

    private Taxon taxon;

    @Inject

    private ESelectionService selService;

    private ISelectionChangedListener selectionChangedListener;

    private static final Logger logger = Logger.getLogger(DistributionEditingSupportE4.class);

    public DistributionEditingSupportE4(TableViewer viewer, ChecklistEditorE4 checklistEditor, int columnIndex) {

        super(viewer);

        this.columnIndex = columnIndex;

        editor = checklistEditor;

        cellEditor = new ComboBoxViewerCellEditor((Composite) this.getViewer().getControl(), SWT.READ_ONLY);

        cellEditor.setLabelProvider(new LabelProvider(){

        	 @Override

        	   public String getText(Object element) {

        	     if (element instanceof PresenceAbsenceTerm) {

        	    	 PresenceAbsenceTerm  status = (PresenceAbsenceTerm)element;

        	    	 Representation rep = status.getPreferredRepresentation(CdmStore.getDefaultLanguage());

        	    	 String label = null;

        	    	 if (rep != null){

        	    	     label = rep.getLabel();

        	    	 }else{

        	    	     label = status.getTitleCache();

        	    	 }

        	    	 String result = null;

        	    	 if (PreferencesUtil.isShowSymbolInChecklistEditor() && !StringUtils.isBlank(status.getSymbol())){

        	    		 result = label + "("+ status.getSymbol()+")";

        	    	 }else{

        	    		 result = label;

        	    	 }

        	    	 return result;

        	     }

        	     return null;

        	   }

        });

        cellEditor.setContentProvider(new ArrayContentProvider());

        List<DefinedTermBase> inputAll = new ArrayList<>();

        PresenceAbsenceTerm noneTerm = PresenceAbsenceTerm.NewInstance();

        noneTerm.setTitleCache(" ", true);

        inputAll.add(noneTerm);

        Collection<DefinedTermBase> input = CdmStore.getTermManager().getPreferredTerms(TermType.PresenceAbsenceTerm);

        List<DefinedTermBase> inputList = new ArrayList(input);

        Comparator<DefinedTermBase> comp = new OrderedTermComparator<>();

        Collections.sort(inputList, comp);

        Collections.sort(inputList, Collections.reverseOrder());

        inputAll.addAll(1,inputList);

        cellEditor.setInput(inputAll);

    }

    @Override

    protected CellEditor getCellEditor(Object element) {

        return cellEditor;

    }

    @Override

    protected boolean canEdit(Object element) {

        return true;

    }

    @Override

    protected PresenceAbsenceTerm getValue(Object element) {

        if (element instanceof Taxon) {

            taxon = (Taxon) element;

            String result = null;

            Distribution distributionForColumn = getDistributionForColumn(taxon);

            if (distributionForColumn != null) {

                PresenceAbsenceTerm status = distributionForColumn.getStatus();

                return status;

            }

           //fireStateChanged();

            return null;

        }

        return null;

    }

    protected void fireStateChanged() {

    	ISelection selection = new StructuredSelection(getDistributionForColumn(taxon));

	   getViewer().setSelection(selection);

    }

    @Override

    protected void setValue(Object element, Object value) {

    	if (element instanceof Taxon && value instanceof PresenceAbsenceTerm) {

            Taxon taxon = (Taxon) element;

            PresenceAbsenceTerm occurenceStatus = (PresenceAbsenceTerm) value;

            Distribution distribution = getDistributionForColumn(taxon);

            boolean changed = false;

            if (distribution != null) {

                // change status for already exsiting distribution

                if (occurenceStatus.getTitleCache().equals(" ")){

                    TaxonDescription descr = (TaxonDescription)distribution.getInDescription();

                    descr.removeElement(distribution);

                    changed = true;

                }else{

                    if (!distribution.getStatus().equals(occurenceStatus)){

                        changed = true;

                        distribution.setStatus(occurenceStatus);

                    }

                }

            } else {

                if (!occurenceStatus.getTitleCache().equals(" ")){

                    createDistributionForColumn(taxon, occurenceStatus);

                    changed = true;

                }

            }

            if (changed){

                editor.changed(element);

            }

            getViewer().refresh();

            EventUtility.postEvent(WorkbenchEventConstants.REFRESH_TAXON_DETAILS, true);

        }

    }

    private static final List<String> DESC_INIT_STRATEGY = Arrays.asList(new String[] { "descriptions", //$NON-NLS-1$

            "descriptions.*", "description.state" }); //$NON-NLS-1$ //$NON-NLS-2$

    /**

     *

     * @param taxon

     * @return

     */

    private Distribution getDistributionForColumn(Taxon taxon) {

        Set<TaxonDescription> listTaxonDescriptions = taxon.getDescriptions();

        TableColumn column = ((TableViewer)getViewer()).getTable().getColumn(columnIndex);

        for (TaxonDescription td : listTaxonDescriptions) {

            for (DescriptionElementBase deb : td.getElements()) {

                if (deb instanceof Distribution) {

                    Distribution distribution = (Distribution) deb;

                    UUID areaUuid = null;

                    for (Map.Entry<UUID,Integer> entry: editor.getAreaPosition().entrySet()){

                        if (entry.getValue().intValue()== columnIndex){

                            areaUuid = entry.getKey();

                            break;

                        }

                    }

                    if (distribution.getArea() != null){

                        if (distribution.getArea().getUuid().equals(areaUuid)){

                            return distribution;

                        }

                    }

                }

            }

        }

        return null;

    }

    private void createDistributionForColumn(Taxon taxon, PresenceAbsenceTerm occurenceStatus) {

        TableColumn column = ((TableViewer)this.getViewer()).getTable().getColumn(columnIndex);

        SortedSet<DefinedTermBase> namedAreas = this.editor.getLabelProvider().getNamedAreas(false);

        if (namedAreas != null) {

            for (DefinedTermBase term : namedAreas) {

                Integer areaIndex = editor.getAreaPosition().get(term.getUuid());

                if (areaIndex == columnIndex){

                    NamedArea area = (NamedArea) term;

                    Distribution distribution = Distribution.NewInstance(area, occurenceStatus);

                    if (editor.getDefaultSource() != null){

                        DescriptionElementSource source = DescriptionElementSource.NewPrimarySourceInstance(editor.getDefaultSource(), "");

                        distribution.addSource(source);

                    }

                    Set<TaxonDescription> descriptions = taxon.getDescriptions();

                    if (!descriptions.isEmpty()) {

                        for (TaxonDescription desc : descriptions) {

                            // add to first taxon description

                            desc.addElement(distribution);

                            break;

                        }

                    } else {// there are no TaxonDescription yet.

                        TaxonDescription td = TaxonDescription.NewInstance(taxon);

                        td.addElement(distribution);

                        break;

                    }

                }

            }

        }

        return;

    }

}