Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.featurequery;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.swing.impl.featuretype.FeatureAttributeListCellRendererImpl;

import org.gvsig.fmap.dal.swing.impl.featuretype.DefaultFeatureAttributesSelectionPanel;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.swing.api.FilteredListController;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingManager;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.fmap.dal.swing.featurequery.FeatureQueryGroupByPanel;

import org.gvsig.timesupport.DataTypes;

import org.gvsig.tools.swing.api.FilteredListModel;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureQueryGroupByPanel

        extends DefaultFeatureQueryGroupByPanelView

        implements FeatureQueryGroupByPanel {

    private class AttributesWithAggregateRenderer extends FeatureAttributeListCellRendererImpl {

        @Override

        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

            JLabel c = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); //To change body of generated methods, choose Tools | Templates.

            FeatureAttributeDescriptor attrdesc = (FeatureAttributeDescriptor) value;

            String aggregate = query.getAggregateFunctions().get(attrdesc.getName());

            if (aggregate != null) {

                c.setText(c.getText() + "  [" + aggregate + "]");

            } else {

                c.setText(c.getText() + "  [<NULL>]");

            }

            return c;

        }

    }

    private FeatureStore store;

    private FeatureType featureType;

    private FilteredListController aggregateFunctionsController;

    private DefaultFeatureAttributesSelectionPanel groupByPanel;

    private FeatureQuery query;

    public DefaultFeatureQueryGroupByPanel() {

        this.initComponents();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = this.getClass().getResource(name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

    @Override

    public void setStore(FeatureStore store) {

        try {

            this.featureType = store.getDefaultFeatureType();

            this.store = store;

            this.query = store.createFeatureQuery();

            this.groupByPanel.setFeatureType(featureType);

            this.groupByPanel.setSelectedNames(query.getGroupByColumns());

            this.updateControls();

        } catch (DataException ex) {

            throw new RuntimeException("Can't assign store", ex);

        }

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        toolsSwingManager.translate(this.btnAttributesFilter);

        toolsSwingManager.translate(this.tabGroup);

        this.groupByPanel = new DefaultFeatureAttributesSelectionPanel();

        this.groupByPanel.allowCalculatedAttributes(true);

        this.pnlGroupByAttributes.setLayout(new BorderLayout());

        this.pnlGroupByAttributes.add(this.groupByPanel, BorderLayout.CENTER);

        this.lstAttributes.setCellRenderer(new AttributesWithAggregateRenderer());

        this.lstAttributes.addListSelectionListener((ListSelectionEvent e) -> {

            if (e.getValueIsAdjusting()) {

                return;

            }

            doSelectAttribute();

        });

        this.cboAggretateFunctions.addActionListener((ActionEvent e) -> {

            doSelectAttribute();

        });

        this.aggregateFunctionsController = toolsSwingManager.createFilteredListController(

                lstAttributes,

                txtAttributesFilter,

                btnAttributesFilter

        );

        this.aggregateFunctionsController.addChangeListener((ChangeEvent ce) -> {

            doSelectAttribute();

        });

        Dimension sz = this.getPreferredSize();

        if (sz.width < DEFAULT_WIDTH) {

            sz.width = DEFAULT_WIDTH;

        }

        if (sz.height < DEFAULT_HEIGHT) {

            sz.height = DEFAULT_HEIGHT;

        }

        this.setPreferredSize(sz);

    }

    private void doSelectAttribute() {

        String previuos = this.txtCurrentAttributeName.getText();

        if (!StringUtils.isBlank(previuos)) {

            String aggregate = (String) this.cboAggretateFunctions.getSelectedItem();

            if (StringUtils.isBlank(aggregate) || aggregate.equalsIgnoreCase("<NULL>")) {

                this.query.getAggregateFunctions().remove(previuos);

            } else {

                this.query.getAggregateFunctions().put(previuos, aggregate);

            }

            this.updateControls();

        }

        FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.lstAttributes.getSelectedValue();

        if (attr == null) {

            return;

        }

        this.txtCurrentAttributeName.setText(attr.getName());

        String aggregate = this.query.getAggregateFunctions().get(attr.getName());

        if (StringUtils.isBlank(aggregate) || aggregate.equalsIgnoreCase("<NULL>")) {

            this.cboAggretateFunctions.setSelectedIndex(0);

        } else {

            this.cboAggretateFunctions.setSelectedItem(aggregate);

        }

    }

    private void updateControls() {

        int indexAttributes = this.lstAttributes.getSelectedIndex();

        if (this.cboAggretateFunctions.getModel().getSize() < 1) {

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

            java.util.function.Function<String, Integer> isAllowed = ((FeatureStoreProviderFactory) (store.getProviderFactory())).allowFunction();

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            for (SymbolTableFactory factory : manager.getSymbolTableFactories()) {

                if (StringUtils.equalsIgnoreCase(Function.GROUP_AGGREGATE, factory.getName())) {

                    SymbolTable symbolTable = factory.create();

                    for (Function function : symbolTable) {

                        if (isAllowed.apply(function.name()) != DataType.NO) {

                            aggregateFunctions.add(function.name());

                        }

                    }

                    break;

                }

            }

            Collections.sort(aggregateFunctions);

            DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();

            model.addElement("<NULL>");

            for (String functionName : aggregateFunctions) {

                model.addElement(functionName);

            }

            this.cboAggretateFunctions.setModel(model);

            this.cboAggretateFunctions.setSelectedIndex(0);

            this.txtCurrentAttributeName.setText("");

        }

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        FilteredListModel model = toolsSwingManager.createFilteredListModel();

        for (FeatureAttributeDescriptor attr : featureType) {

            model.addElement(attr);

        }

        for (FeatureAttributeDescriptor attr : featureType.getExtraColumns().getColumns()) {

            model.addElement(attr);

        }

        for (EditableFeatureAttributeDescriptor attr : query.getExtraColumn().getColumns()) {

            model.addElement(attr);

        }

        model.setFilter(this.txtAttributesFilter.getText());

        model.sort(true);

        this.lstAttributes.setModel(model);

        this.lstAttributes.setSelectedIndex(indexAttributes);

        this.txtCurrentAttributeName.setText("");

        this.cboAggretateFunctions.setSelectedIndex(0);

        // 

        //groupByPanel.setSelectedNames(query.getGroupByColumns());

    }

    public Map<String, String> getFixedConversion() {

//      Map<String, String> fixed = new HashMap<>();

//      ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

//

//      for (Map.Entry<String, String> aggregate : this.query.getAggregateFunctions().entrySet()) {

//          String key = aggregate.getKey();

//          String value = aggregate.getValue();

//          FeatureAttributeDescriptor attr = this.featureType.getAttributeDescriptorFromAll(value);

//          if(attr==null) {

//              attr = this.query.getExtraColumn().get(value);

//              if(attr==null) {

//                  fixed.put(key, value);

//                  continue;

//              }

//          }

//          if(StringUtils.equalsIgnoreCase(key, "SUM")) {

//            switch (attr.getType()) {

//                case DataTypes.BOOLEAN:

//                case DataTypes.STRING:

//                    value = builder.let(

//                            attr.getName(),

//                            builder.toInteger(

//                                    builder.variable(attr.getName()

//                                    )

//                            )

//                    ).toString();

//            }

//          }

//          fixed.put(key, value);

//          

//      }

// 

//      return fixed;   

        return this.query.getAggregateFunctions();

    }

    @Override

    public FeatureQuery fetch(FeatureQuery query) {

        if (query == null) {

            FeatureQuery q = this.query.getCopy();

            q.getAggregateFunctions().clear();

            q.getAggregateFunctions().putAll(getFixedConversion());

            return q;

        }

        query.getGroupByColumns().clear();

        query.getGroupByColumns().addAll(this.groupByPanel.getSelectedNames());

        query.getAggregateFunctions().clear();

        query.getAggregateFunctions().putAll(getFixedConversion());

        return query;

    }

    @Override

    public FeatureQuery fetch() {

        return this.fetch(null);

    }

    public void removeTypeConversion() {

        Map<String, String> fixed = new HashMap<>();

        for (Map.Entry<String, String> aggregate : this.query.getAggregateFunctions().entrySet()) {

            String key = aggregate.getKey();

            String value = aggregate.getValue();

            FeatureAttributeDescriptor attr = this.featureType.getAttributeDescriptorFromAll(value);

            if (attr == null) {

                attr = this.query.getExtraColumn().get(value);

                if (attr == null) {

                    switch (key.toLowerCase()) {

                        case "sum":

                            Code code = ExpressionUtils.compile(value);

                            if (code instanceof Code.Callable) {

                                Code.Callable callable = (Code.Callable) code;

                                switch (callable.name().toLowerCase()) {

                                    case ExpressionBuilder.FUNCTION_LET:

                                        value = ((Code.Identifier) callable.parameters().get(0)).name();

                                        break;

                                }

                            }

                            break;

                    }

                }

            }

            fixed.put(key, value);

        }

        query.getAggregateFunctions().clear();

        query.getAggregateFunctions().putAll(fixed);

    }

    @Override

    public void put(FeatureQuery query) {

        this.query.copyFrom(query);

//    removeTypeConversion();

        groupByPanel.setSelectedNames(query.getGroupByColumns());

        groupByPanel.setExtraColumns(query.getExtraColumn().getColumns());

        this.updateControls();

    }

    public static void selfRegister() {

    }

}