Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.expressionevaluator.suggestions;

import java.util.Objects;

import org.apache.commons.lang.StringUtils;

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

import org.apache.commons.text.similarity.LevenshteinDistance;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.SuggestionProvider;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.Factory;

import org.gvsig.tools.visitor.VisitCanceledException;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class CheckTableFieldsSuggestionProviderFactory implements Factory {

  private final FeatureStore store;

  private FeatureType featureType;

  public CheckTableFieldsSuggestionProviderFactory(FeatureStore store) {

    this.store = store;

    try {

      this.featureType = store.getDefaultFeatureType();

    } catch (DataException ex) {

      this.featureType = null;

    }            

  }

  @Override

  public String getName() {

    return "CheckTableFieldsSuggestion";

  }

  @Override

  public Object create(Object... parameters) {

    SuggestionProvider suggestionProvider = new CheckTableFieldsSuggestionProvider();

    return suggestionProvider;

  }

  private class CheckTableFieldsSuggestionProvider implements SuggestionProvider {

    @Override

    public String getSuggestion(String expression) {

      if ( StringUtils.isBlank(expression)) {

        return null;

      }

      MutableObject<String> suggestion = new MutableObject<>();

      try {

        Code code = ExpressionUtils.compile(expression);

        if (code == null) {

          return null;

        }

        final String storename = store.getName();

        code.accept((Object obj) -> {

          if (obj instanceof Code.Callable ) {

            Code.Callable callable = (Code.Callable)obj;

            if( StringUtils.equalsIgnoreCase(callable.name(),ExpressionBuilder.FUNCTION_GETATTR) ) {

              Code arg0 = callable.parameters().get(0);

              Code arg1 = callable.parameters().get(1);

              if( arg0 instanceof Code.Identifier && arg1 instanceof Code.Constant ) {

                String theStoreName = ((Code.Identifier)arg0).name();

                if( StringUtils.equalsIgnoreCase(storename, theStoreName) ) {

                  String attrname = Objects.toString(((Code.Constant)arg1).value(),"");

                  if( featureType.getAttributeDescriptor(attrname)==null ) {

                    String suggestedAttrName = getSuggestedAttrName(attrname,3);

                    I18nManager i18n = ToolsLocator.getI18nManager();

                    // _The_indicated_field_does_not_exist_in_the_table

                    // The indicated field does not exist in the table.

                    // El campo indicado no existe en la tabla.

                    if( StringUtils.isBlank(suggestedAttrName) ) {

                      suggestion.setValue(

                              i18n.getTranslation("_The_indicated_field_does_not_exist_in_the_table")+

                                      String.format(" (%s.%s)", storename, attrname)

                      );

                    } else {

                      suggestion.setValue(

                              i18n.getTranslation("_The_indicated_field_does_not_exist_in_the_table")+

                                      String.format("\n(%s.%s --> %s.%s)", storename, attrname, storename, suggestedAttrName)

                      );

                    }

                    throw new VisitCanceledException();

                  }

                }

              }

            }

          }

        });

      } catch (Throwable th) {

      }

      return suggestion.getValue();

    }

  }

  private String getSuggestedAttrName(String nameSearched, int maxdistance) {

    LevenshteinDistance comparator = LevenshteinDistance.getDefaultInstance();

    nameSearched = nameSearched.toLowerCase();

    String found_name = null;

    int found_distance = Integer.MAX_VALUE;

    for (FeatureAttributeDescriptor attr : featureType) {

      String name = attr.getName();

      int distance = comparator.apply(name.toLowerCase(), nameSearched);

      if( distance<found_distance ) {

        found_name = name;

        found_distance = distance;

      }

    }

    if( found_distance<=maxdistance ) {

      return found_name;

    }

    return null;

  }

}