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.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

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, Disposable {

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

    private List<Element> elements;

    private List<Element> addElements;

    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_addElements = other.getAddedElements();

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

//      

//      this.symbolTables = new HashMap<>();

//      this.elements = new ArrayList<>();

//      this.addElements = new ArrayList<>();

//      this.suggestionFactories = new HashMap<>();

//

//      for (SymbolTable symbolTable : other_symbolTables) {

//        this.addSymbolTable(symbolTable);

//      }

//      

//      for (Element element : other_addElements) {

//        this.addElements.add((Element) Cloneable.cloneQuietly(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 synchronized 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);

                }

            }

            if( addElements!=null ) {

                for (Element element : addElements) {

                    this.elements.add(element);

                }

            }

        }

        return Collections.unmodifiableList(elements);

    }

    @Override

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

        if( this.addElements==null ) {

            this.addElements = new ArrayList<>();

        }

        this.addElements.add(element);

        element.setConfig(this);

    }

    @Override

    public Collection<SymbolTable> getSymbolTables() {

        if( this.symbolTables==null ) {

            return Collections.EMPTY_LIST;

        }

        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 synchronized 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.");

            LOGGER.warn("Added a symbol table after the elements are build.");

            for (Element element : this.elements) {

                DisposeUtils.disposeQuietly(element);

            }

            this.elements.clear();

        }

        if (this.symbolTables == null) {

            this.symbolTables = new HashMap<>();

        }

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

    }

    @Override

    public void removeAllSymbolTables() {

        if( this.symbolTables!=null ) {

            this.symbolTables.clear();

        }

    }

    @Override

    public synchronized void removeAllElements() {

        if( this.elements!=null ) {

            for (Element element : this.elements) {

                DisposeUtils.disposeQuietly(element);

            }

            this.elements.clear();

        }

    }

    @Override

    public synchronized void removeAddedElements() {

        if( this.addElements !=null ) {

            for (Element element : this.addElements) {

                DisposeUtils.disposeQuietly(element);

            }

            this.addElements.clear();

        }

    }

    @Override

    public int getSimpleElementsLimit() {

        return this.limit;

    }

    @Override

    public void setSimpleElementsLimit(int limit) {

        this.limit = limit;

    }

    @Override

    public void removeSymbolTable(String name) {

        if( this.symbolTables!=null ) {

            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 addPreviewSymbolTable(SymbolTable symbolTable) {

        if( symbolTable==null ) {

            return;

        }

        if( this.previewSymbolTable==null ) {

            this.previewSymbolTable = symbolTable;

            return;

        }

        this.previewSymbolTable.addSymbolTable(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 synchronized 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 synchronized void addSuggestionFactory(Factory factory) {

    if( factory == null ) {

      return;

    }

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

  }

    @Override

    public synchronized void dispose() {

        this.removeAllElements();

        this.removeAllSymbolTables();

        if( this.addElements!=null ) {

            for (Element element : this.addElements) {

                DisposeUtils.disposeQuietly(element);

            }

            this.addElements.clear();

        }

    }

    @Override

    public List<Element> getAddedElements() {

        return this.addElements;

    }

    @Override

    public ExpressionBuilderConfig cloneConfig() {

        try {

            return (ExpressionBuilderConfig) this.clone();

        } catch (CloneNotSupportedException ex) {

            return null;

        }

    }

    @Override

    public synchronized Object clone() throws CloneNotSupportedException {

        DefaultExpressionBuilderConfig other = (DefaultExpressionBuilderConfig) super.clone();

        other.symbolTables = new HashMap<>();

        other.elements = new ArrayList<>();

        other.addElements = new ArrayList<>();

        other.suggestionFactories = new HashMap<>();

        if(this.symbolTables != null){

            for (SymbolTable symbolTable : this.symbolTables.values()) {

                other.addSymbolTable(symbolTable);

            }

        }

        if(this.addElements != null){

            for (Element element : this.addElements) {

                other.addElements.add(element.cloneElement());

            }

        }

        if(this.suggestionFactories != null){

            for (Factory suggestionFactory : this.suggestionFactories.values()) {

                other.addSuggestionFactory(suggestionFactory);

            }

        }

        return other;

    }

}