/*
 * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
 * 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
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.sun.corba.se.impl.encoding;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ByteArrayOutputStream;

import java.nio.ByteBuffer;

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.impl.util.Utility;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.corba.TypeCodeImpl;
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.CompletionStatus;

/**
 * Implementation class that uses Java serialization for output streams.
 * This assumes a GIOP version 1.2 message format.
 *
 * This class uses a ByteArrayOutputStream as the underlying buffer. The
 * first 16 bytes are direct writes into the underlying buffer. This allows
 * [GIOPHeader (12 bytes) + requestID (4 bytes)] to be written as bytes.
 * Subsequent write operations on this output stream object uses
 * ObjectOutputStream class to write into the buffer. This allows marshaling
 * complex types and graphs using the ObjectOutputStream implementation.
 *
 * Note, this class assumes a GIOP 1.2 style header. Note, we expect that the
 * first 16 bytes are written only using the write_octet, write_long or
 * write_ulong method calls.
 *
 * @author Ram Jeyaraman
 */
final class IDLJavaSerializationOutputStream extends CDROutputStreamBase {

    private ORB orb;
    private byte encodingVersion;
    private ObjectOutputStream os;
    private _ByteArrayOutputStream bos;
    private BufferManagerWrite bufferManager;

    // [GIOPHeader(12) + requestID(4)] bytes
    private final int directWriteLength = Message.GIOPMessageHeaderLength + 4;

    protected ORBUtilSystemException wrapper;

    class _ByteArrayOutputStream extends ByteArrayOutputStream {

        _ByteArrayOutputStream(int initialSize) {
            super(initialSize);
        }

        byte[] getByteArray() {
            return this.buf;
        }
    }

    class MarshalObjectOutputStream extends ObjectOutputStream {

        ORB orb;

        MarshalObjectOutputStream(java.io.OutputStream out, ORB orb)
                throws IOException {

            super(out);
            this.orb = orb;
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                    public Object run() {
                        // needs SerializablePermission("enableSubstitution")
                        enableReplaceObject(true);
                        return null;
                    }
                }
            );
        }

        /**
         * Checks for objects that are instances of java.rmi.Remote
         * that need to be serialized as proxy (Stub) objects.
         */
        protected final Object replaceObject(Object obj) throws IOException {
            try {
                if ((obj instanceof java.rmi.Remote) &&
                        !(StubAdapter.isStub(obj))) {
                    return Utility.autoConnect(obj, orb, true);
                }
            } catch (Exception e) {
                IOException ie = new IOException("replaceObject failed");
                ie.initCause(e);
                throw ie;
            }
            return obj;
        }
    }

    public IDLJavaSerializationOutputStream(byte encodingVersion) {
        super();
        this.encodingVersion = encodingVersion;
    }

    public void init(org.omg.CORBA.ORB orb, boolean littleEndian,
                     BufferManagerWrite bufferManager,
                     byte streamFormatVersion,
                     boolean usePooledByteBuffers) {
        this.orb = (ORB) orb;
        this.bufferManager = bufferManager;
        wrapper = ORBUtilSystemException.get((ORB) orb,
                                             CORBALogDomains.RPC_ENCODING);
        bos =
            new _ByteArrayOutputStream(ORBConstants.GIOP_DEFAULT_BUFFER_SIZE);
    }

    // Called from read_octet or read_long or read_ulong method.
    private void initObjectOutputStream() {
        //System.out.print(" os ");
        if (os != null) {
            throw wrapper.javaStreamInitFailed();
        }
        try {
            os = new MarshalObjectOutputStream(bos, orb);
        } catch (Exception e) {
            throw wrapper.javaStreamInitFailed(e);
        }
    }

    // org.omg.CORBA.portable.OutputStream

    // Primitive types.

    public final void write_boolean(boolean value) {
        try {
            os.writeBoolean(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_boolean");
        }
    }

    public final void write_char(char value) {
        try {
            os.writeChar(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_char");
        }
    }

    public final void write_wchar(char value) {
        this.write_char(value);
    }

    public final void write_octet(byte value) {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes
        if (bos.size() < directWriteLength) {
            bos.write(value); // direct write.
            if (bos.size() == directWriteLength) {
                initObjectOutputStream();
            }
            return;
        }

        try {
            os.writeByte(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_octet");
        }
    }

    public final void write_short(short value) {
        try {
            os.writeShort(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_short");
        }
    }

    public final void write_ushort(short value) {
        this.write_short(value);
    }

    public final void write_long(int value) {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes
        if (bos.size() < directWriteLength) {

            // Use big endian (network byte order). This is fixed.
            // Both the writer and reader use the same byte order.
            bos.write((byte)((value >>> 24) & 0xFF));
            bos.write((byte)((value >>> 16) & 0xFF));
            bos.write((byte)((value >>> 8) & 0xFF));
            bos.write((byte)((value >>> 0) & 0xFF));

            if (bos.size() == directWriteLength) {
                initObjectOutputStream();
            } else if (bos.size() > directWriteLength) {
                // Cannot happen. All direct writes are contained
                // within the first 16 bytes.
                wrapper.javaSerializationException("write_long");
            }
            return;
        }

        try {
            os.writeInt(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_long");
        }
    }

    public final void write_ulong(int value) {
        this.write_long(value);
    }

    public final void write_longlong(long value) {
        try {
            os.writeLong(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_longlong");
        }
    }

    public final void write_ulonglong(long value) {
        this.write_longlong(value);
    }

    public final void write_float(float value) {
        try {
            os.writeFloat(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_float");
        }
    }

    public final void write_double(double value) {
        try {
            os.writeDouble(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_double");
        }
    }

    // String types.

    public final void write_string(String value) {
        try {
            os.writeUTF(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_string");
        }
    }

    public final void write_wstring(String value) {
        try {
            os.writeObject(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_wstring");
        }
    }

    // Array types.

    public final void write_boolean_array(boolean[] value,
                                          int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_boolean(value[offset + i]);
        }
    }

    public final void write_char_array(char[] value, int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_char(value[offset + i]);
        }
    }

    public final void write_wchar_array(char[] value, int offset, int length) {
        write_char_array(value, offset, length);
    }

    public final void write_octet_array(byte[] value, int offset, int length) {
        try {
            os.write(value, offset, length);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_octet_array");
        }
    }

    public final void write_short_array(short[] value,
                                        int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_short(value[offset + i]);
        }
    }

    public final void write_ushort_array(short[] value,
                                         int offset, int length){
        write_short_array(value, offset, length);
    }

    public final void write_long_array(int[] value, int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_long(value[offset + i]);
        }
    }

    public final void write_ulong_array(int[] value, int offset, int length) {
        write_long_array(value, offset, length);
    }

    public final void write_longlong_array(long[] value,
                                           int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_longlong(value[offset + i]);
        }
    }

    public final void write_ulonglong_array(long[] value,
                                            int offset,int length) {
        write_longlong_array(value, offset, length);
    }

    public final void write_float_array(float[] value,
                                        int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_float(value[offset + i]);
        }
    }

    public final void write_double_array(double[] value,
                                         int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_double(value[offset + i]);
        }
    }

    // Complex types (objects and graphs).

    public final void write_Object(org.omg.CORBA.Object value) {
        if (value == null) {
            IOR nullIOR = IORFactories.makeIOR(orb);
            nullIOR.write(parent);
            return;
        }
        // IDL to Java formal 01-06-06 1.21.4.2
        if (value instanceof org.omg.CORBA.LocalObject) {
            throw wrapper.writeLocalObject(CompletionStatus.COMPLETED_MAYBE);
        }
        IOR ior = ORBUtility.connectAndGetIOR(orb, value);
        ior.write(parent);
        return;
    }

    public final void write_TypeCode(TypeCode tc) {
        if (tc == null) {
            throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE);
        }
        TypeCodeImpl tci;
        if (tc instanceof TypeCodeImpl) {
            tci = (TypeCodeImpl) tc;
        } else {
            tci = new TypeCodeImpl(orb, tc);
        }
        tci.write_value((org.omg.CORBA_2_3.portable.OutputStream) parent);
    }

    public final void write_any(Any any) {
        if (any == null) {
            throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE);
        }
        write_TypeCode(any.type());
        any.write_value(parent);
    }

    public final void write_Principal(Principal p) {
        // We don't need an implementation for this method, since principal
        // is absent in GIOP version 1.2 or above.
        write_long(p.name().length);
        write_octet_array(p.name(), 0, p.name().length);
    }

    public final void write_fixed(java.math.BigDecimal bigDecimal) {
        // This string might contain sign and/or dot
        this.write_fixed(bigDecimal.toString(), bigDecimal.signum());
    }

    // The string may contain a sign and dot
    private void write_fixed(String string, int signum) {

        int stringLength = string.length();

        // Each octet contains (up to) two decimal digits.
        byte doubleDigit = 0;
        char ch;
        byte digit;

        // First calculate the string length without optional sign and dot.
        int numDigits = 0;
        for (int i=0; i<stringLength; i++) {
            ch = string.charAt(i);
            if (ch == '-' || ch == '+' || ch == '.')
                continue;
            numDigits++;
        }

        for (int i=0; i<stringLength; i++) {
            ch = string.charAt(i);
            if (ch == '-' || ch == '+' || ch == '.')
                continue;
            digit = (byte)Character.digit(ch, 10);
            if (digit == -1) {
                throw wrapper.badDigitInFixed(
                                            CompletionStatus.COMPLETED_MAYBE);
            }
            // If the fixed type has an odd number of decimal digits, then the
            // representation begins with the first (most significant) digit.
            // Otherwise, this first half-octet is all zero, and the first
            // digit is in the second half-octet.
            if (numDigits % 2 == 0) {
                doubleDigit |= digit;
                this.write_octet(doubleDigit);
                doubleDigit = 0;
            } else {
                doubleDigit |= (digit << 4);
            }
            numDigits--;
        }

        // The sign configuration in the last half-octet of the representation,
        // is 0xD for negative numbers and 0xC for positive and zero values.
        if (signum == -1) {
            doubleDigit |= 0xd;
        } else {
            doubleDigit |= 0xc;
        }
        this.write_octet(doubleDigit);
    }

    public final org.omg.CORBA.ORB orb() {
        return this.orb;
    }

    // org.omg.CORBA_2_3.portable.OutputStream

    public final void write_value(java.io.Serializable value) {
        write_value(value, (String) null);
    }

    public final void write_value(java.io.Serializable value,
                                  java.lang.Class clz) {
        write_value(value);
    }

    public final void write_value(java.io.Serializable value,
                                  String repository_id) {
        try {
            os.writeObject(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_value");
        }
    }

    public final void write_value(java.io.Serializable value,
                             org.omg.CORBA.portable.BoxedValueHelper factory) {
        this.write_value(value, (String) null);
    }

    public final void write_abstract_interface(java.lang.Object obj) {

        boolean isCorbaObject = false; // Assume value type.
        org.omg.CORBA.Object theCorbaObject = null;

        // Is it a CORBA.Object?
        if (obj != null && obj instanceof org.omg.CORBA.Object) {
            theCorbaObject = (org.omg.CORBA.Object)obj;
            isCorbaObject = true;
        }

        // Write the boolean flag.
        this.write_boolean(isCorbaObject);

        // Now write out the object.
        if (isCorbaObject) {
            write_Object(theCorbaObject);
        } else {
            try {
                write_value((java.io.Serializable)obj);
            } catch(ClassCastException cce) {
                if (obj instanceof java.io.Serializable) {
                    throw cce;
                } else {
                    ORBUtility.throwNotSerializableForCorba(
                                                    obj.getClass().getName());
                }
            }
        }
    }

    // com.sun.corba.se.os.encoding.MarshalOutputStream

    public final void start_block() {
        throw wrapper.giopVersionError();
    }

    public final void end_block() {
        throw wrapper.giopVersionError();
    }

    public final void putEndian() {
        throw wrapper.giopVersionError();
    }

    public void writeTo(java.io.OutputStream s) throws IOException {
        try {
            os.flush();
            bos.writeTo(s);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "writeTo");
        }
    }

    public final byte[] toByteArray() {
        try {
            os.flush();
            return bos.toByteArray(); // new copy.
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "toByteArray");
        }
    }

    // org.omg.CORBA.DataOutputStream

    public final void write_Abstract (java.lang.Object value) {
        write_abstract_interface(value);
    }

    public final void write_Value(java.io.Serializable value) {
        write_value(value);
    }

    public final void write_any_array(org.omg.CORBA.Any[] value,
                                      int offset, int length) {
        for(int i = 0; i < length; i++) {
            write_any(value[offset + i]);
        }
    }

    // org.omg.CORBA.portable.ValueBase

    public final String[] _truncatable_ids() {
        throw wrapper.giopVersionError();
    }

    // Other.

    public final int getSize() {
        try {
            os.flush();
            return bos.size();
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_boolean");
        }
    }

    public final int getIndex() {
        return getSize();
    }

    protected int getRealIndex(int index) {
        return getSize();
    }

    public final void setIndex(int value) {
        throw wrapper.giopVersionError();
    }

    public final ByteBuffer getByteBuffer() {
        throw wrapper.giopVersionError();
    }

    public final void setByteBuffer(ByteBuffer byteBuffer) {
        throw wrapper.giopVersionError();
    }

    public final boolean isLittleEndian() {
        // Java serialization uses network byte order, that is, big-endian.
        return false;
    }

    public ByteBufferWithInfo getByteBufferWithInfo() {
        try {
            os.flush();
        } catch (Exception e) {
            throw wrapper.javaSerializationException(
                                            e, "getByteBufferWithInfo");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(bos.getByteArray());
        byteBuffer.limit(bos.size());
        return new ByteBufferWithInfo(this.orb, byteBuffer, bos.size());
    }

    public void setByteBufferWithInfo(ByteBufferWithInfo bbwi) {
        throw wrapper.giopVersionError();
    }

    public final BufferManagerWrite getBufferManager() {
        return bufferManager;
    }

    // This will stay a custom add-on until the java-rtf issue is resolved.
    // Then it should be declared in org.omg.CORBA.portable.OutputStream.
    //
    // Pads the string representation of bigDecimal with zeros to fit the given
    // digits and scale before it gets written to the stream.
    public final void write_fixed(java.math.BigDecimal bigDecimal,
                                  short digits, short scale) {
        String string = bigDecimal.toString();
        String integerPart;
        String fractionPart;
        StringBuffer stringBuffer;

        // Get rid of the sign
        if (string.charAt(0) == '-' || string.charAt(0) == '+') {
            string = string.substring(1);
        }

        // Determine integer and fraction parts
        int dotIndex = string.indexOf('.');
        if (dotIndex == -1) {
            integerPart = string;
            fractionPart = null;
        } else if (dotIndex == 0 ) {
            integerPart = null;
            fractionPart = string;
        } else {
            integerPart = string.substring(0, dotIndex);
            fractionPart = string.substring(dotIndex + 1);
        }

        // Pad both parts with zeros as necessary
        stringBuffer = new StringBuffer(digits);
        if (fractionPart != null) {
            stringBuffer.append(fractionPart);
        }
        while (stringBuffer.length() < scale) {
            stringBuffer.append('0');
        }
        if (integerPart != null) {
            stringBuffer.insert(0, integerPart);
        }
        while (stringBuffer.length() < digits) {
            stringBuffer.insert(0, '0');
        }

        // This string contains no sign or dot
        this.write_fixed(stringBuffer.toString(), bigDecimal.signum());
    }

    public final void writeOctetSequenceTo(
            org.omg.CORBA.portable.OutputStream s) {
        byte[] buf = this.toByteArray(); // new copy.
        s.write_long(buf.length);
        s.write_octet_array(buf, 0, buf.length);
    }

    public final GIOPVersion getGIOPVersion() {
        return GIOPVersion.V1_2;
    }

    public final void writeIndirection(int tag, int posIndirectedTo) {
        throw wrapper.giopVersionError();
    }

    void freeInternalCaches() {}

    void printBuffer() {
        byte[] buf = this.toByteArray();

        System.out.println("+++++++ Output Buffer ++++++++");
        System.out.println();
        System.out.println("Current position: " + buf.length);
        //System.out.println("Total length : " + buf.length);
        System.out.println();

        char[] charBuf = new char[16];

        try {

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

                int j = 0;

                // For every 16 bytes, there is one line
                // of output.  First, the hex output of
                // the 16 bytes with each byte separated
                // by a space.
                while (j < 16 && j + i < buf.length) {
                    int k = buf[i + j];
                    if (k < 0)
                        k = 256 + k;
                    String hex = Integer.toHexString(k);
                    if (hex.length() == 1)
                        hex = "0" + hex;
                    System.out.print(hex + " ");
                    j++;
                }

                // Add any extra spaces to align the
                // text column in case we didn't end
                // at 16
                while (j < 16) {
                    System.out.print("   ");
                    j++;
                }

                // Now output the ASCII equivalents.  Non-ASCII
                // characters are shown as periods.
                int x = 0;

                while (x < 16 && x + i < buf.length) {
                    if (ORBUtility.isPrintable((char)buf[i + x])) {
                        charBuf[x] = (char) buf[i + x];
                    } else {
                        charBuf[x] = '.';
                    }
                    x++;
                }
                System.out.println(new String(charBuf, 0, x));
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
        System.out.println("++++++++++++++++++++++++++++++");
    }

    public void alignOnBoundary(int octetBoundary) {
        throw wrapper.giopVersionError();
    }

    // Needed by request and reply messages for GIOP versions >= 1.2 only.
    public void setHeaderPadding(boolean headerPadding) {
        // no-op. We don't care about body alignment while using
        // Java serialization. What the GIOP spec states does not apply here.
    }

    // ValueOutputStream -----------------------------

    public void start_value(String rep_id) {
        throw wrapper.giopVersionError();
    }

    public void end_value() {
        throw wrapper.giopVersionError();
    }

    // java.io.OutputStream

    // Note: These methods are defined in the super class and accessible.

    //public abstract void write(byte b[]) throws IOException;
    //public abstract void write(byte b[], int off, int len)
    //    throws IOException;
    //public abstract void flush() throws IOException;
    //public abstract void close() throws IOException;
}