Application: gvSIG desktop

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

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.UUID;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.impl.featuretype.DefaultFeatureAttributeSelectionPanel;

import static org.gvsig.fmap.dal.swing.impl.searchpanel.DefaultSearchPanel.getAttributeDescriptorLabel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SearchConditionFieldController {

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

  private static class Field extends LabeledValueImpl<String> {

    FeatureAttributeDescriptor attrdesc;

    private final FeatureStore store;

    private final int presentationMode;

    private final boolean showStoreName;

    private final FeatureAttributeDescriptor[] path;

    public Field(FeatureAttributeDescriptor[] path, FeatureStore store, FeatureAttributeDescriptor attrdesc, int presentationMode) {

      this(path, store, attrdesc, presentationMode, false);

    }

    public Field(

            FeatureAttributeDescriptor[] path, 

            FeatureStore store,

            FeatureAttributeDescriptor attrdesc,

            int presentationMode,

            boolean showStoreName

    ) {

      super(

              getAttributeDescriptorLabel(attrdesc, store.getName()),

              attrdesc.getName()

      );

      this.path = path;

      this.store = store;

      this.attrdesc = attrdesc;

      this.presentationMode = presentationMode;

      this.showStoreName = showStoreName;

    }

    public FeatureAttributeDescriptor[] getPath() {

      return this.path;

    }

    @Override

    public String getLabel() {

      String theLabel = getAttributeDescriptorLabel(attrdesc, showStoreName ? store.getName() : null);

      switch (this.presentationMode) {

        case Search.OrderedAttribute.TYPE_REGURAL:

          break;

        case Search.OrderedAttribute.TYPE_FAVORITE:

          theLabel = "<html><b>" + theLabel + "</b></html>";

          break;

        case Search.OrderedAttribute.TYPE_RECENT:

          theLabel = "<html><i><b>" + theLabel + "</b></i></html>";

          break;

      }

      return theLabel;

    }

    public FeatureAttributeDescriptor getParentDescriptor() {

      int l = this.path.length;

      if( l < 2 ) {

        return null;

      }

      return this.path[l-2];

    }

    public FeatureAttributeDescriptor getDescriptor() {

      return this.attrdesc;

    }

    public FeatureStore getFeatureStore() {

      return this.store;

    }

  }

  private FeatureStore store;

  private final JLabel lblFields;

  private final JLabel lblExtraFields;

  private final JLabel lblLogicalOperators;

  private final JLabel lblRelationalOperators;

  private final JComboBox cboValue;

  private Object valueAssigned = null;

  private DropDown ddnFields;

  private DropDown ddnLogicalOperators;

  private DropDown ddnRelationalOperators;

  private LabeledValue[] relationalOperators;

  private LabeledValue[] logicalOperators;

  public SearchConditionFieldController(

          FeatureStore store,

          JLabel lblFields,

          JLabel lblExtraFields,

          JLabel lblRelationalOperators,

          JComboBox cboValue,

          JLabel lblLogicalOperators

  ) {

    this.store = store;

    this.lblFields = lblFields;

    this.lblExtraFields = lblExtraFields;

    this.lblRelationalOperators = lblRelationalOperators;

    this.cboValue = cboValue;

    this.lblLogicalOperators = lblLogicalOperators;

    this.initComponents();

  }

  public boolean isAValidRelationOperator(String name) {

    for (LabeledValue relationalOperator : relationalOperators) {

      if (StringUtils.equalsIgnoreCase(name, (CharSequence) relationalOperator.getValue())) {

        return true;

      }

    }

    return false;

  }

  private void initComponents() {

    try {

      I18nManager i18n = ToolsLocator.getI18nManager();

      ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

      relationalOperators = new LabeledValue[]{

        new LabeledValueImpl(i18n.getTranslation("_Equals_to"), ExpressionBuilder.OPERATOR_EQ),

        new LabeledValueImpl(i18n.getTranslation("_Like_to"), ExpressionBuilder.OPERATOR_ILIKE),

        new LabeledValueImpl(i18n.getTranslation("_Not_equals_to"), ExpressionBuilder.OPERATOR_NE),

        new LabeledValueImpl(i18n.getTranslation("_Greater_than"), ExpressionBuilder.OPERATOR_GT),

        new LabeledValueImpl(i18n.getTranslation("_Greater_or_equal_to"), ExpressionBuilder.OPERATOR_GE),

        new LabeledValueImpl(i18n.getTranslation("_Less_than"), ExpressionBuilder.OPERATOR_LT),

        new LabeledValueImpl(i18n.getTranslation("_Less_or_equal_to"), ExpressionBuilder.OPERATOR_LE)

      };

      logicalOperators = new LabeledValue[]{

        new LabeledValueImpl(i18n.getTranslation("_Or"), ExpressionBuilder.OPERATOR_OR),

        new LabeledValueImpl(i18n.getTranslation("_And"), ExpressionBuilder.OPERATOR_AND)

      };

      this.lblExtraFields.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

      this.ddnFields = toolsSwingManager.createDropDown(lblFields);

      this.ddnFields.setVisibleDropdownArrow(false);

      this.ddnRelationalOperators = toolsSwingManager.createDropDown(lblRelationalOperators);

      this.ddnRelationalOperators.setVisibleDropdownArrow(false);

      if (lblLogicalOperators != null) {

        this.ddnLogicalOperators = toolsSwingManager.createDropDown(lblLogicalOperators);

        this.ddnLogicalOperators.setVisibleDropdownArrow(false);

      }

      DefaultComboBoxModel modelRelationalOperators = new DefaultComboBoxModel();

      for (LabeledValue op : relationalOperators) {

        modelRelationalOperators.addElement(op);

      }

      this.ddnRelationalOperators.setModel(modelRelationalOperators);

      if (this.ddnLogicalOperators != null) {

        DefaultComboBoxModel modelLogicalOperators = new DefaultComboBoxModel();

        for (LabeledValue op : logicalOperators) {

          modelLogicalOperators.addElement(op);

        }

        this.ddnLogicalOperators.setModel(modelLogicalOperators);

      }

      FeatureType featureType = store.getDefaultFeatureType();

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

              Search.COMPLEMENT_MANE, featureType

      );

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

              Search.BASIC_TYPES_FILTER,

              Search.STR_INT_LONG_LABEL_ORDER,

              20

      );

      List<ImageIcon> icons = new ArrayList<>();

//            DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

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

      DefaultComboBoxModel model = new DefaultComboBoxModel();

      for (Search.OrderedAttribute attr : orderedAttributes) {

        FeatureAttributeDescriptor attrdesc = attr.getDescriptor();

        Field field = new Field(

                new FeatureAttributeDescriptor[] { attrdesc },

                this.store, 

                attrdesc, 

                attr.getType()

        );

        model.addElement(field);

        String iconName = attrdesc.getDataType().getIconName();

        if (iconTheme.exists(iconName)) {

          icons.add(iconTheme.get(iconName));

        } else {

          icons.add(null);

        }

      }

      this.ddnFields.setIcons(icons);

      this.ddnFields.setModel(model);

      this.ddnFields.addItemListener(new ItemListener() {

        @Override

        public void itemStateChanged(ItemEvent e) {

          if (e.getStateChange() == ItemEvent.SELECTED) {

            doUpdateValuesList();

          }

        }

      });

      this.lblExtraFields.addMouseListener(new MouseAdapter() {

        @Override

        public void mouseClicked(MouseEvent e) {

          doSelectMoreFields();

        }

      });

      clear();

    } catch (Exception ex) {

      throw new RuntimeException(ex);

    }

  }

  private FeatureType getFeatureType() {

    try {

      return this.store.getDefaultFeatureType();

    } catch (DataException ex) {

      return null;

    }

  }

  private void doSelectMoreFields() {

    DefaultFeatureAttributeSelectionPanel panel = new DefaultFeatureAttributeSelectionPanel(store);

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

    final Dialog dialog = winManager.createDialog(

            panel,

            "Select attribute",

            null,

            WindowManager_v2.BUTTONS_OK_CANCEL

    );

    dialog.addActionListener((ActionEvent e) -> {

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

        doAddAndSelect(

                panel.getSelectedStore(),

                panel.getSelectedAttributeDescriptor(),

                panel.getSelectedPath()

        );

      }

    });

    dialog.show(WindowManager.MODE.DIALOG);

  }

  private void doAddAndSelect(FeatureStore theStore, FeatureAttributeDescriptor attrdesc, FeatureAttributeDescriptor[] path) {

    DefaultComboBoxModel<Field> model = (DefaultComboBoxModel) this.ddnFields.getModel();

    for (int i = 0; i < model.getSize(); i++) {

      Field field = model.getElementAt(i);

      FeatureAttributeDescriptor attrdescN = field.getDescriptor();

      if ( isTheSameStore(theStore, attrdescN.getStore()) 

              && StringUtils.equalsIgnoreCase(attrdesc.getName(), attrdescN.getName())) {

        this.setAttribute(i);

        return;

      }

    }

    Field field = new Field(

            path, 

            theStore, 

            attrdesc, 

            Search.OrderedAttribute.TYPE_REGURAL, 

            !isTheSameStore(store, theStore)

    );

    ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

    if( field.getPath().length>2 ) {

      dialogManager.messageDialog(

              "It not supported to search through this field." + "\n"

                + "Too many links.", 

              "_Warning", 

              JOptionPane.WARNING_MESSAGE

      );

      return;

    }

    FeatureAttributeDescriptor parentDescriptor = field.getParentDescriptor();

    switch(parentDescriptor.getRelationType()) {

      case DynField.RELATION_TYPE_AGGREGATE:

      case DynField.RELATION_TYPE_COMPOSITION:

        if( getForeingKeyName(field.getFeatureStore(), this.store)==null ) {

          dialogManager.messageDialog(

                  "It not supported to search through this field." + "\n"

                    + "The link field was not found.", 

                  "_Warning", 

                  JOptionPane.WARNING_MESSAGE

          );

          return;

        }

        if( getPrimaryKeyName(this.store)==null ) {

          dialogManager.messageDialog(

                  "It not supported to search through this field." + "\n"

                    + "A simple primary key was not found.", 

                  "_Warning", 

                  JOptionPane.WARNING_MESSAGE

          );

          return;

        }

    }

    model.addElement(field);

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

    this.ddnFields.getIcons().add(iconTheme.get(attrdesc.getDataType().getIconName()));

    this.setAttribute(model.getSize() - 1);

  }

  public void clear() {

    this.ddnRelationalOperators.setSelectedIndex(0);

    if (this.ddnLogicalOperators != null) {

      this.ddnLogicalOperators.setSelectedIndex(0);

    }

    this.cboValue.setSelectedIndex(-1);

  }

  private void doUpdateValuesList() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    if (field == null) {

      return;

    }

    final List<Object> values = new ArrayList<>();

    final int limit = 60;

    final long timeLimit = System.currentTimeMillis() + limit * 1000;

    final DefaultComboBoxModel model = new DefaultComboBoxModel();

    this.setEnabled(false);

    final FeatureStore theStore = field.getFeatureStore();

    final FeatureQuery query = theStore.createFeatureQuery();

    query.addAttributeName(field.getDescriptor().getName());

    query.setLimit(1000);

    Thread th = new Thread(new Runnable() {

      @Override

      public void run() {

        try {

          FeatureSet set = theStore.getFeatureSet(query);

          set.accept(new Visitor() {

            @Override

            public void visit(Object o) throws VisitCanceledException, BaseException {

              Object value = ((Feature) o).get(field.getDescriptor().getName());

              if (!values.contains(value)) {

                values.add(value);

              }

              if (System.currentTimeMillis() > timeLimit) {

                throw new VisitCanceledException();

              }

              if (values.size() > 1000) {

                throw new VisitCanceledException();

              }

            }

          });

        } catch (VisitCanceledException ex) {

        } catch (Exception ex) {

          LOGGER.warn("Can't update list of values of '" + field.getLabel() + "'.", ex);

        }

        List<LabeledValue> elements = new ArrayList<>();

        if (!values.isEmpty()) {

          LabeledValue[] availableValues = field.getDescriptor().getAvailableValues();

          Map<String, String> availableValuesMap = new HashMap<>();

          if (availableValues != null) {

            for (LabeledValue availableValue : availableValues) {

              availableValuesMap.put(

                      Objects.toString(availableValue.getValue()),

                      availableValue.getLabel()

              );

            }

          }

          elements.add(new LabeledValueImpl("", null));

          for (Object value : values) {

            String key = Objects.toString(value);

            String label = availableValuesMap.getOrDefault(key, key);

            elements.add(new LabeledValueImpl(label, value));

          }

          elements.sort(null);

        }

        for (LabeledValue element : elements) {

          model.addElement(element);

        }

        SwingUtilities.invokeLater(new Runnable() {

          @Override

          public void run() {

            cboValue.setModel(model);

            if (valueAssigned != null) {

              cboValue.setSelectedItem(valueAssigned);

              valueAssigned = null;

            }

            setEnabled(true);

          }

        });

      }

    });

    th.start();

  }

  public void setEnabled(boolean enabled) {

    this.ddnFields.setEnabled(enabled);

    if (this.ddnLogicalOperators != null) {

      this.ddnLogicalOperators.setEnabled(enabled);

    }

    this.ddnRelationalOperators.setEnabled(enabled);

    this.lblExtraFields.setEnabled(enabled);

  }

  public String getRelationalOperator() {

    LabeledValue<String> op = (LabeledValue) this.ddnRelationalOperators.getSelectedItem();

    if (op == null) {

      return null;

    }

    return op.getValue();

  }

  public int setRelationalOperator(String name) {

    int n = 0;

    for (LabeledValue relationalOperator : relationalOperators) {

      if (StringUtils.equalsIgnoreCase(name, (CharSequence) relationalOperator.getValue())) {

        break;

      }

      n++;

    }

    if (this.relationalOperators.length <= n) {

      return -1;

    }

    this.ddnRelationalOperators.setSelectedIndex(n);

    return n;

  }

  public String getLogicalOperator() {

    if (this.ddnLogicalOperators == null) {

      return null;

    }

    LabeledValue<String> rel = (LabeledValue) this.ddnLogicalOperators.getSelectedItem();

    if (rel == null) {

      return null;

    }

    return rel.getValue();

  }

  public Object getValue() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    if (field == null) {

      return null;

    }

    Object v = this.cboValue.getSelectedItem();

    if (v == null) {

      return null;

    }

    if (v instanceof LabeledValue) {

      v = ((LabeledValue) v).getValue();

      if (v == null) {

        return null;

      }

    }

    if (v instanceof CharSequence) {

      if (StringUtils.isBlank((CharSequence) v)) {

        return null;

      }

    }

    Coercion coercion = field.getDescriptor().getDataType().getCoercion();

    try {

      return coercion.coerce(v);

    } catch (CoercionException ex) {

      return null;

    }

  }

  public void setValue(Object value) {

    this.cboValue.setSelectedItem(value);

    this.valueAssigned = value;

  }

  private Field getCurrentField() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    return field;

  }

  public int setAttribute(String name) {

    ComboBoxModel<Field> model = this.ddnFields.getModel();

    for (int i = 0; i < model.getSize(); i++) {

      Field x = model.getElementAt(i);

      if (StringUtils.equalsIgnoreCase(name, x.getValue())) {

        this.setAttribute(i);

        return i;

      }

    }

    this.setAttribute(-1);

    return -1;

  }

  public void setAttribute(int index) {

    try {

      this.ddnFields.setSelectedIndex(index);

    } catch (Exception ex) {

      this.ddnFields.setSelectedIndex(-1);

    }

    doUpdateValuesList();

  }

  private boolean isTheSameStore(DataStore store1, DataStore store2) {

    String store1FullName = store1.getFullName();

    String store2FullName = store2.getFullName();

    return StringUtils.equalsIgnoreCase(store1FullName, store2FullName);

  }

  private String getPrimaryKeyName(FeatureStore store) {

    try {

      FeatureAttributeDescriptor[] pk = store.getDefaultFeatureType().getPrimaryKey();

      if( pk == null || pk.length!=1 ) {

        return null;

      }

      return pk[0].getName();

    } catch (DataException ex) {

      return null;

    }

  }

  private String getForeingKeyName(FeatureStore store, FeatureStore foreingStore) {

    try {

      for (FeatureAttributeDescriptor descriptor : store.getDefaultFeatureType()) {

        if( descriptor.isForeingKey() ) {

          ForeingKey foreingKey = descriptor.getForeingKey();

          if( isTheSameStore(foreingStore, foreingKey.getFeatureStore(null)) ) {

            return descriptor.getName();

          }

        }

      }

    } catch (DataException ex) {

      return null;

    }

    return null;

  }

  public ExpressionBuilder.Value getFilter() {

    ExpressionBuilder.Value filter = null;

    Object value = this.getValue();

    if( value == null ) {

      return null;

    }

    Field field = this.getCurrentField();

    if( field == null ) {

      return filter;

    }

    if( field.getPath().length>2 ) {

      // No soportado

      return null;

    }

    ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

    FeatureAttributeDescriptor parentDescriptor = field.getParentDescriptor();

    FeatureAttributeDescriptor descriptor = field.getDescriptor();

    if( parentDescriptor==null ) {

      filter = builder.binaryOperator(

              this.getRelationalOperator(),

              builder.column(descriptor.getName()),

              builder.constant(value)

      );

    } else {

      switch(parentDescriptor.getRelationType()) {

        case DynField.RELATION_TYPE_COLLABORATION:

        case DynField.RELATION_TYPE_IDENTITY:

          ExpressionBuilder.Function foreing_value = builder.function(

                DataManager.FUNCTION_FOREING_VALUE,

                builder.tuple(

                        builder.constant(parentDescriptor.getName()),

                        builder.constant(descriptor.getName())

                )

          );

          filter = builder.binaryOperator(

                  this.getRelationalOperator(),

                  builder.column(descriptor.getName()),

                  foreing_value

          );

          break;

        case DynField.RELATION_TYPE_AGGREGATE:

        case DynField.RELATION_TYPE_COMPOSITION:

          ExpressionBuilder.Function select = builder.function("SELECT");

          select.parameter(

            "TABLE", 

            builder.constant(field.getFeatureStore().getName())

          );

          select.parameter(

            "WHERE",

            builder.and(

              builder.eq(

                builder.getattr(

                        builder.column(field.getFeatureStore().getName()),

                        getForeingKeyName(field.getFeatureStore(), this.store)

                ), 

                builder.getattr(

                        builder.column(this.store.getName()),

                        getPrimaryKeyName(this.store)

                ) 

              ),

              builder.binaryOperator(

                this.getRelationalOperator(),

                builder.column(descriptor.getName()),

                builder.constant(this.getValue())

              )

            )

          );

          select.parameter("LIMIT",builder.constant(1));

          String exists_id = "EXISTS"+UUID.randomUUID().toString().replaceAll("-", "");

          filter = builder.function("EXISTS", select, builder.constant(exists_id));

          break;

      }

    }

    return filter;

  }

}