/*

 * 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.

 */

package compiler.compilercontrol.share.scenario;

import compiler.compilercontrol.share.JSONFile;

import compiler.compilercontrol.share.method.MethodDescriptor;

import compiler.compilercontrol.share.method.MethodGenerator;

import jdk.test.lib.Pair;

import java.lang.reflect.Executable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.concurrent.Callable;

import java.util.stream.Collectors;

/**

 * Directive file and state builder class

 */

public class DirectiveBuilder implements StateBuilder<CompileCommand> {

    private static final List<Pair<Executable, Callable<?>>> METHODS

            = new PoolHelper().getAllMethods();

    private final Map<Executable, State> stateMap = new HashMap<>();

    private final String fileName;

    private final Map<MethodDescriptor, List<CompileCommand>> matchBlocks

            = new LinkedHashMap<>();

    private final List<CompileCommand> inlines = new ArrayList<>();

    private boolean isFileValid = true;

    public DirectiveBuilder(String fileName) {

        this.fileName = fileName;

    }

    @Override

    public List<String> getOptions() {

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

        if (!matchBlocks.isEmpty()) {

            // add option only if there are any directive available

            options.add("-XX:CompilerDirectivesFile=" + fileName);

        }

        return options;

    }

    @Override

    public List<CompileCommand> getCompileCommands() {

        return matchBlocks.keySet().stream()

                // only method descriptor is required to check print_directives

                .map(md -> new CompileCommand(null, md, null, null))

                .collect(Collectors.toList());

    }

    @Override

    public boolean isValid() {

        // Invalid directives file makes VM exit with error code

        return isFileValid;

    }

    @Override

    public Map<Executable, State> getStates() {

        writeDirectiveFile();

        if (isFileValid) {

            // Build states for each method according to match blocks

            for (Pair<Executable, Callable<?>> pair : METHODS) {

                State state = getState(pair);

                if (state != null) {

                    stateMap.put(pair.first, state);

                }

            }

            return stateMap;

        } else {

            // return empty map because invalid file doesn't change states

            return new HashMap<>();

        }

    }

    private void writeDirectiveFile() {

        try (DirectiveWriter dirFile = new DirectiveWriter(fileName)) {

            for (MethodDescriptor matchDescriptor : matchBlocks.keySet()) {

                // Write match block with all options converted from commands

                dirFile.match(matchDescriptor);

                for (CompileCommand compileCommand :

                        matchBlocks.get(matchDescriptor)) {

                    handleCommand(dirFile, compileCommand);

                }

                if ("Inlinee.caller()".matches(matchDescriptor.getRegexp())

                        && !inlines.isEmpty()) {

                    // Got a *.* match block, where inline would be written

                    writeInlines(dirFile);

                    inlines.clear();

                }

                dirFile.end(); // ends match block

            }

            /*

             * Write inline directive in the end to the latest match block

             * if we didn't do this before

             * Inlinee caller methods should match this block only

             */

            if (!inlines.isEmpty()) {

                Pair<Executable, Callable<?>> pair = METHODS.get(0);

                MethodDescriptor md = MethodGenerator.anyMatchDescriptor(

                        pair.first);

                CompileCommand cc = new CompileCommand(Command.QUIET, md,

                        null, Scenario.Type.DIRECTIVE);

                List<CompileCommand> commands = new ArrayList<>();

                // Add appropriate "*.*" match block

                commands.add(cc);

                matchBlocks.put(md, commands);

                // Add match block for this descriptor with inlines

                dirFile.match(md);

                writeInlines(dirFile);

                dirFile.end();

            }

            if (!matchBlocks.isEmpty()) {

                // terminates file

                dirFile.end();

            }

        }

    }

    private State getState(Pair<Executable, Callable<?>> pair) {

        State state = null;

        MethodDescriptor execDesc = MethodGenerator.commandDescriptor(

                pair.first);

        boolean isMatchFound = false;

        if (stateMap.containsKey(pair.first)) {

            state = stateMap.get(pair.first);

        }

        for (MethodDescriptor matchDesc : matchBlocks.keySet()) {

            if (execDesc.getCanonicalString().matches(matchDesc.getRegexp())) {

                /*

                 * if executable matches regex

                 * then apply commands from this match to the state

                 */

                for (CompileCommand cc : matchBlocks.get(matchDesc)) {

                    if (state == null) {

                        state = new State();

                    }

                    if (!isMatchFound) {

                        // this is a first found match, apply all commands

                        state.apply(cc);

                    } else {

                        // apply only inline directives

                        switch (cc.command) {

                            case INLINE:

                            case DONTINLINE:

                                state.apply(cc);

                                break;

                        }

                    }

                }

                isMatchFound = true;

            }

        }

        return state;

    }

    private void handleCommand(DirectiveWriter dirFile, CompileCommand cmd) {

        Command command = cmd.command;

        switch (command) {

            case COMPILEONLY:

                dirFile.excludeCompile(cmd.compiler, false);

                break;

            case EXCLUDE:

                dirFile.excludeCompile(cmd.compiler, true);

                break;

            case QUIET:

                /* there are no appropriate directive for this, just make

                   match be enabled */

            case INLINE:

            case DONTINLINE:

                /* Inline commands will be written later.

                   Just make this match be enabled */

                dirFile.emitCompiler(Scenario.Compiler.C1);

                dirFile.option(DirectiveWriter.Option.ENABLE, true);

                dirFile.end();

                dirFile.emitCompiler(Scenario.Compiler.C2);

                dirFile.option(DirectiveWriter.Option.ENABLE, true);

                dirFile.end();

                break;

            case LOG:

                dirFile.option(DirectiveWriter.Option.LOG, true);

                break;

            case PRINT:

                dirFile.option(DirectiveWriter.Option.PRINT_ASSEMBLY, true);

                break;

            case NONEXISTENT:

                dirFile.write(JSONFile.Element.PAIR, command.name);

                dirFile.write(JSONFile.Element.OBJECT);

                dirFile.write(JSONFile.Element.PAIR, command.name);

                dirFile.write(JSONFile.Element.VALUE,

                        cmd.methodDescriptor.getString());

                dirFile.end(); // ends object

                break;

            default:

                throw new Error("TESTBUG: wrong command: " + command);

        }

    }

    private void writeInlines(DirectiveWriter dirFile) {

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

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

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

        for (CompileCommand cc : inlines) {

            String inlineMethodPattern;

            switch (cc.command) {

                case INLINE:

                    inlineMethodPattern = "+" + cc.methodDescriptor.getString();

                    break;

                case DONTINLINE:

                    inlineMethodPattern = "-" + cc.methodDescriptor.getString();

                    break;

                default:

                    throw new Error("TESTBUG: incorrect command got in "

                            + "the list: " + cc.command);

            }

            if (cc.compiler == Scenario.Compiler.C1) {

                c1Block.add(inlineMethodPattern);

            } else if (cc.compiler == Scenario.Compiler.C2) {

                c2Block.add(inlineMethodPattern);

            } else {

                allBlock.add(inlineMethodPattern);

            }

        }

        dirFile.emitCompiler(Scenario.Compiler.C1);

        if (!c1Block.isEmpty()) {

            dirFile.inline(c1Block);

        } else {

            dirFile.option(DirectiveWriter.Option.ENABLE, true);

        }

        dirFile.end();

        dirFile.emitCompiler(Scenario.Compiler.C2);

        if (!c2Block.isEmpty()) {

            dirFile.inline(c2Block);

        } else {

            dirFile.option(DirectiveWriter.Option.ENABLE, true);

        }

        dirFile.end();

        if (!allBlock.isEmpty()) {

            dirFile.inline(allBlock);

        }

    }

    @Override

    public void add(CompileCommand compileCommand) {

        isFileValid &= compileCommand.isValid();

        MethodDescriptor methodDescriptor = compileCommand.methodDescriptor;

        switch (compileCommand.command) {

            case INLINE:

            case DONTINLINE:

                inlines.add(compileCommand);

                break;

        }

        for (MethodDescriptor md: matchBlocks.keySet()) {

            if (methodDescriptor.getCanonicalString().matches(md.getRegexp())) {

                matchBlocks.get(md).add(compileCommand);

            }

        }

        if (!matchBlocks.containsKey(compileCommand.methodDescriptor)) {

            List<CompileCommand> commands = new ArrayList<>();

            commands.add(compileCommand);

            matchBlocks.put(compileCommand.methodDescriptor, commands);

        }

    }

}