/*

 * 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-2009 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.util.Map;

import org.jrubyparser.ast.MethodDefNode;

import org.jrubyparser.ast.Node;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.editor.BaseDocument;

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

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

import org.netbeans.modules.ruby.options.TypeInferenceSettings;

import org.openide.filesystems.FileObject;

/**

 * @todo Test compound assignment:  x = File::Stat.new

 *

 * @author Tor Norbye

 */

public class RubyTypeAnalyzerTest extends RubyTestBase {

    public RubyTypeAnalyzerTest(String testName) {

        super(testName);

        RubyIndexer.userSourcesTest = true;

        TypeInferenceSettings.getDefault().setMethodTypeInference(true);

        TypeInferenceSettings.getDefault().setRdocTypeInference(true);

    }

    @Override

    protected Map<String, ClassPath> createClassPathsForTest() {

        return rubyTestsClassPath();

    }

    private RubyTypeInferencer getInferencer(String file, String caretLine, boolean findMethod) throws Exception {

        FileObject fo = getTestFile("testfiles/" + file);

        int caretOffset = -1;

        if (caretLine != null) {

            Source source = Source.create(fo);

            caretOffset = getCaretOffset(source.createSnapshot().getText().toString(), caretLine);

            enforceCaretOffset(source, caretOffset);

        }

        ParserResult parserResult = getParserResult(fo);

        Node root = AstUtilities.getRoot(parserResult);

        initializeRegistry();

        RubyIndex index = RubyIndex.get(parserResult);

        Node node = root.getNodeAt(caretOffset);

        if (findMethod) {

            MethodDefNode method = AstUtilities.findMethodAtOffset(root, caretOffset);

            assertNotNull(method);

            root = method;

        }

        ContextKnowledge knowledge = new ContextKnowledge(index, root, node, caretOffset, caretOffset, parserResult);

        return RubyTypeInferencer.create(knowledge);

    }

    private void assertTypes(final RubyType actualTypes, final String... expectedTypes) {

        assertTypes(null, actualTypes, expectedTypes);

    }

    private void assertTypes(final String message, final RubyType actualTypes, final String... expectedTypes) {

        assertTypes(message, actualTypes, false, expectedTypes);

    }

    private void assertTypes(final String message, final RubyType actualTypes,

            final boolean hasUnknownMember, final String... expectedTypes) {

        RubyType expected = new RubyType(expectedTypes);

        if (hasUnknownMember) {

            expected.append(RubyType.unknown());

        }

        assertTrue(message + ":" +

                "\n  actualTypes:   " + actualTypes +

                "\n  expectedTypes: " + expected, actualTypes.equals(expected));

    }

    private void assertTypes(String relFilePath, String matchingLine,

            String exprToInfer, String... expectedTypes) throws Exception {

        assertTypes(relFilePath, matchingLine, exprToInfer, false, expectedTypes);

    }

    private void assertTypes(String relFilePath, String matchingLine,

            String exprToInfer, boolean hasUnknownMember, String... expectedTypes) throws Exception {

        RubyTypeInferencer instance = getInferencer(relFilePath, matchingLine, false);

        assertTypes("Types correctly inferred", instance.inferType(exprToInfer), hasUnknownMember, expectedTypes);

    }

    public void testGetType() throws Exception {

        RubyTypeInferencer instance = getInferencer("types.rb", " l^oc = {", false);

        assertTypes(instance.inferType("x"), "Integer");

        // y is reassigned later in the file - make sure that at this

        // point in scope we have the right type

        assertTypes(instance.inferType("y"), "File");

        assertTypes(instance.inferType("$baz"), "Hash");

        assertTypes(instance.inferType("@bar"), "Fixnum");

        assertTypes(instance.inferType("@foo"), "Array");

    }

    public void testGetType2() throws Exception {

        RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

        // Y is assigned different types - make sure that at this position, it's a number

        assertTypes(instance.inferType("y"), "Fixnum");

        // Lots of reassignments - track types through vars, statics, fields, classvars

        assertTypes(instance.inferType("loc"), "Hash");

        assertTypes(instance.inferType("$glob"), "Hash");

        assertTypes(instance.inferType("@field"), "Hash");

        assertTypes(instance.inferType("@@clsvar"), "Hash");

        assertTypes(instance.inferType("loc2"), "Hash");

    }

    public void testMultipleAssigments() throws Exception {

        RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

        assertTypes(instance.inferType("q"), "Fixnum");

        assertTypes(instance.inferType("w"), "Fixnum");

        assertTypes(instance.inferType("e"), "String");

        assertTypes(instance.inferType("@r"), "String");

        assertTypes(instance.inferType("@t"), "Fixnum");

    }

    public void testNestedMultipleAssigments() throws Exception {

        RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

        assertTypes(instance.inferType("u"), "String");

        assertTypes(instance.inferType("i"), "Fixnum");

        assertTypes(instance.inferType("o"), "Float");

        assertTypes(instance.inferType("p"), "File");

    }

    public void testTypeAssertions() throws Exception {

        RubyTypeInferencer instance = getInferencer("types.rb", " l^oc = {", true);

        assertTypes(instance.inferType("param1"), "String");

        assertTypes(instance.inferType("param2"), "Hash");

    }

    public void testBegin() throws Exception {

        RubyTypeInferencer instance = getInferencer("types2.rb", " @f^iles = ARGV.dup", false);

        assertTypes(instance.inferType("go"), "GetoptLong");

    }

    public void testRailsController() throws Exception {

        assertTypes("type_controller.rb", "^end", "request", "ActionController::CgiRequest");

        RubyTypeInferencer instance = getInferencer("type_controller.rb", "^end", false);

        assertTypes(instance.inferType("request"), "ActionController::CgiRequest");

    }

// This test doesn't work; the behavior works in the IDE but the

// Lucene index isn't returning local symbols in the testing framework yet

//    public void testComplex1() throws Exception {

//        RubyTypeInferencer instance = getAnalyzer("types3.rb", "^caret", false);

//        assertEquals("Product", instance.getType("@product"));

//    }

//    public void testComplex2() throws Exception {

//        RubyTypeInferencer instance = getAnalyzer("types3.rb", "^caret", true);

//        assertEquals("ActiveRecord::ConnectionAdapters::TableDefinition", instance.getType("t"));

//    }

    //public void testComplex3() throws Exception {

    //    // XXX TODO

    //    assertFalse("Check that I do closures for each, collect, map, etc.", true);

    //    // also check to_s

    //}

    // TODO: Make sure I can handle compound expressions like this one:

    //  Product.find(params[:id]).destroy

    public void testMigrationType() throws Exception {

        RubyTypeInferencer instance = getInferencer("migrate/20080726182725_create_posts.rb", " t.^time", true);

        assertTypes(instance.inferType("t"), "ActiveRecord::ConnectionAdapters::TableDefinition");

    }

    public void testIfType() throws Exception {

        assertTypes("if_type.rb", "p va^r.in", "var", "String", "NilClass");

    }

    public void testIfElseType() throws Exception {

        assertTypes("if_else_type.rb", "p va^r.in", "var", "String", "Array");

    }

    public void testIfElseType2() throws Exception {

        assertTypes("if_else_type_2.rb", "p va^r.in", "var", "String", "NilClass");

    }

    public void testIfElseWithInBlockReassignmentType() throws Exception {

        assertTypes("if_else_with_block_reassignment_type.rb", "p va^r.in", "var", "Hash", "Array");

    }

    public void testIfElseIfElseType() throws Exception {

        assertTypes("if_elsif_else_type.rb", "p va^r.in", "var", "String", "Array", "Hash");

    }

    public void testUnlessType() throws Exception {

        assertTypes("unless_type.rb", "var.i^", "var", "Array", "Hash");

    }

    public void testForType() throws Exception {

        assertTypes("for_type.rb", "tmp^ = i", "i", false, "Fixnum");

        assertTypes("for_type.rb", "s^ = j", "j", false, "String");

    }

    public void testEqualsType() throws Exception {

        assertTypes("equals_type.rb", "var.t^", "var", "TrueClass", "FalseClass");

        assertTypes("equals_type.rb", "var2.t^", "var2", "TrueClass", "FalseClass");

    }

    public void testIfWithFailingInferenceInBranchType() throws Exception {

        assertTypes("if_with_failing_inference_in_branch_type.rb", "var.to_^", "var", true, "NilClass");

    }

    // TODO inference is still not able to do the below

    public void FIXME_testIfElseNestedSimpleType() throws Exception {

        assertTypes("if_else_nested_simple_type.rb", "var.^ifcond1b", "var", "Float");

        assertTypes("if_else_nested_simple_type.rb", "var.^aa", "var", "NilClass", "Float");

    }

    // TODO inference is still not able to do the below

    public void FIXME_testIfElseNestedType() throws Exception {

        assertTypes("if_else_nested_type.rb", "va^r.ifcond2", "var", "Hash");

        // XXX more, see the if_else_nested_type.rb

    }

    public void testConstant() throws Exception {

        assertTypes("constants.rb", "Colors::RED.byte^", "Colors::RED", "String");

        assertTypes("constants.rb", "puts b.down^case", "b", "String");

        // TODO fix and uncomment when reindexed

        // assertTypes("indexed constants type inference", "constants.rb", "REXML::COPY^RIGHT", "COPYRIGHT", "String");

    }

    public void testMethodType() throws Exception {

        assertTypes("method_type_inference.rb", "puts n^um.abs", "num", "Fixnum");

        assertTypes("method_type_inference.rb", "puts cons^t", "const", "Fixnum");

    }

//    public void testCoreMethodType() throws Exception {

//        assertTypes("core_methods.rb", "ance^stors.delete(String)", "ancestors", "Array");

//        assertTypes("core_methods.rb", "puts has_^one.t", "has_one", "TrueClass", "FalseClass");

//        assertTypes("core_methods.rb", "huh = a.eq^l?(123)", "a", "Fixnum", "Numeric");

//    }

    public void testMethodsChaining() throws Exception {

        assertTypes("methods_chaining.rb", "puts gree^ting", "greeting", "String");

    }

}