Application: gvSIG desktop

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

import java.awt.Cursor;

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 org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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.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.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SearchFieldController {

    private static class FeatureAttribute extends LabeledValueImpl<String> {

        FeatureAttributeDescriptor attrdesc;

        public FeatureAttribute(FeatureAttributeDescriptor attrdesc) {

            this(attrdesc, null, null);

        }

        public FeatureAttribute(FeatureAttributeDescriptor attrdesc, String label, String value) {

            super(

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

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

            );

            this.attrdesc = attrdesc;

        }

        public FeatureAttributeDescriptor getDescriptor() {

            return this.attrdesc;

        }

        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);

            }

            List<FeatureAttributeDescriptor> orderedAttributes = SearchUtils.getOrderedAttributes(

                    this.store, 

                    SearchUtils.BASIC_TYPES_FILTER,

                    SearchUtils.STR_INT_LONG_LABEL_ORDER,

                    20

            );

            DefaultComboBoxModel model = new DefaultComboBoxModel();

            for (FeatureAttributeDescriptor attrdesc : orderedAttributes) {

                model.addElement(new FeatureAttribute(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 void doSelectExtraField() {

    }

    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;

        try {

            FeatureSet set = this.store.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) {

            // FIXME

        }

        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));

            }

        }

        DefaultComboBoxModel model = new DefaultComboBoxModel();

        for (LabeledValue element : elements) {

            model.addElement(element);

        }

        this.cboValue.setModel(model);

    }

    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;

        }

        SearchUtils.getRecentUseds().add(attribute.getDescriptor());

        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.ddnFields.setSelectedIndex(i);

                return;

            }

        }

        this.ddnFields.setSelectedIndex(-1);

    }

    public void setAttribute(int index) {

        try {

            this.ddnFields.setSelectedIndex(index);

        } catch(Exception ex) {

            this.ddnFields.setSelectedIndex(-1);

        }

    }

}