/*
* 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.Header;
using SymbianImageLib.Common.Streams;
using SymbianImageLib.Common.Factory;
using SymbianImageLib.ROM.Image;
using SymbianImageLib.ROM.Header;
using SymbianImageLib.ROM.Structures;

namespace SymbianImageLib.ROM.Content
{
    internal class SIContentROM : SIContent
    {
        #region Constructors
        public SIContentROM( SIROM aImage )
            : base( aImage )
        {
            SIHeaderROM header = (SIHeaderROM) aImage.Header;
            base.RelocationAddress = header.RomBaseAddress;
        }
        #endregion

        #region From SymbianImageContentFile
        public override TSymbianCompressionType CompressionType
        {
            get
            {
                // Compression type comes from overall image header
                TSymbianCompressionType ret = base.ImageHeader.CompressionType;
                return ret;
            }
        }

        public override bool IsRelocationSupported
        {
            get { return false; }
        }

        public override string FileName
        {
            get { return Image.Name; }
        }

        public override uint FileSize
        {
            get { return (uint) base.Image.Stream.Length; }
        }

        public override uint ContentSize
        {
            get
            {
                // This is not 100% accurate, but hopefully good enough...
                uint size = (uint) base.ImageStream.Length;
                return size;
            }
        }

        public override byte[] GetAllData()
        {
            // The image ownes a memory stream (if the image has been decompressed)
            byte[] ret = new byte[ 0 ];
            //
            if ( base.ImageStream is SIMemoryStream )
            {
                SIMemoryStream memStream = (SIMemoryStream) base.ImageStream;
                ret = memStream.Data;
            }
            //
            return ret;
        }

        protected override uint DoProvideDataUInt32( uint aTranslatedAddress )
        {
            using ( SymbianStreamReaderLE reader = Image.Stream.CreateReader( SymbianStreamReaderLE.TCloseOperation.ENone ) )
            {
                reader.Seek( aTranslatedAddress );
                uint ret = reader.ReadUInt32();
                return ret;
            }
        }

        protected override ushort DoProvideDataUInt16( uint aTranslatedAddress )
        {
            using ( SymbianStreamReaderLE reader = Image.Stream.CreateReader( SymbianStreamReaderLE.TCloseOperation.ENone ) )
            {
                reader.Seek( aTranslatedAddress );
                ushort ret = reader.ReadUInt16();
                return ret;
            }
        }

        protected override void DoDecompress()
        {
            base.Trace( "[SymbianImageContentFileROM] DoDecompress() - START - compression type: {0}", CompressionType );
            //
            switch ( CompressionType )
            {
            case TSymbianCompressionType.ENone:
                base.Trace( "[SymbianImageContentFileROM] DoDecompress() - not compressed" );
                break;
            case TSymbianCompressionType.EBytePair:
                base.Trace( "[SymbianImageContentFileROM] DoDecompress() - byte pair" );
                DoDecompressBytePair();
                break;
            default:
            case TSymbianCompressionType.EDeflate:
                base.Trace( "[SymbianImageContentFileROM] DoDecompress() - unsuporrted compression type" );
                throw new NotSupportedException();
            }
            //
            base.Trace( "[SymbianImageROM] DoDecompress() - END" );
        }

        protected override bool GetIsContentPrepared()
        {
            return iContentIsPrepared;
        }
        #endregion

        #region Properties
        public new SIHeaderROM ImageHeader
        {
            get
            {
                SIHeaderROM header = (SIHeaderROM) base.ImageHeader;
                return header;
            }
        }
        #endregion

        #region Internal methods
        private void DoDecompressBytePair()
        {
            if ( iContentIsPrepared == false )
            {
                SIHeaderROM imageHeader = ImageHeader;
                base.Trace( "[SymbianImageROM] DoDecompressBytePair() - START - header uncompressed rom size: {0}", imageHeader.UncompressedRomSize );

                // Create new buffer and copy over rom image header
                SIMemoryStream resultantDataStream = new SIMemoryStream( imageHeader.UncompressedRomSize );

                int numPages = imageHeader.NumberOfPages;
                uint pageTableOffset = imageHeader.RomPageIndexOffset;
                uint romDataOffset = imageHeader.HeaderSizeLoader;
                base.Trace( "[SymbianImageROM] DoDecompressBytePair() - numPages: {0}, pageTableOffset: {1}, romDataOffset: {2}", numPages, pageTableOffset, romDataOffset );
                //
                SymbianDecompressor decompressor = SymbianDecompressor.NewByType( TSymbianCompressionType.EBytePair );
                //
                List<SRomPageInfo> pages = new List<SRomPageInfo>( numPages + 1 );
                for ( int i = 0; i < numPages; i++ )
                {
                    // Read a page table entry
                    long pageOffsetWithinFile = pageTableOffset + ( i * SRomPageInfo.Size );

                    //base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - pageOffsetWithinFile: {1}", i, pageOffsetWithinFile );
                    base.ImageStream.Seek( pageOffsetWithinFile, SeekOrigin.Begin );
                    SRomPageInfo pageInfo = SRomPageInfo.New( (Stream) base.ImageStream, romDataOffset );

                    // Process the entry based upon the compression type
                    //base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - pageInfo.DataSize: {1}, pageInfo.DataStart: {2}, pageInfo.CompressionType: {3}", i, pageInfo.DataSize, pageInfo.DataStart, pageInfo.CompressionType );
                    base.ImageStream.Seek( pageInfo.DataStart, SeekOrigin.Begin );

                    if ( pageInfo.CompressionType == SRomPageInfo.TSymbianCompressionType.ENoCompression )
                    {
                        // Read data - no decompression needed
                        //base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - PAGE NOT COMPRESSED", i );
                        resultantDataStream.Write( base.ImageStream, (int) pageInfo.DataSize );
                    }
                    else if ( pageInfo.CompressionType == SRomPageInfo.TSymbianCompressionType.EBytePair )
                    {
                        //base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - BYTE PAIR PAGE", i );

                        // Read data - need to decompress it
                        byte[] compressedData = new byte[ pageInfo.DataSize ];
                        base.ImageStream.Read( compressedData, 0, compressedData.Length );

                        // Make destination buffer - which is a page big
                        byte[] uncompressedData = new byte[ SRomPageInfo.KPageSize ];

                        // Decompress to buffer - we're handling the page management, so we want raw decompression
                        int error = decompressor.DecompressRaw( compressedData, uncompressedData );

                        // Save it
                        if ( error < 0 )
                        {
                            base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - Exception - bytepair decompression error", i );
                            throw new Exception( "BytePair decompression error: " + error.ToString() );
                        }
                        else if ( error != SRomPageInfo.KPageSize )
                        {
                            base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - Exception - bytepair underflow error", i );
                            throw new Exception( "Decompressor underflow - only created " + error.ToString() + " bytes" );
                        }
                        else
                        {
                            resultantDataStream.Write( uncompressedData );
                        }
                    }
                    else
                    {
                        base.Trace( "[SymbianImageROM] DoDecompressBytePair() - page[{0:d5}] - UNSUPPORTED COMPRESSION TYPE - Exception!", i );
                        throw new NotSupportedException( "Unsupported page compression type" );
                    }

                    // Report progress
                    base.ReportDecompressionEvent( TDecompressionEvent.EEventDecompressionProgress, ( (float) i / (float) numPages ) * 100 );
                }

                // Now we can replace the base class stream (which is just the raw compressed file data) with the new uncompressed version
                base.ImageStream = resultantDataStream;
                iContentIsPrepared = true;

                base.Trace( "[SymbianImageROM] DoDecompressBytePair() - END" );
            }
        }
        #endregion

        #region Data members
        private bool iContentIsPrepared = false;
        #endregion
    }
}