/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

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

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

package com.sun.corba.se.impl.encoding;

import java.io.Serializable;

import java.io.ObjectInputStream;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.math.BigDecimal;

import java.util.LinkedList;

import com.sun.corba.se.spi.orb.ORB;

import com.sun.corba.se.spi.ior.IOR;

import com.sun.corba.se.spi.ior.IORFactories;

import com.sun.corba.se.spi.ior.iiop.GIOPVersion;

import com.sun.corba.se.spi.logging.CORBALogDomains;

import com.sun.corba.se.spi.presentation.rmi.StubAdapter;

import com.sun.corba.se.spi.presentation.rmi.PresentationManager;

import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults;

import com.sun.corba.se.impl.util.Utility;

import com.sun.corba.se.impl.orbutil.ORBUtility;

import com.sun.corba.se.impl.corba.TypeCodeImpl;

import com.sun.corba.se.impl.util.RepositoryId;

import com.sun.corba.se.impl.orbutil.ORBConstants;

import com.sun.corba.se.impl.logging.ORBUtilSystemException;

import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;

import org.omg.CORBA.Any;

import org.omg.CORBA.TypeCode;

import org.omg.CORBA.Principal;

import org.omg.CORBA.portable.IDLEntity;

/**

 * Implementation class that uses Java serialization for input streams.

 * This assumes a GIOP version 1.2 message format.

 *

 * This class uses a ByteArrayInputStream as the underlying buffer. The

 * first 16 bytes are directly read out of the underlying buffer. This allows

 * [GIOPHeader (12 bytes) + requestID (4 bytes)] to be read as bytes.

 * Subsequent write operations on this output stream object uses

 * ObjectInputStream class to read into the buffer. This allows unmarshaling

 * complex types and graphs using the ObjectInputStream implementation.

 *

 * Note, this class assumes a GIOP 1.2 style header. Further, the first

 * 12 bytes, that is, the GIOPHeader is read directly from the received

 * message, before this stream object is called. So, this class effectively

 * reads only the requestID (4 bytes) directly, and uses the

 * ObjectInputStream for further unmarshaling.

 *

 * @author Ram Jeyaraman

 */

public class IDLJavaSerializationInputStream extends CDRInputStreamBase {

    private ORB orb;

    private int bufSize;

    private ByteBuffer buffer;

    private byte encodingVersion;

    private ObjectInputStream is;

    private _ByteArrayInputStream bis;

    private BufferManagerRead bufferManager;

    // [GIOPHeader(12) + requestID(4)] bytes

    private final int directReadLength = Message.GIOPMessageHeaderLength + 4;

    // Used for mark / reset operations.

    private boolean markOn;

    private int peekIndex, peekCount;

    private LinkedList markedItemQ = new LinkedList();

    protected ORBUtilSystemException wrapper;

    class _ByteArrayInputStream extends ByteArrayInputStream {

        _ByteArrayInputStream(byte[] buf) {

            super(buf);

        }

        int getPosition() {

            return this.pos;

        }

        void setPosition(int value) {

            if (value < 0 || value > count) {

                throw new IndexOutOfBoundsException();

            }

            this.pos = value;

        }

    }

    class MarshalObjectInputStream extends ObjectInputStream {

        ORB orb;

        MarshalObjectInputStream(java.io.InputStream out, ORB orb)

                throws IOException {

            super(out);

            this.orb = orb;

            java.security.AccessController.doPrivileged(

                new java.security.PrivilegedAction() {

                    public Object run() {

                        // needs SerializablePermission("enableSubstitution")

                        enableResolveObject(true);

                        return null;

                    }

                }

            );

        }

        /**

         * Connect the Stub to the ORB.

         */

        protected final Object resolveObject(Object obj) throws IOException {

            try {

                if (StubAdapter.isStub(obj)) {

                    StubAdapter.connect(obj, orb);

                }

            } catch (java.rmi.RemoteException re) {

                IOException ie = new IOException("resolveObject failed");

                ie.initCause(re);

                throw ie;

            }

            return obj;

        }

    }

    public IDLJavaSerializationInputStream(byte encodingVersion) {

        super();

        this.encodingVersion = encodingVersion;

    }

    public void init(org.omg.CORBA.ORB orb,

                     ByteBuffer byteBuffer,

                     int bufSize,

                     boolean littleEndian,

                     BufferManagerRead bufferManager) {

        this.orb = (ORB) orb;

        this.bufSize = bufSize;

        this.bufferManager = bufferManager;

        buffer = byteBuffer;

        wrapper =

            ORBUtilSystemException.get((ORB)orb, CORBALogDomains.RPC_ENCODING);

        byte[] buf;

        if (buffer.hasArray()) {

            buf = buffer.array();

        } else {

            buf = new byte[bufSize];

            buffer.get(buf);

        }

        // Note: at this point, the buffer position is zero. The setIndex()

        // method call can be used to set a desired read index.

        bis = new _ByteArrayInputStream(buf);

    }

    // Called from read_octet or read_long or read_ulong method.

    private void initObjectInputStream() {

        //System.out.print(" is ");

        if (is != null) {

            throw wrapper.javaStreamInitFailed();

        }

        try {

            is = new MarshalObjectInputStream(bis, orb);

        } catch (Exception e) {

            throw wrapper.javaStreamInitFailed(e);

        }

    }

    // org.omg.CORBA.portable.InputStream

    // Primitive types.

    public boolean read_boolean() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Boolean)markedItemQ.removeFirst()).booleanValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Boolean)markedItemQ.get(peekIndex++)).booleanValue();

        }

        try {

            boolean value = is.readBoolean();

            if (markOn) { // enqueue

                markedItemQ.addLast(Boolean.valueOf(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_boolean");

        }

    }

    public char read_char() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Character)markedItemQ.removeFirst()).charValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Character)markedItemQ.get(peekIndex++)).charValue();

        }

        try {

            char value = is.readChar();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Character(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_char");

        }

    }

    public char read_wchar() {

        return this.read_char();

    }

    public byte read_octet() {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes

        if (bis.getPosition() < directReadLength) {

            byte b = (byte) bis.read();

            if (bis.getPosition() == directReadLength) {

                initObjectInputStream();

            }

            return b;

        }

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Byte)markedItemQ.removeFirst()).byteValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Byte)markedItemQ.get(peekIndex++)).byteValue();

        }

        try {

            byte value = is.readByte();

            if (markOn) { // enqueue

                //markedItemQ.addLast(Byte.valueOf(value)); // only in JDK 1.5

                markedItemQ.addLast(new Byte(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_octet");

        }

    }

    public short read_short() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Short)markedItemQ.removeFirst()).shortValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Short)markedItemQ.get(peekIndex++)).shortValue();

        }

        try {

            short value = is.readShort();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Short(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_short");

        }

    }

    public short read_ushort() {

        return this.read_short();

    }

    public int read_long() {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes

        if (bis.getPosition() < directReadLength) {

            // Use big endian (network byte order). This is fixed.

            // Both the writer and reader use the same byte order.

            int b1 = (bis.read() << 24) & 0xFF000000;

            int b2 = (bis.read() << 16) & 0x00FF0000;

            int b3 = (bis.read() << 8)  & 0x0000FF00;

            int b4 = (bis.read() << 0)  & 0x000000FF;

            if (bis.getPosition() == directReadLength) {

                initObjectInputStream();

            } else if (bis.getPosition() > directReadLength) {

                // Cannot happen. All direct reads are contained

                // within the first 16 bytes.

                wrapper.javaSerializationException("read_long");

            }

            return (b1 | b2 | b3 | b4);

        }

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Integer)markedItemQ.removeFirst()).intValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Integer)markedItemQ.get(peekIndex++)).intValue();

        }

        try {

            int value = is.readInt();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Integer(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_long");

        }

    }

    public int read_ulong() {

        return this.read_long();

    }

    public long read_longlong() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Long)markedItemQ.removeFirst()).longValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Long)markedItemQ.get(peekIndex++)).longValue();

        }

        try {

            long value = is.readLong();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Long(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_longlong");

        }

    }

    public long read_ulonglong() {

        return read_longlong();

    }

    public float read_float() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Float)markedItemQ.removeFirst()).floatValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Float)markedItemQ.get(peekIndex++)).floatValue();

        }

        try {

            float value = is.readFloat();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Float(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_float");

        }

    }

    public double read_double() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return ((Double)markedItemQ.removeFirst()).doubleValue();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return ((Double)markedItemQ.get(peekIndex++)).doubleValue();

        }

        try {

            double value = is.readDouble();

            if (markOn) { // enqueue

                markedItemQ.addLast(new Double(value));

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_double");

        }

    }

    // String types.

    public String read_string() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return (String) markedItemQ.removeFirst();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

            (peekIndex < peekCount)) { // peek

            return (String) markedItemQ.get(peekIndex++);

        }

        try {

            String value = is.readUTF();

            if (markOn) { // enqueue

                markedItemQ.addLast(value);

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_string");

        }

    }

    public String read_wstring() {

        if (!markOn && !(markedItemQ.isEmpty())) { // dequeue

            return (String) markedItemQ.removeFirst();

        }

        if (markOn && !(markedItemQ.isEmpty()) &&

                (peekIndex < peekCount)) { // peek

            return (String) markedItemQ.get(peekIndex++);

        }

        try {

            String value = (String) is.readObject();

            if (markOn) { // enqueue

                markedItemQ.addLast(value);

            }

            return value;

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_wstring");

        }

    }

    // Array types.

    public void read_boolean_array(boolean[] value, int offset, int length){

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

            value[i+offset] = read_boolean();

        }

    }

    public void read_char_array(char[] value, int offset, int length) {

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

            value[i+offset] = read_char();

        }

    }

    public void read_wchar_array(char[] value, int offset, int length) {

        read_char_array(value, offset, length);

    }

    public void read_octet_array(byte[] value, int offset, int length) {

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

            value[i+offset] = read_octet();

        }

        /* // Cannot use this efficient read due to mark/reset support.

        try {

            while (length > 0) {

                int n = is.read(value, offset, length);

                offset += n;

                length -= n;

            }

        } catch (Exception e) {

            throw wrapper.javaSerializationException(e, "read_octet_array");

        }

        */

    }

    public void read_short_array(short[] value, int offset, int length) {

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

            value[i+offset] = read_short();

        }

    }

    public void read_ushort_array(short[] value, int offset, int length) {

        read_short_array(value, offset, length);

    }

    public void read_long_array(int[] value, int offset, int length) {

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

            value[i+offset] = read_long();

        }

    }

    public void read_ulong_array(int[] value, int offset, int length) {

        read_long_array(value, offset, length);

    }

    public void read_longlong_array(long[] value, int offset, int length) {

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

            value[i+offset] = read_longlong();

        }

    }

    public void read_ulonglong_array(long[] value, int offset, int length) {

        read_longlong_array(value, offset, length);

    }

    public void read_float_array(float[] value, int offset, int length) {

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

            value[i+offset] = read_float();

        }

    }

    public void read_double_array(double[] value, int offset, int length) {

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

            value[i+offset] = read_double();

        }

    }

    // Complex types.

    public org.omg.CORBA.Object read_Object() {

        return read_Object(null);

    }