/*

 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.io.File;

import java.io.IOException;

import java.io.StringWriter;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

import javax.lang.model.element.Modifier;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.ToolProvider;

import com.sun.source.tree.BlockTree;

import com.sun.source.tree.BreakTree;

import com.sun.source.tree.CaseTree;

import com.sun.source.tree.ClassTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.ContinueTree;

import com.sun.source.tree.DoWhileLoopTree;

import com.sun.source.tree.ExpressionStatementTree;

import com.sun.source.tree.ForLoopTree;

import com.sun.source.tree.IfTree;

import com.sun.source.tree.ImportTree;

import com.sun.source.tree.LabeledStatementTree;

import com.sun.source.tree.LineMap;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.ReturnTree;

import com.sun.source.tree.StatementTree;

import com.sun.source.tree.SwitchTree;

import com.sun.source.tree.Tree;

import com.sun.source.tree.WhileLoopTree;

import com.sun.source.util.SourcePositions;

import com.sun.source.util.Trees;

import com.sun.tools.javac.api.JavacTaskImpl;

import jdk.jshell.SourceCodeAnalysis;

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

import static java.lang.Integer.max;

import static java.lang.Integer.min;

import static jdk.jshell.SourceCodeAnalysis.Completeness.*;

public class CompletenessStressTest extends KullaTesting {

    public final static String JDK_ROOT_SRC_PROP = "jdk.root.src";

    public final static String JDK_ROOT_SRC;

    static {

        JDK_ROOT_SRC = System.getProperty(JDK_ROOT_SRC_PROP);

    }

    public File getSourceFile(String fileName) {

        for (File dir : getDirectoriesToTest()) {

            File file = new File(dir, fileName);

            if (file.exists()) {

                return file;

            }

        }

        throw new AssertionError("File not found: " + fileName);

    }

    public File[] getDirectoriesToTest() {

        return new File[]{

                new File(JDK_ROOT_SRC, "nashorn/src"),

                new File(JDK_ROOT_SRC, "langtools/src"),

                new File(JDK_ROOT_SRC, "jaxp/src"),

                new File(JDK_ROOT_SRC, "jaxws/src"),

                new File(JDK_ROOT_SRC, "jdk/src"),

                new File(JDK_ROOT_SRC, "corba/src")

        };

    }

    @DataProvider(name = "crawler")

    public Object[][] dataProvider() throws IOException {

        File[] srcDirs = getDirectoriesToTest();

        List<String[]> list = new ArrayList<>();

        for (File srcDir : srcDirs) {

            String srcDirName = srcDir.getAbsolutePath();

            // this is just to obtain pretty test names for testng tests

            List<String[]> a = Files.walk(Paths.get(srcDirName))

                    .map(Path::toFile)

                    .map(File::getAbsolutePath)

                    .filter(n -> n.endsWith(".java"))

                    .map(n -> n.replace(srcDirName, ""))

                    .map(n -> new String[]{n})

                    .collect(Collectors.toList());

            if (a.isEmpty()) {

                throw new AssertionError("Java sources have not been found in directory: " + srcDirName);

            }

            list.addAll(a);

        }

        return list.toArray(new String[list.size()][]);

    }

    @Test(dataProvider = "crawler")

    public void testFile(String fileName) throws IOException {

        File file = getSourceFile(fileName);

        final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        final StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

        boolean success = true;

        StringWriter writer = new StringWriter();

        writer.write("Testing : " + file.toString() + "\n");

        String text = new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8);

        Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(file);

        JavacTaskImpl task = (JavacTaskImpl) compiler.getTask(null, fileManager, null, null, null, compilationUnits);

        Iterable<? extends CompilationUnitTree> asts = task.parse();

        Trees trees = Trees.instance(task);

        SourcePositions sp = trees.getSourcePositions();

        for (CompilationUnitTree cut : asts) {

            for (ImportTree imp : cut.getImports()) {

                success &= testStatement(writer, sp, text, cut, imp);

            }

            for (Tree decl : cut.getTypeDecls()) {

                success &= testStatement(writer, sp, text, cut, decl);

                if (decl instanceof ClassTree) {

                    ClassTree ct = (ClassTree) decl;

                    for (Tree mem : ct.getMembers()) {

                        if (mem instanceof MethodTree) {

                            MethodTree mt = (MethodTree) mem;

                            BlockTree bt = mt.getBody();

                            // No abstract methods or constructors

                            if (bt != null && mt.getReturnType() != null) {

                                // The modifiers synchronized, abstract, and default are not allowed on

                                // top-level declarations and are errors.

                                Set<Modifier> modifier = mt.getModifiers().getFlags();

                                if (!modifier.contains(Modifier.ABSTRACT)

                                        && !modifier.contains(Modifier.SYNCHRONIZED)

                                        && !modifier.contains(Modifier.DEFAULT)) {

                                    success &= testStatement(writer, sp, text, cut, mt);

                                }

                                testBlock(writer, sp, text, cut, bt);

                            }

                        }

                    }

                }

            }

        }

        fileManager.close();

        if (!success) {

            throw new AssertionError(writer.toString());

        }

    }

    private boolean isLegal(StatementTree st) {

        return !(st instanceof ReturnTree) &&

                !(st instanceof ContinueTree) && !(st instanceof BreakTree);

    }

    private boolean testBranch(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, StatementTree statementTree) {

        if (statementTree instanceof BlockTree) {

            return testBlock(writer, sp, text, cut, (BlockTree) statementTree);

        } else if (isLegal(statementTree)) {

            return testStatement(writer, sp, text, cut, statementTree);

        }

        return true;

    }

    private boolean testBlock(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, BlockTree blockTree) {

        boolean success = true;

        for (StatementTree st : blockTree.getStatements()) {

            if (isLegal(st)) {

                success &= testStatement(writer, sp, text, cut, st);

            }

            if (st instanceof IfTree) {

                IfTree ifTree = (IfTree) st;

                success &= testBranch(writer, sp, text, cut, ifTree.getThenStatement());

                success &= testBranch(writer, sp, text, cut, ifTree.getElseStatement());

            } else if (st instanceof WhileLoopTree) {

                WhileLoopTree whileLoopTree = (WhileLoopTree) st;

                success &= testBranch(writer, sp, text, cut, whileLoopTree.getStatement());

            } else if (st instanceof DoWhileLoopTree) {

                DoWhileLoopTree doWhileLoopTree = (DoWhileLoopTree) st;

                success &= testBranch(writer, sp, text, cut, doWhileLoopTree.getStatement());

            } else if (st instanceof ForLoopTree) {

                ForLoopTree forLoopTree = (ForLoopTree) st;

                success &= testBranch(writer, sp, text, cut, forLoopTree.getStatement());

            } else if (st instanceof LabeledStatementTree) {

                LabeledStatementTree labelTree = (LabeledStatementTree) st;

                success &= testBranch(writer, sp, text, cut, labelTree.getStatement());

            } else if (st instanceof SwitchTree) {

                SwitchTree switchTree = (SwitchTree) st;

                for (CaseTree caseTree : switchTree.getCases()) {

                    for (StatementTree statementTree : caseTree.getStatements()) {

                        success &= testBranch(writer, sp, text, cut, statementTree);

                    }

                }

            }

        }

        return success;

    }

    private boolean testStatement(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, Tree statement) {

        if (statement == null) {

            return true;

        }

        int start = (int) sp.getStartPosition(cut, statement);

        int end = (int) sp.getEndPosition(cut, statement);

        char ch = text.charAt(end - 1);

        SourceCodeAnalysis.Completeness expected = COMPLETE;

        LineMap lineMap = cut.getLineMap();

        int row = (int) lineMap.getLineNumber(start);

        int column = (int) lineMap.getColumnNumber(start);

        switch (ch) {

            case ',':

            case ';':

                expected = (statement instanceof ExpressionStatementTree)

                        ? COMPLETE

                        : COMPLETE_WITH_SEMI;

                --end;

                break;

            case '}':

                break;

            default:

                writer.write(String.format("Unexpected end: row %d, column %d: '%c' -- %s\n",

                        row, column, ch, text.substring(start, end)));

                return true;

        }

        String unit = text.substring(start, end);

        SourceCodeAnalysis.CompletionInfo ci = getAnalysis().analyzeCompletion(unit);

        if (ci.completeness != expected) {

            if (expected == COMPLETE_WITH_SEMI && (ci.completeness == CONSIDERED_INCOMPLETE || ci.completeness == EMPTY)) {

                writer.write(String.format("Empty statement: row %d, column %d: -- %s\n",

                        start, end, unit));

            } else {

                String oops = unit.substring(max(0, ci.unitEndPos - 10), ci.unitEndPos) + "|||" +

                        unit.substring(ci.unitEndPos, min(unit.length(), ci.unitEndPos + 10));

                writer.write(String.format("Expected %s got %s: '%s'  row %d, column %d: -- %s\n",

                        expected, ci.completeness, oops, row, column, unit));

                return false;

            }

        }

        return true;

    }

}