/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Implements ODTDataOutputStream
 *
*/


package com.nokia.tools.themeinstaller.odtconverter;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import com.ibm.icu.text.UnicodeCompressor;

/**
 * Implements ODTDataOutputStream. Helper class for writing strings
 * and numeric values to stream so that native implementation reads
 * them properly.
 *
 */
public class ODTDataOutputStream extends DataOutputStream
    {

    public ODTDataOutputStream( OutputStream aStream )
        {
        super( aStream );
        }

    /**
     * Write unsigned 32-bit integer.
     * Using long as Java's Integer value is restricted to
     * range -2^31 ... 2^31-1
     * @param aValue the value as long
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    public void writeUnsignedInt32( long aValue ) throws IOException, ODTException
        {
        // Using range of unsigned integer
        // Values bigger than 2^32-1 are not allowed
        if ( aValue < 0 || aValue > 0xFFFFFFFFL )
            {
            throw new ODTException(
                    "ODTDataOutputStream writeUnsignedInt32s failed, value out of range" );
            }

        byte[] bArray = new byte[ 4 ];
        bArray[ 3 ] = ( byte ) ( ( aValue & 0xFF000000L ) >> 24 );
        bArray[ 2 ] = ( byte ) ( ( aValue & 0x00FF0000L ) >> 16 );
        bArray[ 1 ] = ( byte ) ( ( aValue & 0x0000FF00L ) >> 8 );
        bArray[ 0 ] = ( byte ) ( aValue & 0x000000FFL );

        int len = bArray.length;
        super.write( bArray, 0, len );
        }

    /**
     * Writes int to stream for native Int32
     * @param aValue
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    public void writeInt32( int aValue ) throws ODTException, IOException
        {
        byte[] bArray = new byte[4]; // we want 32 bit integer
        ByteBuffer buf = ByteBuffer.wrap( bArray );
        // byte order in native is LITTLE_ENDIAN
        buf.order( ByteOrder.LITTLE_ENDIAN );
        buf.putInt( aValue );

        if( buf.hasArray() )
            {
            bArray = buf.array();
            }
        else
            {
            throw new ODTException( "ODTDataOutputStream writeInt32 failed" );
            }

        int len = bArray.length;
        super.write( bArray, 0, len );
        }

    /**
     * Writes int to stream for native Int16
     * @param aValue
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    public void writeInt16( int aValue ) throws ODTException, IOException
        {
        Integer value = new Integer( aValue );
        byte[] bArray = new byte[2]; // we want 16 bit integer
        ByteBuffer buf = ByteBuffer.wrap( bArray );
        // byte order in native is LITTLE_ENDIAN
        buf.order( ByteOrder.LITTLE_ENDIAN );
        buf.putShort( value.shortValue() );

        if( buf.hasArray() )
            {
            bArray = buf.array();
            }
        else
            {
            throw new ODTException( "ODTDataOutputStream writeInt16 failed" );
            }

        int len = bArray.length;
        super.write( bArray, 0, len );
        }

    /**
     * Writes double to stream for native TReal64
     * @param aValue
     * @throws ODTException
     * @throws IOException
     */
    public void writeTReal64( double aValue ) throws ODTException, IOException
        {
        byte[] bArray = new byte[8]; // we want 64 bit TReal
        ByteBuffer buf = ByteBuffer.wrap( bArray );
        buf.order( ByteOrder.LITTLE_ENDIAN );
        buf.putDouble( aValue );

        if( buf.hasArray() )
            {
            bArray = buf.array();
            }
        else
            {
            throw new ODTException( "ODTDataOutputStream writeTReal64 failed" );
            }

        int len = bArray.length;
        super.write( bArray, 0, len );
        }

    /**
     * Writes string to stream for native HBufC8
     *
     * See Symbian common sources for more information:
     *
     * src\common\generic\syslibs\store\USTRM\US_FUNC.CPP
     * ExternalizeL(const TDesC8& aDes8,RWriteStream& aStream)
     *
     * src\common\generic\syslibs\store\INC\U32STD.INL
     * TDesHeader::TDesHeader(const TDesC8& aDes8)
     *
     * @param aS String to write
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    public void writeString8( String aS ) throws ODTException, IOException
        {
        byte[] ba = aS.getBytes();
        int len = ba.length;

        writeCardinality( len, true );

        super.write( ba, 0, len );
        }

    /**
     * Writes string to stream for native HBufC16.
     *
     * See Symbian common sources for more information:
     *
     * src\common\generic\syslibs\store\USTRM\US_FUNC.CPP
     * ExternalizeL(const TDesC16& aDes16,RWriteStream& aStream)
     *
     * src\common\generic\syslibs\store\INC\U32STD.INL
     * TDesHeader::TDesHeader(const TDesC16& aDes16)
     *
     * @param aS String to write
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    public void writeString16( String aS ) throws ODTException, IOException
        {
        // Take length of the String for calculating the cardinality
        // The cardinality is calculated of the original length of the string
        // (before compress) because the original length is again valid when
        // the string is uncompressed in the Symbian side.
        int clen = aS.length();

        // Using UnicodeCopressor to compress string. The Unicode Compression
        // is also used in Unicode builds of Symbian.
        byte[] ba = UnicodeCompressor.compress( aS );
        int len = ba.length;

        writeCardinality( clen, false );

        super.write( ba, 0, len );
        }

    /**
     * Calculates HBufC8 and HBufC16 string length for native stream.
     *
     * See Symbian common sources for more information:
     *
     * src\common\generic\syslibs\store\USTRM\US_UTL.CPP
     * TCardinality::ExternalizeL(RWriteStream& aStream)
     *
     * src\common\generic\syslibs\store\INC\U32STD.INL
     * TDesHeader::TDesHeader(const TDesC16& aDes16)
     * TDesHeader::TDesHeader(const TDesC8& aDes8)
     *
     * @param aLenght string length
     * @param a8bit set true for 8-bit descriptors, this adds one to the count
     * @throws IOException if writing to a stream fails
     * @throws ODTException if data conversion fails
     */
    private void writeCardinality( int aLenght, boolean a8bit ) throws IOException, ODTException
        {
        int count = aLenght * 2;

        if( a8bit )
            {
            count = count + 1;
            }

        if( count <= ( Byte.MAX_VALUE ) )
            {
            super.writeByte( count << 1 );
            }
        else if( count <= ( 65535 >>> 2 ) )
            {
            writeInt16( ( count << 2 ) + 1 );
            }
        else
            {
            writeInt32( ( count << 3 ) + 3 );
            }
        }

    }