package niel.mod.core;

import java.util.Iterator;

import net.minecraft.launchwrapper.IClassTransformer;

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;

/**
 * @author fishtaco, tterrag
 *
 */
public class CoreTransformer implements IClassTransformer{

    private final String CLASS_NAME = "net.minecraft.block.BlockFence";
    private final String OBF_CLASS_NAME = "aoh";
    private final String METHOD_NAME = "canConnectFenceTo";
    private final String METHOD_NAME_OBF = "func_72250_d";
    private final String METHOD_NOTCH = "a";
    private final String METHOD_DESC = "(Lnet/minecraft/world/IBlockAccess;III)Z";
    private final String OBF_RENSP_DESC = "(Lbeu;F)V";
    private final String INSTRUCTION_LINE = "renderArrowsStuckInEntity";
    private final String INSTRUCTION_LINE_OBF = "func_85093_e";
    private final String INSTRUCTION_LINE_NOTCH = "e";
    private final String NEW_MOD_DESC = "(Lnet/minecraft/world/IBlockAccess;III)Z";

    @Override
    public byte[] transform(String arg0, String arg1, byte[] arg2) {
        if (arg1.compareTo(CLASS_NAME) == 0)
            return patchClassASM(arg1, arg2, true);
        return arg2;
    }

    private byte[] patchClassASM(String name, byte[] bytes, boolean isObfuscated)
    {
        ClassNode classNode = new ClassNode();
        ClassReader classReader = new ClassReader(bytes);
        classReader.accept(classNode, 0);

        Iterator<MethodNode> methods = classNode.methods.iterator();
        while (methods.hasNext())
        {
            MethodNode m = methods.next();
            if((m.name.equals(this.METHOD_NAME) || m.name.equals(this.METHOD_NAME_OBF) || m.name.equals(this.METHOD_NOTCH))
                    && (m.desc.equals(this.METHOD_DESC) || m.desc.equals(OBF_RENSP_DESC)))
            {
                System.out.println("BEGINNING TRANSFORMATION!");
                for (int index = 0; index < m.instructions.size(); index++)
                {
                    if(m.instructions.get(index).getType() == AbstractInsnNode.METHOD_INSN)
                    {
                        /*MethodInsnNode mdNode = (MethodInsnNode) m.instructions.get(index);
                        if(mdNode.name.equals(this.INSTRUCTION_LINE) || mdNode.name.equals(this.INSTRUCTION_LINE_OBF) || mdNode.name.equals(this.INSTRUCTION_LINE_NOTCH))
                        {               */
                            LabelNode lmm1Node = new LabelNode(new Label());

                            LabelNode jumpLabel = new LabelNode(new Label());

                            // make new instruction list
                            InsnList toInject = new InsnList();

                            toInject.add(new VarInsnNode(Opcodes.ALOAD, 1));
                            toInject.add(new VarInsnNode(Opcodes.ILOAD, 2));
                            toInject.add(new VarInsnNode(Opcodes.ILOAD, 3));
                            toInject.add(new VarInsnNode(Opcodes.ILOAD, 4));

                            toInject.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "CoreMethods", "canConnectFenceTo", this.NEW_MOD_DESC));

                            toInject.add(new JumpInsnNode(Opcodes.IFNE, lmm1Node));
                            toInject.add(jumpLabel);
                            toInject.add(new InsnNode(Opcodes.RETURN));
                            toInject.add(lmm1Node);

                            m.instructions.insert(m.instructions.get(index), toInject);
                            System.out.println("TRANSFORMATION COMPLETE!");
                            break;
                        }
                    }
                }
        }


        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        classNode.accept(cw);

        return cw.toByteArray();
    }
}