/*
* 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.Text;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using SymbolLib.CodeSegDef;
using SymbolLib.Generics;
using SymbolLib.Engines;
using SymbolLib.Sources.Map.File;
using SymbolLib.Sources.Map.Parser;
using SymbolLib.Sources.Map.Symbol;
using SymbianUtils;
using SymbianUtils.Range;
using SymbianUtils.Tracer;

namespace SymbolLib.Sources.Map.Engine
{
	internal class MapFileEngine : GenericSymbolEngine, SymbolEntryCreator
    {
		#region Events
        public event AsyncReaderBase.Observer Observer;
        #endregion

        #region Constructor & destructor
        public MapFileEngine( ITracer aTracer )
            : base( aTracer )
		{
		}
		#endregion

		#region API
        public static bool IsMapFile( string aFileName )
        {
            string extension = Path.GetExtension( aFileName ).ToLower();
            return ( extension == CodeSegDefinition.KMapFileExtension );
        }

        internal bool IsLoaded( CodeSegDefinition aDefinition )
        {
            bool ret = iMapFile.HostBinaryFileName == aDefinition.ImageFileNameAndPath;
            return ret;
        }

        internal void LoadFromFile( string aMapFileName, TSynchronicity aSynchronicity )
        {
            iMapFileName = aMapFileName;
            iMapFile = MapFile.NewByHostMapFileName( aMapFileName );
            //
            iParser = new MapFileParser( this, aMapFileName, this );
            iParser.Tag = this;
            iParser.iObserver += new SymbianUtils.AsyncReaderBase.Observer( Parser_Observer );
            iParser.SymbolCreated += new MapFileParser.SymbolCreatedHandler( Parser_SymbolCreated );
            iParser.BaseAddressHandler += new MapFileParser.MapFileBaseAddressHandler( Parser_BaseAddressHandler );
            iParser.Read( aSynchronicity );
        }

        internal void Load( CodeSegDefinition aDefinition )
        {
            iMapFile.Fixup( aDefinition );
        }

        internal bool Unload( CodeSegDefinition aDefinition )
        {
            return true;
        }

        internal void UnloadAll()
        {
        }
		#endregion

        #region Properties
        public MapFile MapFile
        {
            get { return iMapFile; }
        }

        public string MapFileName
        {
            get { return iMapFileName; }
        }
        #endregion

        #region From GenericSymbolEngine
        public override void Reset()
		{
            // Do nothing - we cannot unload our only file. This is taken
            // care of by parent class.
            iMapFile = null;
            iParser = null;
            iMapFileName = string.Empty;
        }

        public override bool IsReady
        {
            get
            {
                return true;
            }
        }

        public override bool IsLoaded( string aFileName )
        {
            bool ret = MapFileName == aFileName;
            return ret;
        }

        public override GenericSymbolCollection this[ int aIndex ]
        {
            get
            {
                return iMapFile;
            }
        }

        public override AddressRange Range
        {
            get
            {
                return iMapFile.AddressRange;
            }
        }

        internal override void UnloadUntagged()
        {

        }
        #endregion

        #region From IGenericSymbolCollectionStatisticsInterface
        public override int NumberOfCollections
        {
            get
			{
				return 1;
			}
        }
        #endregion

        #region From SymbolEntryCreator
        public MapSymbol CreateSymbol()
        {
            return MapSymbol.New( iMapFile );
        }
        #endregion

		#region Map file parser observer
        private void Parser_Observer( SymbianUtils.AsyncReaderBase.TEvent aEvent, SymbianUtils.AsyncReaderBase aSender )
        {
            if ( Observer != null )
            {
                Observer( aEvent, aSender );
            }

            if ( aEvent == SymbianUtils.AsyncReaderBase.TEvent.EReadingComplete )
            {
                iMapFile.EnsureAllEntriesHaveSize();
                iMapFile.Sort();

                int x = 0;
                if ( x != 0 )
                {
                    iMapFile.Dump();
                }

                iParser = null;
            }
        }

        private void Parser_SymbolCreated( MapSymbol aSymbol )
        {
            bool addItem = true;
            
            if ( iMapFile.Count > 0 )
            {
                int lastEntryIndex = iMapFile.Count - 1;
                MapSymbol lastEntry = (MapSymbol) iMapFile[ lastEntryIndex ];
                //
                long lastEntrySize = lastEntry.Size;
                long newEntrySize = aSymbol.Size;
                //
                if ( lastEntry.Address == aSymbol.Address )
                {
                    if ( lastEntrySize == 0 && newEntrySize > 0 )
                    {
                        // Remove an entry with zero size to replace it with a better definition...
                        iMapFile.RemoveAt( lastEntryIndex );
                    }
                    else if ( newEntrySize == 0 && lastEntrySize > 0 )
                    {
                        // Don't replace an entry with zero size when we already
                        // have a good item.
                        addItem = false;
                    }
                }
            }
         
            if ( addItem )
            {
                iMapFile.Add( this, aSymbol );
            }
        }

        private void Parser_BaseAddressHandler( uint aBaseAddress )
        {
            iMapFile.GlobalBaseAddress = aBaseAddress;
        }
        #endregion

		#region Internal methods
		#endregion

        #region Data members
        private MapFile iMapFile = null;
        private MapFileParser iParser = null;
        private string iMapFileName = string.Empty;
        #endregion
    }
}