/**

 * Back 2 Browser Bytecode Translator

 * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 2 of the License.

 *

 * This program 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 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://opensource.org/licenses/GPL-2.0.

 */

package org.apidesign.vm4brwsr;

import java.io.IOException;

import org.apidesign.vm4brwsr.ByteCodeParser.TypeArray;

final class StackMapper {

    private final TypeArray stackTypeIndexPairs;

    private final StringArray stackValues;

    private boolean dirty;

    public StackMapper() {

        stackTypeIndexPairs = new TypeArray();

        stackValues = new StringArray();

    }

    public void clear() {

        stackTypeIndexPairs.clear();

        stackValues.clear();

        dirty = false;

    }

    public void syncWithFrameStack(final TypeArray frameStack) {

        clear();

        final int size = frameStack.getSize();

        for (int i = 0; i < size; ++i) {

            pushTypeImpl(VarType.fromStackMapType(frameStack.get(i)));

        }

    }

    public Variable pushI() {

        return pushT(VarType.INTEGER);

    }

    public Variable pushL() {

        return pushT(VarType.LONG);

    }

    public Variable pushF() {

        return pushT(VarType.FLOAT);

    }

    public Variable pushD() {

        return pushT(VarType.DOUBLE);

    }

    public Variable pushA() {

        return pushT(VarType.REFERENCE);

    }

    public Variable pushT(final int type) {

        return getVariable(pushTypeImpl(type));

    }

    void assign(Appendable out, int varType, CharSequence s) throws IOException {

        pushTypeAndValue(varType, s);

    }

    void replace(Appendable out, int varType, String format, CharSequence... arr) 

    throws IOException {

        StringBuilder sb = new StringBuilder();

        ByteCodeToJavaScript.emitImpl(sb, format, arr);

        String[] values = stackValues.toArray();

        final int last = stackTypeIndexPairs.getSize() - 1;

        values[last] = sb.toString();

        dirty = true;

        final int value = (last << 8) | (varType & 0xff);

        stackTypeIndexPairs.set(last, value);

    }

    void flush(Appendable out) throws IOException {

        int count = stackTypeIndexPairs.getSize();

        for (int i = 0; i < count; i++) {

            String val = stackValues.getAndClear(i, true);

            if (val == null) {

                continue;

            }

            CharSequence var = getVariable(stackTypeIndexPairs.get(i));

            ByteCodeToJavaScript.emitImpl(out, "var @1 = @2;", var, val);

        }

        dirty = false;

    }

    public boolean isDirty() {

        return dirty;

    }

    public CharSequence popI() {

        return popT(VarType.INTEGER);

    }

    public CharSequence popL() {

        return popT(VarType.LONG);

    }

    public CharSequence popF() {

        return popT(VarType.FLOAT);

    }

    public CharSequence popD() {

        return popT(VarType.DOUBLE);

    }

    public CharSequence popA() {

        return popT(VarType.REFERENCE);

    }

    public CharSequence popT(final int type) {

        final CharSequence variable = getT(0, type);

        popImpl(1);

        return variable;

    }

    public CharSequence popValue() {

        final CharSequence variable = getT(0, -1);

        popImpl(1);

        return variable;

    }

    public Variable pop(Appendable out) throws IOException {

        flush(out);

        final Variable variable = get(0);

        popImpl(1);

        return variable;

    }

    public void pop(final int count) {

        final int stackSize = stackTypeIndexPairs.getSize();

        if (count > stackSize) {

            throw new IllegalStateException("Stack underflow");

        }

        popImpl(count);

    }

    public CharSequence getI(final int indexFromTop) {

        return getT(indexFromTop, VarType.INTEGER);

    }

    public CharSequence getL(final int indexFromTop) {

        return getT(indexFromTop, VarType.LONG);

    }

    public CharSequence getF(final int indexFromTop) {

        return getT(indexFromTop, VarType.FLOAT);

    }

    public CharSequence getD(final int indexFromTop) {

        return getT(indexFromTop, VarType.DOUBLE);

    }

    public CharSequence getA(final int indexFromTop) {

        return getT(indexFromTop, VarType.REFERENCE);

    }

    public CharSequence getT(final int indexFromTop, final int type) {

        return getT(indexFromTop, type, true);

    }

    public CharSequence getT(final int indexFromTop, final int type, boolean clear) {

        final int stackSize = stackTypeIndexPairs.getSize();

        if (indexFromTop >= stackSize) {

            throw new IllegalStateException("Stack underflow");

        }

        final int stackValue =

                stackTypeIndexPairs.get(stackSize - indexFromTop - 1);

        if (type != -1 && (stackValue & 0xff) != type) {

            throw new IllegalStateException("Type mismatch");

        }

        String value =

            stackValues.getAndClear(stackSize - indexFromTop - 1, clear);

        if (value != null) {

            return value;

        }

        return getVariable(stackValue);

    }

    public Variable get(final int indexFromTop) {

        final int stackSize = stackTypeIndexPairs.getSize();

        if (indexFromTop >= stackSize) {

            throw new IllegalStateException("Stack underflow");

        }

        final int stackValue =

                stackTypeIndexPairs.get(stackSize - indexFromTop - 1);

        return getVariable(stackValue);

    }

    private int pushTypeImpl(final int type) {

        final int count = stackTypeIndexPairs.getSize();

        final int value = (count << 8) | (type & 0xff);

        stackTypeIndexPairs.add(value);

        addStackValue(count, null);

        return value;

    }

    private void pushTypeAndValue(final int type, CharSequence v) {

        final int count = stackTypeIndexPairs.getSize();

        final int value = (count << 8) | (type & 0xff);

        stackTypeIndexPairs.add(value);

        final String val = v.toString();

        addStackValue(count, val);

    }

    private void addStackValue(int at, final String val) {

        final String[] arr = stackValues.toArray();

        if (arr.length > at) {

            arr[at] = val;

        } else {

            stackValues.add(val);

        }

        dirty = true;

    }

    private void popImpl(final int count) {

        final int stackSize = stackTypeIndexPairs.getSize();

        stackTypeIndexPairs.setSize(stackSize - count);

    }

    public Variable getVariable(final int typeAndIndex) {

        final int type = typeAndIndex & 0xff;

        final int index = typeAndIndex >> 8;

        return Variable.getStackVariable(type, index);

    }

}