/*
* 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.Tracer;
using SymbianUtils.Streams;
using SymbianUtils.Strings;
using SymbianStructuresLib.Version;
using SymbianStructuresLib.Uids;
using SymbianStructuresLib.Security;
using SymbianStructuresLib.Compression.Common;
using SymbianImageLib.Common.Header;
using SymbianImageLib.Common.Image;
using SymbianImageLib.E32Image.Exceptions;

namespace SymbianImageLib.E32Image.Header
{
    public class SIHeaderE32Image : SIHeader
    {
        #region Constructors
        internal SIHeaderE32Image( SIImage aImage, SymbianStreamReaderLE aReader )
            : base( aImage )
        {
            long startPos = aReader.Position;
            //
            iUids = new TCheckedUid( aReader );
            iSignature = aReader.ReadUInt32();
            //
            if ( iSignature != KExpectedSignatureUInt32 ) // 'EPOC'
            {
                throw new E32ImageNotSupportedException( "Invalid signature" );
            }
            //
            iHeaderCrc = aReader.ReadUInt32();
            iModuleVersion = aReader.ReadUInt32();
            iCompressionType = SIHeaderE32Image.ReadCompressionType( aReader );
            iToolsVersion = new TVersion( aReader );
            iTimeLo = aReader.ReadUInt32();
            iTimeHi = aReader.ReadUInt32();
            iFlags = aReader.ReadUInt32();
            //
            iCodeSize = aReader.ReadInt32();
            iDataSize = aReader.ReadInt32();
            iHeapSizeMin = aReader.ReadInt32();
            iHeapSizeMax = aReader.ReadInt32();
            iStackSize = aReader.ReadInt32();
            iBssSize = aReader.ReadInt32();
            //
            iEntryPoint = aReader.ReadUInt32();
            iCodeBase = aReader.ReadUInt32();
            iDataBase = aReader.ReadUInt32();
            //
            iDllRefTableCount = aReader.ReadInt32();
            iExportDirOffset = aReader.ReadUInt32();
            iExportDirCount = aReader.ReadInt32();
            //
            iTextSize = aReader.ReadInt32();
            iCodeOffset = aReader.ReadUInt32();
            iDataOffset = aReader.ReadUInt32();
            iImportOffset = aReader.ReadUInt32();
            iCodeRelocOffset = aReader.ReadUInt32();
            iDataRelocOffset = aReader.ReadUInt32();
            //
            iProcessPriority = aReader.ReadInt16();
            //
            iCpuIdentifier = aReader.ReadUInt16();
            //
            iUncompressedSize = aReader.ReadUInt32();
            //
            iS = new SSecurityInfo( aReader );
            iExceptionDescriptor = aReader.ReadUInt32();
            iSpare2 = aReader.ReadUInt16();
            iExportDescSize = aReader.ReadUInt16();
            iExportDescType = aReader.ReadUInt8();
            //
            iHeaderSize = (uint) ( aReader.Position - startPos );
        }
        #endregion

        #region Constants
        public const int KMinimumSize = 16 + 4; // Enough to read UIDs + signature
        #endregion

        #region API
        public static bool IsSymbianImageHeader( byte[] aHeader )
        {
            // We expect to see 16 bytes (3 x UID, 1 x UID checksum) and then
            // the magic word EPOC
            bool ret = false;
            //
            if ( aHeader.Length >= KMinimumSize )
            {
                // We expect 16 bytes are the UID + checksum. Next should be the signature.
                string sig = StringParsingUtils.BytesToString( aHeader, 16, 20 );
                ret = ( sig == KExpectedSignature );
            }
            //
            return ret;
        }
        #endregion

        #region Constants
        public const uint KExpectedSignatureUInt32 = 0x434f5045;
        public const string KExpectedSignature = "EPOC";
        #endregion

        #region Properties
        public TCheckedUid Uid
        {
            get
            {
                return iUids;
            }
        }

        public int CodeSize
        {
            get { return iCodeSize; }
        }

        public int DataSize
        {
            get { return iDataSize; }
        }

        public uint CodeOffset
        {
            get { return iCodeOffset; }
        }

        public uint UncompressedSize
        {
            get { return iUncompressedSize; }
        }

        public uint TotalSize
        {
            // Just like in E32ImageHeader
            get { return CodeOffset; }
        }
        #endregion

        #region From SymbianImageHeader
        public override uint HeaderSize
        {
            get { return iHeaderSize; }
        }

        public override TSymbianCompressionType CompressionType
        {
            get { return iCompressionType; }
        }
        #endregion

        #region Internal methods
        private static TSymbianCompressionType ReadCompressionType( SymbianStreamReaderLE aReader )
        {
            TSymbianCompressionType ret = TSymbianCompressionType.ENone;
            //
            uint type = aReader.ReadUInt32();
            if ( type == (uint) TSymbianCompressionType.EBytePair )
            {
                ret = TSymbianCompressionType.EBytePair;
            }
            else if ( type == (uint) TSymbianCompressionType.EDeflate )
            {
                ret = TSymbianCompressionType.EDeflate;
            }
            else
            {
                throw new E32ImageNotSupportedException( "Unsupported compression type" );
            }
            //
            return ret;
        }
        #endregion

        #region Data members
        private readonly TCheckedUid iUids;
        //
        private readonly uint iSignature;			                            // Contains 'EPOC'.
        private readonly uint iHeaderCrc;			                            // CRC-32 of entire header. @see #KImageCrcInitialiser.
        private readonly uint iModuleVersion;		                            // Version number for this executable (used in link resolution).
        private readonly TSymbianCompressionType iCompressionType;	        // Type of compression used for file contents located after the header. (UID or 0 for none).
        //
        private readonly TVersion iToolsVersion;		                        // Version number of tools which generated this file.
        //
        private readonly uint iTimeLo;			                                // Least significant 32 bits of the time of image creation, in milliseconds since since midnight Jan 1st, 2000.
        private readonly uint iTimeHi;			                                // Most significant 32 bits of the time of image creation, in milliseconds since since midnight Jan 1st, 2000.
        private readonly uint iFlags;				                            // Contains various bit-fields of attributes for the image.
        //
        private readonly int iCodeSize;				                            // Size of executables code. Includes import address table, constant data and export directory.
        private readonly int iDataSize;				                            // Size of executables initialised data.
        private readonly int iHeapSizeMin;			                            // Minimum size for an EXEs runtime heap memory.
        private readonly int iHeapSizeMax;			                            // Maximum size for an EXEs runtime heap memory.
        private readonly int iStackSize;			                            // Size for stack required by an EXEs initial thread.
        private readonly int iBssSize;				                            // Size of executables uninitialised data.
        //
        private readonly uint iEntryPoint;			                            // Offset into code of the entry point.
        private readonly uint iCodeBase;			                            // Virtual address that the executables code is linked for.
        private readonly uint iDataBase;			                            // Virtual address that the executables data is linked for.
        //
        private readonly int iDllRefTableCount;		                            // Number of executable against which this executable is linked. The number of files mention in the import section at iImportOffset.
        private readonly uint iExportDirOffset;		                            // Byte offset into file of the export directory.
        private readonly int iExportDirCount;		                            // Number of entries in the export directory.
        //
        private readonly int iTextSize;				                            // Size of just the text section, also doubles as the offset for the Import Address Table w.r.t. the code section.
        private readonly uint iCodeOffset;			                            // Offset into file of the code section. Also doubles the as header size.
        private readonly uint iDataOffset;			                            // Offset into file of the data section.
        private readonly uint iImportOffset;		                            // Offset into file of the import section (E32ImportSection).
        private readonly uint iCodeRelocOffset;		                            // Offset into file of the code relocation section (E32RelocSection).
        private readonly uint iDataRelocOffset;		                            // Offset into file of the data relocation section (E32RelocSection).
        private readonly short iProcessPriority; 	                            // Initial runtime process priorty for an EXE. (Value from enum TProcessPriority.)
        private readonly ushort iCpuIdentifier;		                            // Value from enum TCpu which indicates the CPU architecture for which the image was created
        //
        private readonly uint iUncompressedSize;	                            // Uncompressed size of file data after the header, or zero if file not compressed.
        //
	    private readonly SSecurityInfo iS;				                        // Platform Security information of executable.
	    private readonly uint iExceptionDescriptor;                             // Offset in bytes from start of code section to Exception Descriptor, bit 0 set if valid.
	    private readonly ushort iSpare2;				                        // Reserved for future use. Set to zero.
	    private readonly ushort iExportDescSize;		                        // Size of export description stored in iExportDesc.
	    private readonly byte iExportDescType;		                            // Type of description of holes in export table

        // Not part of header
        private readonly uint iHeaderSize;
        #endregion
    }
}