Application: gvSIG desktop

package org.gvsig.expressionevaluator.swing.impl;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.expressionevaluator.swing.Element;

import org.gvsig.expressionevaluator.swing.ElementFactory;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.SuggestionProvider;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.util.Factory;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExpressionBuilderConfig

        implements ExpressionBuilderConfig, ExpressionBuilderConfig.Preferences {

    protected static final Logger LOGGER = LoggerFactory.getLogger(DefaultExpressionBuilderConfig.class);

    private List<Element> elements;

    private int limit;

    private Map<String, SymbolTable> symbolTables;

    private final ExpressionEvaluatorSwingManager manager;

    private SymbolTable previewSymbolTable;

    private boolean SQLCompatible;

    private final PropertiesSupportHelper propertiesSupportHelper;

    private boolean showLabelsOfAttributes;

    private boolean allowAggregates;

    private java.util.function.Function<String, Integer>allowedFunctions;

    private Map<String,Factory> suggestionFactories;

    public DefaultExpressionBuilderConfig(ExpressionEvaluatorSwingManager manager) {

        this.manager = manager;

        this.limit = 6;

        this.SQLCompatible = false;

        this.propertiesSupportHelper = new PropertiesSupportHelper();

        this.showLabelsOfAttributes = true;

        this.allowAggregates = false;

        this.suggestionFactories = new HashMap<>();

        initSymbolTables();

    }

    @Override

    public void copyConfigFrom(ExpressionBuilderConfig other) {

      // Hay que tener cuidado al copiar ya que puede darse el caso

      // que "other = this", por eso lo de las variables other_*

      this.getPreferences().copyPreferencesFrom(other.getPreferences());

      this.allowAggregates = other.allowAggregates();

      this.allowedFunctions = other.getAllowedFunctions();      

      this.previewSymbolTable = other.getPreviewSymbolTable();

      Collection<SymbolTable> other_symbolTables = other.getSymbolTables();

      List<Element> other_elements = other.getElements();

      Collection<Factory> other_suggestionFactories = other.getSuggestionFactories();

      this.symbolTables = new HashMap<>();

      this.elements = new ArrayList<>();

      this.suggestionFactories = new HashMap<>();

      for (SymbolTable symbolTable : other_symbolTables) {

        this.addSymbolTable(symbolTable);

      }

      for (Element element : other_elements) {

        this.elements.add(element);

      }

      for (Factory suggestionFactory : other_suggestionFactories) {

        this.addSuggestionFactory(suggestionFactory);

      }

    }

    @Override

    public void copyPreferencesFrom(Preferences other) {

      other.setSQLCompatible(this.SQLCompatible);

      other.setShowLabelsOfElements(this.showLabelsOfAttributes);

      other.setSimpleElementsLimit(limit);

    }

    @Override

    public Preferences getPreferences() {

        return this;

    }

    @Override

    public Collection<Factory> getSuggestionFactories() {

      return this.suggestionFactories.values();

    }

    @Override

    public java.util.function.Function<String, Integer> getAllowedFunctions() {

      return this.allowedFunctions;

    }

    private void initSymbolTables() {

        ExpressionEvaluatorManager theManager = ExpressionEvaluatorLocator.getManager();

        for (SymbolTableFactory factory : theManager.getSymbolTableFactories()) {

          if( factory == null ) {

            continue;

          }

          String factoryName = "(unknown)";

          try {

            factoryName = factory.getName();

            if (factory.isAutoload()) {

                this.addSymbolTable(factory.create());

            }

          } catch(Throwable th) {

            LOGGER.warn("Can't create symbol table '"+factoryName+"'.",th);

          }

        }

    }

    @Override

    public List<Element> getElements() {

        if (this.elements == null || this.elements.isEmpty() ) {

            this.elements = manager.createElements(this.getSymbolTables(), (Function f) -> {

              if( f.group().equalsIgnoreCase(Function.GROUP_AGGREGATE) &&

                      !this.allowAggregates() ) {

                return false;

              }

              java.util.function.Function<String, Integer> isFunctionAllowed = this.isFunctionAllowed();

              if( isFunctionAllowed!=null && isFunctionAllowed.apply(f.name())==DataType.NO ) {

                return false;

              }

              return true;

            });

            for (ElementFactory factory : manager.getElementFactories()) {

                if (factory.isAutoload()) {

                    Element e = factory.createElement();

                    this.elements.add(e);

                    e.setConfig(this);

                }

            }

        }

        return Collections.unmodifiableList(elements);

    }

    @Override

    public void addElement(Element element) {

        if( element==null ) {

            return;

        }

        this.getElements(); // Forzamos a crear la lista de elementos

        for (Element theElement : this.elements) {

            if (theElement.getName().equalsIgnoreCase(element.getName())) {

                return;

            }

        }

        this.elements.add(element);

        element.setConfig(this);

    }

    @Override

    public Collection<SymbolTable> getSymbolTables() {

        return Collections.unmodifiableCollection(this.symbolTables.values());

    }

    @Override

    public void addSymbolTable(String name) {

        ExpressionEvaluatorManager theManager = ExpressionEvaluatorLocator.getManager();

        SymbolTable symbolTable = theManager.getSymbolTable(name);

        if (symbolTable == null) {

            throw new IllegalArgumentException("Can't locate symbol table '" + name + "'.");

        }

        addSymbolTable(symbolTable);

    }

    @Override

    public void addSymbolTable(SymbolTable symbolTable) {

        if (symbolTable == null) {

            return;

        }

        if (this.elements != null && !this.elements.isEmpty() ) {

            throw new IllegalStateException("Can not add symbol tables once the elements are built.");

        }

        if (this.symbolTables == null) {

            this.symbolTables = new HashMap<>();

        }

        this.symbolTables.put(symbolTable.getName(), symbolTable);

    }

    @Override

    public void removeAllSymbolTables() {

        this.symbolTables.clear();

    }

    @Override

    public void removeAllElements() {

        this.elements.clear();

    }

    @Override

    public int getSimpleElementsLimit() {

        return this.limit;

    }

    @Override

    public void setSimpleElementsLimit(int limit) {

        this.limit = limit;

    }

    @Override

    public void removeSymbolTable(String name) {

        this.symbolTables.remove(name);

    }

//    @Override

//    public void setScriptsEnabled(boolean enabled) {

//        this.scriptsEnabled = enabled;

//    }

//

//    @Override

//    public boolean getScriptsEnabled() {

//        return this.scriptsEnabled;

//    }

//

    @Override

    public SymbolTable getPreviewSymbolTable() {

        return this.previewSymbolTable;

    }

    @Override

    public void setPreviewSymbolTable(SymbolTable symbolTable) {

        this.previewSymbolTable = symbolTable;

    }

    @Override

    public void setSQLCompatible(boolean SQLCompatible) {

        this.SQLCompatible = SQLCompatible;

    }

    @Override

    public boolean isSQLCompatible() {

        return SQLCompatible;

    }

    @Override

    public Object getProperty(String string) {

        return this.propertiesSupportHelper.getProperty(string);

    }

    @Override

    public void setProperty(String string, Object o) {

        this.propertiesSupportHelper.setProperty(string, o);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesSupportHelper.getProperties();

    }

    @Override

    public boolean getShowLabelsOfElements() {

        return this.showLabelsOfAttributes;

    }

    @Override

    public void setShowLabelsOfElements(boolean showLabels) {

        this.showLabelsOfAttributes = showLabels;

    }

  @Override

  public boolean allowAggregates() {

    return this.allowAggregates;

  }

  @Override

  public boolean allowAggregates(boolean allow) {

    boolean r = this.allowAggregates;

    this.allowAggregates = allow;

    return r;

  }

  @Override

  public java.util.function.Function<String, Integer> isFunctionAllowed() {

    return this.allowedFunctions;

  }

  @Override

  public void setAllowedFunctions(java.util.function.Function<String, Integer> allow) {

    this.allowedFunctions = allow;

  }

  @Override

  public String getSuggestion(Expression expression) {

    if( expression == null ) {

      return null;

    }

    String text = expression.getPhrase();

    if( StringUtils.isBlank(text) ) {

      return null;

    }

    boolean needseparator = false;

    StringBuilder builder = null;

    for (Factory factory : suggestionFactories.values()) {

      SuggestionProvider provider = (SuggestionProvider) factory.create();

      String suggestion = provider.getSuggestion(text);

      if( suggestion != null ) {

        if( builder == null ) {

          builder = new StringBuilder();

          builder.append(suggestion);

        } else {

          builder.append("\n\n");

          builder.append(suggestion);

        }

      }

    }

    if( builder!=null ) {

      return builder.toString();

    }

    return null;

  }

  @Override

  public void addSuggestionFactory(Factory factory) {

    if( factory == null ) {

      return;

    }

    this.suggestionFactories.put(factory.getName(), factory);

  }

}