EDIT

/**

 * Copyright (C) 2015 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.cdm.vaadin.component.distributionStatus;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import com.vaadin.data.Container;

import com.vaadin.data.Property;

import com.vaadin.data.Property.ValueChangeEvent;

import com.vaadin.data.Property.ValueChangeListener;

import com.vaadin.data.util.BeanItemContainer;

import com.vaadin.data.util.sqlcontainer.RowId;

import com.vaadin.server.Page;

import com.vaadin.server.VaadinSession;

import com.vaadin.ui.AbstractLayout;

import com.vaadin.ui.Alignment;

import com.vaadin.ui.Button.ClickEvent;

import com.vaadin.ui.Button.ClickListener;

import com.vaadin.ui.ComboBox;

import com.vaadin.ui.HorizontalLayout;

import com.vaadin.ui.Notification;

import com.vaadin.ui.OptionGroup;

import com.vaadin.ui.Panel;

import com.vaadin.ui.Table.ColumnHeaderMode;

import com.vaadin.ui.TextField;

import com.vaadin.ui.Tree.ExpandEvent;

import com.vaadin.ui.Tree.ExpandListener;

import com.vaadin.ui.TreeTable;

import com.vaadin.ui.UI;

import com.vaadin.ui.VerticalLayout;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.i18n.Messages;

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.cdm.vaadin.container.CdmSQLContainer;

import eu.etaxonomy.cdm.vaadin.container.NamedAreaContainer;

import eu.etaxonomy.cdm.vaadin.container.TaxonNodeContainer;

import eu.etaxonomy.cdm.vaadin.util.CdmQueryFactory;

import eu.etaxonomy.cdm.vaadin.util.CdmSpringContextHelper;

import eu.etaxonomy.cdm.vaadin.util.DistributionEditorUtil;

import eu.etaxonomy.cdm.vaadin.view.distributionStatus.IDistributionTableView;

import eu.etaxonomy.cdm.vaadin.view.distributionStatus.settings.AreaAndTaxonSettingsPresenter;

/**

 *

 * @author pplitzner

 * A Configuration window for choosing distribution areas and taxa to work with.

 *

 */

public class AreaAndTaxonSettingsConfigWindow

            extends SettingsDialogWindowBase<AreaAndTaxonSettingsPresenter>

            implements ValueChangeListener, ClickListener, ExpandListener{

	/**

	 * 

	 */

    private static final long serialVersionUID = 1439411115014088780L;

    private ComboBox classificationBox;

    private TextField taxonFilter;

    private ComboBox distAreaBox;

    private OptionGroup namedAreaList;

    private TreeTable taxonTree;

    private IDistributionTableView distributionTableView;

    /**

     * The constructor should first build the main layout, set the

     * composition root and then do any custom initialization.

     *

     * The constructor will not be automatically regenerated by the

     * visual editor.

     * @param distributionTableView

     */

    public AreaAndTaxonSettingsConfigWindow(IDistributionTableView distributionTableView) {

        super();

        this.distributionTableView = distributionTableView;

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    protected void init() {

        //init classification

        Classification classification = presenter.getChosenClassification();

        try {

            CdmSQLContainer classificationContainer = new CdmSQLContainer(CdmQueryFactory.generateTableQuery("Classification")); //$NON-NLS-1$

            classificationContainer.sort(new Object[] {"titleCache"}, new boolean[] {true}); //$NON-NLS-1$

            classificationBox.setContainerDataSource(classificationContainer);

        } catch (SQLException e) {

            DistributionEditorUtil.showSqlError(e);

        }

        RowId classificationRow = null;

        if(classification!=null){

            classificationRow = new RowId(classification.getId());

            TaxonNode root = CdmSpringContextHelper.getClassificationService().getRootNode(classification.getUuid());

            showClassificationTaxa(root);

        }

        else if(classificationBox.getItemIds().size()==1){

            //only one classification exists

            classificationRow = (RowId) classificationBox.getItemIds().iterator().next();

        }

        if(classificationRow!=null){

            classificationBox.setValue(classificationRow);

        }

        classificationBox.addValueChangeListener(this);

        taxonFilter.addValueChangeListener(this);

        taxonTree.addExpandListener(this);

        //init areas

        TermVocabulary<NamedArea> chosenAreaVoc = presenter.getChosenAreaVoc();

        Container areaVocContainer = presenter.getAreaContainer();

        if (areaVocContainer.size() == 1){

            chosenAreaVoc = (TermVocabulary<NamedArea>)areaVocContainer.getItemIds().iterator().next();

        }

        distAreaBox.setContainerDataSource(areaVocContainer);

        distAreaBox.setValue(chosenAreaVoc);

        distAreaBox.addValueChangeListener(this);

        if(chosenAreaVoc!=null){

            NamedAreaContainer areaContainer = new NamedAreaContainer(chosenAreaVoc);

            namedAreaList.setContainerDataSource(areaContainer);

        }

        Object selectedAreas = VaadinSession.getCurrent().getAttribute(DistributionEditorUtil.SATTR_SELECTED_AREAS);

        namedAreaList.setValue(selectedAreas);

        okButton.addClickListener(this);

        cancelButton.addClickListener(this);

        updateButtons();

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    protected AbstractLayout buildMainLayout() {

        mainLayout = new VerticalLayout();

        mainLayout.setSizeFull();

        HorizontalLayout leftAndRightContainer = new HorizontalLayout();

        leftAndRightContainer.setImmediate(false);

        leftAndRightContainer.setSizeFull();

        leftAndRightContainer.setMargin(true);

        leftAndRightContainer.setSpacing(true);

        VerticalLayout leftContainer = new VerticalLayout();

        leftContainer.setImmediate(false);

        leftContainer.setSpacing(true);

        leftContainer.setSizeFull();

        VerticalLayout rightContainer = new VerticalLayout();

        rightContainer.setImmediate(false);

        rightContainer.setSpacing(true);

        rightContainer.setSizeFull();

        //classification

        classificationBox = new ComboBox(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_CLASSIFICATION));

        classificationBox.setItemCaptionPropertyId(TaxonNodeContainer.LABEL);

        classificationBox.setInputPrompt(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_SELECT_CLASSIFICATION));

        classificationBox.setImmediate(true);

        classificationBox.setNewItemsAllowed(false);

        classificationBox.setNullSelectionAllowed(false);

        classificationBox.setSizeFull();

        classificationBox.setWidth("100%"); //$NON-NLS-1$

        //taxonFilter

        taxonFilter = new TextField(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_FILTER));

        taxonFilter.setInputPrompt(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_FILTER_TAXA_BY_NAME));

        taxonFilter.setSizeFull();

        taxonFilter.setImmediate(true);

        //distribution area box

        distAreaBox = new ComboBox(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_DISTRIBUTION_AREA));

        distAreaBox.setInputPrompt(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_SELECT_DISTRIBUTION_AREA));

        distAreaBox.setImmediate(true);

        distAreaBox.setNullSelectionAllowed(false);

        distAreaBox.setNewItemsAllowed(false);

        distAreaBox.setSizeFull();

        distAreaBox.setWidth("100%"); //$NON-NLS-1$

        // named areas

        namedAreaList = new OptionGroup();

        namedAreaList.setMultiSelect(true);

        namedAreaList.setSizeFull();

        Panel namedAreaPanel = new Panel(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_AREAS));

        namedAreaPanel.setContent(new VerticalLayout(namedAreaList));

        namedAreaPanel.setSizeFull();

        //taxonomy

        taxonTree = new TreeTable(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_TAXONOMY));

        taxonTree.setSelectable(true);

        taxonTree.setSizeFull();

        taxonTree.setImmediate(true);

        taxonTree.setCacheRate(20);

        taxonTree.setColumnHeaderMode(ColumnHeaderMode.HIDDEN);

        taxonTree.setMultiSelect(true);

        leftContainer.addComponent(distAreaBox);

        leftContainer.addComponent(namedAreaPanel);

        leftContainer.setExpandRatio(distAreaBox, 0.1f);

        leftContainer.setExpandRatio(namedAreaPanel, 0.9f);

        leftContainer.setSizeFull();

        rightContainer.addComponent(classificationBox);

        rightContainer.addComponent(taxonFilter);

        rightContainer.addComponent(taxonTree);

        rightContainer.setExpandRatio(classificationBox, 0.1f);

        rightContainer.setExpandRatio(taxonFilter, 0.1f);

        rightContainer.setExpandRatio(taxonTree, 0.8f);

        leftAndRightContainer.addComponent(leftContainer);

        leftAndRightContainer.addComponent(rightContainer);

        //button toolbar

        HorizontalLayout buttonToolBar = createOkCancelButtons();

        mainLayout.addComponent(leftAndRightContainer);

        mainLayout.addComponent(buttonToolBar);

        mainLayout.setExpandRatio(leftAndRightContainer, 0.9f);

        mainLayout.setExpandRatio(buttonToolBar, 0.1f);

        mainLayout.setComponentAlignment(buttonToolBar, Alignment.BOTTOM_RIGHT);

        return leftAndRightContainer;

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    public void valueChange(ValueChangeEvent event) {

        Property<?> property = event.getProperty();

        if(property==classificationBox){

        	UuidAndTitleCache<TaxonNode> parent = getUuidAndTitleCacheFromRowId(classificationBox.getValue());

        	TaxonNode root = CdmSpringContextHelper.getClassificationService().getRootNode(parent.getUuid());

        	showClassificationTaxa(root);

        }

        else if(property==taxonFilter){

            String filterText = taxonFilter.getValue();

            Property<?> uuidProperty = classificationBox.getContainerProperty(classificationBox.getValue(),"uuid"); //$NON-NLS-1$

            if(uuidProperty==null){

            	Notification.show(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_SELECT_CLASSIFICATION));

            }

            else{

            	if(CdmUtils.isNotBlank(filterText)){

            		UUID classificationUuid = UUID.fromString((String) uuidProperty.getValue());

            		List<UuidAndTitleCache<TaxonNode>> taxa = CdmSpringContextHelper.getTaxonNodeService().getUuidAndTitleCache(null, filterText, classificationUuid);

            		BeanItemContainer<UuidAndTitleCache<TaxonNode>> container = new BeanItemContainer<>(UuidAndTitleCache.class);

            		taxonTree.setContainerDataSource(container);

            		for (UuidAndTitleCache<TaxonNode> taxon : taxa) {

            			container.addItem(taxon);

            			taxonTree.setChildrenAllowed(taxon, false);

            		}

            		taxonTree.setVisibleColumns("titleCache"); //$NON-NLS-1$

            	}

            	else{

            		UuidAndTitleCache<TaxonNode> parent = getUuidAndTitleCacheFromRowId(classificationBox.getValue());

            		TaxonNode root = CdmSpringContextHelper.getClassificationService().getRootNode(parent.getUuid());

            		showClassificationTaxa(root);

            	}

            }

        }

        else if(property==distAreaBox){

            TermVocabulary<NamedArea> vocabulary = (TermVocabulary<NamedArea>) event.getProperty().getValue();

            NamedAreaContainer container = new NamedAreaContainer(vocabulary);

            namedAreaList.setContainerDataSource(container);

        }

        updateButtons();

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    protected boolean isValid() {

        return classificationBox.getValue()!=null && distAreaBox.getValue()!=null;

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    public void buttonClick(ClickEvent event) {

        Object source = event.getSource();

        if(source==okButton){

            List<UUID> taxonNodes = new ArrayList<>();

            TermVocabulary<NamedArea> areaVoc = null;

            String uuidString = (String) classificationBox.getContainerProperty(classificationBox.getValue(),"uuid").getValue(); //$NON-NLS-1$

            UUID classificationUuid = UUID.fromString(uuidString);

            Set<UuidAndTitleCache<TaxonNode>> treeSelection = (Set<UuidAndTitleCache<TaxonNode>>) taxonTree.getValue();

			if(!treeSelection.isEmpty()){

				for (UuidAndTitleCache<TaxonNode> uuidAndTitleCache : treeSelection) {

					taxonNodes.add(uuidAndTitleCache.getUuid());

				}

            }

			if(treeSelection.isEmpty() && CdmUtils.isNotBlank(taxonFilter.getValue())) {

                for (UuidAndTitleCache<TaxonNode> uuidAndTitleCache : (Collection<UuidAndTitleCache<TaxonNode>>) taxonTree.getItemIds()) {

                    taxonNodes.add(uuidAndTitleCache.getUuid());

                }

			}

            areaVoc = (TermVocabulary<NamedArea>) distAreaBox.getValue();

            List<NamedArea> selectedAreas = new ArrayList<>((Set<NamedArea>)namedAreaList.getValue()); //getValue is LinkedHashSet and therefore sorted

            DistributionEditorUtil.updateDistributionView(distributionTableView, taxonNodes, areaVoc, selectedAreas, classificationUuid);

            window.close();

        }

        else if(source==cancelButton){

            window.close();

        }

    }

    /**

     * 

     * {@inheritDoc}

     */

    @Override

    public void nodeExpand(ExpandEvent event) {

        UuidAndTitleCache<TaxonNode> parent = (UuidAndTitleCache<TaxonNode>) event.getItemId();

        ((TaxonNodeContainer) taxonTree.getContainerDataSource()).addChildItems(parent);

    }

    /**

     * Starts a {@link TreeUpdater} thread to populate the {@link #taxonTree} with taxa of the classification specified by the given {@code rootNode}.

     * @param rootNode The root node of the classification whose taxa should be shown in the {@link #taxonTree}.

     */

    private void showClassificationTaxa(TaxonNode rootNode) {

        final Collection<UuidAndTitleCache<TaxonNode>> children = CdmSpringContextHelper.getTaxonNodeService().listChildNodesAsUuidAndTitleCache(rootNode);

        // Enable polling and set frequency to 0.5 seconds

        UI.getCurrent().setPollInterval(500);

        taxonTree.setEnabled(false);

        taxonTree.removeAllItems();

        Notification.show(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_LOADING_TAXA));

        new TreeUpdater(children).start();

    }

    /**

     * Returns the {@link UuidAndTitleCache} object of the classification specified by the given {@link RowId} of the {@link CdmSQLContainer} used in the {@link #classificationBox}.

     * @param classificationSelection

     * @return {@link UuidAndTitleCache} object of the given classification specified by {@code classificationSelection}

     */

    private UuidAndTitleCache<TaxonNode> getUuidAndTitleCacheFromRowId(Object classificationSelection) {

        String uuidString = (String) classificationBox.getContainerProperty(classificationSelection, "uuid").getValue(); //$NON-NLS-1$

        Property<Integer> rootNodeContainerProperty = null;

        Collection<?> ids = classificationBox.getContainerPropertyIds();

        //use for loop here because the case of the root node id columns differs between some DBs

        for (Object id : ids) {

			if(id instanceof String && ((String) id).toLowerCase().equals("rootnode_id")){ //$NON-NLS-1$

				rootNodeContainerProperty = classificationBox.getContainerProperty(classificationSelection, id);

				break;

			}

		}

		int id = rootNodeContainerProperty.getValue();

        String titleCache = (String) classificationBox.getContainerProperty(classificationSelection, "titleCache").getValue(); //$NON-NLS-1$

        UUID uuid = UUID.fromString(uuidString);

        UuidAndTitleCache<TaxonNode> parent = new UuidAndTitleCache<>(uuid, id, titleCache);

        return parent;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected AreaAndTaxonSettingsPresenter getPresenter() {

        return new AreaAndTaxonSettingsPresenter();

    }

    /**

     * Thread to populate {@link AreaAndTaxonSettingsConfigWindow#taxonTree}.

     *

     */

    private class TreeUpdater extends Thread{

    	/**

    	 * The taxa to show.

    	 */

    	private Collection<UuidAndTitleCache<TaxonNode>> children;

    	/**

    	 * Creates a thread to show the given collection of taxa in {@link AreaAndTaxonSettingsConfigWindow#taxonTree}.

    	 * @param children {@link UuidAndTitleCache} of the taxa to show.

    	 */

		public TreeUpdater(Collection<UuidAndTitleCache<TaxonNode>> children) {

			this.children = children;

		}

		/**

		 * 

		 * {@inheritDoc}

		 */

		@Override

    	public void run() {

			UI.getCurrent().access(new Runnable() {

				/**

				 * 

				 * {@inheritDoc}

				 */

				@Override

				public void run() {

					taxonTree.setContainerDataSource(new TaxonNodeContainer(children));

			        Notification notification = new Notification(Messages.getLocalizedString(Messages.AreaAndTaxonSettingsConfigWindow_LOADING_COMPLETE));

			        notification.setDelayMsec(500);

			        notification.show(Page.getCurrent());

			        taxonTree.setEnabled(true);

			        taxonTree.setSortContainerPropertyId("titleCache"); //$NON-NLS-1$

			        taxonTree.sort();

			        //disable polling when all taxa are loaded

			        UI.getCurrent().setPollInterval(-1);

				}

			});

    	}

    }

}