/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.netbeans.modules.ruby;

import java.io.BufferedInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import javax.swing.text.JTextComponent;

import org.jrubyparser.SourcePosition;

import org.jrubyparser.ast.ArgsNode;

import org.jrubyparser.ast.ArgumentNode;

import org.jrubyparser.ast.ClassNode;

import org.jrubyparser.ast.ILocalScope;

import org.jrubyparser.ast.ListNode;

import org.jrubyparser.ast.LocalAsgnNode;

import org.jrubyparser.ast.MethodDefNode;

import org.jrubyparser.ast.Node;

import org.jrubyparser.ast.NodeType;

import org.jrubyparser.ast.INameNode;

import org.netbeans.api.lexer.Token;

import org.netbeans.api.lexer.TokenHierarchy;

import org.netbeans.api.lexer.TokenId;

import org.netbeans.api.lexer.TokenSequence;

import org.netbeans.api.ruby.platform.RubyInstallation;

import org.netbeans.editor.BaseDocument;

import org.netbeans.editor.Utilities;

import org.netbeans.modules.csl.api.CodeCompletionContext;

import org.netbeans.modules.csl.api.CodeCompletionHandler;

import org.netbeans.modules.csl.api.CodeCompletionHandler.QueryType;

import org.netbeans.modules.csl.api.CodeCompletionResult;

import org.netbeans.modules.csl.api.CompletionProposal;

import org.netbeans.modules.csl.api.DeclarationFinder.DeclarationLocation;

import org.netbeans.modules.csl.api.ElementHandle;

import org.netbeans.modules.csl.api.ElementKind;

import org.netbeans.modules.csl.api.ParameterInfo;

import org.netbeans.modules.csl.spi.DefaultCompletionResult;

import org.netbeans.modules.csl.spi.ParserResult;

import org.netbeans.modules.parsing.api.Snapshot;

import org.netbeans.modules.parsing.api.Source;

import org.netbeans.modules.parsing.spi.indexing.support.QuerySupport;

import org.netbeans.modules.ruby.RubyCompletionItem.CallItem;

import org.netbeans.modules.ruby.RubyCompletionItem.ClassItem;

import org.netbeans.modules.ruby.RubyCompletionItem.FieldItem;

import org.netbeans.modules.ruby.RubyCompletionItem.MethodItem;

import org.netbeans.modules.ruby.RubyCompletionItem.ParameterItem;

import org.netbeans.modules.ruby.elements.AstElement;

import org.netbeans.modules.ruby.elements.AstFieldElement;

import org.netbeans.modules.ruby.elements.AstNameElement;

import org.netbeans.modules.ruby.elements.CommentElement;

import org.netbeans.modules.ruby.elements.Element;

import org.netbeans.modules.ruby.elements.IndexedClass;

import org.netbeans.modules.ruby.elements.IndexedElement;

import org.netbeans.modules.ruby.elements.IndexedField;

import org.netbeans.modules.ruby.elements.IndexedMethod;

import org.netbeans.modules.ruby.elements.IndexedVariable;

import org.netbeans.modules.ruby.elements.KeywordElement;

import org.netbeans.modules.ruby.elements.RubyElement;

import org.netbeans.modules.ruby.lexer.Call;

import org.netbeans.modules.ruby.lexer.LexUtilities;

import org.netbeans.modules.ruby.lexer.RubyStringTokenId;

import org.netbeans.modules.ruby.lexer.RubyTokenId;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.util.Exceptions;

import org.openide.util.NbBundle;

import static org.netbeans.modules.ruby.RubyUtils.*;

/**

 * Code completion handler for Ruby.

 * 

 * Bug: I add lists of fields etc. But if these -overlap- the current line,

 *  I throw them away. The problem is that there may be other references

 *  to the field that I should -not- throw away, elsewhere!

 * @todo Ensure that I prefer assignment over reference such that javadoc is

 *   more likely to be there!

 *   

 * 

 * @todo Handle this case:  {@code class HTTPBadResponse < StandardError; end}

 * @todo Code completion should automatically suggest "initialize()" for def completion! (if I'm in a class)

 * @todo It would be nice if you select a method that takes a block, such as Array.each, if we could

 *   insert a { ^ } suffix

 * @todo Use lexical tokens to avoid attempting code completion within comments,

 *   literal strings and regexps

 * @todo Percent-completion doesn't work if you at this to the end of the

 *   document:  x = %    and try to complete.

 * @todo Handle more completion scenarios: Classes (no keywords) after "class Foo <",

 *   classes after "::", parameter completion (!!!), .new() completion (initialize), etc.

 * @todo Make sure completion works during a "::"

 * @todo I need to move the smart-determination from just checking in=Object/Class/Module

 *   to the code which computes matches, since we have for example ObjectMixin in pretty printer

 *   which adds mixin methods to Object.

 * @todo Handle Rails methods that deal with hashes:

 *    - Try figuring out whether the method should take parameters by looking for examples;

 *      lines that start with the method name and looks like it might have arguments

 *    - Try to figure out what the different parameters are if there are hashes

 *    - &lt;tt&gt;: looks like a parameter, e.g. "<tt>:filename</tt>"

 *      and to see which parameter it might correspond to, see the

 *      label; see if any of the parameter names are listed there (possibly in the args list)

 *      A fallback is to look for args that look like they may be hashes, e.g.  

 *      def(foo1, foo2, foo3={}) - the third one is obviously a hash

 * @todo Make code completion when we're in a parameter list include the parameters as well!

 * @todo For .rjs files, insert an object named "page" of type 

 *    ActionView::Helpers::PrototypeHelper::JavaScriptGenerator::GeneratorMethods

 *    (#105088)

 * @todo For .builder files, insert an object named "xml" of type

 *    Builder::XmlMarkup

 * @todo For .rhtml/.html.erb files, insert fields etc. as documented in actionpack's lib/action_view/base.rb

 *    (#105095)

 * @todo For test files in Rails, get testing context (#105043). In particular, actionpack's

 *    ActionController::Assertions needs to be pulled in. This happens in action_controller/assertions.rb.

 * @todo Require-completion should handle ruby gems; it should provide the "preferred" (entry-point) files for

 *    all the ruby gems, and it should hide all the files that are inside the gem

 * @todo Rakefiles files should inherit Rakefile context

 * @todo See http://blog.diegodoval.com/2007/09/ruby_on_os_x_some_useful_links.html

 * @todo Documentation completion in a rdoc should preview that rdoc section

 * @todo Make a dedicated completion item which I return on documentation completion if I want  to

 *    complete the CURRENT element; it basically just wraps the desired comment so we can pull it

 *    out in the document() method

 * @todo Provide code completion for "3|" or "3 |" - show available overloaded operators! This

 *    shouldn't just apply to numbers - any class you've overridden

 * @todo Digest http://blogs.sun.com/coolstuff/entry/using_java_classes_in_jruby

 *    to fix require'java' etc.

 * @todo http://www.innovationontherun.com/scraping-dynamic-websites-using-jruby-and-htmlunit/

 *    Idea: Use a quicktip to require all the jars in the project?

 * @todo The "h" method in <%= %> doesn't show up in RHTML files... where is it?

 * @todo Completion AFTER a method which takes a block (optional or required) should offer

 *    { } and do/end !!

 * @author Tor Norbye

 */

public class RubyCodeCompleter implements CodeCompletionHandler {

    // Another good logical parameter would be SINGLE_WHITESPACE which would

    // insert a whitespace separator IF NEEDED

    /** Live code template parameter: require the given file, if not already done so */

    private static final String KEY_REQUIRE = "require"; // NOI18N

    /** Live code template parameter: find a name in scope that is known to be of the given type */

    private static final String KEY_INSTANCEOF = "instanceof"; // NOI18N

    /** Live code template parameter: compute an unused local variable name */

    private static final String ATTR_UNUSEDLOCAL = "unusedlocal"; // NOI18N

    /** Live code template parameter: pipe variable, since | is a bit mishandled in the UI for editing abbrevs */

    private static final String KEY_PIPE = "pipe"; // NOI18N

    /** Live code template parameter: compute the method name */

    private static final String KEY_METHOD = "method"; // NOI18N

    /** Live code template parameter: compute the method signature */

    private static final String KEY_METHOD_FQN = "methodfqn"; // NOI18N

    /** Live code template parameter: compute the class name (not including the module prefix) */

    private static final String KEY_CLASS = "class"; // NOI18N

    /** Live code template parameter: compute the class fully qualified name */

    private static final String KEY_CLASS_FQN = "classfqn"; // NOI18N

    /** Live code template parameter: compute the superclass of the current class */

    private static final String KEY_SUPERCLASS = "superclass"; // NOI18N

    /** Live code template parameter: compute the filename (not including the path) of the file */

    private static final String KEY_FILE = "file"; // NOI18N

    /** Live code template parameter: compute the full path of the source directory */

    private static final String KEY_PATH = "path"; // NOI18N

    /** Default name values for ATTR_UNUSEDLOCAL and friends */

    private static final String ATTR_DEFAULTS = "defaults"; // NOI18N

    private static final Set<String> selectionTemplates = new HashSet<String>();

    static {

        selectionTemplates.add("begin"); // NOI18N

        selectionTemplates.add("do"); // NOI18N

        selectionTemplates.add("doc"); // NOI18N

        //selectionTemplates.add("dop"); // NOI18N

        selectionTemplates.add("if"); // NOI18N

        selectionTemplates.add("ife"); // NOI18N

    }

    private boolean caseSensitive;

    private int anchor;

    public RubyCodeCompleter() {

    }

    static boolean startsWith(String theString, String prefix, boolean caseSensitive) {

        if (prefix.length() == 0) return true;

        return caseSensitive ? theString.startsWith(prefix)

                             : theString.toLowerCase().startsWith(prefix.toLowerCase());

    }

    private boolean startsWith(String theString, String prefix) {

        return RubyCodeCompleter.startsWith(theString, prefix, caseSensitive);

    }

    /**

     * Compute an appropriate prefix to use for code completion.

     * In Strings, we want to return the -whole- string if you're in a

     * require-statement string, otherwise we want to return simply "" or the previous "\"

     * for quoted strings, and ditto for regular expressions.

     * For non-string contexts, just return null to let the default identifier-computation

     * kick in.

     */

    @SuppressWarnings("unchecked")

    @Override

    public String getPrefix(ParserResult info, int lexOffset, boolean upToOffset) {

        try {

            BaseDocument doc = RubyUtils.getDocument(info);

            if (doc == null) return null;

            TokenHierarchy<Document> th = TokenHierarchy.get((Document)doc);

            doc.readLock(); // Read-lock due to token hierarchy use

            try {

            int requireStart = LexUtilities.getRequireStringOffset(lexOffset, th);

            // XXX todo - do upToOffset

            if (requireStart != -1) return doc.getText(requireStart, lexOffset - requireStart);

            TokenSequence<? extends RubyTokenId> ts = LexUtilities.getRubyTokenSequence(th, lexOffset);

            if (ts == null) return null;

            ts.move(lexOffset);

            if (!ts.moveNext() && !ts.movePrevious()) return null;

            // We're looking at the offset to the RIGHT of the caret and here I care about what's on the left

            if (ts.offset() == lexOffset) ts.movePrevious();

            Token<? extends RubyTokenId> token = ts.token();

            if (token != null) {

                TokenId id = token.id();

                // We're within a String that has embedded Ruby. Drop into the

                // embedded language and see if we're within a literal string there.

                if (id == RubyTokenId.EMBEDDED_RUBY) {

                    ts = (TokenSequence) ts.embedded();

                    assert ts != null;

                    ts.move(lexOffset);

                    if (!ts.moveNext() && !ts.movePrevious()) return null;

                    token = ts.token();

                    id = token.id();

                }

                String tokenText = token.text().toString();

                if ((id == RubyTokenId.STRING_BEGIN) || (id == RubyTokenId.QUOTED_STRING_BEGIN) ||

                        ((id == RubyTokenId.ERROR) && tokenText.equals("%"))) {

                    int currOffset = ts.offset();

                    // Percent completion

                    if ((currOffset == (lexOffset - 1)) && (tokenText.length() > 0) &&

                            (tokenText.charAt(0) == '%')) {

                        return "%";

                    }

                }

            }

            int doubleQuotedOffset = LexUtilities.getDoubleQuotedStringOffset(lexOffset, th);

            if (doubleQuotedOffset != -1) {

                // Tokenize the string and offer the current token portion as the text

                if (doubleQuotedOffset == lexOffset) {

                    return "";

                } else if (doubleQuotedOffset < lexOffset) {

                    String text = doc.getText(doubleQuotedOffset, lexOffset - doubleQuotedOffset);

                    TokenHierarchy hi =

                            TokenHierarchy.create(text, RubyStringTokenId.languageDouble());

                    TokenSequence seq = hi.tokenSequence();

                    seq.move(lexOffset - doubleQuotedOffset);

                    if (!seq.moveNext() && !seq.movePrevious()) {

                        return "";

                    }

                    TokenId id = seq.token().id();

                    String s = seq.token().text().toString();

                    if ((id == RubyStringTokenId.STRING_ESCAPE) ||

                            (id == RubyStringTokenId.STRING_INVALID)) {

                        return s;

                    } else if (s.startsWith("\\")) {

                        return s;

                    } else {

                        return "";

                    }

                } else {

                    // The String offset is greater than the caret position.

                    // This means that we're inside the string-begin section,

                    // for example here: %q|(

                    // In this case, report no prefix

                    return "";

                }

            }

            int singleQuotedOffset = LexUtilities.getSingleQuotedStringOffset(lexOffset, th);

            if (singleQuotedOffset != -1) {

                if (singleQuotedOffset == lexOffset) {

                    return "";

                } else if (singleQuotedOffset < lexOffset) {

                    String text = doc.getText(singleQuotedOffset, lexOffset - singleQuotedOffset);

                    TokenHierarchy hi =

                            TokenHierarchy.create(text, RubyStringTokenId.languageSingle());

                    TokenSequence seq = hi.tokenSequence();

                    seq.move(lexOffset - singleQuotedOffset);

                    if (!seq.moveNext() && !seq.movePrevious()) {

                        return "";

                    }

                    TokenId id = seq.token().id();

                    String s = seq.token().text().toString();

                    if ((id == RubyStringTokenId.STRING_ESCAPE) ||

                            (id == RubyStringTokenId.STRING_INVALID)) {

                        return s;

                    } else if (s.startsWith("\\")) {

                        return s;

                    } else {

                        return "";

                    }

                } else {

                    // The String offset is greater than the caret position.

                    // This means that we're inside the string-begin section,

                    // for example here: %q|(

                    // In this case, report no prefix

                    return "";

                }

            }

            // Regular expression

            int regexpOffset = LexUtilities.getRegexpOffset(lexOffset, th);

            if ((regexpOffset != -1) && (regexpOffset <= lexOffset)) {

                // This is not right... I need to actually parse the regexp

                // (I should use my Regexp lexer tokens which will be embedded here)

                // such that escaping sequences (/\\\\\/) will work right, or

                // character classes (/[foo\]). In both cases the \ may not mean escape.

                String tokenText = token.text().toString();

                int index = lexOffset - ts.offset();

                if ((index > 0) && (index <= tokenText.length()) &&

                        (tokenText.charAt(index - 1) == '\\')) {

                    return "\\";

                } else {

                    // No prefix for regexps unless it's \

                    return "";

                }

                //return doc.getText(regexpOffset, offset-regexpOffset);

            }

            int lineBegin = Utilities.getRowStart(doc, lexOffset);

            if (lineBegin != -1) {

                int lineEnd = Utilities.getRowEnd(doc, lexOffset);

                String line = doc.getText(lineBegin, lineEnd - lineBegin);

                int lineOffset = lexOffset - lineBegin;

                int start = lineOffset;

                if (lineOffset > 0) {

                    for (int i = lineOffset - 1; i >= 0; i--) {

                        char c = line.charAt(i);

                        if (!RubyUtils.isIdentifierChar(c)) {

                            break;

                        } else {

                            start = i;

                        }

                    }

                }

                // Find identifier end

                String prefix;

                if (upToOffset) {

                    prefix = line.substring(start, lineOffset);

                } else {

                    if (lineOffset == line.length()) {

                        prefix = line.substring(start);

                    } else {

                        int n = line.length();

                        int end = lineOffset;

                        for (int j = lineOffset; j < n; j++) {

                            char d = line.charAt(j);

                            // Try to accept Foo::Bar as well

                            if (!RubyUtils.isStrictIdentifierChar(d)) {

                                break;

                            } else {

                                end = j + 1;

                            }

                        }

                        prefix = line.substring(start, end);

                    }

                }

                if (prefix.length() > 0) {

                    if (prefix.endsWith("::")) {

                        return "";

                    }

                    if (prefix.endsWith(":") && prefix.length() > 1) {

                        return null;

                    }

                    // Strip out LHS if it's a qualified method, e.g.  Benchmark::measure -> measure

                    int q = prefix.lastIndexOf("::");

                    if (q != -1) {

                        prefix = prefix.substring(q + 2);

                    }

                    // The identifier chars identified by RubyLanguage are a bit too permissive;

                    // they include things like "=", "!" and even "&" such that double-clicks will

                    // pick up the whole "token" the user is after. But "=" is only allowed at the

                    // end of identifiers for example.

                    if (prefix.length() == 1) {

                        char c = prefix.charAt(0);

                        if (!(Character.isJavaIdentifierPart(c) || c == '@' || c == '$' || c == ':')) {

                            return null;

                        }

                    } else {

                        for (int i = prefix.length() - 2; i >= 0; i--) { // -2: the last position (-1) can legally be =, ! or ?

                            char c = prefix.charAt(i);

                            if (i == 0 && c == ':') {

                                // : is okay at the begining of prefixes

                            } else if (!(Character.isJavaIdentifierPart(c) || c == '@' || c == '$')) {

                                prefix = prefix.substring(i + 1);

                                break;

                            }

                        }

                    }

                    return prefix;

                }

            }

            } finally {

                doc.readUnlock();

            }

            // Else: normal identifier: just return null and let the machinery do the rest

        } catch (BadLocationException ble) {

            // do nothing - see #154991;

        }

        // Default behavior

        return null;

    }

    /** Determine if we're trying to complete the name for a "def" (in which case

     * we'd show the inherited methods).

     * This needs to be enhanced to handle "Foo." prefixes, e.g. def self.foo

     */

    private boolean completeDefOrInclude(List<CompletionProposal> proposals, CompletionRequest request, String fqn) {

        RubyIndex index = request.index;

        String prefix = request.prefix;

        int lexOffset = request.lexOffset;

        TokenHierarchy<Document> th = request.th;

        QuerySupport.Kind kind = request.kind;

        TokenSequence<?extends RubyTokenId> ts = LexUtilities.getRubyTokenSequence(th, lexOffset);

        if ((index != null) && (ts != null)) {

            ts.move(lexOffset);

            if (!ts.moveNext() && !ts.movePrevious()) {

                return false;

            }

            if (ts.offset() == lexOffset) {

                // We're looking at the offset to the RIGHT of the caret

                // position, which could be whitespace, e.g.

                //  "def fo| " <-- looking at the whitespace

                ts.movePrevious();

            }

            Token<?extends RubyTokenId> token = ts.token();

            if (token != null) {

                TokenId id = token.id();

                // See if we're in the identifier - "foo" in "def foo"

                // I could also be a keyword in case the prefix happens to currently

                // match a keyword, such as "next"

                if ((id == RubyTokenId.IDENTIFIER) || (id == RubyTokenId.CONSTANT) || id.primaryCategory().equals("keyword")) {

                    if (!ts.movePrevious()) {

                        return false;

                    }

                    token = ts.token();

                    id = token.id();

                }

                // If we're not in the identifier we need to be in the whitespace after "def"

                if (id != RubyTokenId.WHITESPACE) {

                    // Do something about http://www.netbeans.org/issues/show_bug.cgi?id=100452 here

                    // In addition to checking for whitespace I should look for "Foo." here

                    return false;

                }

                // There may be more than one whitespace; skip them

                while (ts.movePrevious()) {

                    token = ts.token();

                    if (token.id() != RubyTokenId.WHITESPACE) {

                        break;

                    }

                }

                if (token.id() == RubyTokenId.DEF) {

                    Set<IndexedMethod> methods = index.getInheritedMethods(fqn, prefix, kind);

                    for (IndexedMethod method : methods) {

                        // Hmmm, is this necessary? Filtering should happen in the getInheritedMEthods call

                        if ((prefix.length() > 0) && !method.getName().startsWith(prefix)) {

                            continue;

                        }

                        // For def completion, skip local methods, only include superclass and included

                        if ((fqn != null) && fqn.equals(method.getClz())) {

                            continue;

                        }

                        if (method.isNoDoc()) {

                            continue;

                        }

                        // If a method is an "initialize" method I should do something special so that

                        // it shows up as a "constructor" (in a new() statement) but not as a directly

                        // callable initialize method (it should already be culled because it's private)

                        MethodItem item = new MethodItem(method, anchor, request);

                        // Exact matches

                        item.setSmart(method.isSmart());

                        proposals.add(item);

                    }

                    return true;

                } else if (token.id() == RubyTokenId.IDENTIFIER && "include".equals(token.text().toString())) {

                    // Module completion

                    Set<IndexedClass> classes = index.getClasses(prefix, kind, false, true, false);

                    for (IndexedClass clz : classes) {

                        if (clz.isNoDoc()) {

                            continue;

                        }

                        ClassItem item = new ClassItem(clz, anchor, request);

                        item.setSmart(true);

                        proposals.add(item);

                    }     

                    return true;

                }

            }

        }

        return false;

    }

    private void completeGlobals(List<CompletionProposal> proposals, CompletionRequest request, boolean showSymbols) {

        RubyIndex index = request.index;

        String prefix = request.prefix;

        QuerySupport.Kind kind = request.kind;

        Set<IndexedVariable> globals = index.getGlobals(prefix, kind);

        for (IndexedVariable global : globals) {

            RubyCompletionItem item = new RubyCompletionItem(global, anchor, request);

            item.setSmart(true);

            if (showSymbols) {

                item.setSymbol(true);

            }

            proposals.add(item);

        }

    }

    private boolean addParameters(List<CompletionProposal> proposals, CompletionRequest request) {

        IndexedMethod[] methodHolder = new IndexedMethod[1];

        @SuppressWarnings("unchecked")

        Set<IndexedMethod>[] alternatesHolder = new Set[1];

        int[] paramIndexHolder = new int[1];

        int[] anchorOffsetHolder = new int[1];

        ParserResult info = request.parserResult;

        int lexOffset = request.lexOffset;

        int astOffset = request.astOffset;

        if (!RubyMethodCompleter.computeMethodCall(info, lexOffset, astOffset,

                methodHolder, paramIndexHolder, anchorOffsetHolder, alternatesHolder, request.kind)) {

            return false;

        }

        IndexedMethod targetMethod = methodHolder[0];

        int index = paramIndexHolder[0];

        CallItem callItem = new CallItem(targetMethod, index, anchor, request);

        proposals.add(callItem);

        // Also show other documented, not nodoc'ed items (except for those

        // with identical signatures, such as overrides of the same method)

        if (alternatesHolder[0] != null) {

            Set<String> signatures = new HashSet<String>();

            signatures.add(targetMethod.getSignature().substring(targetMethod.getSignature().indexOf('#')+1));

            for (IndexedMethod m : alternatesHolder[0]) {

                if (m != targetMethod && m.isDocumented() && !m.isNoDoc()) {

                    String sig = m.getSignature().substring(m.getSignature().indexOf('#')+1);

                    if (!signatures.contains(sig)) {

                        CallItem item = new CallItem(m, index, anchor, request);

                        proposals.add(item);

                        signatures.add(sig);

                    }

                }

            }

        }

        List<String> params = targetMethod.getParameters();

        if (params == null || params.isEmpty()) {

            return false;

        }

        if  (params.size() <= index) {

            // Just use the last parameter in these cases

            // See for example the TableDefinition.binary dynamic method where

            // you can add a number of parameter names and the options parameter

            // is always the last one

            index = params.size()-1;

        }

        boolean isLastArg = index < params.size()-1;

        String attrs = targetMethod.getEncodedAttributes();

        if (attrs != null && attrs.length() > 0) {

            int offset = -1;

            for (int i = 0; i < 3; i++) {

                offset = attrs.indexOf(';', offset+1);

                if (offset == -1) {

                    break;

                }

            }

            if (offset == -1) {

                Node root = null;

                if (info != null) {

                    root = AstUtilities.getRoot(info);

                }

                IndexedElement match = findDocumentationEntry(root, targetMethod);

                if (match == targetMethod || !(match instanceof IndexedMethod)) {

                    return false;

                }

                targetMethod = (IndexedMethod)match;

                attrs = targetMethod.getEncodedAttributes();

                if (attrs != null && attrs.length() > 0) {

                    offset = -1;

                    for (int i = 0; i < 3; i++) {

                        offset = attrs.indexOf(';', offset+1);

                        if (offset == -1) {

                            break;

                        }

                    }

                }

            }

            String currentName = params.get(index);

            if (currentName.startsWith("*")) {

                // * and & are part of the sig

                currentName = currentName.substring(1);

            } else if (currentName.startsWith("&")) {

                currentName = currentName.substring(1);

            }

            if (offset != -1) {

                // Pick apart

                attrs = attrs.substring(offset+1);

                if (attrs.length() == 0) {

                    return false;

                }

                String[] argEntries = attrs.split(",");

                for (String entry : argEntries) {

                    int parenIndex = entry.indexOf('(');

                    assert parenIndex != -1 : attrs;

                    String name = entry.substring(0, parenIndex);

                    if  (currentName.equals(name)) {

                        // Found a special parameter desc entry for this

                        // parameter - decode it and create completion items

                        // Decode

                        int endIndex = entry.indexOf(')', parenIndex);

                        assert endIndex != -1;

                        String data = entry.substring(parenIndex+1, endIndex);

                        if (data.length() > 0 && data.charAt(0) == '-') {

                            // It's a plain item (e.g. not a hash etc) where

                            // we have some logical types to complete

                            if ("-table".equals(data)) {

                                completeDbTables(proposals, targetMethod, request, isLastArg);

                                // Not exiting - I may have other entries here too

                            } else if ("-column".equals(data)) {

                                completeDbColumns(proposals, targetMethod, request, isLastArg);

                                // Not exiting - I may have other entries here too

                            } else if ("-model".equals(data)) {

                                completeModels(proposals, targetMethod, request, isLastArg);

                            }

                        } else if (data.startsWith("=>")) {

                            // It's a hash; show the given keys

                            // TODO: Determine if the caret is in the

                            // value part, and if so, show the values instead

                            // Uhm... what about fields and such?

                            completeHash(proposals, request, targetMethod, data, isLastArg);

                            // Not exiting - I may have a non-hash entry here too!

                        } else {

                            // Just show a fixed set of values

                            completeFixed(proposals, request, targetMethod, data, isLastArg);

                            // Not exiting - I may have other entries here too

                        }

                    }

                }

            }

        }

        return true;

    }

//    /** Handle insertion of :action, :controller, etc. even for methods without

//     * actual method signatures. Operate at the lexical level.

//     */

//    private void handleRailsKeys(List<CompletionProposal> proposals, CompletionRequest request, IndexedMethod target, String data, boolean isLastArg) {

//        TokenSequence ts = LexUtilities.getRubyTokenSequence(request.doc, anchor);

//        if (ts == null) {

//            return;

//        }

//        boolean inValue = false;

//        ts.move(anchor);

//        String line = null;

//        while (ts.movePrevious()) {

//            final Token token = ts.token();

//            if (token.id() == RubyTokenId.WHITESPACE) {

//                continue;

//            } else if (token.id() == RubyTokenId.NONUNARY_OP &&

//                    (token.text().toString().equals("=>"))) { // NOI18N

//                inValue = true;

//                // TODO - continue on to find out what the key is

//                try {

//                    BaseDocument doc = request.doc;

//                    int lineStart = Utilities.getRowStart(doc, ts.offset());

//                    line = doc.getText(lineStart, ts.offset()-lineStart).trim();

//                } catch (BadLocationException ble) {

//                    Exceptions.printStackTrace(ble);

//                    return;

//                }

//            } else {

//                break;

//            }

//        }

//

//        if (inValue) {

//            if (line.endsWith(":action")) {

//                // TODO

//            } else if (line.endsWith(":controller")) {

//                // Dynamically produce controllers

//                List<String> controllers = RubyUtils.getControllerNames(request.fileObject, true);

//                String prefix = request.prefix;

//                for (String n : controllers) {

//                    n = "'" + n + "'";

//                    if (startsWith(n, prefix)) {

//                        String insert = n;

//                        if (!isLastArg) {

//                            insert = insert + ", ";

//                        }

//                        ParameterItem item = new ParameterItem(target, n, null, insert,  anchor, request);

//                        item.setSymbol(true);

//                        item.setSmart(true);

//                        proposals.add(item);

//                    }

//                }

//            } else if (line.endsWith(":partial")) {

//                // TODO

//            }

//        }

//    }

    private boolean completeHash(List<CompletionProposal> proposals, CompletionRequest request, IndexedMethod target, String data, boolean isLastArg) {

        assert data.startsWith("=>");

        data = data.substring(2);

        String prefix = request.prefix;

        // Determine if we're in the key part or the value part when completing

        boolean inValue = false;

        TokenSequence ts = LexUtilities.getRubyTokenSequence(request.doc, anchor);

        if (ts == null) {

            return false;

        }

        ts.move(anchor);

        String line = null;

        while (ts.movePrevious()) {

            final Token token = ts.token();

            if (token.id() == RubyTokenId.WHITESPACE) {

                continue;

            } else if (token.id() == RubyTokenId.NONUNARY_OP &&

                    (token.text().toString().equals("=>"))) { // NOI18N

                inValue = true;

                // TODO - continue on to find out what the key is

                try {

                    BaseDocument doc = request.doc;

                    int lineStart = Utilities.getRowStart(doc, ts.offset());

                    line = doc.getText(lineStart, ts.offset()-lineStart).trim();

                } catch (BadLocationException ble) {

                    return false;

                }

            } else {

                break;

            }

        }

        List<String> suggestions = new ArrayList<String>();

        String key = null;

        String[] values = data.split("\\|");

        if (inValue) {

            // Find the key and see if we have a type to offer for it

            for (String value : values) {

                int typeIndex = value.indexOf(':');

                if (typeIndex != -1) {

                    String name = value.substring(0, typeIndex);

                    if (line.endsWith(name)) {

                        key = name;

                        // Score - it appears we're using the

                        // key for this item

                        String type = value.substring(typeIndex+1);

                        if ("nil".equals(type)) { // NOI18N

                            suggestions.add("nil"); // NOI18N

                        } else if ("bool".equals(type)) { // NOI18N

                            suggestions.add("true"); // NOI18N

                            suggestions.add("false"); // NOI18N

                        } else if ("submitmethod".equals(type)) { // NOI18N

                            suggestions.add("post"); // NOI18N

                            suggestions.add("get"); // NOI18N

                        } else if ("validationactive".equals(type)) { // NOI18N

                            suggestions.add(":save"); // NOI18N

                            suggestions.add(":create"); // NOI18N

                            suggestions.add(":update"); // NOI18N

                        } else if ("string".equals(type)) { // NOI18N

                            suggestions.add("\""); // NOI18N

                        } else if ("hash".equals(type)) { // NOI18N

                            suggestions.add("{"); // NOI18N

                        } else if ("controller".equals(type)) {

                            // Dynamically produce controllers

                            List<String> controllers = RubyUtils.getControllerNames(request.fileObject, true);

                            for (String n : controllers) {

                                suggestions.add("'" + n + "'");

                            }

                        } else if ("action".equals(type)) {

                            // Dynamically produce actions

                            // This would need to be scoped by the current

                            // context - look at the hash, find the specified

                            // controller and limit it to that

                            List<String> actions = getActionNames(request);

                            for (String n : actions) {

                                suggestions.add("'" + n + "'");

                            }

                        } else if ("status".equals(type)) {

                            return RubyHttpStatusCodeCompleter.complete(proposals, request, anchor, caseSensitive, target);

                        }

                    }

                }

            }

        } else {

            for (String value : values) {

                int typeIndex = value.indexOf(':');

                if (typeIndex != -1) {

                    value = value.substring(0, typeIndex);

                }

                value = ":" + value + " => ";

                suggestions.add(value);

            }

        }

        // I've gotta clean up the colon handling in complete()

        // I originally stripped ":" to make direct (INameNode)getName()

        // comparisons on symbols work directly but it's becoming a liability now

        String colonPrefix = ":" + prefix;

        for (String suggestion : suggestions) {

            if (startsWith(suggestion, prefix) || startsWith(suggestion, colonPrefix)) {

                String insert = suggestion;

                String desc = null;

                if (inValue) {

                    if (!isLastArg) {

                        insert = insert + ", ";

                    }

                    if (key != null) {

                        desc = ":" + key + " = " + suggestion;

                    }

                }

                ParameterItem item = new ParameterItem(target, suggestion, desc, insert,  anchor, request);

                item.setSymbol(true);

                item.setSmart(true);

                proposals.add(item);

            }

        }

        return true;

    }

    /** Get the actions for the given file. If the file is a controller, list the actions within it,

     * otherwise, if the file is a view, list the actions for the corresponding controller.

     * 

     * @param fileInProject the file we're looking up

     * @return A List of action names

     */

    private List<String> getActionNames(CompletionRequest request) {

        FileObject file = request.fileObject;

        FileObject controllerFile = null;

        if (file.getNameExt().endsWith("_controller.rb")) {

            controllerFile = file;

        } else {

            controllerFile = RubyUtils.getRailsControllerFor(file);

        }

        // TODO - check for other :controller-> settings in the hashmap and if present, use it

        if (controllerFile == null) {

            return Collections.emptyList();

        }

        String controllerClass = RubyUtils.getControllerClass(controllerFile);

        if (controllerClass != null) {

            String prefix = request.prefix;

            Set<IndexedMethod> methods = request.index.getMethods(prefix, controllerClass, request.kind);

            List<String> actions = new ArrayList<String>();

            for (IndexedMethod method : methods) {

                if (method.isPublic() && method.getArgs() == null || method.getArgs().length == 0) {

                    actions.add(method.getName());

                }

            }

            return actions;

        }

        // TODO - pull out the methods or this class

        return Collections.emptyList();

    }

    private void completeFixed(List<CompletionProposal> proposals, CompletionRequest request, IndexedMethod target, String data, boolean isLastArg) {

        String[] values = data.split("\\|");

        String prefix = request.prefix;