Application: gvSIG desktop

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

import java.awt.BorderLayout;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.net.URL;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.logging.Level;

import javax.swing.AbstractAction;

import javax.swing.Action;

import static javax.swing.Action.ACTION_COMMAND_KEY;

import static javax.swing.Action.NAME;

import javax.swing.BorderFactory;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableModel;

import org.apache.commons.io.FilenameUtils;

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

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableLong;

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import static org.gvsig.fmap.dal.DataManager.DAL_USE_LABELS;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_BOTH;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_NO;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_YES;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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.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.feature.paging.FacadeOfAFeaturePagingHelper;

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.featurequery.FeatureQueryCalculatedColumnsPanel;

import org.gvsig.fmap.dal.swing.impl.featuretable.SimpleFeaturesTableModel;

import org.gvsig.fmap.dal.swing.impl.featurequery.DefaultFeatureQueryGroupByPanel;

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

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

import org.gvsig.fmap.dal.swing.searchpanel.SearchConditionPanel.SearchConditionPanelFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.i18n.I18nManager;

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

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.swing.icontheme.IconTheme;

import org.gvsig.tools.util.ToolsUtilLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

import org.gvsig.fmap.dal.swing.impl.featurequery.DefaultFeatureQueryCalculatedColumnsPanel;

import org.gvsig.fmap.dal.swing.featuretype.FeatureAttributesSelectionPanel;

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

import org.gvsig.tools.bookmarksandhistory.Bookmark;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_GETVALUE;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_SETVALUE;

import org.gvsig.tools.swing.api.bookmarkshistory.BookmarksController;

import org.gvsig.tools.swing.api.bookmarkshistory.HistoryController;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings({"UseSpecificCatch"})

public class DefaultSearchPanel

        extends DefaultSearchPanelView

        implements FeatureStoreSearchPanel {

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

    static /* friend */ Integer useLabels = null;

    private BookmarksController bookmarksController;

    private HistoryController historyController;

    private FeatureQuery lastQuery;

    public static class UseLabelsYesAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsYesAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_labels"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsYes");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_labels");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_YES;

        }

    }

    public static class UseLabelsNoAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsNoAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_names"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsNo");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_names");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_NO;

        }

    }

    public static class UseLabelsBothAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsBothAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_labels_and_names"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsBoth");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_labels_and_names");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_BOTH;

        }

    }

    public static class SelectColumnsAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public SelectColumnsAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Select_columns_to_display"));

            this.putValue(ACTION_COMMAND_KEY, "SelectColumns");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Select_columns_to_display");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doSelectResultColumnNames();

        }

    }

    public static class CalculatedColumnsAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public CalculatedColumnsAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Calculated_columns"));

            this.putValue(ACTION_COMMAND_KEY, "CalculatedColumns");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Calculated_columns");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doCalculatedColumns();

        }

    }

    public static class GroupByAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public GroupByAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Group_by"));

            this.putValue(ACTION_COMMAND_KEY, "GroupBy");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Group_by");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doGroupBy();

        }

    }

    public static class OrderByAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public OrderByAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Order_by"));

            this.putValue(ACTION_COMMAND_KEY, "SelectOrderBy");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Order_by");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doOrderBy();

        }

    }

    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 JComponent getActionButton(String actionName) {

            return this.panel.getActionButton(actionName);

        }

        @Override

        public int getSelectedsCount() {

            return this.panel.getSelectedFeatureCount();

        }

        @Override

        public Expression getFilterForSelecteds() {

            return this.panel.getFilterForSelectedFeature();

        }

        @Override

        public FeatureQuery getQuery() {

            return this.panel.getQuery();

        }

    }

    private FeatureStore store;

    private final ActionListenerSupport acctionListeners;

    private final Map<String, ActionButtons> actions;

    private boolean showActions = true;

    private DefaultSearchParameters parameters;

    private List<SearchConditionPanel> conditionPanels;

    private static final int PANEL_SIMPLIFIED = 0;

    private static final int PANEL_ADVANCED = 1;

    private static final String BOOKMARKSANDHISTORY_NAME = "SearchPanel";

    private final Bookmarks<Object> bookmarks;

    private final History<Object> history;

    public DefaultSearchPanel(FeatureStore store) {

        this.store = store;

        DisposeUtils.bind(store);

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

        this.actions = new HashMap<>();

        this.parameters = new DefaultSearchParameters();

        FeatureQuery featureQuery = this.store.createFeatureQuery();

        featureQuery.retrievesAllAttributes();

        this.parameters.setQuery(featureQuery);

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

                Search.COMPLEMENT_MANE, getFeatureType()

        );

        List<Search.OrderedAttribute> attributos = search.getOrderedAttributes(

                Search.BASIC_TYPES_FILTER,

                Search.STR_INT_LONG_LABEL_ORDER,

                12

        );

        for (Search.OrderedAttribute attrdesc : attributos) {

            this.parameters.getResultColumnNames().add(attrdesc.getDescriptor().getName());

        }

        this.bookmarks = ToolsLocator.getBookmarksAndHistoryManager().getBookmarksGroup(BOOKMARKSANDHISTORY_NAME);

        this.history = ToolsLocator.getBookmarksAndHistoryManager().getHistoryGroup(BOOKMARKSANDHISTORY_NAME);

    }

    @Override

    public void dispose() {

        DisposeUtils.disposeQuietly(store);

        TableModel m = this.tblResults.getModel();

        if( m instanceof Disposable ) {

            DisposeUtils.disposeQuietly((Disposable) m);

        }

        this.store = null;

        this.tblResults.setModel(new DefaultTableModel());

    }

    @Override

    public JComponent asJComponent() {

        if (this.conditionPanels == 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.conditionPanels = new ArrayList<>();

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.tabSearchMode);

        swingManager.translate(this.btnSearch);

        swingManager.translate(this.btnClear);

        swingManager.translate(this.lblExpressionDeBusqueda);

        swingManager.translate(this.btnAddAccumulatedFilter);

        swingManager.translate(this.btnRemoveAccumulatedFilter);

        swingManager.translate(this.btnViewAccumulatedFilter);

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        JComponent c = cfgActionsManager.getConfigurableActionsComponent(CONFIGURABLE_PANEL_ID, this);

        this.pnlCfgActions.setLayout(new BorderLayout(0, 0));

        this.pnlCfgActions.add(c, BorderLayout.CENTER);

        this.conditionPanels.add(

                new SearchConditionPanelSimplified(

                        parameters,

                        store,

                        btnAddAccumulatedFilter,

                        btnRemoveAccumulatedFilter,

                        btnViewAccumulatedFilter,

                        lblField1,

                        lblExtraFields1,

                        lblRelationalOperator1,

                        cboValue1,

                        lblLogicalOperators1,

                        lblField2,

                        lblExtraFields2,

                        lblRelationalOperator2,

                        cboValue2,

                        lblLogicalOperators2,

                        lblField3,

                        lblExtraFields3,

                        lblRelationalOperator3,

                        cboValue3,

                        lblLogicalOperators3,

                        lblField4,

                        lblExtraFields4,

                        lblRelationalOperator4,

                        cboValue4,

                        null

                )

        );

        this.conditionPanels.add(

                new SearchConditionPanelAdvanced(

                        this.store,

                        txtAdvancedExpression,

                        btnAdvancedExpression,

                        btnAdvancedExpressionHistory,

                        btnAdvancedExpressionBookmarks

                )

        );

        for (SearchConditionPanelFactory factory : DALSwingLocator.getManager().getSearchConditionPanels()) {

            String factoryName = "unknown";

            try {

                factoryName = factory.getName();

                if (factory.isApplicable(store)) {

                    SearchConditionPanel panel = factory.create(this);

                    this.conditionPanels.add(panel);

                    this.tabSearchMode.add(factory.getName(), panel.asJComponent());

                }

            } catch (Throwable th) {

                LOGGER.warn("Can't create search panel '" + factoryName + "'.");

            }

        }

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

            search();

        });

        this.tblResults.getSelectionModel().addListSelectionListener((ListSelectionEvent e) -> {

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

                if (actionButton.action instanceof ListSelectionListener) {

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

                }

            }

        });

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

            clear();

        });

        addActions();

        swingManager.createTableColumnAdjuster(tblResults);

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

        this.bookmarksController = ToolsSwingLocator.getToolsSwingManager().createBookmarksController(this.bookmarks, btnBookmarks);

        this.historyController = ToolsSwingLocator.getToolsSwingManager().createHistoryController(this.history, btnHistory);

        this.historyController.setFilter(null);

        ActionListener bookmarksAndHistoryListener = new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                ActionEventWithCurrentValue<DefaultSearchParameters> b = (ActionEventWithCurrentValue<DefaultSearchParameters>) e;

                switch (b.getID()) {

                    case ID_GETVALUE:

                        DefaultSearchParameters actualParams = (DefaultSearchParameters) fetch(null);

                        b.setCurrentValue(actualParams);

                        break;

                    case ID_SETVALUE:

                        if (b.getCurrentValue() == null) {

                            return;

                        }

                        DefaultSearchParameters searchParams;

                        try {

                            searchParams = b.getCurrentValue().getCopy();

                        } catch (Exception ex) {

                            LOGGER.warn("Not been able to clone export parameters", ex);

                            return;

                        }

                        clear();

                        put(searchParams);

                        search();

                        break;

                }

            }

        };

        this.historyController.addActionListener(bookmarksAndHistoryListener);

        this.bookmarksController.addActionListener(bookmarksAndHistoryListener);

        this.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentHidden(ComponentEvent e) {

                dispose();

            }

        });

        this.tblResults.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        this.tblResults.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if( e.getKeyCode()==KeyEvent.VK_F4 ) {

                    doShowCellInDialog();

                }

            }

        });

        if (this.bookmarks.hasBookmark(this.store.getName())) {

            Bookmark<DefaultSearchParameters> initBookmark = this.bookmarks.get(this.store.getName());

            DefaultSearchParameters initSearchParams = initBookmark.getValue().getCopy();

            clear();

            put(initSearchParams);

        }

        search();

    }

    private void doShowCellInDialog() {

        int row = this.tblResults.getSelectedRow();

        if( row < 0 ) {

            return;

        }

        int col = this.tblResults.getSelectedColumn();

        if( col < 0 ) {

            return;

        }

        String s = Objects.toString(this.tblResults.getValueAt(row, col),null);

        if( StringUtils.isBlank(s) ) {

            return;

        }

        ToolsSwingLocator.getToolsSwingManager().showZoomDialog(

            this, 

            this.tblResults.getColumnName(col), 

            s,

            false

        );

    }

    private FeatureType getFeatureType() {

        try {

            return store.getDefaultFeatureType();

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve the feature type.", ex);

        }

    }

    @Override

    public void setEnabled(boolean enabled) {

        if (this.conditionPanels == null) {

            this.initComponents();

        }

        for (SearchConditionPanel conditionPanel : conditionPanels) {

            conditionPanel.setEnabled(enabled);

        }

        this.btnClear.setEnabled(enabled);

        this.btnSearch.setEnabled(enabled);

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

            actionButton.action.setEnabled(enabled);

        }

    }

    @Override

    public void clear() {

        this.lblMsg.setText("");

        if (this.conditionPanels == null) {

            return;

        }

        for (SearchConditionPanel conditionPanel : conditionPanels) {

            conditionPanel.clear();

        }

        FeatureQuery emptyQuery = this.store.createFeatureQuery();

        emptyQuery.retrievesAllAttributes();

        this.parameters.setQuery(emptyQuery);

        // Mantener las columnas visualizadas

        // Elimina las que no existen en el store como campos calculados que

        // pudieran existir en el fquery

        List<String> resultColumnNames = this.parameters.getResultColumnNames();

        ArrayList<String> toDeleteAlreadyDontExist = new ArrayList<String>();

        for (String resultColumnName : resultColumnNames) {

            try {

                FeatureAttributeDescriptor attr = this.store.getDefaultFeatureType().getAttributeDescriptor(resultColumnName);

                if (attr == null) {

                    toDeleteAlreadyDontExist.add(resultColumnName);

                }

            } catch (DataException ex) {

            }

        }

        resultColumnNames.removeAll(toDeleteAlreadyDontExist);

        resetTable();

    }

    @Override

    public FeatureQuery getLastQuery() {

        return this.lastQuery;

    }

    public boolean isValid(StringBuilder message) {

        int searchMode = this.tabSearchMode.getSelectedIndex();

        SearchConditionPanel panel = this.conditionPanels.get(searchMode);

        boolean valid = panel.isValid(message);

        return valid;

    }

    @Override

    public void search() {

        final MutableObject model = new MutableObject(null);

        StringBuilder message = new StringBuilder();

        if (!this.isValid(message)) {

            ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogManager.messageDialog(

                    "_The_specified_search_condition_is_not_valid",

                    "_Search",

                    JOptionPane.WARNING_MESSAGE

            );

            return;

        }

        lblMsg.setText(ToolsLocator.getI18nManager().getTranslation("_Searching")+"...");

        setEnabled(false);

        Thread th = new Thread(() -> {

            try {

            FeatureQuery myQuery;

            SearchParameters searchParams;

            List<String> resultColumnNames;

            try {

                searchParams = this.fetch(this.parameters.getCopy()); // esto lo actualiza a la ultima // decidir si se devuelve clonado

                resultColumnNames = searchParams.getResultColumnNames();

                Date date = Calendar.getInstance().getTime();

                DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

                String strDate = dateFormat.format(date);

                searchParams.setName("Params: " + strDate);

            } catch (Exception ex) {

                LOGGER.warn("Not able to create search parameters.", ex);

                lblMsg.setText(ToolsLocator.getI18nManager().getTranslation("_Errors_fetching_new_query")+"...");

                resetTable();

                return;

            }

            final MutableLong rowCount=new MutableLong();

            try {

                final List<Feature> features;

                myQuery = this.getQuery().getCopy();

                features = store.getFeatures(myQuery, 20);

                FacadeOfAFeaturePagingHelper facade = (FacadeOfAFeaturePagingHelper) features;

                FeatureType ftype = facade.getFeaturePagingHelper().getFeatureSet().getDefaultFeatureType();

                    // al modelo le pasamos el ftype de esas features

                    SimpleFeaturesTableModel tableModel = new SimpleFeaturesTableModel(

                            ftype,

                            resultColumnNames,

                            features

                    );

                model.setValue(tableModel);

                rowCount.setValue(tableModel.getRowCount());

            } catch (Exception ex) {

                LOGGER.warn("Search not able to be executed. Can't get features or create table model", ex);

                lblMsg.setText(ToolsLocator.getI18nManager().getTranslation("_Errors_getting_new_feature_set")+"...");

                resetTable();

            } finally {

                SwingUtilities.invokeLater(() -> {

                    I18nManager i18n = ToolsLocator.getI18nManager();

                    try {

                        TableModel oldmodel = tblResults.getModel();

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

                        tblResults.setModel(m);

                        SimpleFeaturesTableModel.setCellRenderers(tblResults);

                        if (oldmodel instanceof SimpleFeaturesTableModel) {

                            ((SimpleFeaturesTableModel) oldmodel).dispose();

                        }

                        if (m.hasErrors()) {

                            lblMsg.setText(i18n.getTranslation("_Errors_occurred_during_search"));

                        } else {

                            lblMsg.setText(String.format("%d " + i18n.getTranslation("_elements"), rowCount.getValue()));

                        }

                        if (this.parameters != null && this.parameters.getQuery() != null) {

                            this.history.add(searchParams);                   

                        }

                    } catch (Exception ex) {

                        lblMsg.setText(i18n.getTranslation("_Errors_occurred_during_search"));

                    } finally {

                        setEnabled(true);

                    }

                });

            }

            } catch (Exception ex) {

                LOGGER.warn("Search panel has errors during the search", ex);

                resetTable();

            } finally {

                SwingUtilities.invokeLater(() -> {

                    setEnabled(true);

                });

            }

        });

        th.start();

    }

    private void resetTable() {

        if(!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(this::resetTable);

            return;

        }

        List<String> resultColumnNames = null;

        try {

            resultColumnNames = this.parameters.getResultColumnNames();

        } catch(Exception ex) {

        }

        FeatureType ftype = this.store.getDefaultFeatureTypeQuietly();

        SimpleFeaturesTableModel emptyTableModel = new SimpleFeaturesTableModel(

                ftype,

                resultColumnNames,

                null

        );

        this.tblResults.setModel(emptyTableModel);

    }

    public void setResultColumnNames(List<String> names) {

        this.parameters.getResultColumnNames().clear();

        this.parameters.getResultColumnNames().addAll(names);

        if (this.conditionPanels == null) {

            return;

        }

        SimpleFeaturesTableModel model;

//        model = (SimpleFeaturesTableModel) this.tblResults.getModel();

        List<Feature> features = store.getFeatures(this.parameters.getQuery());

        FacadeOfAFeaturePagingHelper facade = (FacadeOfAFeaturePagingHelper) features;

        FeatureType ftype = facade.getFeaturePagingHelper().getFeatureSet().getDefaultFeatureType();

        model = new SimpleFeaturesTableModel(

                ftype,

                this.parameters.getResultColumnNames(),

                features

        );

        tblResults.setModel(model);

    }

    @Override

    public boolean setFilter(Expression filter) {

        try {

            if (this.conditionPanels == null) {

                this.initComponents();

            }

            if (ExpressionUtils.isPhraseEmpty(filter)) {

                this.clear();

                return true;

            }

            int panel = 0;

            int selected = PANEL_ADVANCED;

            for (SearchConditionPanel conditionPanel : conditionPanels) {

                if (panel != PANEL_ADVANCED && conditionPanel.set(filter)) {

                    selected = panel;

                }

                panel++;

            }

            this.tabSearchMode.setSelectedIndex(selected);

//            SimpleFeaturesTableModel model = new SimpleFeaturesTableModel(this.getStore());

//            tblResults.setModel(model);

//            lblMsg.setText("");

            return true;

        } catch (Exception ex) {

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

            return false;

        }

    }

    @Override

    public List<SearchConditionPanel> getConditionPanels() {

        return Collections.unmodifiableList(this.conditionPanels);

    }

    @Override

    public SearchConditionPanel getConditionPanel(String name) {

        for (SearchConditionPanel panel : conditionPanels) {

            if (StringUtils.equalsIgnoreCase(name, panel.getFactory().getName())) {

                return panel;

            }

        }

        return null;

    }

    @Override

    public Expression getFilterForSelectedFeature() {

        if (this.conditionPanels == null) {

            return null;

        }

        int selectedRow = this.tblResults.getSelectedRow();

        if (selectedRow < 0) {

            return null;

        }

        try {

            List<Feature> features = ((SimpleFeaturesTableModel) 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;

    }

    private void doOrderBy() {

        I18nManager i18n = ToolsLocator.getI18nManager();

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

        FeatureQueryOrderPanel orderPanel = DALSwingLocator.getDataSwingManager().createFeatureStoreOrderPanel();

        orderPanel.setStore(store);

        orderPanel.put(parameters.getQuery());

        Dialog dialog = windowManager.createDialog(

                orderPanel.asJComponent(),

                i18n.getTranslation("_Select_order"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

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

                orderPanel.fetch(this.parameters.getQuery());

                search();

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    @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 int getSelectedFeatureCount() {

        if (this.conditionPanels == 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;

    }

    public static String getAttributeDescriptorLabel(FeatureAttributeDescriptor attrdesc, String tableName) {

        String theLabel;

        int theUseLabels;

        if (useLabels == null) {

            Tags tags = attrdesc.getTags();

            if (tags.has(DAL_USE_LABELS)) {

                theUseLabels = tags.getInt(DAL_USE_LABELS, USE_LABELS_NO);

            } else {

                if (attrdesc.getFeatureType()!=null) {

                    tags = attrdesc.getFeatureType().getTags();

                    theUseLabels = tags.getInt(DAL_USE_LABELS, USE_LABELS_NO);

                } else {

                    theUseLabels = USE_LABELS_NO;

                }

            }

        } else {

            theUseLabels = useLabels;

        }

        switch (theUseLabels) {

            case USE_LABELS_YES:

                if (StringUtils.isBlank(tableName)) {

                    theLabel = attrdesc.getLocalizedLabel();

                } else {

                    theLabel = String.format("%s [%s]", attrdesc.getLocalizedLabel(), tableName);

                }

                break;

            default:

            case USE_LABELS_NO:

                if (StringUtils.isBlank(tableName)) {

                    theLabel = attrdesc.getName();

                } else {

                    theLabel = String.format("%s [%s]", attrdesc.getName(), tableName);

                }

                break;

            case USE_LABELS_BOTH:

                if (StringUtils.isBlank(tableName)) {

                    theLabel = String.format("%s [%s]", attrdesc.getLocalizedLabel(), attrdesc.getName());

                } else {

                    theLabel = String.format("%s [%s/%s]", attrdesc.getLocalizedLabel(), attrdesc.getName(), tableName);

                }

                break;

        }

        return theLabel;

    }

    private void doCalculatedColumns() {

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

        I18nManager i18n = ToolsLocator.getI18nManager();

        final FeatureQueryCalculatedColumnsPanel panel = new DefaultFeatureQueryCalculatedColumnsPanel();

        panel.setStore(this.store);

        panel.put(this.parameters.getQuery());

        final Dialog dialog = winmanager.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Calculated_columns"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

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

                panel.fetch(this.parameters.getQuery());

                search();

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    private void doGroupBy() {

        DataStoreProviderFactory dataFactory = this.store.getProviderFactory();

        int allowGroupBy = ((FeatureStoreProviderFactory) dataFactory).allowGroupBy();

        if (allowGroupBy != DataType.YES) {

          // FIXME: mensaje al usaurio.

          I18nManager i18n = ToolsLocator.getI18nManager();

          ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

          dialogs.messageDialog(

                    i18n.getTranslation("_The_group_function_is_not_available_for_this_table"), 

                    i18n.getTranslation("_Information"), 

                    JOptionPane.INFORMATION_MESSAGE

          );

          return;

        }

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

        I18nManager i18n = ToolsLocator.getI18nManager();

        final FeatureQueryGroupByPanel panelGroupBy = new DefaultFeatureQueryGroupByPanel();

        panelGroupBy.setStore(this.store);

        panelGroupBy.put(this.parameters.getQuery());

        final Dialog dialog = winmanager.createDialog(

                panelGroupBy.asJComponent(),

                i18n.getTranslation("_Select_group_columns_and_aggregate_functions"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

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

                panelGroupBy.fetch(this.parameters.getQuery());

                search();

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    private void doSelectResultColumnNames() {

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

        I18nManager i18n = ToolsLocator.getI18nManager();

        final FeatureAttributesSelectionPanel panelSelectColumns = DALSwingLocator.getManager().createFeatureAttributeSelectionPanel();

        panelSelectColumns.allowCalculatedAttributes(false);

        FeatureType ftype = this.getFeatureType();

        try {

          Feature f = store.findFirst(this.parameters.getQuery());

          if( f!=null ) {

            ftype = f.getType();

          }

        } catch (Throwable ex) {

            LOGGER.warn("Can't retrieve the feature type from the first feature.",ex);

        }

        panelSelectColumns.setFeatureType(ftype);

        panelSelectColumns.setSelectedNames(this.parameters.getResultColumnNames());

        final Dialog dialog = winmanager.createDialog(

                panelSelectColumns.asJComponent(),

                i18n.getTranslation("_Select_the_columns_to_display"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

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

                this.setResultColumnNames(panelSelectColumns.getSelectedNames());

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    @Override

    public void put(SearchParameters inParams) {

        for (SearchConditionPanel conditionPanel : this.conditionPanels) {

            try {

                conditionPanel.put(inParams);

            } catch (Exception ex) {

                LOGGER.warn("Can't open panel", ex);

            }

        }

        this.parameters = (DefaultSearchParameters) inParams;

    }

    private FeatureQuery getQuery() {

        FeatureQuery query;

        try {

            int searchMode = this.tabSearchMode.getSelectedIndex();

            SearchConditionPanel panel = this.conditionPanels.get(searchMode);

            Expression filter = panel.get();

            if (searchMode != PANEL_ADVANCED) {

                this.conditionPanels.get(PANEL_ADVANCED).set(filter);

            }

            query = (FeatureQuery) this.parameters.getQuery().clone();

            query.retrievesAllAttributes();

            if (ExpressionUtils.isPhraseEmpty(filter)) {

                return query;

            }

            query.setFilter(filter);

            query.retrievesAllAttributes();

            return query;

        } catch (Exception ex) {

            LOGGER.warn("Can't build query.", ex);

            return null;

        }

    }

    @Override

    public SearchParameters fetch(SearchParameters outParams) {

        // Actualiza el fquery del parameters con los paneles

        for (SearchConditionPanel conditionPanel : conditionPanels) {

            try {

                conditionPanel.fetch(this.parameters);

            } catch (Exception ex) {

                LOGGER.warn("Panel not able to fetch values", ex);

            }

        }

        // Actualiza el filtro con el panel activo

        int searchMode = this.tabSearchMode.getSelectedIndex();

        SearchConditionPanel panel = this.conditionPanels.get(searchMode);

        Expression filter = panel.get();

        if (searchMode != PANEL_ADVANCED) {

            this.conditionPanels.get(PANEL_ADVANCED).set(filter);

        }

        FeatureQuery query = (FeatureQuery) this.parameters.getQuery();

        this.lastQuery = query.getCopy();

        query.retrievesAllAttributes();

        query.clearFilter();

        if (!ExpressionUtils.isPhraseEmpty(filter)) {

            query.setFilter(filter);

            query.retrievesAllAttributes();

        }

        if (outParams == null) {

            return this.parameters.getCopy();

        }

        outParams.copyFrom(this.parameters.getCopy());

        return outParams;

    }

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

        }

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new UseLabelsYesAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new UseLabelsNoAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new UseLabelsBothAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new SelectColumnsAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new CalculatedColumnsAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new GroupByAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new OrderByAction());

    }

}