/*
 * Copyright (c) 2001-2004 Caucho Technology, Inc.  All rights reserved.
 *
 * The Apache Software License, Version 1.1
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowlegement:
 *       "This product includes software developed by the
 *        Caucho Technology (http://www.caucho.com/)."
 *    Alternately, this acknowlegement may appear in the software itself,
 *    if and wherever such third-party acknowlegements normally appear.
 *
 * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
 *    endorse or promote products derived from this software without prior
 *    written permission. For written permission, please contact
 *    info@caucho.com.
 *
 * 5. Products derived from this software may not be called "Resin"
 *    nor may "Resin" appear in their names without prior written
 *    permission of Caucho Technology.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @author Scott Ferguson
 */

package com.alibaba.com.caucho.hessian3.io;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

/**
 * Debugging input stream for Hessian requests.
 */
public class HessianDebugState implements Hessian2Constants {
    private PrintWriter _dbg;

    private State _state;
    private ArrayList<State> _stateStack = new ArrayList<State>();

    private ArrayList<ObjectDef> _objectDefList
            = new ArrayList<ObjectDef>();

    private ArrayList<String> _typeDefList
            = new ArrayList<String>();

    private int _refId;
    private boolean _isNewline = true;
    private boolean _isObject = false;
    private int _column;

    /**
     * Creates an uninitialized Hessian input stream.
     */
    public HessianDebugState(PrintWriter dbg) {
        _dbg = dbg;

        _state = new InitialState();
    }

    static boolean isString(int ch) {
        switch (ch) {
            case 0x00:
            case 0x01:
            case 0x02:
            case 0x03:
            case 0x04:
            case 0x05:
            case 0x06:
            case 0x07:
            case 0x08:
            case 0x09:
            case 0x0a:
            case 0x0b:
            case 0x0c:
            case 0x0d:
            case 0x0e:
            case 0x0f:

            case 0x10:
            case 0x11:
            case 0x12:
            case 0x13:
            case 0x14:
            case 0x15:
            case 0x16:
            case 0x17:
            case 0x18:
            case 0x19:
            case 0x1a:
            case 0x1b:
            case 0x1c:
            case 0x1d:
            case 0x1e:
            case 0x1f:

            case 0x30:
            case 0x31:
            case 0x32:
            case 0x33:

            case 'R':
            case 'S':
                return true;

            default:
                return false;
        }
    }

    static boolean isInteger(int ch) {
        switch (ch) {
            case 0x80:
            case 0x81:
            case 0x82:
            case 0x83:
            case 0x84:
            case 0x85:
            case 0x86:
            case 0x87:
            case 0x88:
            case 0x89:
            case 0x8a:
            case 0x8b:
            case 0x8c:
            case 0x8d:
            case 0x8e:
            case 0x8f:

            case 0x90:
            case 0x91:
            case 0x92:
            case 0x93:
            case 0x94:
            case 0x95:
            case 0x96:
            case 0x97:
            case 0x98:
            case 0x99:
            case 0x9a:
            case 0x9b:
            case 0x9c:
            case 0x9d:
            case 0x9e:
            case 0x9f:

            case 0xa0:
            case 0xa1:
            case 0xa2:
            case 0xa3:
            case 0xa4:
            case 0xa5:
            case 0xa6:
            case 0xa7:
            case 0xa8:
            case 0xa9:
            case 0xaa:
            case 0xab:
            case 0xac:
            case 0xad:
            case 0xae:
            case 0xaf:

            case 0xb0:
            case 0xb1:
            case 0xb2:
            case 0xb3:
            case 0xb4:
            case 0xb5:
            case 0xb6:
            case 0xb7:
            case 0xb8:
            case 0xb9:
            case 0xba:
            case 0xbb:
            case 0xbc:
            case 0xbd:
            case 0xbe:
            case 0xbf:

            case 0xc0:
            case 0xc1:
            case 0xc2:
            case 0xc3:
            case 0xc4:
            case 0xc5:
            case 0xc6:
            case 0xc7:
            case 0xc8:
            case 0xc9:
            case 0xca:
            case 0xcb:
            case 0xcc:
            case 0xcd:
            case 0xce:
            case 0xcf:

            case 0xd0:
            case 0xd1:
            case 0xd2:
            case 0xd3:
            case 0xd4:
            case 0xd5:
            case 0xd6:
            case 0xd7:

            case 'I':
                return true;

            default:
                return false;
        }
    }

    public void startTop2() {
        _state = new Top2State();
    }

    /**
     * Reads a character.
     */
    public void next(int ch)
            throws IOException {
        _state = _state.next(ch);
    }

    void pushStack(State state) {
        _stateStack.add(state);
    }

    State popStack() {
        return _stateStack.remove(_stateStack.size() - 1);
    }

    void println() {
        if (!_isNewline) {
            _dbg.println();
            _dbg.flush();
        }

        _isNewline = true;
        _column = 0;
    }

    static class ObjectDef {
        private String _type;
        private ArrayList<String> _fields;

        ObjectDef(String type, ArrayList<String> fields) {
            _type = type;
            _fields = fields;
        }

        String getType() {
            return _type;
        }

        ArrayList<String> getFields() {
            return _fields;
        }
    }

    abstract class State {
        State _next;

        State() {
        }

        State(State next) {
            _next = next;
        }

        abstract State next(int ch);

        boolean isShift(Object value) {
            return false;
        }

        State shift(Object value) {
            return this;
        }

        int depth() {
            if (_next != null)
                return _next.depth();
            else
                return 0;
        }

        void printIndent(int depth) {
            if (_isNewline) {
                for (int i = _column; i < depth() + depth; i++) {
                    _dbg.print(" ");
                    _column++;
                }
            }
        }

        void print(String string) {
            print(0, string);
        }

        void print(int depth, String string) {
            printIndent(depth);

            _dbg.print(string);
            _isNewline = false;
            _isObject = false;

            int p = string.lastIndexOf('\n');
            if (p > 0)
                _column = string.length() - p - 1;
            else
                _column += string.length();
        }

        void println(String string) {
            println(0, string);
        }

        void println(int depth, String string) {
            printIndent(depth);

            _dbg.println(string);
            _dbg.flush();
            _isNewline = true;
            _isObject = false;
            _column = 0;
        }

        void println() {
            if (!_isNewline) {
                _dbg.println();
                _dbg.flush();
            }

            _isNewline = true;
            _isObject = false;
            _column = 0;
        }

        void printObject(String string) {
            if (_isObject)
                println();

            printIndent(0);

            _dbg.print(string);
            _dbg.flush();

            _column += string.length();

            _isNewline = false;
            _isObject = true;
        }

        protected State nextObject(int ch) {
            switch (ch) {
                case -1:
                    println();
                    return this;

                case 'N':
                    if (isShift(null))
                        return shift(null);
                    else {
                        printObject("null");
                        return this;
                    }

                case 'T':
                    if (isShift(Boolean.TRUE))
                        return shift(Boolean.TRUE);
                    else {
                        printObject("true");
                        return this;
                    }

                case 'F':
                    if (isShift(Boolean.FALSE))
                        return shift(Boolean.FALSE);
                    else {
                        printObject("false");
                        return this;
                    }

                case 0x80:
                case 0x81:
                case 0x82:
                case 0x83:
                case 0x84:
                case 0x85:
                case 0x86:
                case 0x87:
                case 0x88:
                case 0x89:
                case 0x8a:
                case 0x8b:
                case 0x8c:
                case 0x8d:
                case 0x8e:
                case 0x8f:

                case 0x90:
                case 0x91:
                case 0x92:
                case 0x93:
                case 0x94:
                case 0x95:
                case 0x96:
                case 0x97:
                case 0x98:
                case 0x99:
                case 0x9a:
                case 0x9b:
                case 0x9c:
                case 0x9d:
                case 0x9e:
                case 0x9f:

                case 0xa0:
                case 0xa1:
                case 0xa2:
                case 0xa3:
                case 0xa4:
                case 0xa5:
                case 0xa6:
                case 0xa7:
                case 0xa8:
                case 0xa9:
                case 0xaa:
                case 0xab:
                case 0xac:
                case 0xad:
                case 0xae:
                case 0xaf:

                case 0xb0:
                case 0xb1:
                case 0xb2:
                case 0xb3:
                case 0xb4:
                case 0xb5:
                case 0xb6:
                case 0xb7:
                case 0xb8:
                case 0xb9:
                case 0xba:
                case 0xbb:
                case 0xbc:
                case 0xbd:
                case 0xbe:
                case 0xbf: {
                    Integer value = new Integer(ch - 0x90);

                    if (isShift(value))
                        return shift(value);
                    else {
                        printObject(value.toString());
                        return this;
                    }
                }

                case 0xc0:
                case 0xc1:
                case 0xc2:
                case 0xc3:
                case 0xc4:
                case 0xc5:
                case 0xc6:
                case 0xc7:
                case 0xc8:
                case 0xc9:
                case 0xca:
                case 0xcb:
                case 0xcc:
                case 0xcd:
                case 0xce:
                case 0xcf:
                    return new IntegerState(this, "int", ch - 0xc8, 3);

                case 0xd0:
                case 0xd1:
                case 0xd2:
                case 0xd3:
                case 0xd4:
                case 0xd5:
                case 0xd6:
                case 0xd7:
                    return new IntegerState(this, "int", ch - 0xd4, 2);

                case 'I':
                    return new IntegerState(this, "int");

                case 0xd8:
                case 0xd9:
                case 0xda:
                case 0xdb:
                case 0xdc:
                case 0xdd:
                case 0xde:
                case 0xdf:
                case 0xe0:
                case 0xe1:
                case 0xe2:
                case 0xe3:
                case 0xe4:
                case 0xe5:
                case 0xe6:
                case 0xe7:
                case 0xe8:
                case 0xe9:
                case 0xea:
                case 0xeb:
                case 0xec:
                case 0xed:
                case 0xee:
                case 0xef: {
                    Long value = new Long(ch - 0xe0);

                    if (isShift(value))
                        return shift(value);
                    else {
                        printObject(value.toString() + "L");
                        return this;
                    }
                }

                case 0xf0:
                case 0xf1:
                case 0xf2:
                case 0xf3:
                case 0xf4:
                case 0xf5:
                case 0xf6:
                case 0xf7:
                case 0xf8:
                case 0xf9:
                case 0xfa:
                case 0xfb:
                case 0xfc:
                case 0xfd:
                case 0xfe:
                case 0xff:
                    return new LongState(this, "long", ch - 0xf8, 7);

                case 0x38:
                case 0x39:
                case 0x3a:
                case 0x3b:
                case 0x3c:
                case 0x3d:
                case 0x3e:
                case 0x3f:
                    return new LongState(this, "long", ch - 0x3c, 6);

                case BC_LONG_INT:
                    return new LongState(this, "long", 0, 4);

                case 'L':
                    return new LongState(this, "long");

                case 0x5b:
                case 0x5c: {
                    Double value = new Double(ch - 0x5b);

                    if (isShift(value))
                        return shift(value);
                    else {
                        printObject(value.toString());
                        return this;
                    }
                }

                case 0x5d:
                    return new DoubleIntegerState(this, 3);

                case 0x5e:
                    return new DoubleIntegerState(this, 2);

                case 0x5f:
                    return new MillsState(this);

                case 'D':
                    return new DoubleState(this);

                case 'Q':
                    return new RefState(this);

                case BC_DATE:
                    return new DateState(this);

                case BC_DATE_MINUTE:
                    return new DateState(this, true);

                case 0x00: {
                    String value = "\"\"";

                    if (isShift(value))
                        return shift(value);
                    else {
                        printObject(value.toString());
                        return this;
                    }
                }

                case 0x01:
                case 0x02:
                case 0x03:
                case 0x04:
                case 0x05:
                case 0x06:
                case 0x07:
                case 0x08:
                case 0x09:
                case 0x0a:
                case 0x0b:
                case 0x0c:
                case 0x0d:
                case 0x0e:
                case 0x0f:

                case 0x10:
                case 0x11:
                case 0x12:
                case 0x13:
                case 0x14:
                case 0x15:
                case 0x16:
                case 0x17:
                case 0x18:
                case 0x19:
                case 0x1a:
                case 0x1b:
                case 0x1c:
                case 0x1d:
                case 0x1e:
                case 0x1f:
                    return new StringState(this, 'S', ch);

                case 0x30:
                case 0x31:
                case 0x32:
                case 0x33:
                    return new StringState(this, 'S', ch - 0x30, true);

                case 'R':
                    return new StringState(this, 'S', false);

                case 'S':
                    return new StringState(this, 'S', true);

                case 0x20: {
                    String value = "binary(0)";

                    if (isShift(value))
                        return shift(value);
                    else {
                        printObject(value.toString());
                        return this;
                    }
                }

                case 0x21:
                case 0x22:
                case 0x23:
                case 0x24:
                case 0x25:
                case 0x26:
                case 0x27:
                case 0x28:
                case 0x29:
                case 0x2a:
                case 0x2b:
                case 0x2c:
                case 0x2d:
                case 0x2e:
                case 0x2f:
                    return new BinaryState(this, 'B', ch - 0x20);

                case 0x34:
                case 0x35:
                case 0x36:
                case 0x37:
                    return new BinaryState(this, 'B', ch - 0x34, true);

                case 'A':
                    return new BinaryState(this, 'B', false);

                case 'B':
                    return new BinaryState(this, 'B', true);

                case 'M':
                    return new MapState(this, _refId++);

                case 'H':
                    return new MapState(this, _refId++, false);

                case BC_LIST_VARIABLE:
                    return new ListState(this, _refId++, true);

                case BC_LIST_VARIABLE_UNTYPED:
                    return new ListState(this, _refId++, false);

                case BC_LIST_FIXED:
                    return new CompactListState(this, _refId++, true);

                case BC_LIST_FIXED_UNTYPED:
                    return new CompactListState(this, _refId++, false);

                case 0x70:
                case 0x71:
                case 0x72:
                case 0x73:
                case 0x74:
                case 0x75:
                case 0x76:
                case 0x77:
                    return new CompactListState(this, _refId++, true, ch - 0x70);

                case 0x78:
                case 0x79:
                case 0x7a:
                case 0x7b:
                case 0x7c:
                case 0x7d:
                case 0x7e:
                case 0x7f:
                    return new CompactListState(this, _refId++, false, ch - 0x78);

                case 'C':
                    return new ObjectDefState(this);

                case 0x60:
                case 0x61:
                case 0x62:
                case 0x63:
                case 0x64:
                case 0x65:
                case 0x66:
                case 0x67:
                case 0x68:
                case 0x69:
                case 0x6a:
                case 0x6b:
                case 0x6c:
                case 0x6d:
                case 0x6e:
                case 0x6f:
                    return new ObjectState(this, _refId++, ch - 0x60);

                case 'O':
                    return new ObjectState(this, _refId++);

                default:
                    return this;
            }
        }
    }

    class InitialState extends State {
        @Override
        State next(int ch) {
            println();

            if (ch == 'r') {
                return new ReplyState(this);
            } else if (ch == 'c') {
                return new CallState(this);
            } else
                return nextObject(ch);
        }
    }

    class Top2State extends State {
        @Override
        State next(int ch) {
            println();

            if (ch == 'R') {
                return new Reply2State(this);
            } else if (ch == 'F') {
                return new Fault2State(this);
            } else if (ch == 'C') {
                return new Call2State(this);
            } else if (ch == 'H') {
                return new Hessian2State(this);
            } else if (ch == 'r') {
                return new ReplyState(this);
            } else if (ch == 'c') {
                return new CallState(this);
            } else
                return nextObject(ch);
        }
    }

    class IntegerState extends State {
        String _typeCode;

        int _length;
        int _value;

        IntegerState(State next, String typeCode) {
            super(next);

            _typeCode = typeCode;
        }

        IntegerState(State next, String typeCode, int value, int length) {
            super(next);

            _typeCode = typeCode;

            _value = value;
            _length = length;
        }

        @Override
        State next(int ch) {
            _value = 256 * _value + (ch & 0xff);

            if (++_length == 4) {
                Integer value = new Integer(_value);

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString());

                    return _next;
                }
            } else
                return this;
        }
    }

    class LongState extends State {
        String _typeCode;

        int _length;
        long _value;

        LongState(State next, String typeCode) {
            super(next);

            _typeCode = typeCode;
        }

        LongState(State next, String typeCode, long value, int length) {
            super(next);

            _typeCode = typeCode;

            _value = value;
            _length = length;
        }

        @Override
        State next(int ch) {
            _value = 256 * _value + (ch & 0xff);

            if (++_length == 8) {
                Long value = new Long(_value);

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString() + "L");

                    return _next;
                }
            } else
                return this;
        }
    }

    class DoubleIntegerState extends State {
        int _length;
        int _value;
        boolean _isFirst = true;

        DoubleIntegerState(State next, int length) {
            super(next);

            _length = length;
        }

        @Override
        State next(int ch) {
            if (_isFirst)
                _value = (byte) ch;
            else
                _value = 256 * _value + (ch & 0xff);

            _isFirst = false;

            if (++_length == 4) {
                Double value = new Double(_value);

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString());

                    return _next;
                }
            } else
                return this;
        }
    }

    class RefState extends State {
        String _typeCode;

        int _length;
        int _value;

        RefState(State next) {
            super(next);
        }

        RefState(State next, String typeCode) {
            super(next);

            _typeCode = typeCode;
        }

        RefState(State next, String typeCode, int value, int length) {
            super(next);

            _typeCode = typeCode;

            _value = value;
            _length = length;
        }

        @Override
        boolean isShift(Object o) {
            return true;
        }

        @Override
        State shift(Object o) {
            println("ref #" + o);

            return _next;
        }

        @Override
        State next(int ch) {
            return nextObject(ch);
        }
    }

    class DateState extends State {
        int _length;
        long _value;
        boolean _isMinute;

        DateState(State next) {
            super(next);
        }

        DateState(State next, boolean isMinute) {
            super(next);

            _length = 4;
            _isMinute = isMinute;
        }


        @Override
        State next(int ch) {
            _value = 256 * _value + (ch & 0xff);

            if (++_length == 8) {
                java.util.Date value;

                if (_isMinute)
                    value = new java.util.Date(_value * 60000L);
                else
                    value = new java.util.Date(_value);

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString());

                    return _next;
                }
            } else
                return this;
        }
    }

    class DoubleState extends State {
        int _length;
        long _value;

        DoubleState(State next) {
            super(next);
        }

        @Override
        State next(int ch) {
            _value = 256 * _value + (ch & 0xff);

            if (++_length == 8) {
                Double value = Double.longBitsToDouble(_value);

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString());

                    return _next;
                }
            } else
                return this;
        }
    }

    class MillsState extends State {
        int _length;
        int _value;

        MillsState(State next) {
            super(next);
        }

        @Override
        State next(int ch) {
            _value = 256 * _value + (ch & 0xff);

            if (++_length == 4) {
                Double value = 0.001 * _value;

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value.toString());

                    return _next;
                }
            } else
                return this;
        }
    }

    class StringState extends State {
        private static final int TOP = 0;
        private static final int UTF_2_1 = 1;
        private static final int UTF_3_1 = 2;
        private static final int UTF_3_2 = 3;

        char _typeCode;

        StringBuilder _value = new StringBuilder();
        int _lengthIndex;
        int _length;
        boolean _isLastChunk;

        int _utfState;
        char _ch;

        StringState(State next, char typeCode, boolean isLastChunk) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = isLastChunk;
        }

        StringState(State next, char typeCode, int length) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = true;
            _length = length;
            _lengthIndex = 2;
        }

        StringState(State next, char typeCode, int length, boolean isLastChunk) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = isLastChunk;
            _length = length;
            _lengthIndex = 1;
        }

        @Override
        State next(int ch) {
            if (_lengthIndex < 2) {
                _length = 256 * _length + (ch & 0xff);

                if (++_lengthIndex == 2 && _length == 0 && _isLastChunk) {
                    if (_next.isShift(_value.toString()))
                        return _next.shift(_value.toString());
                    else {
                        printObject("\"" + _value + "\"");
                        return _next;
                    }
                } else
                    return this;
            } else if (_length == 0) {
                if (ch == 's' || ch == 'x') {
                    _isLastChunk = false;
                    _lengthIndex = 0;
                    return this;
                } else if (ch == 'S' || ch == 'X') {
                    _isLastChunk = true;
                    _lengthIndex = 0;
                    return this;
                } else if (ch == 0x00) {
                    if (_next.isShift(_value.toString()))
                        return _next.shift(_value.toString());
                    else {
                        printObject("\"" + _value + "\"");
                        return _next;
                    }
                } else if (0x00 <= ch && ch < 0x20) {
                    _isLastChunk = true;
                    _lengthIndex = 2;
                    _length = ch & 0xff;
                    return this;
                } else if (0x30 <= ch && ch < 0x34) {
                    _isLastChunk = true;
                    _lengthIndex = 1;
                    _length = (ch - 0x30);
                    return this;
                } else {
                    println(String.valueOf((char) ch) + ": unexpected character");
                    return _next;
                }
            }

            switch (_utfState) {
                case TOP:
                    if (ch < 0x80) {
                        _length--;

                        _value.append((char) ch);
                    } else if (ch < 0xe0) {
                        _ch = (char) ((ch & 0x1f) << 6);
                        _utfState = UTF_2_1;
                    } else {
                        _ch = (char) ((ch & 0xf) << 12);
                        _utfState = UTF_3_1;
                    }
                    break;

                case UTF_2_1:
                case UTF_3_2:
                    _ch += ch & 0x3f;
                    _value.append(_ch);
                    _length--;
                    _utfState = TOP;
                    break;

                case UTF_3_1:
                    _ch += (char) ((ch & 0x3f) << 6);
                    _utfState = UTF_3_2;
                    break;
            }

            if (_length == 0 && _isLastChunk) {
                if (_next.isShift(_value.toString()))
                    return _next.shift(_value.toString());
                else {
                    printObject("\"" + _value + "\"");

                    return _next;
                }
            } else
                return this;
        }
    }

    class BinaryState extends State {
        char _typeCode;

        int _totalLength;

        int _lengthIndex;
        int _length;
        boolean _isLastChunk;

        BinaryState(State next, char typeCode, boolean isLastChunk) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = isLastChunk;
        }

        BinaryState(State next, char typeCode, int length) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = true;
            _length = length;
            _lengthIndex = 2;
        }

        BinaryState(State next, char typeCode, int length, boolean isLastChunk) {
            super(next);

            _typeCode = typeCode;
            _isLastChunk = isLastChunk;
            _length = length;
            _lengthIndex = 1;
        }

        @Override
        State next(int ch) {
            if (_lengthIndex < 2) {
                _length = 256 * _length + (ch & 0xff);

                if (++_lengthIndex == 2 && _length == 0 && _isLastChunk) {
                    String value = "binary(" + _totalLength + ")";

                    if (_next.isShift(value))
                        return _next.shift(value);
                    else {
                        printObject(value);
                        return _next;
                    }
                } else
                    return this;
            } else if (_length == 0) {
                if (ch == 'b') {
                    _isLastChunk = false;
                    _lengthIndex = 0;
                    return this;
                } else if (ch == 'B') {
                    _isLastChunk = true;
                    _lengthIndex = 0;
                    return this;
                } else if (ch == 0x20) {
                    String value = "binary(" + _totalLength + ")";

                    if (_next.isShift(value))
                        return _next.shift(value);
                    else {
                        printObject(value);
                        return _next;
                    }
                } else if (0x20 <= ch && ch < 0x30) {
                    _isLastChunk = true;
                    _lengthIndex = 2;
                    _length = (ch & 0xff) - 0x20;
                    return this;
                } else {
                    println(String.valueOf((char) ch) + ": unexpected character");
                    return _next;
                }
            }

            _length--;
            _totalLength++;

            if (_length == 0 && _isLastChunk) {
                String value = "binary(" + _totalLength + ")";

                if (_next.isShift(value))
                    return _next.shift(value);
                else {
                    printObject(value);

                    return _next;
                }
            } else
                return this;
        }
    }

    class MapState extends State {
        private static final int TYPE = 0;
        private static final int KEY = 1;
        private static final int VALUE = 2;

        private int _refId;

        private int _state;
        private int _valueDepth;
        private boolean _hasData;

        MapState(State next, int refId) {
            super(next);

            _refId = refId;
            _state = TYPE;
        }

        MapState(State next, int refId, boolean isType) {
            super(next);

            _refId = refId;

            if (isType)
                _state = TYPE;
            else {
                printObject("map (#" + _refId + ")");
                _state = VALUE;
            }
        }

        @Override
        boolean isShift(Object value) {
            return _state == TYPE;
        }

        @Override
        State shift(Object type) {
            if (_state == TYPE) {
                if (type instanceof String) {
                    _typeDefList.add((String) type);
                } else if (type instanceof Integer) {
                    int iValue = (Integer) type;

                    if (iValue >= 0 && iValue < _typeDefList.size())
                        type = _typeDefList.get(iValue);
                }

                printObject("map " + type + " (#" + _refId + ")");

                _state = VALUE;

                return this;
            } else
                throw new IllegalStateException();
        }

        @Override
        int depth() {
            if (_state == TYPE)
                return _next.depth();
            else if (_state == KEY)
                return _next.depth() + 2;
            else
                return _valueDepth;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    return nextObject(ch);

                case VALUE:
                    if (ch == 'Z') {
                        if (_hasData)
                            println();

                        return _next;
                    } else {
                        if (_hasData)
                            println();

                        _hasData = true;
                        _state = KEY;

                        return nextObject(ch);
                    }

                case KEY:
                    print(" => ");
                    _isObject = false;
                    _valueDepth = _column;

                    _state = VALUE;

                    return nextObject(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class ObjectDefState extends State {
        private static final int TYPE = 1;
        private static final int COUNT = 2;
        private static final int FIELD = 3;
        private static final int COMPLETE = 4;

        private int _refId;

        private int _state;
        private boolean _hasData;
        private int _count;

        private String _type;
        private ArrayList<String> _fields = new ArrayList<String>();

        ObjectDefState(State next) {
            super(next);

            _state = TYPE;
        }

        @Override
        boolean isShift(Object value) {
            return true;
        }

        @Override
        State shift(Object object) {
            if (_state == TYPE) {
                _type = (String) object;

                print("/* defun " + _type + " [");

                _objectDefList.add(new ObjectDef(_type, _fields));

                _state = COUNT;
            } else if (_state == COUNT) {
                _count = (Integer) object;

                _state = FIELD;
            } else if (_state == FIELD) {
                String field = (String) object;

                _count--;

                _fields.add(field);

                if (_fields.size() == 1)
                    print(field);
                else
                    print(", " + field);
            } else {
                throw new UnsupportedOperationException();
            }

            return this;
        }

        @Override
        int depth() {
            if (_state <= TYPE)
                return _next.depth();
            else
                return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    return nextObject(ch);

                case COUNT:
                    return nextObject(ch);

                case FIELD:
                    if (_count == 0) {
                        println("] */");
                        _next.printIndent(0);

                        return _next.nextObject(ch);
                    } else
                        return nextObject(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class ObjectState extends State {
        private static final int TYPE = 0;
        private static final int FIELD = 1;

        private int _refId;

        private int _state;
        private ObjectDef _def;
        private int _count;
        private int _fieldDepth;

        ObjectState(State next, int refId) {
            super(next);

            _refId = refId;
            _state = TYPE;
        }

        ObjectState(State next, int refId, int def) {
            super(next);

            _refId = refId;
            _state = FIELD;

            if (def < 0 || _objectDefList.size() <= def) {
                throw new IllegalStateException(def + " is an unknown object type");
            }

            _def = _objectDefList.get(def);

            println("object " + _def.getType() + " (#" + _refId + ")");
        }

        @Override
        boolean isShift(Object value) {
            if (_state == TYPE)
                return true;
            else
                return false;
        }

        @Override
        State shift(Object object) {
            if (_state == TYPE) {
                int def = (Integer) object;

                _def = _objectDefList.get(def);

                println("object " + _def.getType() + " (#" + _refId + ")");

                _state = FIELD;

                if (_def.getFields().size() == 0)
                    return _next;
            }

            return this;
        }

        @Override
        int depth() {
            if (_state <= TYPE)
                return _next.depth();
            else
                return _fieldDepth;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    return nextObject(ch);

                case FIELD:
                    if (_def.getFields().size() <= _count)
                        return _next.next(ch);

                    _fieldDepth = _next.depth() + 2;
                    println();
                    print(_def.getFields().get(_count++) + ": ");

                    _fieldDepth = _column;

                    _isObject = false;
                    return nextObject(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class ListState extends State {
        private static final int TYPE = 0;
        private static final int LENGTH = 1;
        private static final int VALUE = 2;

        private int _refId;

        private int _state;
        private boolean _hasData;
        private int _count;
        private int _valueDepth;

        ListState(State next, int refId, boolean isType) {
            super(next);

            _refId = refId;

            if (isType)
                _state = TYPE;
            else {
                printObject("list (#" + _refId + ")");
                _state = VALUE;
            }
        }

        @Override
        boolean isShift(Object value) {
            return _state == TYPE || _state == LENGTH;
        }

        @Override
        State shift(Object object) {
            if (_state == TYPE) {
                Object type = object;

                if (type instanceof String) {
                    _typeDefList.add((String) type);
                } else if (object instanceof Integer) {
                    int index = (Integer) object;

                    if (index >= 0 && index < _typeDefList.size())
                        type = _typeDefList.get(index);
                    else
                        type = "type-unknown(" + index + ")";
                }

                printObject("list " + type + "(#" + _refId + ")");

                _state = VALUE;

                return this;
            } else if (_state == LENGTH) {
                _state = VALUE;

                return this;
            } else
                return this;
        }

        @Override
        int depth() {
            if (_state <= LENGTH)
                return _next.depth();
            else if (_state == VALUE)
                return _valueDepth;
            else
                return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    return nextObject(ch);

                case VALUE:
                    if (ch == 'Z') {
                        if (_count > 0)
                            println();

                        return _next;
                    } else {
                        _valueDepth = _next.depth() + 2;
                        println();
                        printObject(_count++ + ": ");
                        _valueDepth = _column;
                        _isObject = false;

                        return nextObject(ch);
                    }

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class CompactListState extends State {
        private static final int TYPE = 0;
        private static final int LENGTH = 1;
        private static final int VALUE = 2;

        private int _refId;

        private boolean _isTyped;
        private boolean _isLength;

        private int _state;
        private boolean _hasData;
        private int _length;
        private int _count;
        private int _valueDepth;

        CompactListState(State next, int refId, boolean isTyped) {
            super(next);

            _isTyped = isTyped;
            _refId = refId;

            if (isTyped)
                _state = TYPE;
            else
                _state = LENGTH;
        }

        CompactListState(State next, int refId, boolean isTyped, int length) {
            super(next);

            _isTyped = isTyped;
            _refId = refId;
            _length = length;

            _isLength = true;

            if (isTyped)
                _state = TYPE;
            else {
                printObject("list (#" + _refId + ")");

                _state = VALUE;
            }
        }

        @Override
        boolean isShift(Object value) {
            return _state == TYPE || _state == LENGTH;
        }

        @Override
        State shift(Object object) {
            if (_state == TYPE) {
                Object type = object;

                if (object instanceof Integer) {
                    int index = (Integer) object;

                    if (index >= 0 && index < _typeDefList.size())
                        type = _typeDefList.get(index);
                    else
                        type = "type-unknown(" + index + ")";
                } else if (object instanceof String)
                    _typeDefList.add((String) object);

                printObject("list " + type + " (#" + _refId + ")");

                if (_isLength) {
                    _state = VALUE;

                    if (_length == 0)
                        return _next;
                } else
                    _state = LENGTH;

                return this;
            } else if (_state == LENGTH) {
                _length = (Integer) object;

                if (!_isTyped)
                    printObject("list (#" + _refId + ")");

                _state = VALUE;

                if (_length == 0)
                    return _next;
                else
                    return this;
            } else
                return this;
        }

        @Override
        int depth() {
            if (_state <= LENGTH)
                return _next.depth();
            else if (_state == VALUE)
                return _valueDepth;
            else
                return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    return nextObject(ch);

                case LENGTH:
                    return nextObject(ch);

                case VALUE:
                    if (_length <= _count)
                        return _next.next(ch);
                    else {
                        _valueDepth = _next.depth() + 2;
                        println();
                        printObject(_count++ + ": ");
                        _valueDepth = _column;
                        _isObject = false;

                        return nextObject(ch);
                    }

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class Hessian2State extends State {
        private static final int MAJOR = 0;
        private static final int MINOR = 1;

        private int _state;
        private int _major;
        private int _minor;

        Hessian2State(State next) {
            super(next);
        }

        @Override
        int depth() {
            return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case MAJOR:
                    _major = ch;
                    _state = MINOR;
                    return this;

                case MINOR:
                    _minor = ch;
                    println(-2, "hessian " + _major + "." + _minor);
                    return _next;

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class CallState extends State {
        private static final int MAJOR = 0;
        private static final int MINOR = 1;
        private static final int HEADER = 2;
        private static final int METHOD = 3;
        private static final int VALUE = 4;
        private static final int ARG = 5;

        private int _state;
        private int _major;
        private int _minor;

        CallState(State next) {
            super(next);
        }

        @Override
        int depth() {
            return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case MAJOR:
                    _major = ch;
                    _state = MINOR;
                    return this;

                case MINOR:
                    _minor = ch;
                    _state = HEADER;
                    println(-2, "call " + _major + "." + _minor);
                    return this;

                case HEADER:
                    if (ch == 'H') {
                        println();
                        print("header ");
                        _isObject = false;
                        _state = VALUE;
                        return new StringState(this, 'H', true);
                    } else if (ch == 'm') {
                        println();
                        print("method ");
                        _isObject = false;
                        _state = ARG;
                        return new StringState(this, 'm', true);
                    } else {
                        println((char) ch + ": unexpected char");
                        return popStack();
                    }

                case VALUE:
                    print(" => ");
                    _isObject = false;
                    _state = HEADER;
                    return nextObject(ch);

                case ARG:
                    if (ch == 'Z')
                        return _next;
                    else
                        return nextObject(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class Call2State extends State {
        private static final int METHOD = 0;
        private static final int COUNT = 1;
        private static final int ARG = 2;

        private int _state = METHOD;
        private int _i;
        private int _count;

        Call2State(State next) {
            super(next);
        }

        @Override
        int depth() {
            return _next.depth() + 5;
        }

        @Override
        boolean isShift(Object value) {
            return _state != ARG;
        }

        @Override
        State shift(Object object) {
            if (_state == METHOD) {
                println(-5, "Call " + object);

                _state = COUNT;
                return this;
            } else if (_state == COUNT) {
                Integer count = (Integer) object;

                _count = count;

                _state = ARG;

                if (_count == 0)
                    return _next;
                else
                    return this;
            } else
                return this;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case COUNT:
                    return nextObject(ch);

                case METHOD:
                    return nextObject(ch);

                case ARG:
                    if (_count <= _i)
                        return _next.next(ch);
                    else {
                        println();
                        print(-3, _i++ + ": ");

                        return nextObject(ch);
                    }

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class ReplyState extends State {
        private static final int MAJOR = 0;
        private static final int MINOR = 1;
        private static final int HEADER = 2;
        private static final int VALUE = 3;
        private static final int END = 4;

        private int _state;
        private int _major;
        private int _minor;

        ReplyState(State next) {
            _next = next;
        }

        @Override
        int depth() {
            return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case MAJOR:
                    if (ch == 't' || ch == 'S')
                        return new RemoteState(this).next(ch);

                    _major = ch;
                    _state = MINOR;
                    return this;

                case MINOR:
                    _minor = ch;
                    _state = HEADER;
                    println(-2, "reply " + _major + "." + _minor);
                    return this;

                case HEADER:
                    if (ch == 'H') {
                        _state = VALUE;
                        return new StringState(this, 'H', true);
                    } else if (ch == 'f') {
                        print("fault ");
                        _isObject = false;
                        _state = END;
                        return new MapState(this, 0);
                    } else {
                        _state = END;
                        return nextObject(ch);
                    }

                case VALUE:
                    _state = HEADER;
                    return nextObject(ch);

                case END:
                    println();
                    if (ch == 'Z') {
                        return _next;
                    } else
                        return _next.next(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class Reply2State extends State {
        Reply2State(State next) {
            super(next);

            println(-2, "Reply");
        }

        @Override
        int depth() {
            return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            return nextObject(ch);
        }
    }

    class Fault2State extends State {
        Fault2State(State next) {
            super(next);

            println(-2, "Fault");
        }

        @Override
        int depth() {
            return _next.depth() + 2;
        }

        @Override
        State next(int ch) {
            return nextObject(ch);
        }
    }

    class IndirectState extends State {
        IndirectState(State next) {
            super(next);
        }

        @Override
        boolean isShift(Object object) {
            return _next.isShift(object);
        }

        @Override
        State shift(Object object) {
            return _next.shift(object);
        }

        @Override
        State next(int ch) {
            return nextObject(ch);
        }
    }

    class RemoteState extends State {
        private static final int TYPE = 0;
        private static final int VALUE = 1;
        private static final int END = 2;

        private int _state;
        private int _major;
        private int _minor;

        RemoteState(State next) {
            super(next);
        }

        @Override
        State next(int ch) {
            switch (_state) {
                case TYPE:
                    println(-1, "remote");
                    if (ch == 't') {
                        _state = VALUE;
                        return new StringState(this, 't', false);
                    } else {
                        _state = END;
                        return nextObject(ch);
                    }

                case VALUE:
                    _state = END;
                    return _next.nextObject(ch);

                case END:
                    return _next.next(ch);

                default:
                    throw new IllegalStateException();
            }
        }
    }

    class StreamingState extends State {
        private int _digit;
        private int _length;
        private boolean _isLast;
        private boolean _isFirst = true;

        private State _childState;

        StreamingState(State next, boolean isLast) {
            super(next);

            _isLast = isLast;
            _childState = new InitialState();
        }

        @Override
        State next(int ch) {
            if (_digit < 2) {
                _length = 256 * _length + ch;
                _digit++;

                if (_digit == 2 && _length == 0 && _isLast) {
                    _refId = 0;
                    return _next;
                } else {
                    if (_digit == 2)
                        println(-1, "packet-start(" + _length + ")");

                    return this;
                }
            } else if (_length == 0) {
                _isLast = (ch == 'P');
                _digit = 0;

                return this;
            }

            _childState = _childState.next(ch);

            _length--;

            if (_length == 0 && _isLast) {
                println(-1, "");
                println(-1, "packet-end");
                _refId = 0;
                return _next;
            } else
                return this;
        }
    }
}