Application: gvSIG desktop

package org.gvsig.expressionevaluator.swing.impl;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.util.Collection;

import java.util.Objects;

import javax.swing.Action;

import javax.swing.JComponent;

import javax.swing.JEditorPane;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

import javax.swing.JScrollPane;

import javax.swing.Timer;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

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.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.ReprMethod;

import static org.gvsig.expressionevaluator.swing.JExpressionBuilder.CONFIGURABLE_PANEL_ID;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractAutomaticExpressionChecker {

    private static final Color COLOR_ERROR = new Color(255,225,232);

    private static final Color COLOR_SUGGESTION = new Color(255,255,159);

    private final JTextComponent text;

    private final ExpressionBuilderConfig builderConfig;

    private Color color_ok;

    private Timer timerExpression;

    private JMenuItem menuItemShowPreview;

    private JMenuItem menuItemShowTip;

    private JMenuItem menuItemShowMessage;

    private String message;

    protected String tip;

    private String preview;

    private DocumentListener doclistener;

    private KeyAdapter keylistener;

    private ActionListener timelistener;

    public AbstractAutomaticExpressionChecker(ExpressionBuilderConfig config, JTextComponent theText) {

        this.text = theText;

        this.builderConfig = config;

        this.initComponents();

    }

    private void initComponents() {

        final I18nManager i18n = ToolsLocator.getI18nManager();

        final ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        this.color_ok = this.text.getBackground();

        toolsSwingManager.setDefaultPopupMenu(this.text);

        toolsSwingManager.addClearButton(this.text);

        JPopupMenu popupMenu = this.text.getComponentPopupMenu();

        this.menuItemShowTip = new JMenuItem(i18n.getTranslation("_Show_tip"));

        this.menuItemShowTip.addActionListener((ActionEvent e) -> {

          if( StringUtils.isBlank(tip) ) {

            return;

          }

          JOptionPane.showMessageDialog(

                  text.getParent(),

                  toHTML(tip),

                  i18n.getTranslation("Tip"),

                  JOptionPane.INFORMATION_MESSAGE

          );

        });

        popupMenu.add(this.menuItemShowTip);

        this.menuItemShowPreview = new JMenuItem(i18n.getTranslation("_Show_preview"));

        this.menuItemShowPreview.addActionListener((ActionEvent e) -> {

          showMessageDialog(i18n.getTranslation("_Preview_value"),preview);

        });

        popupMenu.add(this.menuItemShowPreview);

        this.menuItemShowMessage = new JMenuItem(i18n.getTranslation("_Show_message"));

        this.menuItemShowMessage.addActionListener((ActionEvent e) -> {

          showMessageDialog(i18n.getTranslation("_Message"),message+"\n\n"+tip);

        });

        popupMenu.add(this.menuItemShowMessage);

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        Collection<Action> actions = cfgActionsManager.getConfigurableActions(CONFIGURABLE_PANEL_ID);

        if( !actions.isEmpty() ) {

          popupMenu.addSeparator();

          for( Action action :  actions) {

            JMenuItem item = new JMenuItem(action);

            item.addActionListener((ActionEvent e) -> {

              e.setSource(this);

              action.actionPerformed(e);

            });

            popupMenu.add(item);

          }

        }        

        this.timelistener = (ActionEvent e) -> {

          doCheckExpression();

          stateChanged();

        };

        this.doclistener = new DocumentListener() {

            @Override

            public void insertUpdate(DocumentEvent e) {

                timerExpression.restart();

            }

            @Override

            public void removeUpdate(DocumentEvent e) {

                timerExpression.restart();

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                timerExpression.restart();

            }

        };

        this.keylistener = new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if (e.getKeyCode() == KeyEvent.VK_C && e.isControlDown()) {

                    doCheckExpression();

                }

            }

        };

        this.timerExpression = new Timer(3000, this.timelistener);

        this.timerExpression.setRepeats(false);

        this.text.getDocument().addDocumentListener(this.doclistener);

        this.text.addKeyListener(this.keylistener);

    }

    private void doCheckExpression() {

        if( this.text == null || this.builderConfig == null ) {

            return;

        }

        if( !this.text.isShowing() || !this.text.isEnabled() ) {

            this.timerExpression.restart();

            return;

        }

        Expression expression = this.getExpression();

        this.setTip(null);

        this.setPreview(null);

        this.setMessage(JOptionPane.INFORMATION_MESSAGE, null);

        if (expression == null) {

            return;

        }

        try {

            expression.getCode();

            this.setMessage(JOptionPane.INFORMATION_MESSAGE, "");

        } catch (ExpressionSyntaxException ex) {

            this.setMessage(JOptionPane.ERROR_MESSAGE, ex.getDescription());

            return;

        } catch (Exception ex) {

            this.setMessage(JOptionPane.ERROR_MESSAGE, "Syntax error in expression");

            return;

        }

        final Mutable<String> theTip = new MutableObject<>(null);

        expression.setSQLCompatible(false);

        if (this.builderConfig.getPreviewSymbolTable() == null) {

            try {

                ExpressionEvaluatorManager theManager = ExpressionEvaluatorLocator.getManager();

                MutableSymbolTable symbolTable = theManager.createSymbolTable();

                Object theValue = expression.execute(symbolTable);

                this.setPreview(theValue);

            } catch (Exception ex) {

                this.setMessage(JOptionPane.INFORMATION_MESSAGE, "");

            }

        } else {

            try {

                Object theValue = expression.execute(this.builderConfig.getPreviewSymbolTable());

                this.setPreview(theValue);

            } catch (ExpressionRuntimeException ex) {

                theTip.setValue(ex.getTip());

                this.setMessage(JOptionPane.ERROR_MESSAGE, "Runtime error. " + ex.getMessage());

            } catch (Exception ex) {

                this.setMessage(JOptionPane.ERROR_MESSAGE, "Runtime error. " + ex.getMessage());

            }

        }

        if( this.builderConfig.getPreferences().isSQLCompatible() ) {

            Code code = expression.getCode();

            try {

                code.accept(new Visitor() {

                    @Override

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

                        Code code = (Code) obj;

                        switch(code.code()) {

                            case Code.CALLABLE:

                                Function function = ((Callable)code).function();

                                if( function!=null && !function.isSQLCompatible() ) {

                                    theTip.setValue(I18N.Avoid_the_use_of_functions_not_compatible_with_SQL_in_this_data_source(function.name()));

                                }

                                break;

                            case Code.IDENTIFIER:

                                if( builderConfig.getPreviewSymbolTable()!=null && 

                                        !builderConfig.getPreviewSymbolTable().isSQLCompatible(((Identifier)code).name()) ) {

                                    theTip.setValue(I18N.Avoid_the_use_of_functions_not_compatible_with_SQL_in_this_data_source(((Identifier)code).name()));

                                }

                                break;

                            case Code.METHOD:

                                theTip.setValue(I18N.Avoid_the_use_of_functions_not_compatible_with_SQL_in_this_data_source(((Callable)code).name()));

                                break;

                        }

                    }

                });

            } catch (BaseException ex) {

            }

        }

        String suggestion = this.getSuggestion();

        if( suggestion!=null ) {

          if( StringUtils.isBlank(theTip.getValue()) ) {

            theTip.setValue(suggestion);

          } else {

            theTip.setValue(suggestion+"\n\n"+theTip.getValue());

          }

        }

        if( !StringUtils.isBlank(theTip.getValue()) ) {

            this.setTip(theTip.getValue());

            if( this.text.getBackground()==this.color_ok ) {

              this.text.setBackground(COLOR_SUGGESTION);

            }

//            this.setMessage(JOptionPane.INFORMATION_MESSAGE, theTip.getValue());

        }

    }

    protected boolean isTipEnabled() {

        return !StringUtils.isBlank(this.tip);

    }

    protected boolean isPreviewEnabled() {

        return !StringUtils.isBlank(this.preview);

    }

    protected boolean isMessageEnabled() {

        return !StringUtils.isBlank(this.message);

    }

    protected String getTip() {

        return this.tip;

    }

    protected String getMessage() {

        return this.message;

    }

    protected String getPreview() {

        return this.preview; 

    }

    protected void showMessageDialog() {

        final I18nManager i18n = ToolsLocator.getI18nManager();

        if( this.isMessageEnabled() ) {

            this.showMessageDialog(

                    i18n.getTranslation("_Message"),

                    this.getMessage()

            );

        } else if( this.isPreviewEnabled()) {

            this.showMessageDialog(

                    i18n.getTranslation("_Preview_value"),

                    this.getPreview()

            );

        }

    }

    protected void showMessageDialog(String title, String msg) {

        final I18nManager i18n = ToolsLocator.getI18nManager();

        final ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        JEditorPane textMessage = new JEditorPane();

        JScrollPane scroll = new JScrollPane(textMessage);

        scroll.setPreferredSize(new Dimension(500, 300));

        toolsSwingManager.setDefaultPopupMenu(textMessage);

        textMessage.setContentType("text/html");

        textMessage.setText(toHTML(msg));

        textMessage.setCaretPosition(0);

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

        Dialog dialog = winmgr.createDialog(

                scroll,

                title, 

                null,

                WindowManager_v2.BUTTONS_OK

        );

        dialog.show(WindowManager.MODE.DIALOG);        

    }

    protected void setPreview(Object value) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        ReprMethod repr = manager.getReprMethod(value);

        this.preview = repr.repr(value);

        this.text.setToolTipText(

                toHTML(StringUtils.abbreviate(Objects.toString(this.preview,""),100))

        );

        this.menuItemShowPreview.setEnabled(this.isPreviewEnabled());

        this.text.setBackground(color_ok);

    }

    protected void setMessage(int mode, String text) {

        if( StringUtils.isBlank(text) ) {

            this.message = "";

            this.text.setToolTipText("");

            this.menuItemShowMessage.setEnabled(false);

            this.text.setBackground(color_ok);

            return;

        } 

        this.message = text;

        this.text.setToolTipText(

                toHTML(StringUtils.abbreviate(Objects.toString(text,""),100))

        );

        this.menuItemShowMessage.setEnabled(true);

        switch (mode) {

            case JOptionPane.INFORMATION_MESSAGE:

                this.text.setBackground(COLOR_SUGGESTION);

                break;

            case JOptionPane.WARNING_MESSAGE:

            case JOptionPane.ERROR_MESSAGE:

            default:

                this.text.setBackground(COLOR_ERROR);

                break;

        }

    }

    protected void setTip(String theTip) {

        this.tip = theTip;

        this.menuItemShowTip.setEnabled(this.isTipEnabled());

    }

    protected abstract Expression getExpression();

    protected abstract String getSuggestion();

    protected String toHTML(String s) {

      s = StringUtils.replace(s, "<html>", "");

      s = StringUtils.replace(s, "</html>", "");

      s = StringUtils.replace(s, "\n", "<br>");

      s = "<html>"+s+"</html>";

      return s;

    }

    protected void stateChanged() {

    }

}