/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

import org.apache.bcel.Constants;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.Constant;
import org.apache.bcel.classfile.ConstantFieldref;
import org.apache.bcel.classfile.ConstantMethodref;
import org.apache.bcel.classfile.ConstantNameAndType;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.generic.CPInstruction;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.InstructionConstants;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.TargetLostException;
import org.apache.bcel.util.InstructionFinder;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;

/**
 * make JDK 1.5 classfiles (version 49.0) compatible with JDK 1.3 (version 47.0)
 * by making the following changes:
 *
 * 1. replace references to java.lang.StringBuilder with java.lang.StringBuffer
 * 2. replace Integer.valueOf(int) with macromedia.asc.util.Boxing.valueOf(int)
 * 3. reorder this$outer and super() code snippets in inner class constructors,
 *    to please the 1.3 verifier.
 * 4. replace java.lang.AssertionError with java.lang.Error
 *
 * NOTE TO MAINTAINERS:
 * additional class reference changes can be added by adding entries in the strings
 * table.  these are simple substitutions.  Note that usually both the classname
 * reference and signatures of its methods must be changed.
 *
 * To adjust bytecode, we use BCEL's InstructionFinder, which lets us do regexp
 * matching on instruction sequences.  Once we find a match, we make the necessary
 * changes to a method's existing InstructionList.
 *
 * @author Edwin Smith
 */
public class Downgrader implements Constants
{
    static HashMap<String,String> strings = new HashMap<String,String>();

    static
    {
        // replace StringBuilder with StringBuffer
        strings.put("java/lang/StringBuilder", "java/lang/StringBuffer");
        strings.put("(Ljava/lang/String;)Ljava/lang/StringBuilder;", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
        strings.put("(Ljava/lang/Object;)Ljava/lang/StringBuilder;", "(Ljava/lang/Object;)Ljava/lang/StringBuffer;");
        strings.put("(I)Ljava/lang/StringBuilder;", "(I)Ljava/lang/StringBuffer;");
        strings.put("(C)Ljava/lang/StringBuilder;", "(C)Ljava/lang/StringBuffer;");
        strings.put("(Z)Ljava/lang/StringBuilder;", "(Z)Ljava/lang/StringBuffer;");
        strings.put("(D)Ljava/lang/StringBuilder;", "(D)Ljava/lang/StringBuffer;");
        strings.put("(J)Ljava/lang/StringBuilder;", "(J)Ljava/lang/StringBuffer;");

        // replace java.lang.AssertionError with java/lang/Error
        strings.put("java/lang/AssertionError", "java/lang/Error");
        
        //strings.put("java/lang/Iterable", "macromedia/asc/util/Iterable");
    }

    ConstantPoolGen cpool;

    void downgrade(String filename) throws IOException
    {
        byte[] b = new byte[(int) new File(filename).length()];
        InputStream in = new FileInputStream(filename);
        new DataInputStream(in).readFully(b);
        in.close();

        ClassParser parser = new ClassParser(new ByteArrayInputStream(b), filename);
        JavaClass jc = parser.parse();
        boolean changed;
        changed = downgrade(jc);

        if (changed)
        {
            b = jc.getBytes();

            FileOutputStream out = new FileOutputStream(filename);
            out.write(b);
            out.close();
        }
    }

    private boolean downgrade(JavaClass jc)
    {
        if (jc.getMajor() <= 47)
            return false;

        Method[] methods = jc.getMethods();
        cpool = new ConstantPoolGen(jc.getConstantPool().getConstantPool());

        jc.setMajor(47);

        for (int i=1, n=cpool.getSize(); i < n; i++)
        {
            Constant constant = cpool.getConstant(i);
            switch (constant.getTag())
            {
            case Constants.CONSTANT_Utf8:
                ConstantUtf8 cstring = (ConstantUtf8)constant;
                String bytes = cstring.getBytes();
                String newbytes = (String) strings.get(bytes);
                if (newbytes != null)
                    cstring.setBytes(newbytes);
                break;
            case Constants.CONSTANT_Double:
            case Constants.CONSTANT_Long:
                i++;
                break;
            case Constants.CONSTANT_Methodref:
                ConstantMethodref cmethod = (ConstantMethodref) constant;
                if (cmethod.getClass(cpool.getConstantPool()).equals("java.lang.Integer"))
                {
                    ConstantNameAndType cnt = (ConstantNameAndType) cpool.getConstant(cmethod.getNameAndTypeIndex());

                    if (cnt.getName(cpool.getConstantPool()).equals("valueOf") &&
                        cnt.getSignature(cpool.getConstantPool()).equals("(I)Ljava/lang/Integer;"))
                    {
                        cmethod.setClassIndex(cpool.addClass("macromedia.asc.util.Boxing"));
                    }
                }
                
                else if (cmethod.getClass(cpool.getConstantPool()).equals("java.lang.Double"))
                {
                    ConstantNameAndType cnt = (ConstantNameAndType) cpool.getConstant(cmethod.getNameAndTypeIndex());

                    if (cnt.getName(cpool.getConstantPool()).equals("valueOf") &&
                        cnt.getSignature(cpool.getConstantPool()).equals("(D)Ljava/lang/Double;"))
                    {
                        cmethod.setClassIndex(cpool.addClass("macromedia.asc.util.Boxing"));
                    }
                }
                break;
            }
        }

        for (int i=0, n = methods.length; i < n; i++)
        {
            if (!(methods[i].isAbstract() || methods[i].isNative()))
            {
                MethodGen mg = new MethodGen(methods[i], jc.getClassName(), cpool);

                boolean changed = change1(mg);

                if (methods[i].getName().equals("<init>"))
                    changed |= change2(mg);

//                changed |= change3(mg);

                if (changed)
                {
                    mg.setMaxStack();
                    methods[i] = mg.getMethod();
                }
            }
        }

        jc.setConstantPool(cpool.getFinalConstantPool());
        return true;
    }

    private boolean change2(MethodGen mg)
    {
        InstructionList il = mg.getInstructionList();
        InstructionFinder f   = new InstructionFinder(il);
        String            pat = "ALOAD_0 ALOAD_1 PUTFIELD ALOAD_0 INVOKESPECIAL";

        boolean changed = false;
        for(Iterator j = f.search(pat, new IsInnerConstructor()); j.hasNext(); )
        {
            InstructionHandle[] match = (InstructionHandle[]) j.next();

            // replace
            //    ALOAD_0       [0] 
            //    ALOAD_1		[1]
            //    PUTFIELD		[2]
            //    ALOAD_0		[3]
            //    INVOKESPECIAL	[4]
            // with
            //    ALOAD_0		[0]
            //    INVOKESPECIAL	[4]
            //    ALOAD_0		[3]
            //    ALOAD_1		[1]
            //    PUTFIELD		[2]

            changed = true;
            try
            {
                InstructionList il2 = new InstructionList();
                il2.append(match[3].getInstruction());
                il2.append(match[4].getInstruction());
                il.delete(match[3], match[4]);
                il.insert(match[0], il2);
            }
            catch (TargetLostException e)
            {
            	System.err.println("ERROR IN "+mg);
                e.printStackTrace();
            }
        }
        return changed;
    }

    class IsInnerConstructor implements InstructionFinder.CodeConstraint
    {
        public boolean checkCode(InstructionHandle[] match)
        {
            InstructionHandle ih = match[2];
            CPInstruction putfield = (CPInstruction) ih.getInstruction();
            Constant cc = cpool.getConstant(putfield.getIndex());
            if (cc.getTag() != CONSTANT_Fieldref)
                return false;
            ConstantFieldref cfield = (ConstantFieldref) cc;
            ConstantNameAndType cnt = (ConstantNameAndType) cpool.getConstant(cfield.getNameAndTypeIndex());
            if (!cnt.getName(cpool.getConstantPool()).equals("this$0"))
                return false;
            return true;
        }
    }

/*    private boolean change3(MethodGen mg)
    {
        InstructionList il = mg.getInstructionList();
        InstructionFinder f   = new InstructionFinder(il);
        String            pat = "INVOKESTATIC";

        boolean changed = false;
        for(Iterator j = f.search(pat, new IsIntegerValueOf()); j.hasNext(); )
        {
            InstructionHandle[] match = (InstructionHandle[]) j.next();

            // replace
            //    (expr)
            //    INVOKESTATIC Integer.valueOf(int):Integer
            // with
            //    (expr)
            //    NEW        Integer
            //    DUP_X1
            //    SWAP
            //    INVOKESPECIAL  Integer(int)

            changed = true;
            try
            {
                InstructionFactory factory = new InstructionFactory(cpool);
                InstructionList il2 = new InstructionList();

                il2.append(factory.createNew("java.lang.Integer"));
                il2.append(InstructionConstants.DUP_X1);
                il2.append(InstructionConstants.SWAP);
				il2.append(factory.createInvoke("java.lang.Integer", "Integer", Type.VOID, new Type[] { Type.INT }, INVOKESPECIAL));

                il.append(match[0], il2);
                il.delete(match[0]);
                System.out.println(il);
            }
            catch (TargetLostException e)
            {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return changed;
    }

    class IsIntegerValueOf implements InstructionFinder.CodeConstraint
    {
        public boolean checkCode(InstructionHandle[] match)
        {
            InstructionHandle ih = match[0];
            CPInstruction invokestatic = (CPInstruction) ih.getInstruction();
            Constant cc = cpool.getConstant(invokestatic.getIndex());
            if (cc.getTag() != CONSTANT_Methodref)
                return false;
            ConstantMethodref cmethod = (ConstantMethodref) cc;
            if (cmethod.getClass(cpool.getConstantPool()).equals("java.lang.Integer"))
            {
                ConstantNameAndType cnt = (ConstantNameAndType) cpool.getConstant(cmethod.getNameAndTypeIndex());
                if (cnt.getName(cpool.getConstantPool()).equals("valueOf") &&
                    cnt.getSignature(cpool.getConstantPool()).equals("(I)Ljava/lang/Integer;"))
                {
                    return true;
                }
            }
            return false;
        }
    }
*/

    private boolean change1(MethodGen mg)
    {
        InstructionList il = mg.getInstructionList();
        InstructionFinder f   = new InstructionFinder(il);
        String            pat = "[LDC_W|LDC] INVOKEVIRTUAL IFNE ICONST_1 GOTO ICONST_0";

        boolean changed = false;
        for(Iterator j = f.search(pat, new IsLdcClass()); j.hasNext(); )
        {
            InstructionHandle[] match = (InstructionHandle[]) j.next();

            // replace
            //    LDC_W <class>
            //    INVOKEVIRTUAL Class.desiredAssertionStatus
            //    IFNE
            //    ICONST_1
            //    goto
            //    ICONST_0
            // with
            //    ICONST_1

            changed = true;
            match[0].setInstruction(InstructionConstants.ICONST_1);
            try
            {
                il.delete(match[1], match[5]);
//                System.out.println(il);
            }
            catch (TargetLostException e)
            {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return changed;
    }

    class IsLdcClass implements InstructionFinder.CodeConstraint
    {
        public boolean checkCode(InstructionHandle[] match)
        {
            InstructionHandle ih = match[0];
            CPInstruction ldc_w = (CPInstruction) ih.getInstruction();
            Constant cc = cpool.getConstant(ldc_w.getIndex());
            if (cc.getTag() != CONSTANT_Class)
                return false;

            ih = match[1];
            CPInstruction invokevirtual = (CPInstruction) ih.getInstruction();
            ConstantMethodref cm = (ConstantMethodref) cpool.getConstant(invokevirtual.getIndex());
            ConstantNameAndType cnt = (ConstantNameAndType) cpool.getConstant(cm.getNameAndTypeIndex());
            if (!cnt.getName(cpool.getConstantPool()).equals("desiredAssertionStatus"))
                return false;
            return true;
        }
    }

    public static void main(String[] args)
    {
		for (int i = 0, length = args.length; i < length; i++)
		{
			String dirname = args[i];

			File dir = new File(dirname);
			try
			{
				downgradeDir(dir);
			}
			catch (Throwable e)
			{
				e.printStackTrace();
				System.exit(1);
			}
		}
    }

    static void downgradeDir(File dir) throws IOException
    {
        System.out.println(dir);
        File[] files = dir.listFiles(new FilenameFilter()
        {
            public boolean accept(File dir, String name)
            {
                return name.endsWith(".class") || new File(dir,name).isDirectory();
            }
        });

        for (int i=0, n=files.length; i < n; i++)
        {
            if (files[i].isDirectory())
                downgradeDir(files[i]);
            else
                new Downgrader().downgrade(files[i].getPath());
        }
    }
}