/*
 * Copyright (c) 2009, 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 com.sun.classanalyzer;

import com.sun.tools.classfile.*;
import com.sun.tools.classfile.Type.*;
import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
import static com.sun.tools.classfile.AccessFlags.*;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

/**
 *
 * @author Mandy Chung
 */
public class ClassFileParser {

    final Klass this_klass;
    final ClassFile classfile;
    final ConstantPoolParser constantPoolParser;
    final AnnotationParser annotationParser;
    final CodeAttributeParser codeAttributeParser;
    private final boolean buildDeps;

    protected ClassFileParser(InputStream in, long size, boolean buildDeps) throws IOException {
        try {
            this.classfile = ClassFile.read(in);
            this.this_klass = getKlass(this.classfile);
            this.buildDeps = buildDeps;
            this.constantPoolParser = new ConstantPoolParser(this);
            this.annotationParser = new AnnotationParser(this);
            this.codeAttributeParser = new CodeAttributeParser(this);
        } catch (ConstantPoolException ex) {
            throw new RuntimeException(ex);
        }
    }

    private Klass getKlass(ClassFile cf) throws ConstantPoolException {
        Klass k = Klass.getKlass(cf.getName());
        k.setAccessFlags(cf.access_flags.flags);
        k.setFileSize(cf.byteLength());
        return k;
    }

    public static ClassFileParser newParser(InputStream in, long size, boolean buildDeps) throws IOException {
        return new ClassFileParser(in, size, buildDeps);
    }

    public static ClassFileParser newParser(String classPathname, boolean buildDeps) throws IOException {
        return newParser(new File(classPathname), buildDeps);
    }

    public static ClassFileParser newParser(File f, boolean buildDeps) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(f));
        try {
            return newParser(in, f.length(), buildDeps);
        } finally {
            in.close();
        }
    }

    public void parseDependency(boolean publicAPIs) throws IOException {
        if (publicAPIs && !classfile.access_flags.is(ACC_PUBLIC)) {
            // process public APIs only
            return;
        }

        parseClassInfo();
        if (!publicAPIs) {
            // parse all references in the classfile
            constantPoolParser.parseDependency();
        }
        parseMethods(publicAPIs);
        parseFields(publicAPIs);
    }

    void parseClassInfo() throws IOException {
        ConstantPool cpool = classfile.constant_pool;
        try {
            Signature_attribute sigAttr = (Signature_attribute) classfile.attributes.get(Attribute.Signature);
            if (sigAttr == null) {
                // use info from class file header
                if (classfile.isClass() && classfile.super_class != 0) {
                    String sn = classfile.getSuperclassName();
                    addExtends(sn);
                }
                for (int i = 0; i < classfile.interfaces.length; i++) {
                    String interf = classfile.getInterfaceName(i);
                    if (classfile.isClass()) {
                        addImplements(interf);
                    } else {
                        addExtends(interf);
                    }
                }
            } else {
                Type t = sigAttr.getParsedSignature().getType(cpool);
                // The signature parser cannot disambiguate between a
                // FieldType and a ClassSignatureType that only contains a superclass type.
                if (t instanceof Type.ClassSigType) {
                    Type.ClassSigType cst = Type.ClassSigType.class.cast(t);
                    if (cst.superclassType != null) {
                        for (Klass k : getKlass(cst.superclassType)) {
                            addExtends(k);
                        }
                    }
                    if (cst.superinterfaceTypes != null) {
                        for (Type t1 : cst.superinterfaceTypes) {
                            for (Klass k : getKlass(t1)) {
                                addImplements(k);
                            }
                        }
                    }
                } else {
                    for (Klass k : getKlass(t)) {
                        addExtends(k);
                    }
                }
            }
            // parse attributes
            annotationParser.parseAttributes(classfile.attributes);
        } catch (ConstantPoolException ex) {
            throw new RuntimeException(ex);
        }
    }

    private void parseFields(boolean publicAPIs) throws IOException {
        ConstantPool cpool = classfile.constant_pool;
        for (Field f : classfile.fields) {
            try {
                AccessFlags flags = f.access_flags;
                if (publicAPIs && !flags.is(ACC_PUBLIC) && !flags.is(ACC_PROTECTED)) {
                    continue;
                }
                String fieldname = f.getName(cpool);
                Signature_attribute sigAttr = (Signature_attribute) f.attributes.get(Attribute.Signature);

                if (sigAttr == null) {
                    Set<Klass> types = parseDescriptor(f.descriptor);
                    String info = getFlag(flags) + " " + f.descriptor.getFieldType(cpool) + " " + fieldname;
                    addFieldTypes(types, info, flags);
                } else {
                    Type t = sigAttr.getParsedSignature().getType(cpool);
                    String info = getFlag(flags) + " " + t + " " + fieldname;
                    addFieldTypes(getKlass(t), info, flags);
                }
                // parse attributes
                annotationParser.parseAttributes(f.attributes);
            } catch (ConstantPoolException ex) {
                throw new RuntimeException(ex);
            } catch (InvalidDescriptor ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    private void parseMethods(boolean publicAPIs) {
        for (Method m : classfile.methods) {
            if (publicAPIs && !m.access_flags.is(ACC_PUBLIC) && !m.access_flags.is(ACC_PROTECTED)) {
                // only interest in the API level
                return;
            }

            parseMethod(m);
        }
    }

    String checkClassName(String classname) {
        int i = 0;
        while (i < classname.length()) {
            switch (classname.charAt(i)) {
                case 'Z':
                case 'B':
                case 'C':
                case 'S':
                case 'I':
                case 'J':
                case 'F':
                case 'D':
                    return "";
                case 'L':
                    if (!classname.endsWith(";")) {
                        throw new RuntimeException("Invalid classname " + classname);
                    }
                    return classname.substring(i + 1, classname.length() - 1);
                case '[':
                    i++;
                    break;
                default:
                    if (classname.endsWith(";")) {
                        throw new RuntimeException("Invalid classname " + classname);
                    }
                    return classname;

            }
        }
        throw new RuntimeException("Invalid classname " + classname);
    }

    private void addExtends(String classname) throws IOException {
        if (!buildDeps) {
            return;
        }

        addExtends(Klass.getKlass(classname));
    }

    private void addExtends(Klass k) {
        if (!buildDeps) {
            return;
        }

        ResolutionInfo resInfo = ResolutionInfo.resolvedExtends(this_klass, k);
        resInfo.setPublicAccess(classfile.access_flags.is(ACC_PUBLIC));
        this_klass.addDep(k, resInfo);
        k.addReferrer(this_klass, resInfo);
    }

    private void addImplements(String classname) throws IOException {
        if (!buildDeps) {
            return;
        }

        addImplements(Klass.getKlass(classname));
    }

    private void addImplements(Klass k) {
        if (!buildDeps) {
            return;
        }

        ResolutionInfo resInfo = ResolutionInfo.resolvedImplements(this_klass, k);
        resInfo.setPublicAccess(classfile.access_flags.is(ACC_PUBLIC));

        this_klass.addDep(k, resInfo);

        k.addReferrer(this_klass, resInfo);
    }

    private Set<Klass> getKlass(Type type) throws IOException {
        Set<Klass> refTypes = new TreeSet<Klass>();
        if (!buildDeps) {
            return refTypes;
        }

        type.accept(typevisitor, refTypes);
        return refTypes;
    }
    private Type.Visitor<Void, Set<Klass>> typevisitor = new Type.Visitor<Void, Set<Klass>>() {

        public Void visitSimpleType(SimpleType type, Set<Klass> klasses) {
            // nop
            return null;
        }

        public Void visitArrayType(ArrayType type, Set<Klass> klasses) {
            try {
                klasses.addAll(getKlass(type.elemType));
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
            return null;

        }

        public Void visitMethodType(MethodType type, Set<Klass> klasses) {
            throw new InternalError("Unexpected type " + type);
        }

        public Void visitClassSigType(ClassSigType type, Set<Klass> klasses) {
            try {
                if (type.superclassType != null) {
                    klasses.addAll(getKlass(type.superclassType));
                }
                if (type.superinterfaceTypes != null) {
                    for (Type t : type.superinterfaceTypes) {
                        klasses.addAll(getKlass(t));
                    }
                }
                if (type.typeParamTypes != null) {
                    for (Type t : type.typeParamTypes) {
                        klasses.addAll(getKlass(t));
                    }
                }
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
            return null;
        }

        public Void visitClassType(ClassType type, Set<Klass> klasses) {
            klasses.add(Klass.getKlass(type.getBinaryName()));
            if (type.typeArgs != null) {
                for (Type t : type.typeArgs) {
                    try {
                        klasses.addAll(getKlass(t));
                    } catch (IOException ex) {
                        throw new RuntimeException(ex);
                    }
                }
            }
            return null;

        }

        public Void visitTypeParamType(TypeParamType type, Set<Klass> klasses) {
            try {
                if (type.classBound != null) {
                    klasses.addAll(getKlass(type.classBound));
                }
                if (type.interfaceBounds != null) {
                    for (Type t : type.interfaceBounds) {
                        klasses.addAll(getKlass(t));
                    }
                }

            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }

            return null;

        }

        public Void visitWildcardType(WildcardType type, Set<Klass> klasses) {
            if (type.boundType != null) {
                try {
                    klasses.addAll(getKlass(type.boundType));
                } catch (IOException ex) {
                    throw new RuntimeException(ex);
                }
            }
            return null;

        }
    };

    private void printMethod(Method m) {
        try {
            System.out.println("parsing " + m.getName(classfile.constant_pool) + "(" +
                    m.descriptor.getParameterTypes(classfile.constant_pool) + ") return type " +
                    m.descriptor.getReturnType(classfile.constant_pool));

        } catch (ConstantPoolException ex) {
        } catch (InvalidDescriptor ex) {
        }
    }

    private static StringBuilder appendWord(StringBuilder sb, String word) {
        if (sb.length() > 0) {
            sb.append(" ");
        }
        sb.append(word);
        return sb;
    }

    private static String getFlag(AccessFlags flags) {
        StringBuilder modifier = new StringBuilder();
        if (flags.is(ACC_PUBLIC)) {
            modifier.append("public");
        }
        if (flags.is(ACC_PRIVATE)) {
            modifier.append("private");
        }
        if (flags.is(ACC_PROTECTED)) {
            modifier.append("protected");
        }
        if (flags.is(ACC_STATIC)) {
            appendWord(modifier, "static");
        }
        if (flags.is(ACC_FINAL)) {
            appendWord(modifier, "final");
        }
        if (flags.is(ACC_SYNCHRONIZED)) {
            // return "synchronized";
        }
        if (flags.is(0x80)) {
            // return (t == Type.Field ? "transient" : null);
            // return "transient";
        }
        if (flags.is(ACC_VOLATILE)) {
            // return "volatile";
        }
        if (flags.is(ACC_NATIVE)) {
            // return "native";
        }
        if (flags.is(ACC_ABSTRACT)) {
            appendWord(modifier, "abstract");
        }
        if (flags.is(ACC_STRICT)) {
            // return "strictfp";
        }
        if (flags.is(ACC_MODULE)) {
            appendWord(modifier, "module");
        }
        return modifier.toString();
    }

    private Klass.Method toKlassMethod(Method m, Descriptor d) {
        try {
            ConstantPool cpool = classfile.constant_pool;
            String methodname = m.getName(cpool);
            StringBuilder sb = new StringBuilder();
            sb.append(getFlag(m.access_flags));
            if (methodname.equals("<init>")) {
                String s = this_klass.getBasename() + d.getParameterTypes(cpool);
                appendWord(sb, s);
            } else if (methodname.equals("<clinit>")) {
                // <clinit>
                appendWord(sb, methodname);
            } else {
                String s = d.getReturnType(cpool) + " " + methodname + d.getParameterTypes(cpool);
                appendWord(sb, s);
            }
            String signature = sb.toString().replace('/', '.');
            return this_klass.getMethod(methodname, signature);
        } catch (ConstantPoolException ex) {
            throw new RuntimeException(ex);
        } catch (InvalidDescriptor ex) {
            throw new RuntimeException(ex);
        }
    }

    Klass.Method parseMethod(Method m) {
        AccessFlags flags = m.access_flags;
        Descriptor d;
        List<? extends Type> methodExceptions = null;
        try {
            ConstantPool cpool = classfile.constant_pool;
            Klass.Method kmethod;
            Signature_attribute sigAttr = (Signature_attribute) m.attributes.get(Attribute.Signature);
            if (sigAttr == null) {
                d = m.descriptor;
                Set<Klass> types = parseDescriptor(d);

                kmethod = toKlassMethod(m, d);
                addMethodTypes(types, kmethod, flags);
            } else {
                Type.MethodType methodType;
                Signature methodSig = sigAttr.getParsedSignature();
                d = methodSig;
                try {
                    kmethod = toKlassMethod(m, d);
                    methodType = (Type.MethodType) methodSig.getType(cpool);
                    addMethodTypes(getKlass(methodType.returnType), kmethod, flags);
                    if (methodType.paramTypes != null) {
                        for (Type t : methodType.paramTypes) {
                            addMethodTypes(getKlass(t), kmethod, flags);
                        }
                    }
                    if (methodType.typeParamTypes != null) {
                        for (Type t : methodType.typeParamTypes) {
                            addMethodTypes(getKlass(t), kmethod, flags);
                        }
                    }

                    methodExceptions = methodType.throwsTypes;
                    if (methodExceptions != null) {
                        if (methodExceptions.size() == 0) {
                            methodExceptions = null;
                        } else {
                            for (Type t : methodExceptions) {
                                addCheckedExceptionTypes(getKlass(t), kmethod, flags);
                            }
                        }
                    }
                } catch (ConstantPoolException e) {
                    throw new RuntimeException(e);
                }
            }

            Attribute e_attr = m.attributes.get(Attribute.Exceptions);
            if (e_attr != null && methodExceptions == null) {
                // if there are generic exceptions, there must be erased exceptions
                if (e_attr instanceof Exceptions_attribute) {
                    Exceptions_attribute exceptions = (Exceptions_attribute) e_attr;
                    for (int i = 0; i < exceptions.number_of_exceptions; i++) {
                        String classname = checkClassName(exceptions.getException(i, classfile.constant_pool));
                        if (classname.length() > 0 && buildDeps) {
                            Klass to = Klass.getKlass(classname);
                            ResolutionInfo resInfo = ResolutionInfo.resolvedCheckedException(this_klass, to, kmethod);
                            resInfo.setPublicAccess(flags.is(ACC_PUBLIC));

                            this_klass.addDep(to, resInfo);
                            to.addReferrer(this_klass, resInfo);
                        }
                    }
                } else {
                    throw new RuntimeException("Invalid attribute: " + e_attr);
                }
            }

            Code_attribute c_attr = (Code_attribute) m.attributes.get(Attribute.Code);
            if (c_attr != null) {
                codeAttributeParser.parse(c_attr, kmethod);
            }
            kmethod.isAbstract = classfile.access_flags.is(ACC_ABSTRACT);
            kmethod.setCodeLength(m.byteLength());

            // parse annotation attributes
            annotationParser.parseAttributes(m.attributes, kmethod);
            return kmethod;
        } catch (ConstantPoolException ex) {
            throw new RuntimeException(ex);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }

    private void addFieldTypes(Set<Klass> types, String info, AccessFlags flags) {
        if (types.isEmpty() || !buildDeps) {
            return;
        }

        for (Klass to : types) {
            ResolutionInfo resInfo = ResolutionInfo.resolvedField(this_klass, to, info);
            resInfo.setPublicAccess(flags.is(ACC_PUBLIC));

            this_klass.addDep(to, resInfo);
            to.addReferrer(this_klass, resInfo);
        }
    }

    private void addReferencedTypes(Method m, Descriptor d, AccessFlags flags) {
        Set<Klass> types = parseDescriptor(d);

        Klass.Method method = toKlassMethod(m, d);
        addMethodTypes(types, method, flags);
    }

    private void addMethodTypes(Set<Klass> types, Klass.Method method, AccessFlags flags) {
        if (types.isEmpty() || !buildDeps) {
            return;
        }
        for (Klass to : types) {
            ResolutionInfo resInfo = ResolutionInfo.resolvedMethodSignature(this_klass, to, method);
            resInfo.setPublicAccess(flags.is(ACC_PUBLIC));

            this_klass.addDep(to, resInfo);
            to.addReferrer(this_klass, resInfo);
        }
    }

    private void addCheckedExceptionTypes(Set<Klass> types, Klass.Method method, AccessFlags flags) {
        if (types.isEmpty() || !buildDeps) {
            return;
        }
        for (Klass to : types) {
            ResolutionInfo resInfo = ResolutionInfo.resolvedCheckedException(this_klass, to, method);
            resInfo.setPublicAccess(flags.is(ACC_PUBLIC));

            this_klass.addDep(to, resInfo);
            to.addReferrer(this_klass, resInfo);
        }
    }

    private Set<Klass> parseDescriptor(Descriptor d) {
        Set<Klass> types = new TreeSet<Klass>();
        try {
            String desc = d.getValue(classfile.constant_pool);
            int p = 0;
            while (p < desc.length()) {
                String type;
                char ch;
                switch (ch = desc.charAt(p++)) {
                    case '(':
                    case ')':
                    case '[':
                    case 'B':
                    case 'C':
                    case 'D':
                    case 'F':
                    case 'I':
                    case 'J':
                    case 'S':
                    case 'Z':
                    case 'V':
                        continue;
                    case 'L':
                        int sep = desc.indexOf(';', p);
                        if (sep == -1) {
                            throw new RuntimeException("Invalid descriptor: " + (p - 1) + " " + desc);
                        }
                        type = checkClassName(desc.substring(p, sep));
                        p = sep + 1;
                        break;
                    default:
                        throw new RuntimeException("Invalid descriptor: " + (p - 1) + " " + desc);
                }

                if (!type.isEmpty() && buildDeps) {
                    Klass to = Klass.getKlass(type);
                    types.add(to);

                }
            }
        } catch (ConstantPoolException ex) {
            throw new RuntimeException(ex);
        }
        return types;
    }
}