/*******************************************************************************
 * Copyright (c) 2008, 2020 SAP AG, IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    SAP AG - initial API and implementation
 *    Andrew Johnson/IBM Corporation - debug verbose option
 *******************************************************************************/
package org.eclipse.mat.ui.internal.query.arguments;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import org.eclipse.jface.layout.TableColumnLayout;
import org.eclipse.jface.resource.FontDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.window.DefaultToolTip;
import org.eclipse.jface.window.ToolTip;
import org.eclipse.mat.SnapshotException;
import org.eclipse.mat.internal.snapshot.ArgumentParser;
import org.eclipse.mat.internal.snapshot.HeapObjectContextArgument;
import org.eclipse.mat.internal.snapshot.HeapObjectParamArgument;
import org.eclipse.mat.query.IContextObject;
import org.eclipse.mat.query.IQueryContext;
import org.eclipse.mat.query.annotations.Argument;
import org.eclipse.mat.query.registry.ArgumentDescriptor;
import org.eclipse.mat.query.registry.ArgumentSet;
import org.eclipse.mat.snapshot.ISnapshot;
import org.eclipse.mat.snapshot.SnapshotFactory;
import org.eclipse.mat.snapshot.model.IObject;
import org.eclipse.mat.snapshot.query.IHeapObjectArgument;
import org.eclipse.mat.ui.MemoryAnalyserPlugin;
import org.eclipse.mat.ui.Messages;
import org.eclipse.mat.ui.accessibility.AccessibleCompositeAdapter;
import org.eclipse.mat.ui.internal.query.arguments.LinkEditor.Mode;
import org.eclipse.mat.ui.internal.query.arguments.TextEditor.DecoratorType;
import org.eclipse.mat.util.MessageUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

public class ArgumentsTable implements ArgumentEditor.IEditorListener
{
    private static final int MIN_EDITOR_WIDTH = 50;
    private static final String ADDRESS_PREFIX = "0x";//$NON-NLS-1$

    /**
     * The end of line string for this machine.
     */
    protected static final String EOL = System.getProperty("line.separator", "\n");//$NON-NLS-1$//$NON-NLS-2$

    private static final String ARGUMENT = Messages.ArgumentsTable_Argument;
    private static final String VALUE = Messages.ArgumentsTable_Value;

    private LocalResourceManager resourceManager = new LocalResourceManager(JFaceResources.getResources());

    private Table table;
    private Font boldFont;
    private Font normalFont;
    private int tableRowHeight = SWT.DEFAULT;

    private List<ITableListener> listeners = Collections.synchronizedList(new ArrayList<ITableListener>());

    private Map<ArgumentEditor, String> errors = Collections.synchronizedMap(new HashMap<ArgumentEditor, String>());
    private Mode mode = Mode.SIMPLE_MODE;
    private Map<ArgumentDescriptor, Mode> modeMap;

    private IQueryContext context;
    private ArgumentSet argumentSet;

    public interface ITableListener
    {
        void onInputChanged();

        void onError(String message);

        void onFocus(String message);

        void onModeChange(Mode mode);
    }

    public ArgumentsTable(Composite parent, int style, IQueryContext context, ArgumentSet argumentSet, Mode mode)
    {
        this.context = context;
        this.argumentSet = argumentSet;
        this.mode = mode;

        TableColumnLayout tableColumnLayout = new TableColumnLayout();
        parent.setLayout(tableColumnLayout);

        table = new Table(parent, style);
        Font parentFont = parent.getFont();
        table.setFont(parentFont);
        table.setLinesVisible(true);
        table.setHeaderVisible(true);
        AccessibleCompositeAdapter.access(table);

        TableColumn column = new TableColumn(table, SWT.NONE);
        column.setText(ARGUMENT);
        tableColumnLayout.setColumnData(column, new ColumnWeightData(0, 100));

        column = new TableColumn(table, SWT.NONE);
        column.setText(VALUE);
        tableColumnLayout.setColumnData(column, new ColumnWeightData(100, 100));

        boldFont = resourceManager.createFont(FontDescriptor.createFrom(parentFont).setStyle(SWT.BOLD));
        normalFont = resourceManager.createFont(FontDescriptor.createFrom(parentFont).setStyle(SWT.NORMAL));

        modeMap = new HashMap<ArgumentDescriptor, Mode>(argumentSet.getQueryDescriptor().getArguments().size());
        for (ArgumentDescriptor descriptor : argumentSet.getQueryDescriptor().getArguments())
        {
            if (isHeapObject(descriptor))
                modeMap.put(descriptor, mode);
        }

        table.addListener(SWT.MeasureItem, new Listener()
        {
            public void handleEvent(Event event)
            {
                event.height = tableRowHeight;
            }
        });

        createTableContent();

        new DefaultToolTip(table, ToolTip.NO_RECREATE, false)
        {
            private ArgumentDescriptor getEntry(Event event)
            {
                TableItem item = table.getItem(new Point(event.x, event.y));
                if (item != null && item.getData() != null) { return ((ArgumentEditor) item.getData()).getDescriptor(); }
                return null;
            }

            protected String getText(Event event)
            {
                ArgumentDescriptor entry = getEntry(event);
                if (entry != null) { return entry.getHelp(); }
                return null;
            }

            protected boolean shouldCreateToolTip(Event event)
            {
                table.setToolTipText(""); //$NON-NLS-1$
                return getEntry(event) != null && super.shouldCreateToolTip(event);
            }

            protected Object getToolTipArea(Event event)
            {
                return getEntry(event);
            }
        }.activate();

    }

    private void setTableRowHeight(int height)
    {
        tableRowHeight = Math.max(tableRowHeight, height);
    }

    public void dispose()
    {
        // clear error messages
        errors.clear();
        errors = null;
        modeMap.clear();
        modeMap = null;
        if (resourceManager != null)
        {
            resourceManager.dispose();
            resourceManager = null;
        }
    }

    // //////////////////////////////////////////////////////////////
    // private constructor methods
    // //////////////////////////////////////////////////////////////

    private void createTableContent()
    {
        table.setData(argumentSet);

        for (ArgumentDescriptor descriptor : argumentSet.getQueryDescriptor().getArguments())
        {
            if (context.available(descriptor.getType(), descriptor.getAdvice()))
                continue;

            String flag = createArgumentLabel(descriptor);

            boolean isHeapObject = isHeapObject(descriptor);

            Object argumentValue = argumentSet.getArgumentValue(descriptor);

            if (IContextObject.class.isAssignableFrom(descriptor.getType()))
            {
                TableItem item = new TableItem(table, SWT.NONE);
                item.setFont(normalFont);
                item.setText(new String[] { flag, Messages.ArgumentsTable_selectedRows });
            }
            else if (descriptor.isMultiple() && !isHeapObject)
            {
                List<?> values = (List<?>) argumentValue;

                if (values == null)
                    values = (List<?>) descriptor.getDefaultValue();

                if (values == null || values.isEmpty())
                {
                    addEditorRow(descriptor, flag, null, -1);
                }
                else
                {
                    Iterator<?> valueIt = values.iterator();
                    Object firstValue = valueIt.next();
                    addEditorRow(descriptor, flag, firstValue, -1);
                    while (valueIt.hasNext())
                    {
                        Object objValue = valueIt.next();
                        addEditorRow(descriptor, "..\"..", objValue, -1); //$NON-NLS-1$
                    }
                    addEditorRow(descriptor, "..\"..", null, -1); //$NON-NLS-1$
                }
            }
            else if (isHeapObject && argumentValue instanceof HeapObjectContextArgument)
            {
                // when query is called for the certain object instance (from
                // the view). In that case hoa cannot be modified
                TableItem item = new TableItem(table, SWT.NONE);
                item.setFont(normalFont);
                item.setText(new String[] { flag, String.valueOf(argumentValue) });
            }
            else if (isHeapObject)
            {
                Object value = argumentValue;
                if (value == null)
                {
                    // Experimental
                    // No heap object provided, so see if query has a default heap object argument
                    value = descriptor.getDefaultValue();
                    if (value instanceof IHeapObjectArgument)
                    {
                        // The default heap object argument has a null snapshot,
                        ISnapshot snapshot = (ISnapshot) context.get(ISnapshot.class, null);
                        // So convert it to a string then reparse in this context.
                        // Only really makes sense for class name or OQL arguments as object 
                        // addresses won't apply between snapshots (except boot classloader @0x0 ?)
                        String line = ((IHeapObjectArgument) value).getLabel();
                        try
                        {
                            HeapObjectParamArgument hoa = ArgumentParser.consumeHeapObjects(snapshot, line);
                            value = hoa;
                        }
                        catch (SnapshotException e)
                        {
                            value = null;
                        }
                    }
                    else
                    {
                        // Value could be Integer(0) for int argument, etc. so not suitable below
                        value = null;
                    }
                }
                addHeapObjectTableItems(descriptor, (HeapObjectParamArgument) value);
            }
            else
            {
                Object value = argumentValue;
                if (value == null)
                    value = descriptor.getDefaultValue();

                addEditorRow(descriptor, flag, value, -1);
            }

        }

        for (Control control : table.getChildren())
        {
            if (control instanceof ArgumentEditor)
                ((ArgumentEditor) control).addListener(this);
        }
        try
        {
            table.getChildren()[0].setFocus();
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            // $JL-EXC$
            // should not happen as we assume that table should have at least
            // one child.
            // If by any reason the exception occurs, the focus will not be set
        }
    }

    private boolean isHeapObject(ArgumentDescriptor descriptor)
    {
        boolean isHeapObject = descriptor.getAdvice() == Argument.Advice.HEAP_OBJECT //
                        || IObject.class.isAssignableFrom(descriptor.getType()) //
                        || IHeapObjectArgument.class.isAssignableFrom(descriptor.getType());
        return isHeapObject;
    }

    private String createArgumentLabel(ArgumentDescriptor descriptor)
    {
        String flag = descriptor.getFlag();
        if (flag == null)
            return descriptor.getName();
        else
            return "-" + flag;//$NON-NLS-1$
    }

    private void addEditorRow(ArgumentDescriptor descriptor, String flag, Object value, int index)
    {
        TableItem item;
        if (index > 0)
            item = new TableItem(table, SWT.NONE, index);
        else
            item = new TableItem(table, SWT.NONE);

        item.setText(flag);

        setFont(descriptor, item);

        TableEditor editor = createEditor();

        ArgumentEditor aec = TableEditorFactory.createTableEditor(table, context, descriptor, item);
        aec.setFont(item.getFont());
        editor.setEditor(aec, item, 1);
        item.setData(aec);
        // Adjust the table height for the editor
        setTableRowHeight(aec.computeSize(SWT.DEFAULT, SWT.DEFAULT).y);

        // listener should be added only to the new rows, for rows with default
        // values listeners are added after the table is created and filled with
        // default values
        if (index > 0)
        {
            aec.addListener(this);

            // ugly: w/o pack, the table does not redraw the editors correctly
            table.pack();
            table.getParent().pack();

            setNewTabOrder();
        }

        try
        {
            if (value != null)
                aec.setValue(value);
        }
        catch (SnapshotException e)
        {
            // $JL-EXC$
            // leave editor empty
        }
    }

    private void setFont(ArgumentDescriptor descriptor, TableItem item)
    {
        // to make the rows in the table a little higher we set the bigger font
        // to the whole table.
        // and in this method we return the normal size and highlight mandatory
        // arguments.
        if (descriptor.isMandatory())
        {
            // Normal font for whole row
            item.setFont(normalFont);
            // Bold font for first box in row
            item.setFont(0, boldFont);
        }
        else
            item.setFont(normalFont);
    }

    private void setNewTabOrder()
    {
        // this method is called when the new row was inserted to reassure that
        // the "Tab" button works correct.
        TableItem[] items = table.getItems();
        // we need to include to the TabList only those items that are editors
        Control[] newTabOrder = new Control[table.getChildren().length];
        for (int i = 0, j = 0; i < items.length; i++, j++)
        {
            if (items[i].getData() != null)
                newTabOrder[j] = (ArgumentEditor) items[i].getData();
            else
                j--;
        }

        table.setTabList(newTabOrder);
    }

    private void addHeapObjectTableItems(ArgumentDescriptor descriptor, int index, TextEditor.DecoratorType decorator)
    {
        TableItem item = new TableItem(table, SWT.NONE, index);
        setFont(descriptor, item);

        TableEditor editor = createEditor();

        ImageTextEditor aec = new ImageTextEditor(table, context, descriptor, item, decorator);
        aec.setFont(item.getFont());
        editor.setEditor(aec, item, 1);
        item.setData(aec);
        // Adjust the table height for the image button
        setTableRowHeight(aec.computeSize(SWT.DEFAULT, SWT.DEFAULT).y);

        aec.addListener(this);
        // ugly: w/o pack, the table does not redraw the editors correctly
        table.getParent().pack();

        setNewTabOrder();

    }

    private void addHeapObjectTableItems(ArgumentDescriptor descriptor, HeapObjectParamArgument initialInput)
    {
        // Some queries can only cope with one object
        boolean singleObject = isSingleObjectDescriptor(descriptor);
        DecoratorType types[] = TextEditor.DecoratorType.values();
        if (singleObject)
        {
            // The query is only expecting one object so make the object address
            // query first
            types = new DecoratorType[] { TextEditor.DecoratorType.OBJECT_ADDRESS, TextEditor.DecoratorType.PATTERN,
                            TextEditor.DecoratorType.QUERY };
        }
        // If an initial input would be hidden in simple mode then switch to advanced
        if (initialInput != null && (types[0] != TextEditor.DecoratorType.OBJECT_ADDRESS && !initialInput.getAddresses().isEmpty() ||
                        types[0] != TextEditor.DecoratorType.QUERY && !initialInput.getOqls().isEmpty() ||
                        types[0] != TextEditor.DecoratorType.PATTERN && !initialInput.getPatterns().isEmpty()))
        {
            // check whether Mode.ADVANCED_MODE and switch to it if not the case
            verifyMode();
        }
        
        if (modeMap.get(descriptor).equals(Mode.SIMPLE_MODE))
        {
            // Only have one type in simple mode
            types = new TextEditor.DecoratorType[]{types[0]};
        }
        
        String label = createArgumentLabel(descriptor);
        for (TextEditor.DecoratorType decorator : types)
        {
            boolean createExtra = true;
            if (decorator.equals(TextEditor.DecoratorType.PATTERN))
            {
                // when the mode of the table is switched after a pattern was
                // provided - keep the pattern
                List<Pattern> patterns = null;

                if (initialInput != null)
                {
                    patterns = initialInput.getPatterns();
                }
                // create a new row for each pattern
                if (patterns != null)
                {
                    for (Pattern pattern : patterns)
                    {
                        createHeapObjectRow(descriptor, pattern.toString(), decorator, label);
                        // a work around: to avoid "objects" label for each of
                        // the three editors
                        label = "";//$NON-NLS-1$
                    }
                }
            }
            else if (decorator.equals(TextEditor.DecoratorType.OBJECT_ADDRESS))
            {
                List<Long> addresses = null;
                if (initialInput != null)
                {
                    addresses = initialInput.getAddresses();
                }
                // create a new row for each pattern
                if (addresses != null)
                {
                    for (Long address : addresses)
                    {
                        createHeapObjectRow(descriptor, ADDRESS_PREFIX + Long.toHexString(address), decorator, label);
                        label = "";//$NON-NLS-1$
                        // Don't create a spare row when we only need one object
                        createExtra &= !singleObject;
                    }
                }
            }
            else
            // TextEditor.DecoratorType.QUERY
            {
                List<String> oqls = null;
                if (initialInput != null)
                {
                    oqls = initialInput.getOqls();
                }
                // create a new row for each pattern
                if (oqls != null)
                {
                    for (String oql : oqls)
                    {
                        createHeapObjectRow(descriptor, oql, decorator, label);
                        label = "";//$NON-NLS-1$
                        // Don't create a spare row when we only need one object
                        createExtra &= !singleObject;
                    }
                }
            }

            if (createExtra)
            {
                // plus one empty row for this type of decorator in any case
                createHeapObjectRow(descriptor, null, decorator, label);
                label = "";//$NON-NLS-1$
            }
        }

        for (TextEditor.DecoratorType decorator : types)
        {
            if (decorator.equals(TextEditor.DecoratorType.PATTERN))
            {
                // Add the subclass instance box if the class name pattern is visible
                addCheckBoxRows(descriptor, CheckBoxEditor.Type.INCLUDE_CLASS_INSTANCE, (initialInput != null) ? initialInput
                                .isIncludeClassInstance() : false);
                break;
            }
        }

        if (modeMap.get(descriptor).equals(Mode.ADVANCED_MODE))
        {
            addCheckBoxRows(descriptor, CheckBoxEditor.Type.INCLUDE_SUBCLASSES, (initialInput != null) ? initialInput
                            .isIncludeSubclasses() : false);
            addCheckBoxRows(descriptor, CheckBoxEditor.Type.INTEPRET_AS_CLASSLOADER,
                            (initialInput != null) ? initialInput.isIncludeLoadedInstances() : false);
            addCheckBoxRows(descriptor, CheckBoxEditor.Type.RETAINED, (initialInput != null) ? initialInput
                            .isRetained() : false);
            if (MemoryAnalyserPlugin.getDefault().isDebugging())
            {
                addCheckBoxRows(descriptor, CheckBoxEditor.Type.VERBOSE, (initialInput != null) ? initialInput
                            .isVerbose() : false);
            }
        }

        addLink(descriptor, modeMap.get(descriptor));
        table.getParent().pack();
    }

    private boolean isSingleObjectDescriptor(ArgumentDescriptor descriptor)
    {
        return !descriptor.isMultiple()
                        && isHeapObject(descriptor)
                        && (IObject.class.isAssignableFrom(descriptor.getType()) || 
                            descriptor.getType() == int.class ||
                            descriptor.getType() == Integer.class);
    }

    private void verifyMode()
    {
        if (mode.equals(Mode.SIMPLE_MODE))
            mode = Mode.ADVANCED_MODE;

    }

    private void createHeapObjectRow(ArgumentDescriptor descriptor, String value, TextEditor.DecoratorType decorator,
                    String label)
    {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(label);
        setFont(descriptor, item);

        TableEditor editor = createEditor();

        ImageTextEditor aec = new ImageTextEditor(table, context, descriptor, item, decorator);
        aec.setFont(item.getFont());
        editor.setEditor(aec, item, 1);
        item.setData(aec);
        // Adjust the table height for the image button
        setTableRowHeight(aec.computeSize(SWT.DEFAULT, SWT.DEFAULT).y);

        if (value != null)
        {
            try
            {
                if (decorator.equals(TextEditor.DecoratorType.OBJECT_ADDRESS))
                {
                    // This is a bit strange - the value gets resolved as an objectid
                    ISnapshot snapshot = (ISnapshot) context.get(ISnapshot.class, null);
                    long addr = new BigInteger(value.substring(2), 16).longValue();
                    // Check address is valid
                    Integer ival = Integer.valueOf(snapshot.mapAddressToId(addr));
                    // but set the hex value
                    aec.setValue(value);
                }
                else 
                {
                    aec.setValue(value);
                }
            }
            catch (SnapshotException e)
            {
                // $JL-EXC$
                // leave editor empty
            }
        }
    }

    private void addLink(ArgumentDescriptor descriptor, Mode mode)
    {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setFont(normalFont);
        item.setText("");//$NON-NLS-1$
        TableEditor editor = createEditor();

        LinkEditor aec = new LinkEditor(table, context, descriptor, item, mode);
        aec.setFont(item.getFont());
        editor.setEditor(aec, item, 1);
        item.setData(aec);
        // Adjust the table height for the editor
        setTableRowHeight(aec.computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
    }

    private TableEditor createEditor()
    {
        TableEditor editor = new TableEditor(table);
        editor.horizontalAlignment = SWT.LEFT;
        editor.grabHorizontal = true;
        editor.minimumWidth = MIN_EDITOR_WIDTH;

        return editor;
    }

    private void addCheckBoxRows(ArgumentDescriptor descriptor, CheckBoxEditor.Type type, boolean selected)
    {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setFont(normalFont);
        item.setText("");//$NON-NLS-1$

        TableEditor editor = createEditor();

        CheckBoxEditor aec = new CheckBoxEditor(table, context, descriptor, item, type);
        aec.setFont(item.getFont());
        editor.setEditor(aec, item, 1);
        item.setData(aec);
        // Adjust the table height for the editor
        setTableRowHeight(aec.computeSize(SWT.DEFAULT, SWT.DEFAULT).y);

        try
        {
            aec.setValue(selected);
        }
        catch (SnapshotException e)
        {
            // $JL-EXC$
            // leave unselected
        }
    }

    public synchronized void onValueChanged(Object value, ArgumentDescriptor descriptor, TableItem item,
                    ArgumentEditor argEditor)
    {
        int myIndex = table.indexOf(item);

        // remove error message
        onError(argEditor, null);
        onError(null, null);

        boolean isHeapObject = isHeapObject(descriptor);

        boolean isLastOne = descriptor.isMultiple()
                        && !isHeapObject
                        && (myIndex + 1 == table.getItemCount() || ((ArgumentEditor) table.getItem(myIndex + 1)
                                        .getData()).getDescriptor() != descriptor);

        // update argument set -- heap objects
        if (isHeapObject)
        {
            // if (value == null)
            // return;

            if (argEditor instanceof ImageTextEditor)
            {
                // verify current modification
                verifyHeapObjectTextEditorInput((ImageTextEditor) argEditor);
            }
            // if there are no errors in all the fields describing the hoa -
            // create HeapObject and add it to the argumentSet
            if (noErrorsInHoa())
            {
                // overwrite hoa on every modification
                argumentSet.removeArgumentValue(descriptor);
                HeapObjectParamArgument hoa = createHeapObjectDefinition(descriptor);

                if (hoa.isComplete())
                {
                    argumentSet.setArgumentValue(descriptor, hoa);
                    // add new row only when there are no errors
                    if ((argEditor instanceof ImageTextEditor)
                                    && isNewRowNeeded(descriptor, ((ImageTextEditor) argEditor).getDecorator()))
                    {
                        addHeapObjectTableItems(descriptor, myIndex + 1, ((ImageTextEditor) argEditor).getDecorator());
                    }
                }
                else if (descriptor.isMandatory())
                {
                    // add error message on null argument
                    onError(null, Messages.ArgumentsTable_ProvidePattern);
                }

            }
        }
        // update lists
        else if (descriptor.isMultiple())
        {
            List<Object> values = new ArrayList<Object>();

            Control[] children = table.getChildren();
            for (int ii = 0; ii < children.length; ii++)
            {
                if (!(children[ii] instanceof ArgumentEditor))
                    continue;

                ArgumentEditor editor = (ArgumentEditor) children[ii];
                if (editor.getDescriptor() == descriptor)
                {
                    Object v = editor.getValue();
                    if (v != null)
                        values.add(v);
                }
            }

            if (values.isEmpty())
                values = null;

            Object defaultValue = descriptor.getDefaultValue();
            if (defaultValue == null || !defaultValue.equals(values))
                argumentSet.setArgumentValue(descriptor, values);
            else
                argumentSet.removeArgumentValue(descriptor);

            // warn a/b mandatory arguments
            if (descriptor.isMandatory() && values == null)
                onError(argEditor, MessageUtil.format(Messages.ArgumentsTable_isMandatory, descriptor.getName()));

            // insert new row at myIndex + 1
            if (isLastOne && value != null)
                addEditorRow(descriptor, "..\"..", null, myIndex + 1);//$NON-NLS-1$
        }
        else
        {
            Object defaultValue = descriptor.getDefaultValue();

            if (defaultValue == null || !defaultValue.equals(value))
            {
                argumentSet.setArgumentValue(descriptor, value);
            }
            else
            {
                argumentSet.removeArgumentValue(descriptor);
            }

            // warn a/b mandatory arguments
            if (descriptor.isMandatory() && value == null)
                onError(argEditor, MessageUtil.format(Messages.ArgumentsTable_isMandatory, descriptor.getName()));
        }

        // inform about value changes
        fireInputChangedEvent();
    }

    private boolean isNewRowNeeded(ArgumentDescriptor descriptor, DecoratorType decorator)
    {
        boolean notEmpty = true;
        Control[] children = table.getChildren();
        for (Control control : children)
        {
            if ((control instanceof ImageTextEditor) && ((ImageTextEditor) control).getDescriptor().equals(descriptor)
                            && ((ImageTextEditor) control).getDecorator().equals(decorator))
            {
                notEmpty = notEmpty && ((ImageTextEditor) control).getValue() != null
                                && !((ImageTextEditor) control).getValue().equals("");//$NON-NLS-1$
                // If the decorator is not a pattern and we only need one argument then only have one
                notEmpty &= decorator.equals(TextEditor.DecoratorType.PATTERN) || !isSingleObjectDescriptor(descriptor);
            }
        }
        return notEmpty;
    }

    private HeapObjectParamArgument createHeapObjectDefinition(ArgumentDescriptor descriptor)
    {
        ISnapshot snapshot = (ISnapshot) context.get(ISnapshot.class, null);
        HeapObjectParamArgument hoa = new HeapObjectParamArgument(snapshot);

        Control[] children = table.getChildren();
        for (Control control : children)
        {
            if (!descriptor.equals(((ArgumentEditor) control).getDescriptor()))
                continue;

            if (control instanceof CheckBoxEditor)
            {
                Boolean value = (Boolean) ((CheckBoxEditor) control).getValue();
                switch (((CheckBoxEditor) control).getType())
                {
                    case INCLUDE_CLASS_INSTANCE:
                    {
                        hoa.setIncludeClassInstance(value);
                        break;
                    }
                    case INCLUDE_SUBCLASSES:
                    {
                        hoa.setIncludeSubclasses(value);
                        break;
                    }
                    case INTEPRET_AS_CLASSLOADER:
                    {
                        hoa.setIncludeLoadedInstances(value);
                        break;
                    }
                    case RETAINED:
                    {
                        hoa.setRetained(value);
                        break;
                    }
                    case VERBOSE:
                    {
                        hoa.setVerbose(value);
                        break;
                    }
                }
            }
            else if (control instanceof ImageTextEditor)
            {
                ImageTextEditor editor = (ImageTextEditor) control;
                if (editor.getValue() != null)
                {
                    DecoratorType decorator = editor.getDecorator();
                    String line = ((ImageTextEditor) control).getValue().toString().trim();
                    // Ensure that types and values are appropriate
                    if (decorator == TextEditor.DecoratorType.QUERY && line.toLowerCase(Locale.ENGLISH).startsWith("select")) //$NON-NLS-1$
                    {
                        hoa.addOql(line);
                    }
                    else if (decorator == TextEditor.DecoratorType.OBJECT_ADDRESS && line.startsWith(ADDRESS_PREFIX))
                    {
                        hoa.addObjectAddress(new BigInteger(line.substring(2), 16).longValue());

                    }
                    else
                    // Pattern
                    {
                        if (decorator == TextEditor.DecoratorType.PATTERN && !line.equals(""))//$NON-NLS-1$
                        {
                            hoa.addPattern(Pattern.compile(line));
                        }

                    }
                }
            } // control of other types do not belong to the HeapObject
            // arguments
        }
        return hoa;
    }

    private void verifyHeapObjectTextEditorInput(ImageTextEditor editor)
    {
        TextEditor.DecoratorType decorator = editor.getDecorator();
        if (editor.getValue() != null)
        {
            onError(editor, null);

            String line = editor.getValue().toString().trim();

            if (decorator.equals(TextEditor.DecoratorType.QUERY))
            {
                if (line.equals(""))//$NON-NLS-1$
                    return;
                try
                {
                    SnapshotFactory.createQuery(line);
                }
                catch (SnapshotException e)
                {
                    // $JL-EXC$

                    // fix: reformat message for proper displaying
                    String msg = e.getMessage();

                    if (msg.startsWith(Messages.ArgumentsTable_Encountered))
                    {
                        int p = msg.indexOf(Messages.ArgumentsTable_WasExpecting);
                        if (p >= 0)
                            msg = msg.substring(p, msg.length()).replace(EOL, " ");//$NON-NLS-1$
                    }

                    onError(editor, msg);
                }
            }
            else if (decorator.equals(TextEditor.DecoratorType.OBJECT_ADDRESS))
            {
                if (line.length() > 2 && ADDRESS_PREFIX.equals(line.substring(0, 2)))
                {
                    try
                    {
                        new BigInteger(line.substring(2), 16).longValue();
                    }
                    catch (NumberFormatException e)
                    {
                        // $JL-EXC$
                        onError(editor, Messages.ArgumentsTable_InvalidAddress + e.getMessage());
                    }
                }
                else if (line.length() < 2 && !line.startsWith(ADDRESS_PREFIX.substring(0, line.length()))
                                || line.length() >= 2 && !line.startsWith(ADDRESS_PREFIX.substring(0, 2)))
                {

                    onError(editor, Messages.ArgumentsTable_InvalidAddress + line);
                }
                else if (line.length() != 0)
                {
                    onError(editor, Messages.ArgumentsTable_AddressNotComplete);
                }
            }
            else
            // Pattern
            {
                if (!line.equals(""))//$NON-NLS-1$
                {
                    try
                    {
                        Pattern.compile(line);
                    }
                    catch (PatternSyntaxException e)
                    {
                        // $JL-EXC$
                        int idx = Math.max(0, Math.min(e.getIndex(), line.length())); 
                        onError(editor, MessageUtil.format(Messages.ArgumentsTable_InvalidClassNamePattern, e.getIndex(), line.substring(0, idx), e.getDescription()));
                    }
                }

            }
        }
    }

    private boolean noErrorsInHoa()
    {
        for (Map.Entry<ArgumentEditor, String> entry : errors.entrySet())
        {
            if (entry.getKey() instanceof ImageTextEditor) { return false; }
        }
        return true;
    }

    public synchronized void onError(ArgumentEditor editor, String message)
    {
        synchronized (errors)
        {
            if (message == null)
            {
                if (errors.remove(editor) != null)
                {

                    if (errors.isEmpty())
                        fireErrorMessageEvent(null);
                    else
                        fireErrorMessageEvent(errors.values().iterator().next());

                }
            }
            else
            {
                errors.put(editor, message);
                fireErrorMessageEvent(message);
            }
        }
    }

    // //////////////////////////////////////////////////////////////
    // table listener implementation
    // //////////////////////////////////////////////////////////////

    public void addListener(ITableListener listener)
    {
        this.listeners.add(listener);
    }

    public void removeListener(ITableListener listener)
    {
        this.listeners.remove(listener);
    }

    private void fireInputChangedEvent()
    {
        synchronized (listeners)
        {
            for (ITableListener listener : listeners)
                listener.onInputChanged();
        }
    }

    private void fireErrorMessageEvent(String message)
    {
        synchronized (listeners)
        {
            for (ITableListener listener : listeners)
                listener.onError(message);
        }
    }

    public void fireFocusChangedEvent(String message)
    {
        synchronized (listeners)
        {
            for (ITableListener listener : listeners)
                listener.onFocus(message);
        }
    }

    public void onFocus(String message)
    {
        fireFocusChangedEvent(message);
    }

    public void onModeChange(Mode mode, ArgumentDescriptor descriptor)
    {
        // add new mode for this descriptor to the HashMap to be able to proceed
        // different descriptors independently
        if (modeMap == null)
        {
            modeMap = new HashMap<ArgumentDescriptor, Mode>();
        }

        modeMap.put(descriptor, mode);

        List<ITableListener> copy = new ArrayList<ITableListener>(listeners);
        for (ITableListener listener : copy)
            listener.onModeChange(mode);
        // clear error messages
        errors.clear();
        fireErrorMessageEvent(null);

        table.removeAll();
        Control[] children = table.getChildren();
        for (Control control : children)
        {
            control.dispose();
        }

        this.createTableContent();
    }

}