Application: gvSIG desktop

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

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.Action;

import javax.swing.BorderFactory;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.TableModel;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang.mutable.MutableObject;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_AND;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_OR;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.fmap.dal.DataStore;

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.FeatureStore;

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

import org.gvsig.fmap.dal.swing.AbstractDALActionFactory.AbstractDALActionContext;

import org.gvsig.fmap.dal.swing.DALActionFactory;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.searchpanel.FeatureStoreSearchPanel;

import org.gvsig.tools.ToolsLocator;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultSearchPanel

        extends DefaultSearchPanelView

        implements FeatureStoreSearchPanel {

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

    private Expression currentSearch;

    private class FeaturesTableModel extends AbstractTableModel {

        private final List<Feature> features;

        private final List<String> columnNames;

        private final FeatureType featureType;

        public FeaturesTableModel(FeatureType featureType) {

            this(featureType, null, null);

        }

        public FeaturesTableModel(FeatureType featureType, List<String> columnNames, List<Feature> features) {

            this.features = features;

            this.featureType = featureType;

            if (columnNames == null || columnNames.isEmpty()) {

                this.columnNames = new ArrayList<>();

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

                        Search.COMPLEMENT_MANE, featureType

                );

                List<FeatureAttributeDescriptor> attributos = search.getOrderedAttributes(

                        Search.BASIC_TYPES_FILTER,

                        Search.STR_INT_LONG_LABEL_ORDER,

                        12

                );

                for (FeatureAttributeDescriptor attrdesc : attributos) {

                    this.columnNames.add(attrdesc.getName());

                }

            } else {

                this.columnNames = columnNames;

            }

        }

        public List<Feature> getFeatures() {

            return this.features;

        }

        @Override

        public int getRowCount() {

            if (this.features == null) {

                return 0;

            }

            return this.features.size();

        }

        @Override

        public int getColumnCount() {

            return this.columnNames.size();

        }

        @Override

        public String getColumnName(int columnIndex) {

            String attrName = this.columnNames.get(columnIndex);

            if (this.featureType == null) {

                return attrName;

            }

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc == null) {

                return "C" + columnIndex;

            }

            return attrdesc.getLabel();

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            if (this.featureType == null) {

                return String.class;

            }

            String attrName = this.columnNames.get(columnIndex);

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc == null) {

                return String.class;

            }

            Class theClass = attrdesc.getDataType().getDefaultClass();

            if( theClass==null ) {

                return String.class;

            }

            return theClass;

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            return false;

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            if (this.features == null) {

                return null;

            }

            Feature feature = this.features.get(rowIndex);

            String attrName = this.columnNames.get(columnIndex);

            try {

                return feature.get(attrName);

            } catch (Throwable th) {

                return null;

            }

        }

        @Override

        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

        }

    }

    private class ActionButtons {

        private final DALActionFactory factory;

        private final Action action;

        private final JButton button;

        public ActionButtons(DALActionFactory factory, Action action, JButton button) {

            this.factory = factory;

            this.action = action;

            this.button = button;

        }

    }

    public static class SearchActionContext extends AbstractDALActionContext {

        private final DefaultSearchPanel panel;

        public SearchActionContext(DefaultSearchPanel panel) {

            super(FeatureStoreSearchPanel.ACTION_CONTEXT_NAME);

            this.panel = panel;

        }

        @Override

        public DataStore getStore() {

            return this.panel.getStore();

        }

        @Override

        public Expression getFilter() {

            return this.panel.getCurrentSearch();

        }

        @Override

        public JComponent getActionButton(String actionName) {

            return this.panel.getActionButton(actionName);

        }

        @Override

        public int getSelectedsCount() {

            return this.panel.getSelectedFeatureCount();

        }

        @Override

        public Expression getFilterForSelecteds() {

            return this.panel.getSearchForSelectedFeature();

        }

    }

    private final FeatureStore store;

    private final ActionListenerSupport acctionListeners;

    private List<SearchFieldController> searchFields;

    private ExpressionPickerController advancedExpression;

    private final Map<String, ActionButtons> actions;

    private boolean showActions = true;

    private int maxSearhFields = 4;

    public DefaultSearchPanel(FeatureStore store) {

        this.store = store;

        this.acctionListeners = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

        this.searchFields = null;

        this.actions = new HashMap<>();

    }

    @Override

    public JComponent asJComponent() {

        if( this.searchFields==null ) {

            this.initComponents();

        }

        return this;

    }

    private void addActions() {

        if( !this.showActions ) {

            return;

        }

        this.pnlActions.removeAll();

        this.pnlActions.setLayout(new FlowLayout(FlowLayout.TRAILING, 8, 4));

        SearchActionContext actionContext = new SearchActionContext(this);

        Collection<DALActionFactory> factories = DALSwingLocator.getSwingManager().getStoreActions();

        for (DALActionFactory factory : factories) {

            Action action = factory.createAction(actionContext);

            JButton button = new JButton(action);

            this.actions.put(factory.getName(), new ActionButtons(factory, action, button));

            button.setBorder(BorderFactory.createEmptyBorder());

            button.setBorderPainted(false);

            button.setFocusPainted(false);

            button.setContentAreaFilled(false);

            button.setCursor(new Cursor(Cursor.HAND_CURSOR));

            this.pnlActions.add(button);

        }

        this.pnlActions.revalidate();

        this.pnlActions.repaint();

    }

    @Override

    public void addActionListener(ActionListener listener) {

        this.acctionListeners.addActionListener(listener);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.acctionListeners.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener listener) {

        this.acctionListeners.removeActionListener(listener);

    }

    @Override

    public void removeAllActionListener() {

        this.acctionListeners.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent event) {

        this.acctionListeners.fireActionEvent(event);

    }

    @Override

    public boolean hasActionListeners() {

        return this.acctionListeners.hasActionListeners();

    }

    private void initComponents() {

        this.searchFields = new ArrayList<>();

        SearchFieldController controller = new SearchFieldController(

                store,

                lblField1,

                lblExtraFields1,

                lblRelationalOperator1,

                cboValue1,

                lblLogicalOperators1

        );

        this.searchFields.add(controller);

        controller = new SearchFieldController(

                store,

                lblField2,

                lblExtraFields2,

                lblRelationalOperator2,

                cboValue2,

                lblLogicalOperators2

        );

        this.searchFields.add(controller);

        controller = new SearchFieldController(

                store,

                lblField3,

                lblExtraFields3,

                lblRelationalOperator3,

                cboValue3,

                lblLogicalOperators3

        );

        this.searchFields.add(controller);

        controller = new SearchFieldController(

                store,

                lblField4,

                lblExtraFields4,

                lblRelationalOperator4,

                cboValue4,

                null

        );

        this.searchFields.add(controller);

        try {

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

                    Search.COMPLEMENT_MANE, this.store.getDefaultFeatureType()

            );

            List<FeatureAttributeDescriptor> orderedAttributes = search.getOrderedAttributes(

                    Search.BASIC_TYPES_FILTER,

                    Search.STR_INT_LONG_LABEL_ORDER,

                    5

            );

            this.maxSearhFields = Integer.min(orderedAttributes.size(), 4);

            int n = 0;

            for (SearchFieldController searchField : searchFields) {

                if( n<this.maxSearhFields ) {

                    searchField.setAttribute(orderedAttributes.get(n++).getName());

                } else {

                    searchField.setEnabled(false);

                }

            }

        } catch (DataException ex) {

            LOGGER.warn("Can't determine order of attributes", ex);

        }

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        this.advancedExpression = expressionSwingManager.createExpressionPickerController(

                txtAdvancedExpression, 

                btnAdvancedExpression,

                btnAdvancedExpressionHistory,

                btnAdvancedExpressionBookmarks

        );

        this.advancedExpression.addElement(

            DALSwingLocator.getSwingManager().createFeatureStoreElement(store)

        );

        this.btnSearch.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSearch();

            }

        });

        this.tblResults.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                for (ActionButtons actionButton : actions.values()) {

                    if( actionButton.action instanceof ListSelectionListener) {

                        ((ListSelectionListener) actionButton.action).valueChanged(e);

                    }

                }

            }

        });

        this.btnClear.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                clear();

            }

        });

        addActions();

        this.setPreferredSize(new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT));

        doSearch(null);

    }

    @Override

    public void setEnabled(boolean enabled) {

        if( this.searchFields==null ) {

            initComponents();

        }

        int n=0;

        for (SearchFieldController searchField : searchFields) {

            if( n<this.maxSearhFields ) {

                searchField.setEnabled(enabled);

            } else {

                searchField.setEnabled(false);

            }

            n++;

        }

        this.btnClear.setEnabled(enabled);

        this.btnSearch.setEnabled(enabled);

        this.advancedExpression.setEnabled(enabled);

        for (ActionButtons actionButton : actions.values()) {

            actionButton.action.setEnabled(enabled);

        }

    }

    public void clear() {

        if( this.searchFields==null ) {

            return;

        }

        for (SearchFieldController searchField : searchFields) {

            searchField.clear();

        }

        this.advancedExpression.set(null);

    }

    @Override

    public Expression getFilter() {

        Expression filter;

        int searchMode = this.tabSearchMode.getSelectedIndex();

        if (searchMode == 1) { // Avanzada

            filter = this.advancedExpression.get();

        } else {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String relational = OPERATOR_OR;

            for (SearchFieldController searchField : searchFields) {

                if (searchField.getAttribute() != null && searchField.getValue() != null) {

                    ExpressionBuilder.BinaryOperator cond = builder.binaryOperator(

                            searchField.getRelationalOperator(),

                            searchField.isAttributeAnExpression()

                            ? builder.custom(searchField.getAttribute())

                            : builder.column(searchField.getAttribute()),

                            builder.constant(searchField.getValue())

                    );

                    if (relational.equals(OPERATOR_AND)) {

                        builder.and(cond);

                    } else {

                        builder.or(cond);

                    }

                    relational = searchField.getLogicalOperator();

                }

            }

            if (builder.isEmpty()) {

                filter = null;

            } else {

                filter = ExpressionUtils.createExpression(builder.toString());

            }

        }

        if (ExpressionUtils.isPhraseEmpty(filter)) {

            return null;

        }

        return filter;

    }

    private void doSearch() {

        Expression filter = this.getFilter();

        doSearch(filter);

    }

    private void doSearch(final Expression exp) {

        final MutableObject model = new MutableObject(null);

        lblMsg.setText("Searching...");

        setEnabled(false);

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                try {

                    final List<Feature> features;

                    if (exp == null) {

                        features = store.getFeatures();

                    } else {

                        features = store.getFeatures(exp);

                    }

                    currentSearch = exp;

                    model.setValue( new FeaturesTableModel(

                            store.getDefaultFeatureType(),

                            null,

                            features

                        )

                    );

                } catch (DataException ex) {

                    LOGGER.warn("Can't get features or create table model",ex);

                } finally {

                    SwingUtilities.invokeLater(new Runnable() {

                        @Override

                        public void run() {

                            TableModel m = (TableModel) model.getValue();

                            tblResults.setModel(m);

                            lblMsg.setText(String.format("%d elementos", m.getRowCount()));

                            setEnabled(true);

                        }

                    });

                }

            }

        });

        th.start();

    }

    @Override

    public Expression getCurrentSearch() {

        return this.currentSearch;

    }

    @Override

    public boolean setFilter(Expression filter) {

        try {

            if( this.advancedExpression==null ) {

                this.initComponents();

            }

            if( ExpressionUtils.isPhraseEmpty(filter) ) {

                this.clear();

                return true;

            }

            this.advancedExpression.set(filter);

            this.tabSearchMode.setSelectedIndex(1);

            Code code = filter.getCode();

            if( code.code()==Code.CALLER) {

                SearchFieldController searchField = this.searchFields.get(0);

                Code.Caller caller = (Code.Caller)code;

                if( searchField.isAValidRelationOperator(caller.name())) {

                    Code op1 = caller.parameters().get(0);

                    Code op2 = caller.parameters().get(1);

                    if( op1.code()==Code.IDENTIFIER && op2.code()==Code.CONSTANT ) {

                        if( searchField.setAttribute(((Code.Identifier)op1).name())>=0 ) {

                            searchField.setRelationalOperator(caller.name());

                            searchField.setValue(((Code.Constant)op2).value());

                            this.tabSearchMode.setSelectedIndex(0);

                        }

                    }

                }

            }

            FeaturesTableModel model = new FeaturesTableModel(this.getStore().getDefaultFeatureType());

            tblResults.setModel(model);

            lblMsg.setText("");

            return true;

        } catch(Exception ex) {

            LOGGER.warn("Can't set current search", ex);

            return false;

        }

    }

    @Override

    public void setCurrentSearch(Expression filter) {

        if( this.setFilter(filter) ) {

            doSearch();

        }

    }

    @Override

    public Expression getSearchForSelectedFeature() {

        if( this.searchFields==null ) {

            return null;

        }

        int selectedRow = this.tblResults.getSelectedRow();

        if (selectedRow < 0) {

            return null;

        }

        try {

            List<Feature> features = ((FeaturesTableModel) this.tblResults.getModel()).getFeatures();

            Feature feature = features.get(selectedRow);

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            FeatureType ftype = this.store.getDefaultFeatureType();

            for (FeatureAttributeDescriptor attrdesc : ftype.getPrimaryKey()) {

                builder.and(

                        builder.eq(

                                builder.column(attrdesc.getName()),

                                builder.constant(feature.get(attrdesc.getName()))

                        )

                );

            }

            Expression filter = ExpressionUtils.createExpression(builder.toString());

            return filter;

        } catch (Exception ex) {

            LOGGER.warn("Can't build search for the selected feature.", ex);

            return null;

        }

    }

    @Override

    public FeatureStore getStore() {

        return store;

    }

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

    }

    public static void selfRegister() {

        String[][] iconNames = new String[][]{

            new String[]{"dalswing", "featurestore-column"},

            new String[]{"dalswing", "featurestore-foreing-key"},

            new String[]{"dalswing", "featurestore-table"},

            new String[]{"dalswing", "search-action-showform"},

            new String[]{"dalswing", "search-action-select"},

            new String[]{"dalswing", "search-action-select-add"},

            new String[]{"dalswing", "search-action-select-filter"}

        };

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

        for (String[] icon : iconNames) {

            URL url = DefaultSearchPanel.class.getResource(icon[1] + ".png");

            theme.registerDefault("DALSwing", icon[0], icon[1], null, url);

        }

    }

    @Override

    public int getSelectedFeatureCount() {

        if( this.searchFields==null ) {

            return 0;

        }

        return this.tblResults.getSelectedRowCount();

    }

    @Override

    public JComponent getActionButton(String name) {

        ActionButtons actionButton = this.actions.get(name);

        if( actionButton==null ) {

            return null;

        }

        return actionButton.button;

    }

    @Override

    public void setShowActions(boolean showActions) {

        this.showActions = showActions;

    }

    @Override

    public boolean isShowActions() {

        return this.showActions;

    }

}