/**

 * 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 org.apidesign.javap.TypeArray;

final class StackMapper {

    private final TypeArray stackTypeIndexPairs;

    private int[] typeCounters;

    private int[] typeMaxCounters;

    public StackMapper() {

        stackTypeIndexPairs = new TypeArray();

        typeCounters = new int[VarType.LAST + 1];

        typeMaxCounters = new int[VarType.LAST + 1];

    }

    public void clear() {

        for (int type = 0; type <= VarType.LAST; ++type) {

            typeCounters[type] = 0;

        }

        stackTypeIndexPairs.clear();

    }

    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));

    }

    public Variable popI() {

        return popT(VarType.INTEGER);

    }

    public Variable popL() {

        return popT(VarType.LONG);

    }

    public Variable popF() {

        return popT(VarType.FLOAT);

    }

    public Variable popD() {

        return popT(VarType.DOUBLE);

    }

    public Variable popA() {

        return popT(VarType.REFERENCE);

    }

    public Variable popT(final int type) {

        final Variable variable = getT(0, type);

        popImpl(1);

        return variable;

    }

    public Variable pop() {

        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 Variable getI(final int indexFromTop) {

        return getT(indexFromTop, VarType.INTEGER);

    }

    public Variable getL(final int indexFromTop) {

        return getT(indexFromTop, VarType.LONG);

    }

    public Variable getF(final int indexFromTop) {

        return getT(indexFromTop, VarType.FLOAT);

    }

    public Variable getD(final int indexFromTop) {

        return getT(indexFromTop, VarType.DOUBLE);

    }

    public Variable getA(final int indexFromTop) {

        return getT(indexFromTop, VarType.REFERENCE);

    }

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

        final int stackSize = stackTypeIndexPairs.getSize();

        if (indexFromTop >= stackSize) {

            throw new IllegalStateException("Stack underflow");

        }

        final int stackValue =

                stackTypeIndexPairs.get(stackSize - indexFromTop - 1);

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

            throw new IllegalStateException("Type mismatch");

        }

        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 = typeCounters[type];

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

        incCounter(type);

        stackTypeIndexPairs.add(value);

        return value;

    }

    private void popImpl(final int count) {

        final int stackSize = stackTypeIndexPairs.getSize();

        for (int i = stackSize - count; i < stackSize; ++i) {

            final int value = stackTypeIndexPairs.get(i);

            decCounter(value & 0xff);

        }

        stackTypeIndexPairs.setSize(stackSize - count);

    }

    private void incCounter(final int type) {

        final int newValue = ++typeCounters[type];

        if (typeMaxCounters[type] < newValue) {

            typeMaxCounters[type] = newValue;

        }

    }

    private void decCounter(final int type) {

        --typeCounters[type];

    }

    public Variable getVariable(final int typeAndIndex) {

        final int type = typeAndIndex & 0xff;

        final int index = typeAndIndex >> 8;

        return Variable.getStackVariable(type, index);

    }

}