Application: gvSIG desktop

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

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.tree.TreePath;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.complements.Search;

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

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

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

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

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

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

import org.gvsig.fmap.dal.swing.impl.searchpanel.AdvancedAttributeSelectionTreeModel.Node;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.exception.BaseException;

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

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

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

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SearchFieldController {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchFieldController.class);

    private static class FeatureAttribute extends LabeledValueImpl<String> {

        FeatureAttributeDescriptor attrdesc;

        private final FeatureStore store;

        public FeatureAttribute(FeatureStore store, FeatureAttributeDescriptor attrdesc) {

            this(store, attrdesc, null, null);

        }

        public FeatureAttribute(

                FeatureStore store,

                FeatureAttributeDescriptor attrdesc, 

                String label, 

                String value

            ) {

            super(

                    ObjectUtils.defaultIfNull(label, attrdesc.getLabel()),

                    ObjectUtils.defaultIfNull(value, attrdesc.getName())

            );

            this.store = store;

            this.attrdesc = attrdesc;

        }

        public FeatureAttributeDescriptor getDescriptor() {

            return this.attrdesc;

        }

        public FeatureStore getFeatureStore() {

            return this.store;

        }

        public boolean isExpression() {

            FeatureType type = this.attrdesc.getFeatureType();

            if (type == null) {

                return false;

            }

            Object x = type.get(this.getValue());

            return x == null;

        }

    }

    private FeatureStore store;

    private final JLabel lblFields;

    private final JLabel lblExtraFields;

    private final JLabel lblLogicalOperators;

    private final JLabel lblRelationalOperators;

    private final JComboBox cboValue;

    private DropDown ddnFields;

    private DropDown ddnLogicalOperators;

    private DropDown ddnRelationalOperators;

    private final LabeledValue[] relationalOperators = {

        new LabeledValueImpl("Equals to", ExpressionBuilder.OPERATOR_EQ),

        new LabeledValueImpl("Like to", ExpressionBuilder.OPERATOR_ILIKE),

        new LabeledValueImpl("Not equals to", ExpressionBuilder.OPERATOR_NE),

        new LabeledValueImpl("Greater than", ExpressionBuilder.OPERATOR_GT),

        new LabeledValueImpl("Greater or equal to", ExpressionBuilder.OPERATOR_GE),

        new LabeledValueImpl("Less than", ExpressionBuilder.OPERATOR_LT),

        new LabeledValueImpl("Less or equal to", ExpressionBuilder.OPERATOR_LE)

    };

    private final LabeledValue[] logicalOperators = {

        new LabeledValueImpl("Or", ExpressionBuilder.OPERATOR_OR),

        new LabeledValueImpl("And", ExpressionBuilder.OPERATOR_AND)

    };

    public SearchFieldController(

            FeatureStore store,

            JLabel lblFields,

            JLabel lblExtraFields,

            JLabel lblRelationalOperators,

            JComboBox cboValue,

            JLabel lblLogicalOperators

    ) {

        this.store = store;

        this.lblFields = lblFields;

        this.lblExtraFields = lblExtraFields;

        this.lblRelationalOperators = lblRelationalOperators;

        this.cboValue = cboValue;

        this.lblLogicalOperators = lblLogicalOperators;

        this.initComponents();

    }

    private void initComponents() {

        try {

            ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

            this.lblExtraFields.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

            this.ddnFields = toolsSwingManager.createDropDown(lblFields);

            this.ddnRelationalOperators = toolsSwingManager.createDropDown(lblRelationalOperators);

            if (lblLogicalOperators != null) {

                this.ddnLogicalOperators = toolsSwingManager.createDropDown(lblLogicalOperators);

            }

            DefaultComboBoxModel modelRelationalOperators = new DefaultComboBoxModel();

            for (LabeledValue op : relationalOperators) {

                modelRelationalOperators.addElement(op);

            }

            this.ddnRelationalOperators.setModel(modelRelationalOperators);

            if (this.ddnLogicalOperators != null) {

                DefaultComboBoxModel modelLogicalOperators = new DefaultComboBoxModel();

                for (LabeledValue op : logicalOperators) {

                    modelLogicalOperators.addElement(op);

                }

                this.ddnLogicalOperators.setModel(modelLogicalOperators);

            }

            FeatureType featureType = store.getDefaultFeatureType();

            Search search = (Search) ToolsLocator.getComplementsManager().get(

                    Search.COMPLEMENT_MANE, featureType

            );

            List<FeatureAttributeDescriptor> orderedAttributes = search.getOrderedAttributes(

                    Search.BASIC_TYPES_FILTER,

                    Search.STR_INT_LONG_LABEL_ORDER,

                    20

            );

            DefaultComboBoxModel model = new DefaultComboBoxModel();

            for (FeatureAttributeDescriptor attrdesc : orderedAttributes) {

                model.addElement(new FeatureAttribute(this.store, attrdesc));

            }

            this.ddnFields.setModel(model);

            this.ddnFields.addItemListener(new ItemListener() {

                @Override

                public void itemStateChanged(ItemEvent e) {

                    if (e.getStateChange() == ItemEvent.SELECTED) {

                        doUpdateValuesList();

                    }

                }

            });

            this.lblExtraFields.addMouseListener(new MouseAdapter() {

                @Override

                public void mouseClicked(MouseEvent e) {

                    doSelectExtraField();

                }

            });

            clear();

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    private FeatureType getFeatureType() {

        try {

            return this.store.getDefaultFeatureType();

        } catch (DataException ex) {

            return null;

        }

    }

    private void doSelectExtraField() {

        FeatureType featureType = this.getFeatureType();

        Search search = (Search) ToolsLocator.getComplementsManager().get(

                Search.COMPLEMENT_MANE, featureType

        );

        List<FeatureAttributeDescriptor> orderedAttributes = search.getOrderedAttributes(

                Search.BASIC_TYPES_FILTER,

                Search.LABEL_ORDER,

                -1

        );

        AdvancedAttributeSelectionTreeModel treeModel = new AdvancedAttributeSelectionTreeModel(

                this.store,

                orderedAttributes

        );

        final JTree tree = new JTree();

        tree.setCellRenderer(new AdvancedAttributeSelectionTreeCellRenderer());

        tree.setModel(treeModel);

        JScrollPane scrollpane = new JScrollPane(tree);

        scrollpane.setPreferredSize(new Dimension(400, 300));

        scrollpane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);

        scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);

        WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        final Dialog dialog = winManager.createDialog(

                scrollpane,

                "Select attribute",

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                if (dialog.getAction() == WindowManager_v2.BUTTONS_OK) {

                    TreePath path = tree.getSelectionPath();

                    doAddAndSelect(path.getPath());

                }

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    private void doAddAndSelect(Object[] nodes) {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

        ExpressionBuilder.Function list = builder.list();

        for (int i = 1; i < nodes.length; i++) {

            Node node = (Node) nodes[i];

            FeatureAttributeDescriptor attrdesc = node.getValue();

            list.parameter(builder.constant(attrdesc.getName()));

        }

        Node node = (Node) nodes[nodes.length - 1];

        FeatureStore theStore = node.getFeatureStore();

        FeatureAttributeDescriptor attrdesc = node.getValue();

        String storeFullName = theStore.getFullName();

        DefaultComboBoxModel<FeatureAttribute> model = (DefaultComboBoxModel) this.ddnFields.getModel();

        for (int i = 0; i < model.getSize(); i++) {

            FeatureAttribute attr = model.getElementAt(i);

            FeatureAttributeDescriptor attrdescN = attr.getDescriptor();

            if (StringUtils.equalsIgnoreCase(storeFullName, attrdescN.getStore().getFullName())

                    && StringUtils.equalsIgnoreCase(attrdesc.getName(), attrdescN.getName())) {

                this.setAttribute(i);

                return;

            }

        }

        String formula = builder.function(DataManager.FUNCTION_FOREING_VALUE, list).toString();

        String label = attrdesc.getLabel() + " [" + theStore.getName() + "]";

        if (StringUtils.equalsIgnoreCase(storeFullName, this.store.getFullName())) {

            label = attrdesc.getLabel();

            formula = attrdesc.getName();

        }

        FeatureAttribute attribute = new FeatureAttribute(theStore, attrdesc, label, formula);

        model.addElement(attribute);

        this.setAttribute(model.getSize() - 1);

    }

    public void clear() {

        this.ddnRelationalOperators.setSelectedIndex(0);

        if (this.ddnLogicalOperators != null) {

            this.ddnLogicalOperators.setSelectedIndex(0);

        }

        this.cboValue.setSelectedIndex(-1);

    }

    private void doUpdateValuesList() {

        final FeatureAttribute attribute = (FeatureAttribute) this.ddnFields.getSelectedItem();

        if (attribute == null) {

            return;

        }

        final List<Object> values = new ArrayList<>();

        final int limit = 60;

        final long timeLimit = System.currentTimeMillis() + limit * 1000;

        final DefaultComboBoxModel model = new DefaultComboBoxModel();

        this.setEnabled(false);

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                try {

                    FeatureSet set = attribute.getFeatureStore().getFeatureSet();

                    set.accept(new Visitor() {

                        @Override

                        public void visit(Object o) throws VisitCanceledException, BaseException {

                            Object value = ((Feature) o).get(attribute.getDescriptor().getName());

                            if (!values.contains(value)) {

                                values.add(value);

                            }

                            if (System.currentTimeMillis() > timeLimit) {

                                throw new VisitCanceledException();

                            }

                            if (values.size() > 1000) {

                                throw new VisitCanceledException();

                            }

                        }

                    });

                } catch (VisitCanceledException ex) {

                } catch (Exception ex) {

                    LOGGER.warn("Can't update list of values of '"+attribute.getLabel()+"'.", ex);

                }

                List<LabeledValue> elements = new ArrayList<>();

                if (!values.isEmpty()) {

                    LabeledValue[] availableValues = attribute.getDescriptor().getAvailableValues();

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

                    if (availableValues != null) {

                        for (LabeledValue availableValue : availableValues) {

                            availableValuesMap.put(

                                    Objects.toString(availableValue.getValue()),

                                    availableValue.getLabel()

                            );

                        }

                    }

                    elements.add(new LabeledValueImpl("", null));

                    for (Object value : values) {

                        String key = Objects.toString(value);

                        String label = availableValuesMap.getOrDefault(key, key);

                        elements.add(new LabeledValueImpl(label, value));

                    }

                    elements.sort(null);

                }

                for (LabeledValue element : elements) {

                    model.addElement(element);

                }

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        cboValue.setModel(model);

                        setEnabled(true);

                    }

                });

            }

        });

        th.start();

    }

    public void setEnabled(boolean enabled) {

        this.ddnFields.setEnabled(enabled);

        if( this.ddnLogicalOperators!=null ) {

            this.ddnLogicalOperators.setEnabled(enabled);

        }

        this.ddnRelationalOperators.setEnabled(enabled);

        this.lblExtraFields.setEnabled(enabled);

    }

    public String getRelationalOperator() {

        LabeledValue<String> op = (LabeledValue) this.ddnRelationalOperators.getSelectedItem();

        if (op == null) {

            return null;

        }

        return op.getValue();

    }

    public String getLogicalOperator() {

        if (this.ddnLogicalOperators == null) {

            return null;

        }

        LabeledValue<String> rel = (LabeledValue) this.ddnLogicalOperators.getSelectedItem();

        if (rel == null) {

            return null;

        }

        return rel.getValue();

    }

    public Object getValue() {

        final FeatureAttribute attribute = (FeatureAttribute) this.ddnFields.getSelectedItem();

        if (attribute == null) {

            return null;

        }

        Object v = this.cboValue.getSelectedItem();

        if (v == null) {

            return null;

        }

        if (v instanceof LabeledValue) {

            v = ((LabeledValue) v).getValue();

            if (v == null) {

                return null;

            }

        }

        if (v instanceof CharSequence) {

            if (StringUtils.isBlank((CharSequence) v)) {

                return null;

            }

        }

        DataTypesManager.Coercion coercion = attribute.getDescriptor().getDataType().getCoercion();

        try {

            return coercion.coerce(v);

        } catch (CoercionException ex) {

            return null;

        }

    }

    public boolean isAttributeAnExpression() {

        final FeatureAttribute attribute = (FeatureAttribute) this.ddnFields.getSelectedItem();

        if (attribute == null) {

            return false;

        }

        return attribute.isExpression();

    }

    public String getAttribute() {

        final FeatureAttribute attribute = (FeatureAttribute) this.ddnFields.getSelectedItem();

        if (attribute == null) {

            return null;

        }

        attribute.getDescriptor().recentUsed();

        return attribute.getValue();

    }

    public void setAttribute(String name) {

        ComboBoxModel<FeatureAttribute> model = this.ddnFields.getModel();

        for (int i = 0; i < model.getSize(); i++) {

            FeatureAttribute x = model.getElementAt(i);

            if (StringUtils.equalsIgnoreCase(name, x.getLabel())) {

                this.setAttribute(i);

                return;

            }

        }

        this.setAttribute(-1);

    }

    public void setAttribute(int index) {

        try {

            this.ddnFields.setSelectedIndex(index);

        } catch (Exception ex) {

            this.ddnFields.setSelectedIndex(-1);

        }

        doUpdateValuesList();

    }

};