package edu.upol.paradise.tests.manual;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewConstructor;
import javassist.CtNewMethod;
import javassist.Modifier;
import javassist.bytecode.Bytecode;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.ConstPool;
import javassist.bytecode.InstructionPrinter;
import javassist.bytecode.Opcode;


public class Brainfuck {
    private ClassPool cp = ClassPool.getDefault();
    private int counter = 0;

    private class StoredJmpPoint {
        public int jmpPoint;
        public int bcodePoint;
    }

    private String source;

    private Runnable compile() throws Throwable {
        String className = "edu.upol.paradise.tests.manual.BrainFuck$" + counter++;
        CtClass cls = cp.makeClass(className);
        cls.addInterface(cp.getCtClass("java/lang/Runnable"));
        CtField f = new CtField(CtClass.intType, "pointer", cls);
        f.setModifiers(Modifier.PUBLIC);
        cls.addField(f, "0");
        f = new CtField(cp.get("[I"), "tape", cls);
        f.setModifiers(Modifier.PUBLIC);
        cls.addField(f, "new int[30000]");
        CtMethod m = CtNewMethod.make("public void run(){}", cls);
        ConstPool pool = m.getMethodInfo().getConstPool();

        Bytecode bc = new Bytecode(pool);

        compile(source, bc, pool, cls);

        CodeAttribute at = bc.toCodeAttribute();
        at.computeMaxStack();
        at.setMaxLocals(1);

        m.getMethodInfo().setCodeAttribute(at);
        InstructionPrinter.print(m, System.err);

        cls.addMethod(m);
        CtConstructor ct = CtNewConstructor.defaultConstructor(cls);
        cls.addConstructor(ct);

        return (Runnable) cls.toClass().newInstance();
    }

    private void compile(String src, Bytecode bc, ConstPool pool, CtClass cls) {
        Queue<StoredJmpPoint> bq = new LinkedList<StoredJmpPoint>();

        for (char c : src.toCharArray()){
            switch (c){
            case '>':
                movePointerRight(bc, pool, cls);
                break;
            case '<':
                movePointerLeft(bc, pool, cls);
                break;
            case '+':
                addToPointed(bc, pool, cls);
                break;
            case '-':
                subFromPointed(bc, pool, cls);
                break;
            case '.':
                print(bc, pool, cls);
                break;
            case ',':
                read(bc, pool, cls);
                break;
            case '[':
                beginloop(bc, pool, cls, bq);
                break;
            case ']':
                endloop(bc, pool, cls, bq);
                break;
            }
        }

        bc.addReturn(null);
    }

    private void endloop(Bytecode bc, ConstPool pool, CtClass cls,
            Queue<StoredJmpPoint> bq) {

        StoredJmpPoint jp = bq.poll();

        loadFromTape(bc, cls);
        bc.addOpcode(Opcode.IFNE);
        int point = bc.currentPc();
        bc.add(0, 0);
        bc.write16bit(bc.currentPc()-2, (jp.jmpPoint - point + 1));
        point = bc.currentPc();
        bc.write16bit(jp.bcodePoint, point-jp.bcodePoint+1);
    }

    private void beginloop(Bytecode bc, ConstPool pool, CtClass cls,
            Queue<StoredJmpPoint> bq) {

        StoredJmpPoint jp = new StoredJmpPoint();

        jp.jmpPoint = bc.currentPc();
        loadFromTape(bc, cls);
        bc.addOpcode(Opcode.IFEQ);
        jp.bcodePoint = bc.currentPc();
        bc.add(0, 0);

        bq.add(jp);
    }

    private void read(Bytecode bc, ConstPool pool, CtClass cls) {
        // store
        bc.addAload(0);
        bc.addGetfield(cls, "tape", "[I");
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");

        bc.addGetstatic("java/lang/System", "in", "Ljava/io/InputStream;");
        bc.addInvokevirtual("java/io/InputStream", "read", "()I");

        bc.addOpcode(Opcode.IASTORE);
    }

    private void print(Bytecode bc, ConstPool pool, CtClass cls) {

        bc.addGetstatic("java/lang/System", "out", "Ljava/io/PrintStream;");
        // load
        loadFromTape(bc, cls);
        // print
        bc.addInvokevirtual("java/io/PrintStream", "print", "(C)V");

    }

    private void addToPointed(Bytecode bc, ConstPool pool, CtClass cls) {
        // store
        bc.addAload(0);
        bc.addGetfield(cls, "tape", "[I");
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");

        // load
        loadFromTape(bc, cls);

        // inc
        bc.addIconst(1);
        bc.addOpcode(Opcode.IADD);
        bc.addOpcode(Opcode.IASTORE);
    }

    private void subFromPointed(Bytecode bc, ConstPool pool, CtClass cls) {
        // store
        bc.addAload(0);
        bc.addGetfield(cls, "tape", "[I");
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");

        // load
        loadFromTape(bc, cls);

        // inc
        bc.addIconst(1);
        bc.addOpcode(Opcode.ISUB);
        bc.addOpcode(Opcode.IASTORE);
    }


    private void loadFromTape(Bytecode bc, CtClass cls) {
        bc.addAload(0);
        bc.addGetfield(cls, "tape", "[I");
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");
        bc.addOpcode(Opcode.IALOAD);
    }

    private void movePointerLeft(Bytecode bc, ConstPool pool, CtClass cls) {
        bc.addAload(0); // for putfield
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");
        bc.addIconst(1);
        bc.addOpcode(Opcode.ISUB);
        bc.addIconst(0);
        bc.addInvokestatic("java/lang/Math", "max", "(II)I");
        bc.addPutfield(cls, "pointer", "I");
    }

    private void movePointerRight(Bytecode bc, ConstPool pool, CtClass cls) {
        bc.addAload(0); // for putfield
        bc.addAload(0); // for pointer
        bc.addGetfield(cls, "pointer", "I");
        bc.addIconst(1);
        bc.addOpcode(Opcode.IADD);
        addTapeMax(bc, pool, cls);
        bc.addInvokestatic("java/lang/Math", "min", "(II)I");
        bc.addPutfield(cls, "pointer", "I");
    }

    private void addTapeMax(Bytecode bc, ConstPool pool, CtClass cls) {
        bc.addAload(0);
        bc.addGetfield(cls, "tape", "[I");
        bc.addOpcode(Opcode.ARRAYLENGTH);
    }

    private void setSource(String code) {
        this.source = code;
    }

    public static void main(String[] arg) throws Throwable{
        String code = ",>>[-]<<[->>+<<]";
        Brainfuck bf = new Brainfuck();
        bf.setSource(code);
        Runnable r = bf.compile();
        r.run();
    }
}