/*
 * Copyright (c) 2015, 2016, 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 sampleapi.generator;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.sun.source.util.JavacTask;
import com.sun.tools.javac.api.JavacTool;
import com.sun.tools.javac.api.JavacTaskImpl;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.JCTree.*;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.Symtab;
import java.nio.file.Path;

import sampleapi.util.*;

public class PackageGenerator {

    public String packageName;
    String packageDirName;
    public String id;

    ArrayList<JCCompilationUnit> topLevels;
    Map<String, Integer> nameIndex;
    public Map<String, JCClassDecl> idBases;
    Map<String, JCAnnotation> idAnnos;

    TreeMaker make;
    Names names;
    Symtab syms;
    DocumentBuilderFactory factory;
    Documentifier documentifier;
    boolean fx;

    public PackageGenerator() {
        JavacTool jt = JavacTool.create();
        JavacTask task = jt.getTask(null, null, null, null, null, null);
        Context ctx = ((JavacTaskImpl)task).getContext();

        make = TreeMaker.instance(ctx);
        names = Names.instance(ctx);
        syms = Symtab.instance(ctx);
        factory = DocumentBuilderFactory.newInstance();

        documentifier = Documentifier.instance(ctx);
    }

    boolean isDataSetProcessed = false;

    public static PackageGenerator processDataSet(Element rootElement) {
        PackageGenerator result = new PackageGenerator();
        result.isDataSetProcessed = true;
        result.topLevels = new ArrayList<>();
        result.nameIndex = new HashMap<>();
        result.idBases = new HashMap<>();
        result.idAnnos = new HashMap<>();
        result.fx = false;

        if (!rootElement.getTagName().equals("package")) {
            throw new IllegalStateException("Unexpected tag name: "
                    + rootElement.getTagName());
        }
        result.packageName = rootElement.getAttribute("name");
        result.id = rootElement.getAttribute("id");
        result.fx = "fx".equals(rootElement.getAttribute("style"));
        result.packageDirName = result.packageName.replace('.', '/');

        // process nodes (toplevels)
        NodeList nodeList = rootElement.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);

            if (!(node instanceof Element)) {
                continue;
            }
            result.processTopLevel((Element) node);
        }
        return result;
    }

    public void generate(Path outDir) {
        if (!isDataSetProcessed)
            throw new RuntimeException("No Data Set processed");

        try {
            File pkgDir = new File(outDir.toFile(), packageDirName);
            pkgDir.mkdirs();

            for (JCCompilationUnit decl : topLevels) {
                JCClassDecl classDecl = (JCClassDecl) decl.getTypeDecls().get(0);
                File outFile
                        = new File(pkgDir, classDecl.getSimpleName().toString() + ".java");
                FileWriter writer = new FileWriter(outFile);
                writer.write(decl.toString());
                writer.flush();
                writer.close();
            }

            // package-info
            File outFile = new File(pkgDir, "package-info.java");
            FileWriter writer = new FileWriter(outFile);
            writer.write("/**\n");
            writer.write(documentifier.getDocGenerator().getPackageComment());
            writer.write("*/\n");
            writer.write("package " + packageName + ";\n");
            writer.flush();
            writer.close();

            // overview
            outFile = new File(pkgDir, "overview.html");
            writer = new FileWriter(outFile);
            writer.write("<html>\n");
            writer.write("<head>\n<title>" + packageName + "</title>\n</head>\n");
            writer.write("<body>\n");
            writer.write("<p>Package " + packageName + " overview.\n");
            writer.write("</body>\n");
            writer.write("</html>\n");
            writer.flush();
            writer.close();
        } catch (IOException e) {
            throw new RuntimeException("Error writing output");
        }
    }

    // levels' processing methods

    void processTopLevel(Element tlTag) {
        String kind = tlTag.getTagName();

        if (kind.equals("annodecl")) {
            // decls stored separately, does not affect bases
            String declId = tlTag.getAttribute("id");
            if (!declId.startsWith("@"))
                declId = "@" + declId;
            idAnnos.put(declId, processAnnoDecl(tlTag));
            return;
        }

        ListBuffer<JCTree>[] bases = processBases(tlTag, null);

        for (JCTree base : bases[0]) { // [0] - bases namely
            JCPackageDecl pkg = make.PackageDecl(
                                    List.<JCAnnotation>nil(),
                                    make.QualIdent(
                                        new Symbol.PackageSymbol(
                                            names.fromString(packageName),
                                            null)));
            ListBuffer<JCTree> topLevelParts = new ListBuffer<>();
            topLevelParts.append(pkg);
            topLevelParts.appendList(bases[1]); // [1] imports
            topLevelParts.append(base);

            JCCompilationUnit topLevel = make.TopLevel(topLevelParts.toList());
            documentifier.documentify(topLevel, fx);
            topLevels.add(topLevel);
        }
    }

    ListBuffer<JCTree>[] processBases(Element baseTag, HashMap<String, Integer> scope) {
        String kind = baseTag.getTagName();
        String baseName = baseTag.getAttribute("basename");
        String typeParam = baseTag.getAttribute("tparam");
        String baseId = baseTag.getAttribute("id");
        System.out.println("Found class id: " + baseId);

        long kindFlag = 0;
        switch (kind) {
            case "class":
                // no flags for class
                break;
            case "interface":
                kindFlag |= Flags.INTERFACE;
                break;
            case "enum":
                kindFlag |= Flags.ENUM;
                break;
            case "annotation":
                kindFlag |= Flags.ANNOTATION | Flags.INTERFACE;
                break;
        }

        // go through other nodes; add modifiers to multiplier
        NodeList nodes = baseTag.getChildNodes();
        ListBuffer<JCTree> bases = new ListBuffer<>();
        ListBuffer<JCTree> members = new ListBuffer<>();
        ListBuffer<JCTree> imports = new ListBuffer<>();
        JCExpression extType = null;
        ListBuffer<JCExpression> implTypes = new ListBuffer<>();
        SimpleMultiplier multiply = new SimpleMultiplier();
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);

            if (!(node instanceof Element))
                continue;
            Element element = (Element)node;
            switch (element.getTagName()) {
                case "modifier":
                    multiply.addAxis(element.getTextContent());
                    break;
                case "anno":
                    multiply.addAxis(element.getTextContent());
                    break;
                case "member":
                    // process members here
                    members.appendList(processMembers(element, baseName, kind));
                    break;
                case "extend":
                    String classId = element.getAttribute("id");   // this pkg
                    String classRef = element.getAttribute("ref"); // external
                    if (classId.length() !=0 &&
                        idBases.containsKey(classId)) {
                        // if have base, take methods from base members
                        JCClassDecl baseDecl = idBases.get(classId);
                        extType = make.Type(
                                      getTypeByName(
                                          baseDecl.getSimpleName().toString()));
                        members.appendList(processMethods(baseDecl.getMembers(), false));
                    } else if (classRef.length() !=0) {
                        extType = make.Type(getTypeByName(classRef));
                    }
                    break;
                case "implement":
                    String interfaceId = element.getAttribute("id");
                    String interfaceRef = element.getAttribute("ref");
                    if (interfaceId.length() != 0 &&
                        idBases.containsKey(interfaceId)) {
                        JCClassDecl baseDecl = idBases.get(interfaceId);
                        implTypes.add(
                            make.Type(
                                getTypeByName(
                                    baseDecl.getSimpleName().toString())));
                        members.appendList(processMethods(baseDecl.getMembers(), true));
                    } else if (interfaceRef.length() != 0) {
                        implTypes.add(make.Type(getTypeByName(interfaceRef)));
                    }
                    break;
                case "import":
                    imports.append(
                        make.Import(
                            make.Ident(names.fromString(element.getTextContent())),
                            false));
            }
        }

        // process modifiers through multiplier
        multiply.initIterator();
        while (multiply.hasNext()) {
            ArrayList<String> tuple = multiply.getNext();

            long declFlags = kindFlag;
            ListBuffer<JCAnnotation> annos = new ListBuffer<>();
            for (String modifier : tuple) {
                if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
                    annos.add(idAnnos.get(modifier)); // it's anno
                else
                    declFlags |= getFlagByName(modifier); // it's modifier
            }

            String declName = (scope == null)
                                  ? getUniqName(baseName)
                                  : baseName + getUniqIndex(scope, baseName);
            JCClassDecl baseDecl = make.ClassDef(
                                       make.Modifiers(declFlags, annos.toList()),
                                       names.fromString(declName),
                                       processTypeParams(typeParam), // type params
                                       extType,                      // ext
                                       implTypes.toList(),           // impl
                                       members.toList());            // members

            // fix constructors names
            fixConstructorNames(baseDecl);

            bases.append(baseDecl);

            // for non-empty ids store first base occurence from multiplied sequence
            if (baseId.length() != 0) {
                idBases.put(baseId, baseDecl);
                baseId = "";
            }
        }

        return new ListBuffer[] { bases, imports };
    }

    List<JCTypeParameter> processTypeParams(String typeParams) {

        if (typeParams == null || typeParams.length() == 0)
            return List.<JCTypeParameter>nil(); // empty

        String[] typeVarsArr = typeParams.split(",");
        ListBuffer<JCTypeParameter> typeParamsDecls = new ListBuffer<>();

        for (String typeVar : typeVarsArr) {
            typeParamsDecls.add(
                make.TypeParameter(names.fromString(typeVar),
                                    List.<JCExpression>nil()));
        }

        return typeParamsDecls.toList();
    }

    ListBuffer<JCTree> processMembers(Element memberTag, String name, String kind) {
        ListBuffer<JCTree> members = new ListBuffer<>();
        NodeList nodes = memberTag.getChildNodes();
        HashMap<String, Integer> scope = new HashMap<>();
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);

            if (!(node instanceof Element))
                continue;

            switch (((Element)node).getTagName()) {
                case "field":
                    members.appendList(processFields((Element)node, scope));
                    break;
                case "serialfield":
                    members.append(processSerialFields((Element)node));
                    break;
                case "constant":
                    members.appendList(processConstants((Element)node, scope));
                    break;
                case "constructor":
                    members.appendList(processMethods((Element)node, scope, true, true));
                    break;
                case "method":
                    boolean needBody = kind.equals("class") || kind.equals("enum");
                    members.appendList(processMethods((Element)node, scope, needBody, false));
                    break;
                case "class":
                case "interface":
                case "enum":
                case "annotation":
                    members.appendList(processBases((Element)node, scope)[0]);
                    break;
            }
        }

        return members;
    }

    ListBuffer<JCTree> processFields(Element fieldsNode, HashMap<String, Integer> scope) {
        String kind = fieldsNode.getTagName();
        String baseName = fieldsNode.getAttribute("basename");

        ListBuffer<JCTree> fields = new ListBuffer<>();
        NodeList nodes = fieldsNode.getChildNodes();
        SimpleMultiplier multiply = new SimpleMultiplier(); // for modifiers
        String[] types = new String[] {};
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);

            if (!(node instanceof Element))
                continue;

            // parse type and modifiers
            switch (((Element)node).getTagName()) {
                case "modifier":
                    multiply.addAxis(((Element)node).getTextContent());
                    break;
                case "anno":
                    multiply.addAxis(((Element)node).getTextContent());
                case "type":
                    types = ((Element)node).getTextContent().split("\\|");
                    break;
            }
        }

        // process through modifiers and types
        multiply.initIterator();
        while (multiply.hasNext()) {
            ArrayList<String> tuple = multiply.getNext();

            long declFlags = 0;
            ListBuffer<JCAnnotation> annos = new ListBuffer<>();
            for (String modifier : tuple) {
                if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
                    annos.add(idAnnos.get(modifier)); // it's anno
                else
                    declFlags |= getFlagByName(modifier); // it's modifier
            }


            for (String type : types) {
                String declName = baseName + getUniqIndex(scope, baseName);

                Type initType = getTypeByName(type);
                JCExpression initExpr = null;
                if ((declFlags & Flags.STATIC) != 0) // static to be initialized
                    initExpr = make.Literal(initType.isPrimitive() ?
                                             initType.getTag() :
                                             TypeTag.BOT,
                                             "String".equals(type)
                                                 ? new String("blah-blah-blah")
                                                 : Integer.valueOf(0));

                JCVariableDecl fieldDecl = make.VarDef(
                                               make.Modifiers(declFlags, annos.toList()),
                                               names.fromString(declName),
                                               make.Type(getTypeByName(type)),
                                               initExpr);

                fields.append(fieldDecl);
            }
        }

        return fields;
    }

    JCTree processSerialFields(Element sfNode) {
        String baseName = sfNode.getAttribute("basename");
        String[] fieldTypes = sfNode.getTextContent().split(",");

        ListBuffer<JCExpression> serialFields = new ListBuffer<>();
        HashMap<String, Integer> scope = new HashMap<>();

        for (String fType : fieldTypes) {
            String fieldName = baseName + getUniqIndex(scope, baseName);
            serialFields.add(
                make.NewClass(
                    null,
                    null,
                    make.Type(getTypeByName("ObjectStreamField")),
                    List.from(
                        new JCTree.JCExpression[] {
                            make.Literal(fieldName),
                            make.Ident(names.fromString(fType + ".class"))
                        }),
                    null));
        }

        JCTree sfDecl = make.VarDef(
                            make.Modifiers(
                                Flags.PRIVATE | Flags.STATIC | Flags.FINAL),
                            names.fromString("serialPersistentFields"),
                            make.TypeArray(
                                make.Type(getTypeByName("ObjectStreamField"))),
                            make.NewArray(
                                null,
                                List.<JCExpression>nil(),
                                serialFields.toList()));

        return sfDecl;
    }

    ListBuffer<JCTree> processConstants(Element constNode, HashMap<String, Integer> scope) {
        String baseName = constNode.getAttribute("basename");
        int count = 1;
        try {
            count = Integer.parseInt(constNode.getAttribute("count"));
        } catch (Exception e) {} // nothing to do, will use count = 1

        long declFlags = Flags.PUBLIC | Flags.STATIC | Flags.FINAL | Flags.ENUM;
        ListBuffer<JCTree> fields = new ListBuffer<>();

        for (int i = 0; i < count; i++) {
            String declName = baseName +
                              ((count == 1) ? "" : getUniqIndex(scope, baseName));

            JCVariableDecl constDecl = make.VarDef(
                                           make.Modifiers(declFlags),
                                           names.fromString(declName),
                                           null,  // no need for type in enum decl
                                           null); // no init

            fields.append(constDecl);
        }
        return fields;
    }

    ListBuffer<JCTree> processMethods(Element methodsNode, HashMap<String, Integer> scope, boolean needBody, boolean isConstructor) {
        String kind = methodsNode.getTagName();
        String baseName = methodsNode.getAttribute("basename");
        String name = methodsNode.getAttribute("name");
        String methodTypeParam = methodsNode.getAttribute("tparam");

        ListBuffer<JCTree> methods = new ListBuffer<>();
        NodeList nodes = methodsNode.getChildNodes();
        SimpleMultiplier multiply = new SimpleMultiplier(); // for modifiers
        String[] types = new String[0];
        String[] params = new String[] { "none" }; // default - no params
        ListBuffer<Type> throwTypes = new ListBuffer<>();
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);

            if (!(node instanceof Element))
                continue;

            // parse type and modifiers
            switch (((Element)node).getTagName()) {
                case "modifier":
                    multiply.addAxis(((Element)node).getTextContent());
                    break;
                case "anno":
                    multiply.addAxis(((Element)node).getTextContent());
                    break;
                case "type":
                    types = ((Element)node).getTextContent().split("\\|");
                    break;
                case "param":
                    params = ((Element)node).getTextContent().split("\\|");
                    break;
                case "throw":
                    throwTypes.add(
                        getTypeByName(((Element)node).getTextContent()));
                    break;

            }
        }

        // constructor?
        if (isConstructor) {
            baseName = "constructor";
            types = new String[] { "" };
        }

        // direct name not indexed
        boolean isDirectName = false;
        if (name.length() > 0) {
            baseName = name;
            isDirectName = true;
        }

        // process through modifiers and types
        multiply.initIterator();
        while (multiply.hasNext()) {
            ArrayList<String> tuple = multiply.getNext();

            long declFlags = 0;
            ListBuffer<JCAnnotation> annos = new ListBuffer<>();
            for (String modifier : tuple) {
                if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
                    annos.add(idAnnos.get(modifier)); // it's anno
                else
                    declFlags |= getFlagByName(modifier); // it's modifier
            }

            for (String type : types) {
                String declName = baseName
                                  + ((isConstructor || isDirectName)
                                     ? "" : getUniqIndex(scope, baseName));

                JCBlock body = null;
                if (needBody && (declFlags & Flags.ABSTRACT) == 0) { // create body
                    List<JCStatement> bodyStatements = List.<JCStatement>nil();
                    if (!type.equals("") && !type.equals("void")) { // create return statement
                        Type retType = getTypeByName(type);
                        bodyStatements = List.<JCStatement>of(
                                             make.Return(
                                                 make.Literal(
                                                     retType.isPrimitive() ?
                                                         retType.getTag() :
                                                         TypeTag.BOT,
                                                     Integer.valueOf(0))));
                    }
                    body = make.Block(0, bodyStatements);
                }

                // same method by different params (if they exist)
                for (String param : params) {

                    JCMethodDecl methodDecl =
                        make.MethodDef(
                            make.Modifiers(declFlags, annos.toList()),
                            names.fromString(declName),
                            isConstructor ? null : make.Type(getTypeByName(type)),
                            processTypeParams(methodTypeParam), // type params
                            null,                               // no receiver
                            processParams(param),               // formal params
                            make.Types(throwTypes.toList()),   // throws
                            body,
                            null);                              // no default value YET

                    methods.append(methodDecl);
                }
            }
        }

        return methods;
    }

    JCAnnotation processAnnoDecl(Element annoDeclNode) {
        String annoId = annoDeclNode.getAttribute("id");

        ListBuffer<JCExpression> args = new ListBuffer<>();
        String className = "";

        NodeList nodes = annoDeclNode.getChildNodes();
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);

            if (!(node instanceof Element))
                continue;

            switch (((Element)node).getTagName()) {
                case "class":
                    className = ((Element)node).getTextContent();
                    break;
                case "arg":
                    String argName = ((Element)node).getAttribute("name");
                    String argValue = ((Element)node).getAttribute("value");

                    JCExpression arg;
                    if (argName.length() == 0)
                        arg = make.Ident(names.fromString(argValue));
                    else
                        arg = make.Assign(
                                  make.Ident(names.fromString(argName)),
                                  make.Ident(names.fromString(argValue)));

                    args.add(arg);
                    break;
            }
        }

        return make.Annotation(
                   make.Ident(names.fromString(className)),
                   args.toList());
    }

    ListBuffer<JCTree> processMethods(List<JCTree> tree, boolean needBody) {
        // for "extends" clause; returns methods only
        ListBuffer<JCTree> methods = new ListBuffer<>();
        for (JCTree memberDecl : tree) {
            if (memberDecl instanceof JCMethodDecl) {
                JCMethodDecl methodDecl = (JCMethodDecl)memberDecl;
                JCTree retTypeTree = methodDecl.getReturnType();

                // skip constructors
                if (retTypeTree == null)
                    continue;

                if (needBody) {
                    // here we need to 'implement' interface declared methods
                    Type retType = retTypeTree.type;

                    List<JCStatement> bodyStatements = List.<JCStatement>nil();
                    if (retType.getTag() != TypeTag.VOID)
                        bodyStatements = List.<JCStatement>of(
                                             make.Return(
                                                 make.Literal(
                                                     retType.isPrimitive() ?
                                                         retType.getTag() :
                                                         TypeTag.BOT,
                                                     Integer.valueOf(0))));

                    JCBlock body = make.Block(0, bodyStatements);

                    methodDecl = make.MethodDef(
                                     methodDecl.getModifiers(),
                                     methodDecl.getName(),
                                     (JCExpression)methodDecl.getReturnType(),
                                     methodDecl.getTypeParameters(),
                                     methodDecl.getReceiverParameter(),
                                     methodDecl.getParameters(),
                                     methodDecl.getThrows(),
                                     body,
                                     (JCExpression)methodDecl.getDefaultValue());
                }

                methods.add(methodDecl);
            }
        }
        return methods;
    }

    void fixConstructorNames(JCClassDecl baseDecl) {
        ListBuffer<JCTree> newMembers = new ListBuffer<>();
        List<JCTree> members = baseDecl.getMembers();
        Name name = baseDecl.getSimpleName();

        for (JCTree memberDecl : members) {
            JCTree newDecl = memberDecl;

            if (memberDecl instanceof JCMethodDecl) {
                JCMethodDecl methodDecl = (JCMethodDecl)memberDecl;
                JCTree retTypeTree = methodDecl.getReturnType();

                if (retTypeTree == null)
                    newDecl = make.MethodDef(
                                  methodDecl.getModifiers(),
                                  name,
                                  (JCExpression)methodDecl.getReturnType(),
                                  methodDecl.getTypeParameters(),
                                  methodDecl.getReceiverParameter(),
                                  methodDecl.getParameters(),
                                  methodDecl.getThrows(),
                                  methodDecl.getBody(),
                                  (JCExpression)methodDecl.getDefaultValue());
            }

            newMembers.add(newDecl);
        }

        baseDecl.defs = newMembers.toList();
    }

    List<JCVariableDecl> processParams(String paramTypes) {

        if ("none".equals(paramTypes))
            return List.<JCVariableDecl>nil(); // empty

        String[] typesArr = paramTypes.split(",(?!(\\w+,)*\\w+>)");
        ListBuffer<JCVariableDecl> paramsDecls = new ListBuffer<>();

        int i = 0;
        for (String typeName : typesArr) {
            String paramName = "param"
                               + (typesArr.length == 1 ? "" : String.valueOf(i));
            paramsDecls.add(
                make.VarDef(make.Modifiers(0),
                             names.fromString(paramName),
                             make.Type(getTypeByName(typeName)),
                             null));
            i++;
        }

        return paramsDecls.toList();
    }

    //
    // util methods
    //

    String getUniqName(String name) {
        if (!nameIndex.containsKey(name))
            nameIndex.put(name, 0);
        Integer index = nameIndex.get(name);
        String uniqName = name + index;
        nameIndex.put(name, index + 1);
        return uniqName;
    }

    int getUniqIndex(HashMap<String, Integer> scope, String name) {
        if (!scope.containsKey(name))
            scope.put(name, 0);
        Integer index = scope.get(name);
        scope.put(name, index + 1);
        return index;
    }

    long getFlagByName(String modifierName) {
        switch (modifierName) {
            case "public":
                return Flags.PUBLIC;
            case "private":
                return Flags.PRIVATE;
            case "protected":
                return Flags.PROTECTED;
            case "static":
                return Flags.STATIC;
            case "final":
                return Flags.FINAL;
            case "abstract":
                return Flags.ABSTRACT;
            case "strictfp":
                return Flags.STRICTFP;
            default:
                return 0;
        }
    }

    Type getTypeByName(String typeName) {
        //check for primitive types
        switch (typeName) {
            case "void":
                return syms.voidType;
            case "boolean":
                return syms.booleanType;
            case "byte":
                return syms.byteType;
            case "char":
                return syms.charType;
            case "double":
                return syms.doubleType;
            case "float":
                return syms.floatType;
            case "int":
                return syms.intType;
            case "long":
                return syms.longType;
            default:
                return getTypeByName(typeName, List.<Type>nil());
        }
    }

    Type getTypeByName(String typeName, List<Type> tparams) {
        return new Type.ClassType(
                   Type.noType,
                   tparams,
                   new Symbol.ClassSymbol(0, names.fromString(typeName), null));
    }
}