/*

 * 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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 xmlkit; // -*- mode: java; indent-tabs-mode: nil -*-

import com.sun.tools.classfile.AccessFlags;

import com.sun.tools.classfile.Annotation;

import com.sun.tools.classfile.Annotation.Annotation_element_value;

import com.sun.tools.classfile.Annotation.Array_element_value;

import com.sun.tools.classfile.Annotation.Class_element_value;

import com.sun.tools.classfile.Annotation.Enum_element_value;

import com.sun.tools.classfile.Annotation.Primitive_element_value;

import com.sun.tools.classfile.AnnotationDefault_attribute;

import com.sun.tools.classfile.Attribute;

import com.sun.tools.classfile.Attributes;

import com.sun.tools.classfile.BootstrapMethods_attribute;

import com.sun.tools.classfile.CharacterRangeTable_attribute;

import com.sun.tools.classfile.ClassFile;

import com.sun.tools.classfile.Code_attribute;

import com.sun.tools.classfile.CompilationID_attribute;

import com.sun.tools.classfile.ConstantPool;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Fieldref_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_InterfaceMethodref_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_InvokeDynamic_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodHandle_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodType_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Methodref_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_NameAndType_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;

import com.sun.tools.classfile.ConstantPool.CPInfo;

import com.sun.tools.classfile.ConstantPool.InvalidIndex;

import com.sun.tools.classfile.ConstantPoolException;

import com.sun.tools.classfile.ConstantValue_attribute;

import com.sun.tools.classfile.DefaultAttribute;

import com.sun.tools.classfile.Deprecated_attribute;

import com.sun.tools.classfile.Descriptor.InvalidDescriptor;

import com.sun.tools.classfile.EnclosingMethod_attribute;

import com.sun.tools.classfile.Exceptions_attribute;

import com.sun.tools.classfile.Field;

import com.sun.tools.classfile.InnerClasses_attribute;

import com.sun.tools.classfile.InnerClasses_attribute.Info;

import com.sun.tools.classfile.Instruction;

import com.sun.tools.classfile.Instruction.TypeKind;

import com.sun.tools.classfile.LineNumberTable_attribute;

import com.sun.tools.classfile.LocalVariableTable_attribute;

import com.sun.tools.classfile.LocalVariableTypeTable_attribute;

import com.sun.tools.classfile.Method;

import com.sun.tools.classfile.MethodParameters_attribute;

import com.sun.tools.classfile.Module_attribute;

import com.sun.tools.classfile.Module_attribute.ExportsEntry;

import com.sun.tools.classfile.Module_attribute.ProvidesEntry;

import com.sun.tools.classfile.Module_attribute.RequiresEntry;

import com.sun.tools.classfile.Opcode;

import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;

import com.sun.tools.classfile.Signature_attribute;

import com.sun.tools.classfile.SourceDebugExtension_attribute;

import com.sun.tools.classfile.SourceFile_attribute;

import com.sun.tools.classfile.SourceID_attribute;

import com.sun.tools.classfile.StackMapTable_attribute;

import com.sun.tools.classfile.StackMapTable_attribute.append_frame;

import com.sun.tools.classfile.StackMapTable_attribute.chop_frame;

import com.sun.tools.classfile.StackMapTable_attribute.full_frame;

import com.sun.tools.classfile.StackMapTable_attribute.same_frame;

import com.sun.tools.classfile.StackMapTable_attribute.same_frame_extended;

import com.sun.tools.classfile.StackMapTable_attribute.same_locals_1_stack_item_frame;

import com.sun.tools.classfile.StackMapTable_attribute.same_locals_1_stack_item_frame_extended;

import com.sun.tools.classfile.StackMap_attribute;

import com.sun.tools.classfile.Synthetic_attribute;

import com.sun.tools.classfile.TypeAnnotation;

import com.sun.tools.classfile.TypeAnnotation.Position;

import static com.sun.tools.classfile.TypeAnnotation.TargetType.THROWS;

import java.io.*;

import java.util.*;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import xmlkit.XMLKit.Element;

/*

 * @author jrose, ksrini

 */

public class ClassReader {

    private static final CommandLineParser CLP = new CommandLineParser(""

            + "-source:     +> = \n"

            + "-dest:       +> = \n"

            + "-encoding:   +> = \n"

            + "-jcov           $ \n   -nojcov         !-jcov        \n"

            + "-verbose        $ \n   -noverbose      !-verbose     \n"

            + "-keepPath       $ \n   -nokeepPath     !-keepPath    \n"

            + "-keepCP         $ \n   -nokeepCP       !-keepCP      \n"

            + "-keepOrder      $ \n   -nokeepOrder    !-keepOrder   \n"

            + "-continue       $ \n   -nocontinue     !-continue    \n"

            + "-@         >-@  . \n"

            + "-              +? \n"

            + "\n");

    // Protected state for representing the class file.

    protected Element cfile;          // <ClassFile ...>

    protected Element cpool;          // <ConstantPool ...>

    protected Element klass;          // <Class ...>

    protected List<String> thePool;    // stringified flattened Constant Pool

    public static void main(String[] ava) throws IOException {

        ArrayList<String> av = new ArrayList<>(Arrays.asList(ava));

        HashMap<String, String> props = new HashMap<>();

        props.put("-encoding:", "UTF8");  // default

        props.put("-keepOrder", null);    // CLI default

        props.put("-pretty", "1");     // CLI default

        props.put("-continue", "1");     // CLI default

        CLP.parse(av, props);

        //System.out.println(props+" ++ "+av);

        File source = asFile(props.get("-source:"));

        File dest = asFile(props.get("-dest:"));

        String encoding = props.get("-encoding:");

        boolean contError = props.containsKey("-continue");

        ClassReader options = new ClassReader();

        options.copyOptionsFrom(props);

        /*

        if (dest == null && av.size() > 1) {

        dest = File.createTempFile("TestOut", ".dir", new File("."));

        dest.delete();

        if (!dest.mkdir())

        throw new RuntimeException("Cannot create "+dest);

        System.out.println("Writing results to "+dest);

        }

         */

        if (av.isEmpty()) {

            av.add("");  //to enter this loop

        }

        boolean readList = false;

        for (String a : av) {

            if (readList) {

                readList = false;

                InputStream fin;

                if (a.equals("-")) {

                    fin = System.in;

                } else {

                    fin = new FileInputStream(a);

                }

                BufferedReader files = makeReader(fin, encoding);

                for (String file; (file = files.readLine()) != null;) {

                    doFile(file, source, dest, options, encoding, contError);

                }

                if (fin != System.in) {

                    fin.close();

                }

            } else if (a.equals("-@")) {

                readList = true;

            } else if (a.startsWith("-")) {

                throw new RuntimeException("Bad flag argument: " + a);

            } else if (source.getName().endsWith(".jar")) {

                doJar(a, source, dest, options, encoding, contError);

            } else {

                doFile(a, source, dest, options, encoding, contError);

            }

        }

    }

    private static File asFile(String str) {

        return (str == null) ? null : new File(str);

    }

    private static void doFile(String a,

            File source, File dest,

            ClassReader options, String encoding,

            boolean contError) throws IOException  {

        if (!contError) {

            doFile(a, source, dest, options, encoding);

        } else {

            try {

                doFile(a, source, dest, options, encoding);

            } catch (Exception ee) {

                System.out.println("Error processing " + source + ": " + ee);

                ee.printStackTrace();

            }

        }

    }

    private static void doJar(String a, File source, File dest,

                              ClassReader options, String encoding,

                              Boolean contError) throws IOException {

        try {

            JarFile jf = new JarFile(source);

            for (JarEntry je : Collections.list(jf.entries())) {

                String name = je.getName();

                if (!name.endsWith(".class")) {

                    continue;

                }

                try {

                    doStream(name, jf.getInputStream(je), dest, options, encoding);

                } catch (Exception e) {

                    if (contError) {

                        System.out.println("Error processing " + source + ": " + e);

                        e.printStackTrace();

                        continue;

                    }

                }

            }

        } catch (IOException ioe) {

            throw ioe;

        }

    }

    private static void doStream(String a, InputStream in, File dest,

                                 ClassReader options, String encoding) throws IOException {

        File f = new File(a);

        ClassReader cr = new ClassReader(options);

        Element e;

        if (options.verbose) {

            System.out.println("Reading " + f);

        }

        e = cr.readFrom(in);

        OutputStream out;

        if (dest == null) {

            out = System.out;

        } else {

            File outf = new File(dest, f.isAbsolute() ? f.getName() : f.getPath());

            String outName = outf.getName();

            File outSubdir = outf.getParentFile();

            outSubdir.mkdirs();

            int extPos = outName.lastIndexOf('.');

            if (extPos > 0) {

                outf = new File(outSubdir, outName.substring(0, extPos) + ".xml");

            }

            out = new FileOutputStream(outf);

        }

        Writer outw = makeWriter(out, encoding);

        if (options.pretty || !options.keepOrder) {

            e.writePrettyTo(outw);

        } else {

            e.writeTo(outw);

        }

        if (out == System.out) {

            outw.write("\n");

            outw.flush();

        } else {

            outw.close();

        }

    }

    private static void doFile(String a,

            File source, File dest,

            ClassReader options, String encoding) throws IOException {

        File inf = new File(source, a);

        if (dest != null && options.verbose) {

            System.out.println("Reading " + inf);

        }

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(inf));

        doStream(a, in, dest, options, encoding);

    }

    public static BufferedReader makeReader(InputStream in,

                                            String encoding) throws IOException {

        Reader inw;

        in = new BufferedInputStream(in);  // add buffering

        if (encoding == null) {

            inw = new InputStreamReader(in);

        } else {

            inw = new InputStreamReader(in, encoding);

        }

        return new BufferedReader(inw);  // add buffering

    }

    public static Writer makeWriter(OutputStream out,

                                    String encoding) throws IOException {

        Writer outw;

        if (encoding == null) {

            outw = new OutputStreamWriter(out);

        } else {

            outw = new OutputStreamWriter(out, encoding);

        }

        return new BufferedWriter(outw);  // add buffering

    }

    public Element result() {

        return cfile;

    }

    protected InputStream in;

    protected ByteArrayOutputStream buf = new ByteArrayOutputStream(1024);

    // input options

    public boolean pretty = false;

    public boolean verbose = false;

    public boolean keepPath = false;

    public boolean keepCP = false;

    public boolean keepBytes = false;

    public boolean parseBytes = true;

    public boolean resolveRefs = true;

    public boolean keepOrder = true;

    public boolean keepSizes = false;

    public ClassReader() {

        cfile = new Element("ClassFile");

    }

    public ClassReader(ClassReader options) {

        this();

        copyOptionsFrom(options);

    }

    public void copyOptionsFrom(ClassReader options) {

        pretty = options.pretty;

        verbose = options.verbose;

        keepPath = options.keepPath;

        keepCP = options.keepCP;

        keepOrder = options.keepOrder;

    }

    public void copyOptionsFrom(Map<String, String> options) {

        if (options.containsKey("-pretty")) {

            pretty = (options.get("-pretty") != null);

        }

        if (options.containsKey("-verbose")) {

            verbose = (options.get("-verbose") != null);

        }

        if (options.containsKey("-keepPath")) {

            keepPath = (options.get("-keepPath") != null);

        }

        if (options.containsKey("-keepCP")) {

            keepCP = (options.get("-keepCP") != null);

        }

        if (options.containsKey("-keepOrder")) {

            keepOrder = (options.get("-keepOrder") != null);

        }

    }

    protected String getCpString(int i) {

        return thePool.get(i);

    }

    public Element readFrom(InputStream in) throws IOException {

        try {

            this.in = in;

            ClassFile c = ClassFile.read(in);

            // read the file header

            if (c.magic != 0xCAFEBABE) {

                throw new RuntimeException("bad magic number " +

                        Integer.toHexString(c.magic));

            }

            cfile.setAttr("magic", "" + c.magic);

            int minver = c.minor_version;

            int majver = c.major_version;

            cfile.setAttr("minver", "" + minver);

            cfile.setAttr("majver", "" + majver);

            readCP(c);

            readClass(c);

            return result();

        } catch (InvalidDescriptor | ConstantPoolException ex) {

            throw new IOException("Fatal error", ex);

        }

    }

    public Element readFrom(File file) throws IOException {

        try (InputStream strm = new FileInputStream(file)) {

            Element e = readFrom(new BufferedInputStream(strm));

            if (keepPath) {

                e.setAttr("path", file.toString());

            }

            return e;

        }

    }

    private void readClass(ClassFile c) throws IOException,

                                               ConstantPoolException,

                                               InvalidDescriptor {

        klass = new Element("Class");

        cfile.add(klass);

        String thisk = c.getName();

        klass.setAttr("name", thisk);

        AccessFlags af = new AccessFlags(c.access_flags.flags);

        klass.setAttr("flags", flagString(af, klass));

        if (!"java/lang/Object".equals(thisk)) {

            if (c.super_class != 0) {

                klass.setAttr("super", c.getSuperclassName());

            }

        }

        for (int i : c.interfaces) {

            klass.add(new Element("Interface", "name", getCpString(i)));

        }

        readFields(c, klass);

        readMethods(c, klass);

        readAttributesFor(c, c.attributes, klass);

        klass.trimToSize();

    }

    private void readFields(ClassFile c, Element klass) throws IOException {

        int len = c.fields.length;

        Element fields = new Element(len);

        for (Field f : c.fields) {

            Element field = new Element("Field");

            field.setAttr("name", getCpString(f.name_index));

            field.setAttr("type", getCpString(f.descriptor.index));

            field.setAttr("flags", flagString(f.access_flags.flags, field));

            readAttributesFor(c, f.attributes, field);

            field.trimToSize();

            fields.add(field);

        }

        if (!keepOrder) {

            fields.sort();

        }

        klass.addAll(fields);

    }

    private void readMethods(ClassFile c, Element klass) throws IOException {

        int len = c.methods.length;

        Element methods = new Element(len);

        for (Method m : c.methods) {

            Element member = new Element("Method");

            member.setAttr("name", getCpString(m.name_index));

            member.setAttr("type", getCpString(m.descriptor.index));

            member.setAttr("flags", flagString(m.access_flags.flags, member));

            readAttributesFor(c, m.attributes, member);

            member.trimToSize();

            methods.add(member);

        }

        if (!keepOrder) {

            methods.sort();

        }

        klass.addAll(methods);

    }

    private AccessFlags.Kind getKind(Element e) {

        switch(e.getName()) {

            case "Class":

                return AccessFlags.Kind.Class;

            case "InnerClass":

                return AccessFlags.Kind.InnerClass;

            case "Field":

                return AccessFlags.Kind.Field ;

            case "Method":

                return AccessFlags.Kind.Method;

            default: throw new RuntimeException("should not reach here");

        }

    }

    protected String flagString(int flags, Element holder) {

        return flagString(new AccessFlags(flags), holder);

    }

    protected String flagString(AccessFlags af, Element holder) {

        return flagString(af, holder.getName());

    }

    protected String flagString(int flags, String kind) {

        return flagString(new AccessFlags(flags), kind);

    }

    protected String flagString(AccessFlags af, String kind) {

        Set<String> mods = null;

        switch (kind) {

            case "Class":

                mods = af.getClassFlags();

                break;

            case "InnerClass":

                mods = af.getInnerClassFlags();

                break;

            case "Field":

                mods = af.getFieldFlags();

                break;

            case "Method":