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 javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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 implements SearchConditionPanel {

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

    @Override

    public JComponent asJComponent() {

        return null;

    }

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

  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;

  public SearchConditionPanelSimplified(

          FeatureStore store,

          JButton btnAddToAccumulatedFilter,

          JButton btnRemoveAccumulatedFilter,

          JButton btnViewAccumulatedFilter,

          JLabel lblField1,

          JLabel lblExtraFields1,

          JLabel lblRelationalOperator1,

          JComboBox cboValue1,

          JLabel lblLogicalOperators1,

          JLabel lblField2,

          JLabel lblExtraFields2,

          JLabel lblRelationalOperator2,

          JComboBox cboValue2,

          JLabel lblLogicalOperators2,

          JLabel lblField3,

          JLabel lblExtraFields3,

          JLabel lblRelationalOperator3,

          JComboBox cboValue3,

          JLabel lblLogicalOperators3,

          JLabel lblField4,

          JLabel lblExtraFields4,

          JLabel lblRelationalOperator4,

          JComboBox cboValue4,

          JLabel lblLogicalOperators4

  ) {

    this.store = store;

    this.searchFields = new ArrayList<>();

    SearchConditionFieldController controller = new SearchConditionFieldController(

            store,

            lblField1,

            lblExtraFields1,

            lblRelationalOperator1,

            cboValue1,

            lblLogicalOperators1

    );

    this.searchFields.add(controller);

    controller = new SearchConditionFieldController(

            store,

            lblField2,

            lblExtraFields2,

            lblRelationalOperator2,

            cboValue2,

            lblLogicalOperators2

    );

    this.searchFields.add(controller);

    controller = new SearchConditionFieldController(

            store,

            lblField3,

            lblExtraFields3,

            lblRelationalOperator3,

            cboValue3,

            lblLogicalOperators3

    );

    this.searchFields.add(controller);

    controller = new SearchConditionFieldController(

            store,

            lblField4,

            lblExtraFields4,

            lblRelationalOperator4,

            cboValue4,

            null

    );

    this.searchFields.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;

  }

  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 : searchFields) {

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

  }

  public void clearAccumulatedFilter() {

    this.accumulatedFilter = null;

    this.btnRemoveAccumulatedFilter.setEnabled(false);

    this.btnViewAccumulatedFilter.setEnabled(false);

    this.btnAddAccumulatedFilter.setToolTipText(this.baseToolTip);

  }

  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.searchFields == null) {

      initComponents();

    }

    int n = 0;

    for (SearchConditionFieldController searchField : searchFields) {

      if (n < this.maxSearhFields) {

        searchField.setEnabled(enabled);

      } else {

        searchField.setEnabled(false);

      }

      n++;

    }

  }

  @Override

  public void clear() {

    if (this.searchFields == null) {

      return;

    }

    for (SearchConditionFieldController searchField : searchFields) {

      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 : searchFields) {

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

  }

  @Override

  public boolean set(Expression filter) {

    Code code = filter.getCode();

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

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

            return true;

          }

        }

      }

    }

    return false;

  }

}