/*
* 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.IO;
using System.Text;
using System.Collections.Generic;
using SymbianUtils;
using SymbianUtils.Range;
using SymbianUtils.Streams;
using SymbianStructuresLib.Arm;
using SymbianStructuresLib.Arm.Instructions;
using SymbianStructuresLib.CodeSegments;
using SymbianStructuresLib.Debug.Common.Id;
using SymbianStructuresLib.Debug.Common.FileName;
using SymbianStructuresLib.Debug.Common.Interfaces;
using SymbianStructuresLib.Debug.Code.Interfaces;

namespace SymbianStructuresLib.Debug.Code
{
    public sealed class CodeCollection : DisposableObject, IComparable<CodeCollection>, IArmInstructionProvider
    {
        #region Static constructors
        public static CodeCollection New( IPlatformIdAllocator aIdAllocator, string aFileNameInHost, string aFileNameInDevice )
        {
            CodeCollection ret = new CodeCollection( aIdAllocator, aFileNameInHost, aFileNameInDevice );
            return ret;
        }

        public static CodeCollection NewCopy( IPlatformIdAllocator aIdAllocator, CodeCollection aCollection )
        {
            CodeCollection ret = new CodeCollection( aIdAllocator, aCollection );
            return ret;
        }

        public static CodeCollection NewByHostFileName( IPlatformIdAllocator aIdAllocator, string aFileName )
        {
            CodeCollection ret = new CodeCollection( aIdAllocator, aFileName );
            return ret;
        }
        #endregion

        #region Delegates & events
        public delegate void RelocationStatusChangeHandler( CodeCollection aCollection );
        public event RelocationStatusChangeHandler RelocationStatusChanged;
        #endregion

        #region Constructors
        private CodeCollection( IPlatformIdAllocator aIdAllocator, string aFileNameInHost )
		{
            iId = aIdAllocator.AllocateId();
            iFileName = PlatformFileName.NewByHostName( aFileNameInHost );
		}

        private CodeCollection( IPlatformIdAllocator aIdAllocator, string aFileNameInHost, string aFileNameInDevice )
            : this( aIdAllocator, aFileNameInHost )
        {
            iFileName.FileNameInDevice = aFileNameInDevice;
        }

        private CodeCollection( IPlatformIdAllocator aIdAllocator, CodeCollection aCopy )
        {
            iId = aIdAllocator.AllocateId();
            //
            iCode = aCopy.iCode;
            iTag = aCopy.iTag;
            iFlags = aCopy.iFlags;
            iTagged = aCopy.iTagged;
            iBaseAddress = aCopy.iBaseAddress;
            iCodeSegmentResolver = aCopy.iCodeSegmentResolver;
            iRelocationHandler = aCopy.iRelocationHandler;
            iFileName = PlatformFileName.New( aCopy.FileName );
            iInstructionConverter = aCopy.IfaceInstructionConverter;
            iCodeSegmentResolver = aCopy.IfaceCodeSegmentResolver;
            iRelocationHandler = aCopy.IfaceRelocationHandler;
        }            
		#endregion

        #region API
        public bool Contains( uint aAddress )
        {
            bool ret = IsInstructionAddressValid( aAddress );
            return ret;
        }

        public bool IsMatchingCodeSegment( CodeSegDefinition aCodeSegment )
        {
            bool ret = false;
            //
            if ( iCodeSegmentResolver != null )
            {
                ret = iCodeSegmentResolver.IsMatchingCodeSegment( this, aCodeSegment );
            }
            else
            {
                PlatformFileName codeSegName = PlatformFileName.NewByDeviceName( aCodeSegment.FileName );
                ret = FileName.Equals( codeSegName );
            }
            //
            return ret;
        }

        public void Relocate( uint aTo )
        {
            if ( aTo != iBaseAddress )
            {
                uint old = iBaseAddress;
                iBaseAddress = aTo;
                //
                if ( iRelocationHandler != null )
                {
                    iRelocationHandler.PrepareForRelocation( this, old, BaseAddress );
                }
            }
        }
        #endregion

		#region Properties
		public uint Size
		{
            get
            {
                uint ret = 0;
                if ( iCode != null )
                {
                    ret = (uint) iCode.Length;
                }
                return ret;
            }
		}

        public bool Tagged
        {
            get { return iTagged; }
            set
            { 
                iTagged = value; 
            }
        }

        public bool IsRelocatable
        {
            get { return ( iFlags & TFlags.EFlagsIsRelocatable ) == TFlags.EFlagsIsRelocatable; }
            set
            {
                lock ( iFlagLock )
                {
                    bool wasSet = ( iFlags & TFlags.EFlagsIsRelocatable ) == TFlags.EFlagsIsRelocatable;
                    if ( wasSet != value )
                    {
                        if ( value )
                        {
                            iFlags |= TFlags.EFlagsIsRelocatable;
                        }
                        else
                        {
                            iFlags &= ~TFlags.EFlagsIsRelocatable;
                        }

                        // Report event if needed
                        if ( RelocationStatusChanged != null )
                        {
                            RelocationStatusChanged( this );
                        }
                    }
                }
            }
        }

        public bool IsFixed
        {
            get { return !IsRelocatable; }
            set { IsRelocatable = !value; }
        }

        public object Tag
        {
            get { return iTag; }
            set
            {
                iTag = value;
            }
        }

        public uint BaseAddress
        {
            get
            {
                uint ret = iBaseAddress;
                return ret;
            }
        }

        public bool IsCodeAvailable
        {
            get { return iCode != null; }
        }

        public byte[] Code
        {
            get { return iCode; }
            set
            {
                iCode = value;
            }
        }

        public PlatformId Id
        {
            get { return iId; }
        }

        public PlatformFileName FileName
		{
			get { return iFileName; }
		}

        public CodeCollectionList ParentList
        {
            get { return iParentList; }
            internal set { iParentList = value; }
        }
		#endregion

        #region Properties - interfaces
        public ICodeCollectionCodeSegmentResolver IfaceCodeSegmentResolver
        {
            get { return iCodeSegmentResolver; }
            set { iCodeSegmentResolver = value; }
        }

        public ICodeCollectionRelocationHandler IfaceRelocationHandler
        {
            get { return iRelocationHandler; }
            set { iRelocationHandler = value; }
        }

        public ICodeCollectionInstructionConverter IfaceInstructionConverter
        {
            get { return iInstructionConverter; }
            set { iInstructionConverter = value; }
        }
        #endregion

        #region Internal enumerations
        [Flags]
        private enum TFlags : byte
        {
            EFlagsNone = 0,
            EFlagsIsRelocatable = 1
        };
        #endregion

        #region Internal constants
        #endregion

        #region Internal methods
        #endregion

        #region From IArmInstructionProvider
        public bool IsInstructionAddressValid( uint aAddress )
        {
            bool valid = false;
            //
            if ( IsCodeAvailable )
            {
                AddressRange range = new AddressRange( this.BaseAddress, 0 );
                range.UpdateMax( range.Min + iCode.Length );
                //
                valid = range.Contains( aAddress );
            }
            //
            return valid;
        }

        public uint GetDataUInt32( uint aAddress )
        {
            uint ret = 0;
            IArmInstruction[] inst = null;
            //
            bool available = GetInstructions( aAddress, TArmInstructionSet.EARM, 1, out inst );
            if ( available && inst.Length >= 1 )
            {
                ret = inst[ 0 ].AIRawValue;
            }
            //
            return ret;
        }

        public ushort GetDataUInt16( uint aAddress )
        {
            ushort ret = 0;
            IArmInstruction[] inst = null;
            //
            bool available = GetInstructions( aAddress, TArmInstructionSet.ETHUMB, 1, out inst );
            if ( available && inst.Length >= 1 )
            {
                ret = inst[ 0 ].AIRawValue;
            }
            //
            return ret;
        }

        public bool GetInstructions( uint aAddress, TArmInstructionSet aInstructionSet, int aCount, out IArmInstruction[] aInstructions )
        {
            bool valid = false;
            aInstructions = new IArmInstruction[ 0 ];
      
            // We need the code and the instruction converter
            if ( IsCodeAvailable && IfaceInstructionConverter != null )
            {
                // Check range is valid
                AddressRange range = new AddressRange( iBaseAddress, 0 );
                range.UpdateMax( range.Min + iCode.Length );
                uint extent = aAddress + ( (uint) aCount * (uint) aInstructionSet );
                //
                valid = range.Contains( aAddress ) && range.Contains( extent );
                if ( valid )
                {
                    List<uint> rawInstructions = new List<uint>();
                    //
                    using ( SymbianStreamReaderLE reader = SymbianStreamReaderLE.New( new MemoryStream( iCode ) ) )
                    {
                        uint address = aAddress - iBaseAddress;
                        reader.Seek( address );
                        //
                        for ( int i = 0; i < aCount; i++ )
                        {
                            uint value = 0;
                            //
                            switch ( aInstructionSet )
                            {
                            case TArmInstructionSet.ETHUMB:
                                value = reader.ReadUInt16();
                                break;
                            case TArmInstructionSet.EARM:
                                value = reader.ReadUInt32();
                                break;
                            default:
                            case TArmInstructionSet.EJAZELLE:
                                throw new NotSupportedException( "Jazelle is not supported" );
                            }
                            //
                            rawInstructions.Add( value );
                            address += (uint) aInstructionSet;
                        }
                    }
                    //
                    aInstructions = iInstructionConverter.ConvertRawValuesToInstructions( aInstructionSet, rawInstructions.ToArray(), aAddress );
                }
            }

            // Return empty array if not valid
            return valid;
        }
        #endregion

        #region From IComparable<CodeCollection>
        public int CompareTo( CodeCollection aCollection )
		{
            int ret = ( aCollection.FileName == this.FileName ) ? 0 : -1;
			//
            if ( ret == 0 )
            {
                if ( BaseAddress == aCollection.BaseAddress )
                {
                    ret = 0;
                }
                else if ( BaseAddress > aCollection.BaseAddress )
                {
                    ret = 1;
                }
                else
                {
                    ret = -1;
                }
            }
			//
			return ret;
		}
		#endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                base.CleanupManagedResources();
            }
            finally
            {
                iTag = null;
                iParentList = null;
                iInstructionConverter = null;
                iCodeSegmentResolver = null;
                iRelocationHandler = null;
            }
        }
        #endregion

        #region From System.Object
        public override string ToString()
        {
            return iFileName.ToString();
        }

        public override bool Equals( object aObject )
        {
            if ( aObject != null && aObject is CodeCollection )
            {
                CodeCollection col = (CodeCollection) aObject;
                bool ret = ( col.FileName == this.FileName );
                return ret;
            }
            //
            return base.Equals( aObject );
        }

        public override int GetHashCode()
        {
            return iFileName.GetHashCode();
        }
        #endregion

        #region Data members
        private readonly PlatformId iId;
        private readonly PlatformFileName iFileName;
        private object iTag = null;
        private object iFlagLock = new object();
        private byte[] iCode = null;
        private uint iBaseAddress = 0;
        private bool iTagged = false;
        private TFlags iFlags = TFlags.EFlagsNone;
        private CodeCollectionList iParentList = null;
        private ICodeCollectionCodeSegmentResolver iCodeSegmentResolver = null;
        private ICodeCollectionRelocationHandler iRelocationHandler = null;
        private ICodeCollectionInstructionConverter iInstructionConverter = null;
		#endregion
    }
}