EDIT

/**

* Copyright (C) 2019 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.ui.dialog.configurator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.eclipse.jface.layout.GridLayoutFactory;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.CheckStateChangedEvent;

import org.eclipse.jface.viewers.CheckboxTableViewer;

import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

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

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

import eu.etaxonomy.cdm.api.service.description.AggregationMode;

import eu.etaxonomy.cdm.api.service.description.AggregationSourceMode;

import eu.etaxonomy.cdm.api.service.description.DistributionAggregationConfiguration;

import eu.etaxonomy.cdm.filter.LogicFilter;

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

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.OriginalSourceType;

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

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

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

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

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.ui.combo.OriginalSourceTypeComparator;

import eu.etaxonomy.taxeditor.ui.dialog.SuperAreaSelectionWizard;

/**

 * @author k.luther

 * @since 15.11.2019

 */

public class DistributionAggregationWizardPage extends WizardPage implements Listener, SelectionListener{

    private DistributionAggregationConfiguration configurator;

    private Combo comboHigherRank;

    private Combo comboLowerRank;

    private Combo comboSourceModeChildParent;

    private Combo comboSourceModeSubAreaSuperArea;

    private CheckboxTableViewer aggregationModeViewer;

    private Button btnSelectSuperAreas;

    private Button buttonSuperArea;

    private Combo comboAreaLevel;

    private Combo comboStatusOrder;

    private Combo comboClassificationSelection;

    private List<Classification> classifications;

    private Classification selectedClassification;

    private Button checkUseSelectedTaxonNode;

    private Button checkUseSelectedClassification;

    private Button checkUseSelectedSubtree;

    private Button checkExportUnpublished;

    private TaxonNode subTreeNode;

    private CheckboxTableViewer sourceTypeViewer;

    Object[] checkedElements;

    Map<String, OriginalSourceType> typeMap = new HashMap();

    Comparator comparator = new Comparator<Rank>(){

        @Override

        public int compare(Rank o1, Rank o2) {

            return o2.compareTo(o1);

        }

    };

    /**

     * @param pageName

     */

    public DistributionAggregationWizardPage(DistributionAggregationConfiguration configurator) {

        super("Distribution aggregation configuration");

        this.configurator = configurator;

        this.setDescription("Configure the aggregation");

    }

    @Override

    public void createControl(Composite parent) {

        final Composite composite = new Composite(parent, SWT.NULL);

        String taxonStr = "";

        int count = configurator.getTaxonNodeFilter().getSubtreeFilter().size();

        for (LogicFilter<TaxonNode> filter: configurator.getTaxonNodeFilter().getSubtreeFilter()){

            subTreeNode = CdmApplicationState.getCurrentAppConfig().getTaxonNodeService().load(filter.getUuid());

            count--;

            if (subTreeNode.hasTaxon()){

                taxonStr += subTreeNode.getTaxon().getName().getTitleCache();

                if (count>0){

                    taxonStr += ", ";

                }

            }

        }

        if (StringUtils.isNotBlank(taxonStr)){

            checkUseSelectedSubtree= new Button(composite,  SWT.RADIO);

            checkUseSelectedSubtree.setText("Aggregation for selected subtree(s) "+  taxonStr);

            checkUseSelectedSubtree.addListener(SWT.Selection, new Listener() {

                @Override

                public void handleEvent(Event e) {

                    Button b = (Button) e.widget;

                    GridData data = (GridData)  comboClassificationSelection.getLayoutData();

                    data.exclude = b.getSelection();

                    comboClassificationSelection.setEnabled(!data.exclude);

                    updateHigherRankCombo();

               }

            });

            checkUseSelectedTaxonNode= new Button(composite,  SWT.RADIO);

            checkUseSelectedTaxonNode.setText("Aggregation only for "+  taxonStr);

            checkUseSelectedTaxonNode.addListener(SWT.Selection, new Listener() {

                @Override

                public void handleEvent(Event e) {

                    Button b = (Button) e.widget;

                    GridData data = (GridData)  comboClassificationSelection.getLayoutData();

                    data.exclude = b.getSelection();

                    comboClassificationSelection.setEnabled(!data.exclude);

                    updateHigherRankCombo();

                }

            });

        }

        checkUseSelectedClassification= new Button(composite,  SWT.RADIO);

        checkUseSelectedClassification.setText("Aggregate selected classification");

        checkUseSelectedClassification.addListener(SWT.Selection, new Listener() {

           @Override

           public void handleEvent(Event e) {

               Button b = (Button) e.widget;

               GridData data = (GridData)  comboClassificationSelection.getLayoutData();

               data.exclude = b.getSelection();

               comboClassificationSelection.setEnabled(data.exclude);

               updateHigherRankCombo();

           }

        });

        GridLayoutFactory.fillDefaults();

        if (subTreeNode!= null){

            selectedClassification = subTreeNode.getClassification();

        }

        GridData gridDataClassificationCombo = new GridData();

        gridDataClassificationCombo = new GridData(GridData.BEGINNING, GridData.CENTER, true, false);

        gridDataClassificationCombo.horizontalIndent = 5;

        comboClassificationSelection = new Combo(composite, SWT.BORDER| SWT.READ_ONLY);

        comboClassificationSelection.setLayoutData(gridDataClassificationCombo);

        classifications = CdmStore.getService(IClassificationService.class).list(null, null, null, null, null);

        Collections.sort(classifications, new Comparator<Classification>() {

            @Override

            public int compare(Classification o1, Classification o2) {

                if (o1.equals(o2)){

                    return 0;

                }

                int result = o1.getTitleCache().compareTo(o2.getTitleCache());

                if (result == 0){

                    return o1.getUuid().compareTo(o2.getUuid());

                }

                return result;

            }

        });

        for(Classification tree : classifications){

            comboClassificationSelection.add(tree.getName().getText(), classifications.indexOf(tree));

        }

        comboClassificationSelection.select(classifications.indexOf(selectedClassification));

        comboClassificationSelection.addSelectionListener(this);

        if (StringUtils.isNotBlank(taxonStr)){

            checkUseSelectedSubtree.setSelection(true);

            comboClassificationSelection.setEnabled(false);

        }else{

            checkUseSelectedClassification.setSelection(true);

        }

        Label separator = new Label(composite, SWT.HORIZONTAL | SWT.SEPARATOR);

        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);

        gridData.horizontalSpan = 2;

        gridData.verticalIndent = 5;

        separator.setLayoutData(gridData);

        GridLayout gridLayout = new GridLayout();

        gridLayout.numColumns = 1;

        composite.setLayout(gridLayout);

        final Composite control = new Composite(composite, SWT.NULL);

        GridLayout gridLayoutControl = new GridLayout();

        gridLayoutControl.numColumns = 2;

        control.setLayout(gridLayoutControl);

        control.setLayoutData(new GridData(SWT.FILL, SWT.LEFT, true, true));

        Label higherRankLabel = new Label(control, SWT.NULL);

        higherRankLabel.setText("Highest rank");

        comboHigherRank = new Combo(control, SWT.BORDER | SWT.READ_ONLY);

        updateHigherRankCombo();

        comboHigherRank.addListener(SWT.Selection, this);

        Label lowerRankLabel = new Label(control, SWT.NULL);

        lowerRankLabel.setText("Lowest rank");

        comboLowerRank = new Combo(control, SWT.BORDER | SWT.READ_ONLY);

        updateLowerRankCombo();

        comboLowerRank.addListener(SWT.Selection, this);

        separator = new Label(composite, SWT.HORIZONTAL | SWT.SEPARATOR);

        gridData = new GridData(GridData.FILL_HORIZONTAL);

        gridData.horizontalSpan = 2;

        gridData.verticalIndent = 5;

        separator.setLayoutData(gridData);

        Label aggregationModeLabel = new Label(control, SWT.NULL);

        aggregationModeLabel.setText("Aggregation mode");

        aggregationModeLabel.setToolTipText("Selecting none would delete all existing aggregated distributions");

        aggregationModeViewer =  CheckboxTableViewer.newCheckList(control, SWT.BORDER | SWT.SINGLE);

        aggregationModeViewer.setContentProvider(new ArrayContentProvider());

        aggregationModeViewer.setLabelProvider(new LabelProvider(){

            @Override

            public String getText(Object element){

                if (element instanceof AggregationMode){

                    if (((AggregationMode)element).equals(AggregationMode.ToParent)){

                        return "From child to parent taxon";

                    }

                    if (((AggregationMode)element).equals(AggregationMode.WithinTaxon)){

                        return "From sub area to super area";

                    }

                }

                return null;

            }

        });

        List<AggregationMode> aggregationModeList = new ArrayList<>();

        for (AggregationMode mode: AggregationMode.values()){

            aggregationModeList.add(mode);

        }

        aggregationModeViewer.setInput(aggregationModeList);

        aggregationModeViewer.addCheckStateListener(new ICheckStateListener(){

            @Override

            public void checkStateChanged(    CheckStateChangedEvent event){

                Object[] checked =aggregationModeViewer.getCheckedElements();

                boolean areachecked = false;

                boolean toParentChecked = false;

                for (int i = 0; i<checked.length;i++){

                    if (checked[i] instanceof AggregationMode){

                        if (((AggregationMode)checked[i]).equals(AggregationMode.WithinTaxon)){

                            areachecked = true;

                        }

                        if (((AggregationMode)checked[i]).equals(AggregationMode.ToParent)){

                            toParentChecked = true;

                        }

                    }

                }

                comboAreaLevel.setEnabled(areachecked);

                buttonSuperArea.setEnabled(areachecked);

                comboSourceModeSubAreaSuperArea.setEnabled(areachecked);

                comboSourceModeChildParent.setEnabled(toParentChecked);

                getWizard().getContainer().updateButtons();

              }

        });

        Label areaLevelLabel = new Label(control, SWT.NULL);

        areaLevelLabel.setText("Area Level");

        areaLevelLabel.setToolTipText("Selecting the area level to which the distribution should be aggregated");

        comboAreaLevel = new Combo(control,  SWT.BORDER | SWT.READ_ONLY);

        List<NamedAreaLevel> namedAreaLevels = CdmStore.getTermManager().getAllTerms(TermType.NamedAreaLevel, null);

        for (NamedAreaLevel level: namedAreaLevels) {

            comboAreaLevel.add(level.getLabel());

            comboAreaLevel.setData(level.getLabel(), level);

        }

        comboAreaLevel.addSelectionListener(this);

        comboAreaLevel.setEnabled(false);

        GridData gridData2 = new GridData();

        gridData2.horizontalSpan = 2;

        gridData2.horizontalAlignment = SWT.LEFT;

        buttonSuperArea = new Button(control, SWT.PUSH );

        buttonSuperArea.setLayoutData(gridData2);

        buttonSuperArea.setEnabled(false);

        buttonSuperArea.setText("Select Super Areas");

        buttonSuperArea.setToolTipText("If area aggregation is selected, the super areas can be selected. If none are selected the top level areas are used.");

        buttonSuperArea.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                SuperAreaSelectionWizard availableDistributionWizard = new SuperAreaSelectionWizard(configurator, (NamedAreaLevel)comboAreaLevel.getData(comboAreaLevel.getText()));

                WizardDialog dialog = new WizardDialog(StoreUtil.getShell(),

                        availableDistributionWizard);

                int open = dialog.open();

            }

        });

        Label sourceModeLabel = new Label(control, SWT.NULL);

        sourceModeLabel.setText("Source mode child/parent");

        sourceModeLabel.setToolTipText("Defines the source mode if aggregation from child to parent taxon is selected.");

        comboSourceModeChildParent = new Combo(control,  SWT.BORDER| SWT.READ_ONLY);

        comboSourceModeChildParent.setText(Messages.DistributionAggregationConfiguration_AggregationMode);

        comboSourceModeChildParent.add("None");

        comboSourceModeChildParent.setData(null);

        for (AggregationSourceMode mode :AggregationSourceMode.values()){

            comboSourceModeChildParent.add(mode.toString());

            comboSourceModeChildParent.setData(mode.toString(), mode);

        }

        comboSourceModeChildParent.addSelectionListener(this);

        comboSourceModeChildParent.setEnabled(false);

        comboSourceModeChildParent.select(0);

        Label sourceModeLabelSuperArea = new Label(control, SWT.NULL);

        sourceModeLabelSuperArea.setText("Source mode sub area/super area");

        sourceModeLabelSuperArea.setToolTipText("Defines the source mode if aggregation from sub area to super area is selected.");

        comboSourceModeSubAreaSuperArea = new Combo(control,  SWT.BORDER| SWT.READ_ONLY);

        comboSourceModeSubAreaSuperArea.setText(Messages.DistributionAggregationConfiguration_AggregationMode);

        comboSourceModeSubAreaSuperArea.add("None");

        comboSourceModeSubAreaSuperArea.setData(null);

        for (AggregationSourceMode mode :AggregationSourceMode.values()){

            comboSourceModeSubAreaSuperArea.add(mode.toString());

            comboSourceModeSubAreaSuperArea.setData(mode.toString(), mode);

        }

        comboSourceModeSubAreaSuperArea.addSelectionListener(this);

        comboSourceModeSubAreaSuperArea.setEnabled(false);

        comboSourceModeSubAreaSuperArea.select(0);

        Label sourceTypeLabel = new Label(control, SWT.NULL);

        sourceTypeLabel.setText("Source type");

        sourceTypeLabel.setToolTipText("Type of sources that should added to the aggregated distribution");

        sourceTypeViewer = CheckboxTableViewer.newCheckList(control, SWT.BORDER | SWT.SINGLE);

        sourceTypeViewer.setContentProvider(new ArrayContentProvider());

        sourceTypeViewer.addCheckStateListener(new ICheckStateListener(){

            @Override

            public void checkStateChanged(    CheckStateChangedEvent event){

                checkedElements=sourceTypeViewer.getCheckedElements();

                getWizard().getContainer().updateButtons();

              }

        });

        List<String> typeStrings = new ArrayList<>();

        OriginalSourceType[] typeArray = OriginalSourceType.values();

        Arrays.sort(typeArray, new OriginalSourceTypeComparator(null));

        Arrays.stream(typeArray).forEach(p ->typeMap.put(p.getMessage(), p));

        Arrays.stream(typeArray).forEach(p ->typeStrings.add(p.getMessage()));

        typeStrings.remove(OriginalSourceType.NomenclaturalReference.getMessage());

        sourceTypeViewer.setInput(typeStrings);

        sourceTypeViewer.setChecked(OriginalSourceType.PrimaryMediaSource.getMessage(), true);

        sourceTypeViewer.setChecked(OriginalSourceType.PrimaryTaxonomicSource.getMessage(), true);

        sourceTypeViewer.getTable().setEnabled(false);

        //aggregation mode

        Label selectStatusLabel = new Label(control, SWT.NULL);

        selectStatusLabel.setText("Status order");

        comboStatusOrder = new Combo(control, SWT.PUSH );

        comboStatusOrder.add("Default - by Presence Absence Term vocabulary");

        comboStatusOrder.setData("Default - by Presence Absence Term vocabulary", null);

        for (TermTree tree: CdmStore.getService(ITermTreeService.class).list(TermType.PresenceAbsenceTerm, null, 0, null,null)){

            comboStatusOrder.add(tree.getTitleCache());

            comboStatusOrder.setData(tree.getTitleCache(), tree);

        }

        comboStatusOrder.addSelectionListener(this);

        comboStatusOrder.select(0);

        checkExportUnpublished = new Button(composite,  SWT.CHECK);

        checkExportUnpublished.setText("Export unpublished taxa");

        GridLayoutFactory.fillDefaults();

        setControl(composite);

    }

    @Override

    public void widgetSelected(SelectionEvent e) {

        if (e.getSource().equals(comboSourceModeChildParent) || e.getSource().equals(comboSourceModeSubAreaSuperArea)){

            AggregationSourceMode modeChild = (AggregationSourceMode)comboSourceModeChildParent.getData(comboSourceModeChildParent.getText());

            AggregationSourceMode modeArea = (AggregationSourceMode)comboSourceModeSubAreaSuperArea.getData(comboSourceModeSubAreaSuperArea.getText());

            if ((modeChild != null && modeChild.equals(AggregationSourceMode.ALL) || modeChild.equals(AggregationSourceMode.ALL_SAMEVALUE)) ||(modeArea != null && modeArea.equals(AggregationSourceMode.ALL) || modeArea.equals(AggregationSourceMode.ALL_SAMEVALUE))){

                sourceTypeViewer.getTable().setEnabled(true);

            }else{

                sourceTypeViewer.getTable().setEnabled(false);

            }

        }

        if (e.getSource().equals(comboAreaLevel)){

            buttonSuperArea.setEnabled(StringUtils.isNotBlank(comboAreaLevel.getText()));

        }

    }

    @Override

    public void widgetDefaultSelected(SelectionEvent e) {

        // TODO Auto-generated method stub

    }

    @Override

    public void handleEvent(Event event) {

        if (event.widget.equals(comboHigherRank)){

            updateLowerRankCombo();

        }

        if (event.widget.equals(selectedClassification)){

            updateHigherRankCombo();

            updateLowerRankCombo();

        }

        if (event.widget.equals(this.checkUseSelectedClassification)){

            updateHigherRankCombo();

            updateLowerRankCombo();

        }

        if (event.widget.equals(this.checkUseSelectedSubtree)){

            updateHigherRankCombo();

            updateLowerRankCombo();

        }

        if (event.widget.equals(this.checkUseSelectedTaxonNode)){

            updateHigherRankCombo();

            updateLowerRankCombo();

        }

    }

    private void updateHigherRankCombo() {

        comboHigherRank.removeAll();

        List<Rank> rankList = new ArrayList<>();

        TaxonName name = null;

        if (subTreeNode != null){

            if (subTreeNode.getTaxon() != null){

                name = subTreeNode.getTaxon().getName();

            }

        }

        comboHigherRank.add("");

        if (name != null){

            for (Rank rank: CdmStore.getTermManager().getPreferredTerms(Rank.class)){

                if (useClassification() || (name != null && name.getRank().isHigher(rank))){

                    rankList.add(rank);

                }

            }

        }else{

            for (Rank rank: CdmStore.getTermManager().getPreferredTerms(Rank.class)){

                rankList.add(rank);

            }

        }

        rankList.sort(comparator);

        for (Rank rank: rankList){

            comboHigherRank.add(rank.getLabel());

            comboHigherRank.setData(rank.getLabel(), rank);

        }

    }

   private void updateLowerRankCombo() {

       comboLowerRank.removeAll();

       TaxonName name = null;

       List<Rank> rankList = new ArrayList<>();

       if (subTreeNode != null){

           if (subTreeNode.getTaxon() != null){

               name = subTreeNode.getTaxon().getName();

           }

       }

       comboLowerRank.add("");

       for (Rank rank: CdmStore.getTermManager().getPreferredTerms(Rank.class)){

           if (subTreeNode == null && (comboHigherRank.getText() == null || (comboHigherRank.getData(comboHigherRank.getText()) != null && ((Rank)comboHigherRank.getData(comboHigherRank.getText())).isHigher(rank)))){

               rankList.add(rank);

           }else if (name == null || name.getRank().isHigher(rank)) {

               if(StringUtils.isBlank(comboHigherRank.getText()) || comboHigherRank.getData(comboHigherRank.getText()) != null && ((Rank)comboHigherRank.getData(comboHigherRank.getText())).isHigher(rank)){

               // the rank is lower than higher rank and lower than the rank of the subtree name

                   rankList.add(rank);

               }

           }

       }

       rankList.sort(comparator);

       for (Rank rank: rankList){

           comboLowerRank.add(rank.getLabel());

           comboLowerRank.setData(rank.getLabel(), rank);

       }

   }

   public Rank getHigherRank(){

       if (StringUtils.isNotBlank(comboHigherRank.getText())){

           return (Rank)comboHigherRank.getData(comboHigherRank.getText());

       }

       return null;

   }

   public Rank getLowerRank(){

       if (StringUtils.isNotBlank(comboLowerRank.getText())){

           return (Rank)comboLowerRank.getData(comboLowerRank.getText());

       }

       return null;

   }

   public AggregationSourceMode getSourceModeChildParent(){

       if (StringUtils.isNotBlank(comboSourceModeChildParent.getText())){

           return (AggregationSourceMode)comboSourceModeChildParent.getData(comboSourceModeChildParent.getText());

       }

       return null;

   }

   public AggregationSourceMode getSourceModeSuperAreaSubArea(){

       if (StringUtils.isNotBlank(comboSourceModeSubAreaSuperArea.getText())){

           return (AggregationSourceMode)comboSourceModeSubAreaSuperArea.getData(comboSourceModeSubAreaSuperArea.getText());

       }

       return null;

   }

   public TermTree getStatusOrder(){

       if (StringUtils.isNotBlank(comboStatusOrder.getText())){

           return (TermTree)comboStatusOrder.getData(comboStatusOrder.getText());

       }

       return null;

   }

   public boolean useClassification(){

       return checkUseSelectedClassification.getSelection();

   }

   public boolean useSubtree(){

       return checkUseSelectedSubtree.getSelection();

   }

   public boolean useTaxonNode(){

       return checkUseSelectedTaxonNode.getSelection();

   }

   public boolean useUnpublishedData(){

       return checkExportUnpublished.getSelection();

   }

   public EnumSet<OriginalSourceType> getSourceTypes(){

       List<OriginalSourceType> list = new ArrayList<>();

       for (Object o: sourceTypeViewer.getCheckedElements()){

           String string = null;

           if (o instanceof String){

               string = (String)o;

           }

           if (string != null){

               list.add(typeMap.get(string));

           }

       }

       return EnumSet.copyOf(list);

   }

   public List<AggregationSourceMode> getAggregationMode(){

       List<AggregationSourceMode> result = new ArrayList<>();

       for (Object o: aggregationModeViewer.getCheckedElements()){

           if (o instanceof AggregationSourceMode){

               result.add((AggregationSourceMode)o);

           }

       }

       return result;

   }

    public Classification getSelectedClassification() {

        return selectedClassification;

    }

    public TaxonNode getSubTreeNode() {

        return subTreeNode;

    }

}