/*

* 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;

using SymbianUtils.Tracer;

using SymbianUtils.Streams;

using SymbianStructuresLib.Uids;

using SymbianStructuresLib.Compression.Common;

using SymbianImageLib.Common.Content;

using SymbianImageLib.Common.Image;

using SymbianImageLib.Common.Streams;

using SymbianImageLib.E32Image.Image;

using SymbianImageLib.E32Image.Header;

namespace SymbianImageLib.E32Image.Content

{

    public class SIContentE32Image : SIContent

    {

        #region Constructors

        internal SIContentE32Image( SymbianImageE32 aImage, string aName, uint aSize, long aImageContentOffset )

            :  base( aImage )

        {

            iName = aName;

            iFileSize = aSize;

            iFileSize = aSize;

        }

        #endregion

        #region From SymbianImageContentFile

        public override TSymbianCompressionType CompressionType

        {

            get { return base.ImageHeader.CompressionType; }

        }

        public override string FileName

        {

            get { return iName; }

        }

        public override uint FileSize

        {

            get { return iFileSize; }

        }

        public override uint ContentSize

        {

            get

            {

                uint ret = 0;

                //

                lock ( iCodeSyncRoot )

                {

                    if ( iCode != null )

                    {

                        ret = (uint) iCode.Length;

                    }

                }

                //

                return ret;

            }

        }

        public override TCheckedUid Uid

        {

            get { return ImageHeader.Uid; }

        }

        public override byte[] GetAllData()

        {

            lock ( iCodeSyncRoot )

            {

                return iCode;

            }

        }

        protected override uint DoProvideDataUInt32( uint aTranslatedAddress )

        {

            uint ret = 0;

            //

            if ( iStream != null )

            {

                using ( SymbianStreamReaderLE reader = SymbianStreamReaderLE.New( iStream, SymbianStreamReaderLE.TCloseOperation.ENone ) )

                {

                    reader.Seek( aTranslatedAddress );

                    ret = reader.ReadUInt32();

                }

            }

            //

            return ret;

        }

        protected override ushort DoProvideDataUInt16( uint aTranslatedAddress )

        {

            ushort ret = 0;

            //

            if ( iStream != null )

            {

                using ( SymbianStreamReaderLE reader = SymbianStreamReaderLE.New( iStream, SymbianStreamReaderLE.TCloseOperation.ENone ) )

                {

                    reader.Seek( aTranslatedAddress );

                    ret = reader.ReadUInt16();

                }

            }

            //

            return ret;

        }

        protected override void DoDecompress()

        {

            lock ( iCodeSyncRoot )

            {

                if ( iCode == null )

                {

                    TSymbianCompressionType type = this.CompressionType;

                    switch ( type )

                    {

                    default:

                    case TSymbianCompressionType.ENone:

                        // NB: This has not yet been observed in reality

                        DecompressNone();

                        break;

                    case TSymbianCompressionType.EDeflate:

                    case TSymbianCompressionType.EBytePair:

                        {

                            using ( SymbianDecompressor decompressor = SymbianDecompressor.NewByType( type ) )

                            {

                                //

                                switch ( type )

                                {

                                case TSymbianCompressionType.EBytePair:

                                    DecompressBytePair( decompressor );

                                    break;

                                case TSymbianCompressionType.EDeflate:

                                    DecompressDeflate( decompressor );

                                    break;

                                }

                            }

                            break;

                        }

                    }

                    if ( iCode != null )

                    {

                        if ( iStream != null )

                        {

                            iStream.Dispose();

                            iStream = null;

                        }

                        //

                        iStream = new MemoryStream( iCode );

                    }

                }

            }

        }

        protected override bool GetIsContentPrepared()

        {

            lock ( iCodeSyncRoot )

            {

                return ( iCode != null );

            }

        }

        #endregion

        #region Properties

        public new SIHeaderE32Image ImageHeader

        {

            get { return (SIHeaderE32Image) base.ImageHeader; }

        }

        public new SymbianImageE32 Image

        {

            get { return (SymbianImageE32) base.Image; }

        }

        #endregion

        #region Internal methods

        private byte[] DecompressCommon( SymbianDecompressor aDecompressor, int aSeekOffset, int aAmountToRead, int aMaximumOutputSize, out int aNumberOfInputBytesRead )

        {

            System.Diagnostics.Debug.WriteLine( "[SIContentE32Image] DecompressCommon - START - " + base.Image.Name + " # " + System.Threading.Thread.CurrentThread.Name );

            //

            uint imageContentSize = iFileSize;

            uint orighdrsz = ImageHeader.TotalSize;

            uint remainder = imageContentSize - orighdrsz;

            //

            using ( SymbianStreamReaderLE reader = base.ImageStream.CreateReader( SymbianStreamReaderLE.TCloseOperation.EResetPosition ) )

            {

                long codePos = Image.ContentOffsetWithinDataStream + orighdrsz + aSeekOffset;

                reader.Seek( codePos );

                //

                byte[] input = reader.ReadBytes( aAmountToRead );

                byte[] output = new byte[ aMaximumOutputSize ];

                // The decompressor tells us how many bytes of output it really created.

                int numberOfBytesCreated = aDecompressor.DecompressImage( input, output, out aNumberOfInputBytesRead );

                // We can then return that to the callee.

                byte[] ret = new byte[ numberOfBytesCreated > 0 ? numberOfBytesCreated : 0 ];

                if ( numberOfBytesCreated > 0 )

                {

                    Array.Copy( output, ret, numberOfBytesCreated );

                }

                //

                System.Diagnostics.Debug.WriteLine( "[SIContentE32Image] DecompressCommon - END - " + base.Image.Name + " # " + System.Threading.Thread.CurrentThread.Name );

                //

                return ret;

            }

        }

        private void DecompressNone()

        {

            uint imageContentSize = iFileSize;

            uint orighdrsz = ImageHeader.TotalSize;

            uint uncompressedSize = ImageHeader.UncompressedSize;

            using ( SymbianStreamReaderLE reader = base.ImageStream.CreateReader( SymbianStreamReaderLE.TCloseOperation.EResetPosition ) )

            {

                long codePos = Image.ContentOffsetWithinDataStream + orighdrsz;

                reader.Seek( codePos );

                //

                lock ( iCodeSyncRoot )

                {

                    iCode = reader.ReadBytes( (int) uncompressedSize );

                }

            }

        }

        private void DecompressBytePair( SymbianDecompressor aDecompressor )

        {

            int inputBytesRead = 0;

            //

            uint imageContentSize = iFileSize;

            uint orighdrsz = ImageHeader.TotalSize;

            uint uncompressedSize = ImageHeader.UncompressedSize;

            // First decompress the code

            byte[] code = DecompressCommon( aDecompressor, 0, (int) ( imageContentSize - orighdrsz ), (int) uncompressedSize, out inputBytesRead );

            if ( code.Length < ImageHeader.CodeSize )

            {

                throw new Exception( "E32Image bytepair decompression did not provide enough code" );

            }

            // Now get the data

            int remainder = (int) ( uncompressedSize - inputBytesRead );

            byte[] data = DecompressCommon( aDecompressor, inputBytesRead, remainder, (int) uncompressedSize, out inputBytesRead );

            // We should have read all the decompressed data

            int totalAmountOfDecompressedDataSupplied = data.Length + code.Length;

            if ( totalAmountOfDecompressedDataSupplied != uncompressedSize )

            {

                throw new Exception( "E32Image bytepair decompression did not supply enough decompressed output" );

            }

            lock ( iCodeSyncRoot )

            {

                iCode = new byte[ uncompressedSize ];

                Array.Copy( code, iCode, code.Length );

                Array.Copy( data, 0, iCode, code.Length, data.Length );

            }

        }

        private void DecompressDeflate( SymbianDecompressor aDecompressor )

        {

            int inputBytesRead = 0;

            //

            uint imageContentSize = iFileSize;

            uint orighdrsz = ImageHeader.TotalSize;

            uint uncompressedSize = ImageHeader.UncompressedSize;

            byte[] combinedDataAndCode = DecompressCommon( aDecompressor, 0, (int) ( imageContentSize - orighdrsz ), (int) uncompressedSize, out inputBytesRead );

            if ( combinedDataAndCode.Length != uncompressedSize )

            {

                throw new Exception( "E32Image inflate decompression did not supply enough decompressed output" );

            }

            lock ( iCodeSyncRoot )

            {

                iCode = combinedDataAndCode;

            }

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                base.CleanupManagedResources();

            }

            finally

            {

                if ( iStream != null )

                {

                    iStream.Dispose();

                    iStream = null;

                }

            }

        }

        #endregion

        #region Data members

        private readonly string iName;

        private readonly uint iFileSize;

        private byte[] iCode = null;

        private object iCodeSyncRoot = new object();

        private MemoryStream iStream = null;

        #endregion

    }

}