/*
* 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.Threading;
using System.Collections;
using System.Collections.Generic;
using SymbianUtils;
using SymbianUtils.Tracer;
using SymbolLib.Generics;
using SymbolLib.Engines.ROFS;
using SymbolLib.Engines.ROM;
using SymbolLib.Sources.Map.Engine;
using SymbolLib.Sources.Symbol.Engine;
using SymbolLib.CodeSegDef;

namespace SymbolLib.Engines
{
	public class SymbolManager : ITracer
    {
        #region Construct & destruct
        public SymbolManager()
            : this( null )
		{
		}

        public SymbolManager( ITracer aTracer )
        {
            iTracer = aTracer;
            //
            iEngineROM = new ROMEngine( this );
            iEngineROFS = new ROFSEngine( this );
        }
		#endregion

		#region API
        public void Clear()
        {
            ClearTags();
            ROFSEngine.Reset();
            ROMEngine.Reset();
        }

        public Dictionary<string, string> GetSupportedExtensions()
        {
            Dictionary<string, string> ret = new Dictionary<string, string>();
            //
            ret.Add( "*.symbol", "Symbian OS Symbol File" );
            ret.Add( "*.map", "Symbian OS Map File" );
            ret.Add( "*.oby", "Symbian OS Obey File" );
            //
            return ret;
        }

		public bool IsLoaded( string aFileName )
		{
            string fileName = aFileName.ToLower();
			bool loaded = iEngineROM.IsLoaded( fileName );
            //
            if  ( loaded == false )
            {
                loaded = iEngineROFS.IsLoaded( fileName );
            }
            //
			return loaded;
		}

        public void ClearTags()
        {
            iEngineROM.ClearTags();
            iEngineROFS.ClearTags();
        }

        public void LoadDynamicCodeSegment( CodeSegDefinition aCodeSegment, TSynchronicity aSynchronicity )
        {
            ROFSEngine.LoadFromDefinition( aCodeSegment, aSynchronicity );
        }

        public void LoadDynamicCodeSegments( CodeSegDefinitionCollection aCodeSegments, TSynchronicity aSynchronicity )
        {
            // Unload any pre-existing dynamically loaded content
            ROFSEngine.UnloadAll();

            // We must attempt to dynamically load all the code segements listed. 
            // For codesegments that we have no corresponding collection for, we'll allow
            // a stub codesegment to be created in the ROFS engine - this ensures we
            // at least show the codesegment name (though not function addresses) when we
            // encounter an unrecognised address within the codesegment address space.
            //
            // For everything else, we load it (if it exists) or then if it's already been
            // loaded by the CORE ROM symbol file, we ignore the request.

            // These are the code segs that we'll eventually push through to the
            // ROFS engine.
            CodeSegDefinitionCollection codeSegsToAttemptToLoad = new CodeSegDefinitionCollection();

            // First pass - identify which code seg entries we already have loaded.
            foreach ( CodeSegDefinition def in aCodeSegments )
            {
                // Check if there is already a valid definition for this entry in
                // the CORE ROM symbol table. If there is, the we don't need to do
                // anything.
                bool loaded = ROMEngine.IsLoaded( def );
                if ( !loaded )
                {
                    Trace( "SymbolManager.LoadDynamicCodeSegments() - will attempt to load: " + def );
                    codeSegsToAttemptToLoad.Add( def );
                }
                else
                {
                    Trace( "SymbolManager.LoadDynamicCodeSegments() - not loading XIP code seg: " + def );
                }
            }

            // Now, we have a ratified list that contains only code segments that weren't already managed
            // by the CORE ROM engine.
            ROFSEngine.LoadFromDefinitionCollection( codeSegsToAttemptToLoad, aSynchronicity );
        }

        public static TFileType IsSupported( string aFileName )
        {
            TFileType ret = TFileType.EFileNotSupported;
            //
            FileInfo fileInfo = new FileInfo( aFileName );
            if ( fileInfo.Exists )
            {
                // Try rom then rofs
                ret = ROMEngine.IsSupported( aFileName );
                if ( ret == TFileType.EFileNotSupported )
                {
                    ret = ROFSEngine.IsSupported( aFileName );
                }
            }
            //
            return ret;
        }
		#endregion

		#region Properties
        public ROMEngine ROMEngine
		{
			get { return iEngineROM; }
		}
		
		public ROFSEngine ROFSEngine
		{
			get { return iEngineROFS; }
		}

		public int NumberOfCollections
		{
			get
			{
				int count = 0;
				//
				count += iEngineROM.NumberOfCollections;
				count += iEngineROFS.NumberOfCollections;
				//
				return count;
			}
		}

		public int NumberOfEntries
		{
			get
			{
				int count = 0;
				//
				count += iEngineROM.NumberOfEntries;
				count += iEngineROFS.NumberOfEntries;
				//
				return count;
			}
		}

		public bool IsReady
		{
			get
			{
				bool readyROM = iEngineROM.IsReady;
                bool readyROFS = iEngineROFS.IsReady;
                //
				return ( readyROM && readyROFS );
			}
		}
		#endregion

		#region Lookup API
		public bool AddressInRange( long aAddress )
		{
			bool ret = iEngineROFS.AddressInRange( aAddress );
			if	( !ret )
			{
				ret = iEngineROM.AddressInRange( aAddress );
			}
			return ret;
		}

        /// <summary>
        /// Performs as substring match within each collection's host binary file name
        /// for aFileName.
        /// </summary>
        /// <param name="aHostBinaryFileName"></param>
        /// <returns></returns>
        public GenericSymbolCollection[] CollectionsByHostBinarySearch( string aFileName )
        {
            List<GenericSymbolCollection> ret = new List<GenericSymbolCollection>();
            //
            ret.AddRange( iEngineROM.CollectionsByHostBinarySearch( aFileName ) );
            ret.AddRange( iEngineROFS.CollectionsByHostBinarySearch( aFileName ) );
            //
            return ret.ToArray();
        }

        public string SymbolNameByAddress( long aAddress )
        {
            string ret = string.Empty;

            SymbolLib.Generics.GenericSymbol symbol = EntryByAddress( aAddress );
            if  ( symbol != null )
            {
                ret = symbol.Symbol;
            }

            return ret;
        }

		public GenericSymbol EntryByAddress( long aAddress )
		{
			GenericSymbolCollection collection = null;
			GenericSymbol ret = EntryByAddress( aAddress, out collection );
			return ret;
		}

		public GenericSymbol EntryByAddress( long aAddress, out GenericSymbolCollection aCollection )
		{
            aCollection = null;
            GenericSymbolCollection rofsCollection = null;

			// First check with the map file engine to see if there is a loaded
			// code segment entry that matches the specified address.
			GenericSymbol ret = iEngineROFS.EntryByAddress( aAddress, ref rofsCollection );
			//
			if	( ret == null )
			{
                GenericSymbolCollection romCollection = null;
                ret = iEngineROM.EntryByAddress( aAddress, ref romCollection );

                // Decide which collection to return in the case that 
                // a) we found a matching symbol, or 
                // b) when we didn't.
                if ( ret == null && rofsCollection != null )
                {
                    // ROFS wins by default if we found something inside the ROFS engine...
                    aCollection = rofsCollection;
                }
                else
                {
                    // Otherwise we'll use the ROM collection (irrespective of whether something
                    // was found or not)
                    aCollection = romCollection;
                }
			}
            else
            {
                // ROFS wins
                aCollection = rofsCollection;
            }

			return ret;
		}

		public GenericSymbolCollection CollectionByAddress( long aAddress )
		{
			// First check with the map file engine to see if there is a loaded
			// code segment entry that matches the specified address.
			GenericSymbolCollection ret = iEngineROFS.CollectionByAddress( aAddress );
			//
			if	( ret == null )
			{
				ret = iEngineROM.CollectionByAddress( aAddress );
			}
			//
			return ret;
		}		
		#endregion

        #region ITracer Members
        public void Trace( string aMessage )
        {
            if ( iTracer != null )
            {
                iTracer.Trace( aMessage );
            }
        }

        public void Trace( string aFormat, params object[] aParams )
        {
            Trace( string.Format( aFormat, aParams ) );
        }
        #endregion

		#region Data members
        private readonly ITracer iTracer;
        private readonly ROMEngine iEngineROM;
        private readonly ROFSEngine iEngineROFS;
		#endregion
	}
}