Application: gvSIG desktop

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

import java.awt.event.ActionEvent;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import javax.json.Json;

import javax.json.JsonObject;

import javax.json.JsonObjectBuilder;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.event.ChangeListener;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.i18n.I18nManager;

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

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

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class SearchConditionPanelSimplified

        extends AbstractSearchConditionPanel

        implements SearchConditionPanel {

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

    public static final String PANEL_NAME = "SearchConditionPanelSimplified";

    @Override

    public JComponent asJComponent() {

        return null;

    }

    @Override

    public void put(SearchParameters params) {

        Map<String, JsonObject> allPersistenceJson = params.getValues();

        JsonObject jsonState = allPersistenceJson.get(PANEL_NAME);

        this.fromJson(jsonState);

    }

    @Override

    public SearchParameters fetch(SearchParameters params) {

        if (params == null) {

            return null;

        }

        Map<String, JsonObject> persistenceJson = params.getValues();

        JsonObject jsonState = this.toJson();

        persistenceJson.put(PANEL_NAME, jsonState);

        return params;

    }

    private static class SearchConditionPanelAdvancedFactory

            implements SearchConditionPanelFactory {

        @Override

        public boolean isApplicable(FeatureStore store) {

            return true;

        }

        @Override

        public SearchConditionPanel create(Object... os) {

            return null;

        }

        @Override

        public String getName() {

            return "Simplified";

        }

    }

    private static final SearchConditionPanelFactory FACTORY = new SearchConditionPanelAdvancedFactory();

    private final FeatureStore store;

    private final List<SearchConditionFieldController> searchFieldsControllers;

    private int maxSearhFields = 4;

    private String accumulatedFilter;

    private final JButton btnAddAccumulatedFilter;

    private final JButton btnRemoveAccumulatedFilter;

    private final JButton btnViewAccumulatedFilter;

    private final String baseToolTip;

    private SearchConditionPanelFactory factory;

    private final ChangeListenerHelper changeListenerHelper;

    public SearchConditionPanelSimplified(

            SearchParameters parameters,

            FeatureStore store,

            JButton btnAddToAccumulatedFilter,

            JButton btnRemoveAccumulatedFilter,

            JButton btnViewAccumulatedFilter,

            JLabel lblField1,

            JLabel lblExtraFields1,

            JLabel lblRelationalOperator1,

            JComboBox cboValue1,

            JLabel lblNull1,

            JLabel lblLogicalOperators1,

            JLabel lblField2,

            JLabel lblExtraFields2,

            JLabel lblRelationalOperator2,

            JComboBox cboValue2,

            JLabel lblNull2,

            JLabel lblLogicalOperators2,

            JLabel lblField3,

            JLabel lblExtraFields3,

            JLabel lblRelationalOperator3,

            JComboBox cboValue3,

            JLabel lblNull3,

            JLabel lblLogicalOperators3,

            JLabel lblField4,

            JLabel lblExtraFields4,

            JLabel lblRelationalOperator4,

            JComboBox cboValue4,

            JLabel lblNull4,

            JLabel lblLogicalOperators4

    ) {

        this.changeListenerHelper = ToolsSwingLocator.getToolsSwingManager().createChangeListenerHelper();

        this.store = store;

        this.searchFieldsControllers = new ArrayList<>();

        SearchConditionFieldController controller = new SearchConditionFieldController(

                parameters,

                store,

                lblField1,

                lblExtraFields1,

                lblRelationalOperator1,

                cboValue1,

                lblNull1,

                lblLogicalOperators1

        );

        this.searchFieldsControllers.add(controller);

        controller = new SearchConditionFieldController(

                parameters,

                store,

                lblField2,

                lblExtraFields2,

                lblRelationalOperator2,

                cboValue2,

                lblNull2,

                lblLogicalOperators2

        );

        this.searchFieldsControllers.add(controller);

        controller = new SearchConditionFieldController(

                parameters,

                store,

                lblField3,

                lblExtraFields3,

                lblRelationalOperator3,

                cboValue3,

                lblNull3,

                lblLogicalOperators3

        );

        this.searchFieldsControllers.add(controller);

        controller = new SearchConditionFieldController(

                parameters,

                store,

                lblField4,

                lblExtraFields4,

                lblRelationalOperator4,

                cboValue4,

                lblNull4,

                null

        );

        this.searchFieldsControllers.add(controller);

        this.accumulatedFilter = null;

        this.btnAddAccumulatedFilter = btnAddToAccumulatedFilter;

        this.btnRemoveAccumulatedFilter = btnRemoveAccumulatedFilter;

        this.btnViewAccumulatedFilter = btnViewAccumulatedFilter;

        this.baseToolTip = this.btnAddAccumulatedFilter.getToolTipText();

        initComponents();

    }

    @Override

    public SearchConditionPanelFactory getFactory() {

        return FACTORY;

    }

    @Override

    public boolean isValid(StringBuilder message) {

        boolean valid = true;

        for (SearchConditionFieldController searchField : searchFieldsControllers) {

            if (!searchField.isValid(message)) {

                valid = false;

            }

        }

        return valid;

    }

    private void initComponents() {

        try {

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

                    Search.COMPLEMENT_MANE, this.store.getDefaultFeatureType()

            );

            List<Search.OrderedAttribute> 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 (SearchConditionFieldController searchField : searchFieldsControllers) {

                if (n < this.maxSearhFields) {

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

                } else {

                    searchField.setEnabled(false);

                }

            }

        } catch (DataException ex) {

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

        }

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

            addToAccumulatedFilter(this.getCurrentFilter());

        });

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

            clearAccumulatedFilter();

        });

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

            showAccumulatedFilter();

        });

        this.btnRemoveAccumulatedFilter.setEnabled(false);

        this.btnViewAccumulatedFilter.setEnabled(false);

        this.btnAddAccumulatedFilter.setEnabled(true);

    }

    public void addToAccumulatedFilter(String filter) {

        if (StringUtils.isBlank(filter)) {

            return;

        }

        String theAccumulatedFilter = this.accumulatedFilter;

        this.clear();

        if (!StringUtils.isBlank(theAccumulatedFilter)) {

            filter = "( " + theAccumulatedFilter + ") AND \n( " + filter + ")";

        }

        this.btnAddAccumulatedFilter.setToolTipText("<html><b>" + this.baseToolTip + "</b><br><br>" + filter.replaceAll("\\n", "<br>") + "</html>");

        this.accumulatedFilter = filter;

        this.btnRemoveAccumulatedFilter.setEnabled(true);

        this.btnViewAccumulatedFilter.setEnabled(true);

        this.changeListenerHelper.fireEvent();

    }

    public void clearAccumulatedFilter() {

        this.accumulatedFilter = null;

        this.btnRemoveAccumulatedFilter.setEnabled(false);

        this.btnViewAccumulatedFilter.setEnabled(false);

        this.btnAddAccumulatedFilter.setToolTipText(this.baseToolTip);

        this.changeListenerHelper.fireEvent();

    }

    public void showAccumulatedFilter() {

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

        DataSwingManager manager = DALSwingLocator.getDataSwingManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        JExpressionBuilder panel = manager.createQueryFilterExpresion(store);

        panel.setExpression(ExpressionUtils.createExpression(this.getAccumulatedFilter()));

        Dialog dialog = winmanager.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Expression_builder"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

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

                this.clearAccumulatedFilter();

                this.addToAccumulatedFilter(panel.getExpression().getPhrase());

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    @Override

    public void setEnabled(boolean enabled) {

        if (this.searchFieldsControllers == null) {

            initComponents();

        }

        int n = 0;

        for (SearchConditionFieldController searchField : searchFieldsControllers) {

            if (n < this.maxSearhFields) {

                searchField.setEnabled(enabled);

            } else {

                searchField.setEnabled(false);

            }

            n++;

        }

    }

    @Override

    public void clear() {

        if (this.searchFieldsControllers == null) {

            return;

        }

        for (SearchConditionFieldController searchField : searchFieldsControllers) {

            searchField.clear();

        }

        this.clearAccumulatedFilter();

    }

    @Override

    public Expression get() {

        String currentFilter = this.getCurrentFilter();

        if (StringUtils.isBlank(accumulatedFilter)) {

            if (StringUtils.isBlank(currentFilter)) {

                return null;

            }

            return ExpressionUtils.createExpression(currentFilter);

        }

        if (StringUtils.isBlank(currentFilter)) {

            return ExpressionUtils.createExpression(accumulatedFilter);

        }

        return ExpressionUtils.createExpression("( " + accumulatedFilter + " ) AND ( " + currentFilter + " )");

    }

    public String getAccumulatedFilter() {

        return this.accumulatedFilter;

    }

    public String getCurrentFilter() {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

        String relational = OPERATOR_OR;

        for (SearchConditionFieldController searchField : searchFieldsControllers) {

            ExpressionBuilder.Value cond = searchField.getFilter();

            if (cond != null) {

                if (relational.equals(OPERATOR_AND)) {

                    builder.and(cond);

                } else {

                    builder.or(cond);

                }

                relational = searchField.getLogicalOperator();

            }

        }

        if (builder.isEmpty()) {

            return null;

        }

        return builder.toString();

    }

    public JsonObject toJson() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        int i = 0;

        for (SearchConditionFieldController searchField : searchFieldsControllers) {

            JsonObject jsonState = searchField.toJson();

            String name = DataTypeUtils.toString(i);

            builder.add(name, jsonState);

            i++;

        }

        JsonObject jsonBuild = builder.build();

        return jsonBuild;

    }

    public void fromJson(JsonObject json) {

        if (json==null) {

            return;

        }

        int i = 0;

        for (SearchConditionFieldController searchFieldController : searchFieldsControllers) {

            String index = DataTypeUtils.toString(i);

            JsonObject jsonField = json.getJsonObject(index);

            searchFieldController.fromJson(jsonField);

            i++;

        }

    }

    @Override

    public boolean set(Expression filter) {

        try {

            Code code = filter.getCode();

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

                SearchConditionFieldController searchField = this.searchFieldsControllers.get(0);

                Code.Callable caller = (Code.Callable) 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());

                            return true;

                        }

                    }

                }

            }

            return false;

        } finally {

            this.changeListenerHelper.fireEvent();

        }

    }

    @Override

    public void addChangeListener(ChangeListener listener) {

        this.changeListenerHelper.addChangeListener(listener);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListenerHelper.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener listener) {

        this.changeListenerHelper.removeChangeListener(listener);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListenerHelper.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListenerHelper.hasChangeListeners();

    }

}