/*
* Copyright (c) 2009 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:
*
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using SymbianUtils;

namespace SymbianUtils.Streams
{
    public class SymbianStreamReaderLE : DisposableObject
    {
        #region Enumerations
        [Flags]
        public enum TCloseOperation
        {
            ENone = 0,
            ECloseStream = 1,
            EResetPosition = 2
        }
        #endregion

        #region Factory
        public static SymbianStreamReaderLE New( Stream aStream )
        {
            return new SymbianStreamReaderLE( aStream, TCloseOperation.ENone );
        }

        public static SymbianStreamReaderLE New( Stream aStream, TCloseOperation aFlags )
        {
            return new SymbianStreamReaderLE( aStream, aFlags );
        }
        #endregion

        #region Constructors
        private SymbianStreamReaderLE( Stream aStream, TCloseOperation aFlags )
        {
            iStream = aStream;
            iFlags = aFlags;
            iOriginalPosition = aStream.Position;
        }
        #endregion

        #region API
        public sbyte ReadInt8()
        {
            sbyte b = (sbyte) iStream.ReadByte();
            return b;
        }

        public short ReadInt16()
        {
            sbyte low = ReadInt8();
            sbyte high = ReadInt8();
            int ret = ( high << 8 ) + low;
            return (short) ret;
        }

        public int ReadInt32()
        {
            int low = ReadInt16();
            int high = ReadInt16();
            int ret = ( high << 16 ) + low;
            return ret;
        }

        public byte ReadUInt8()
        {
            return (byte) iStream.ReadByte();
        }

        public ushort ReadUInt16()
        {
            byte[] temp = new byte[ 2 ];
            iStream.Read( temp, 0, temp.Length );
            //
            ushort ret = 0;
            for ( int i = 1; i >= 0; i-- )
            {
                ret |= temp[ i ];
                if ( i > 0 )
                {
                    ret <<= 8;
                }
            }
            return ret;
        }

        public uint ReadUInt32()
        {
            uint low = ReadUInt16();
            uint high = ReadUInt16();
            uint ret = ( high << 16 ) + low;
            return ret;
        }

        public string ReadString( int aLengthInCharacters )
        {
            byte[] bytes = new byte[ aLengthInCharacters ];
            //
            string ret = string.Empty;
            if ( iStream.Read( bytes, 0, bytes.Length ) == bytes.Length )
            {
                ret = SymbianUtils.Strings.StringParsingUtils.BytesToString( bytes );
            }
            //
            return ret;
        }

        public string ReadStringUTF16( int aLengthInCharacters )
        {
            byte[] bytes = new byte[ aLengthInCharacters * 2 ];
            //
            string ret = string.Empty;
            if ( iStream.Read( bytes, 0, bytes.Length ) == bytes.Length )
            {
                ret = Encoding.Unicode.GetString( bytes );
            }
            //
            return ret;
        }

        public byte[] ReadBytes( int aCount )
        {
            byte[] bytes = new byte[ aCount ];
            int ret = iStream.Read( bytes, 0, bytes.Length );
            if ( ret != bytes.Length )
            {
                throw new Exception( "Unable to read byte data" );
            }
            return bytes;
        }

        public long Seek( long aPosition )
        {
            long ret = Seek( aPosition, SeekOrigin.Begin );
            return ret;
        }

        public long Seek( long aPosition, SeekOrigin aOrigin )
        {
            long ret = iStream.Seek( aPosition, aOrigin );
            return ret;
        }
        #endregion

        #region Properties
        public Stream BaseStream
        {
            get { return iStream; }
        }

        public long Position
        {
            get { return iStream.Position; }
            set
            {
                Seek( value );
            }
        }

        public long Offset
        {
            get
            {
                long ret = Position - iOriginalPosition;
                return ret;
            }
        }
        #endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                base.CleanupManagedResources();
            }
            finally
            {
                if ( iStream != null )
                {
                    if ( ( iFlags & TCloseOperation.EResetPosition ) != 0 )
                    {
                        iStream.Seek( iOriginalPosition, SeekOrigin.Begin );
                    }
                    //
                    if ( ( iFlags & TCloseOperation.ECloseStream ) != 0 )
                    {
                        iStream.Close();
                    }
                }
                iStream = null;
            }
        }
        #endregion

        #region Data members
        private readonly TCloseOperation iFlags;
        private readonly long iOriginalPosition;
        private Stream iStream = null;
        #endregion
    }
}