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

namespace SymbolLib.Engines.ROFS
{
	public class ROFSEngine : SymbolEngineBase
	{
		#region Constructors
		internal ROFSEngine( ITracer aTracer )
            : base( aTracer )
		{
            iEngineMap = new MapFileEngineCollection( this );
            iEngineMap.Observer += new SymbianUtils.AsyncReaderBase.Observer( MapEngine_Observer );
        
            iEngineSymbol = new SymbolFileEngineCollection( this, SymbolFileEngine.TActivationType.EOnDemand, true );
			iEngineSymbol.Observer += new SymbianUtils.AsyncReaderBase.Observer( SymbolEngine_Observer );
		}
		#endregion

        #region API
        public static TFileType IsSupported( string aFileName )
        {
            TFileType ret = TFileType.EFileNotSupported;
            //
            try
            {
                string extension = Path.GetExtension( aFileName ).ToLower();
                if ( extension == ".symbol" )
                {
                    bool sawSomeValidContent = false;
                    //
                    SymbolFileEngine tempEngine = new SymbolFileEngine(null,  SymbolFileEngine.TActivationType.EOnDemand, true );
                    SymbolsForBinary symbols = tempEngine.ReadFirstCollection( aFileName, out sawSomeValidContent );

                    // For a valid ROFS symbol file, the first symbol should have an address of zero.
                    bool valid = ( symbols != null && symbols.Count > 0 && symbols[ 0 ].Address == 0 );
                    if ( valid )
                    {
                        ret = TFileType.EFileRofsSymbol;
                    }
                    else if ( sawSomeValidContent )
                    {
                        // Probably just a file containing data files rather than code, but that's okay.
                        ret = TFileType.EFileRofsSymbol;
                    }
                }
                else if ( extension == ".map" )
                {
                    ret = MapFileEngineCollection.IsSupported( aFileName );
                }
            }
            catch(Exception)
            {
            }
            //
            return ret;
        }
        #endregion

        #region Properties
        public CodeSegDefinitionParser DefinitionParser
        {
            get { return iEngineMap.CodeSegParser; }
        }

        public CodeSegResolver DefinitionResolver
        {
            get { return iEngineMap.CodeSegResolver; }
        }

        public SymbolFileEngineCollection SymbolFiles
        {
            get { return iEngineSymbol; }
        }

        public string[] SymbolFileNames
        {
            get
            {
                string[] ret = iEngineSymbol.SymbolFileNames;
                return ret;
            }
        }

        public string[] SymbolFileCollectionFileNames
		{
			get
			{
                string[] ret = iEngineSymbol.BinaryFileNames;
                return ret;
			}
		}

        public List<string> MapFileNames
        {
            get
            {
                List<string> ret = new List<string>();
                lock ( iEngineMap )
                {
                    ret.AddRange( iEngineMap.MapFileNames );
                }
                return ret;
            }
        }
        #endregion

        #region From SymbolEngineBase
        public override bool AddressInRange( long aAddress )
        {
            // Try map files first, then symbols (should be
            // quicker this way).
            bool ret = false;
            lock ( iEngineMap )
            {
                ret = iEngineMap.Range.Contains( aAddress );
            }
            if ( ret == false )
            {
                lock ( iEngineSymbol )
                {
                    ret = iEngineSymbol.Range.Contains( aAddress );
                }
            }
            //
            return ret;
        }

        public override int FileNameCount
        {
            get
            {
				int count = 0;
				//
                lock ( iEngineSymbol )
                {
                    count += iEngineSymbol.SymbolFileCount;
                }
                lock ( iEngineMap )
                {
                    count += iEngineMap.NumberOfCollections;
                }
				//
                return count;
            }
        }

        public override string FileName( int aIndex )
        {
            string ret = string.Empty;
            //
            lock ( iEngineMap )
            {
                lock ( iEngineSymbol )
                {
                    int countSymbolFiles = iEngineSymbol.SymbolFileCount;
                    int countMapFiles = iEngineMap.NumberOfCollections;
                    //
                    if ( aIndex < countSymbolFiles )
                    {
                        ret = iEngineSymbol.SymbolFileName( aIndex );
                    }
                    else
                    {
                        // Must be a map index
                        aIndex -= countSymbolFiles;
                        //
                        if ( aIndex >= 0 && aIndex < iEngineMap.NumberOfCollections )
                        {
                            ret = iEngineMap.MapFileName( aIndex );
                        }
                    }
                }
            }
            //            
            return ret;
        }

        public override void LoadFromFile( string aFileName, TSynchronicity aSynchronicity )
        {
            if ( SymbolFileEngine.IsSymbolFile( aFileName ) )
            {
                iEngineSymbol.LoadFromFile( aFileName, aSynchronicity );
            }
            else if ( MapFileEngine.IsMapFile( aFileName ) )
            {
                iEngineMap.LoadFromFile( aFileName, aSynchronicity );
            }
            else
            {
                throw new NotSupportedException();
            }
        }

        public override bool LoadFromDefinition( CodeSegDefinition aDefinition, TSynchronicity aSynchronicity )
        {
            // Try Symbol file first
            bool wasActivated = false;

            lock ( this )
            {
                wasActivated = iEngineSymbol.Load( aDefinition );
                if ( wasActivated == false )
                {
                    wasActivated = iEngineMap.Load( aDefinition, aSynchronicity );
                }
            }

            return wasActivated;
        }

        public override void UnloadAll()
        {
            lock ( iEngineMap )
            {
                iEngineMap.UnloadAll();
            }
            lock ( iEngineSymbol )
            {
                iEngineSymbol.UnloadAll();
            }
        }

        public override bool Unload( CodeSegDefinition aDefinition )
        {
            bool ret = false;
            lock ( this )
            {
                ret = iEngineMap.Unload( aDefinition );

                // Try with the Symbol engine if it wasn't a loaded map codeseg
                if ( ret == false )
                {
                    ret = iEngineSymbol.Unload( aDefinition );
                }
            }

            return ret;
        }

        public override bool IsLoaded( CodeSegDefinition aDefinition )
        {
            bool ret = false;
            lock ( iEngineMap )
            {
                ret = iEngineMap.IsLoaded( aDefinition );
            }
            if ( ret == false )
            {
                // Try with the Symbol engine if it wasn't a loaded map codeseg
                lock( iEngineSymbol )
                {
                    ret = iEngineSymbol.IsLoaded( aDefinition );
                }
            }

            return ret;
        }
        #endregion

        #region From GenericSymbolEngine
        public override bool IsReady
        {
            get
            {
                bool mapReady = false;
                lock( iEngineMap )
                {
                    mapReady = iEngineMap.IsReady;
                }
                //
                bool symbolReady = false;
                lock ( iEngineSymbol )
                {
                    symbolReady = iEngineSymbol.IsReady;
                }
                //
                bool ret = ( mapReady && symbolReady );
                return ret;
            }
        }

        public override void Reset()
        {
            lock ( iEngineMap )
            {
                iEngineMap.Reset();
            }
            lock( iEngineSymbol )
            {
                iEngineSymbol.Reset();
            }
        }

        public override bool IsLoaded( string aFileName )
        {
            bool loaded = false;
            lock ( iEngineMap )
            {
                loaded = iEngineMap.IsLoaded( aFileName );
            }
            if ( loaded == false )
            {
                lock ( iEngineSymbol )
                {
                    loaded = iEngineSymbol.IsLoaded( aFileName );
                }
            }
            //
            return loaded;
        }

        public override GenericSymbolCollection this[ int aIndex ]
        {
            get
            {
                GenericSymbolCollection ret = null;
                //
                lock ( iEngineMap )
                {
                    lock ( iEngineSymbol )
                    {
                        int mapCount = iEngineMap.NumberOfCollections;
                        if ( aIndex >= 0 && aIndex < mapCount )
                        {
                            ret = iEngineMap[ aIndex ];
                        }
                        else
                        {
                            int symbolBaseIndex = ( aIndex - mapCount );
                            int symbolCount = iEngineSymbol.NumberOfCollections;
                            if ( symbolBaseIndex >= 0 && symbolBaseIndex < symbolCount )
                            {
                                ret = iEngineSymbol[ symbolBaseIndex ];
                            }
                        }
                    }
                }
                //
                return ret;
            }
        }

        public override AddressRange Range
        {
            get
            {
                AddressRange ret = new AddressRange();
                //
                lock ( iEngineMap )
                {
                    ret.Update( iEngineMap.Range );
                }
                lock ( iEngineSymbol )
                {
                    ret.Update( iEngineSymbol.Range );
                }
                //
                return ret;
            }
        }

        internal override void UnloadUntagged()
        {

        }
        #endregion

        #region From IGenericSymbolCollectionStatisticsInterface
        public override int NumberOfCollections
        {
            get
            {
                int count = 0;
                //
                lock ( iEngineMap )
                {
                    count += iEngineMap.NumberOfCollections;
                }
                lock ( iEngineSymbol )
                {
                    count += iEngineSymbol.NumberOfCollections;
                }
                //
                return count;
            }
        }
        #endregion
        
        #region Event handlers
        private void MapEngine_Observer( SymbianUtils.AsyncReaderBase.TEvent aEvent, SymbianUtils.AsyncReaderBase aSender )
        {
            System.Diagnostics.Debug.Assert( aSender.Tag is MapFileEngine );
            MapFileEngine engine = (MapFileEngine) aSender.Tag;
            //
            switch( aEvent )
            {
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingStarted:
                OnParsingStarted( engine.MapFileName );
                break;
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingProgress:
                OnParsingProgress( engine.MapFileName, aSender.Progress );
                break;
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingComplete:
                OnParsingCompleted( engine.MapFileName );
                break;
            }
        }

        private void MapEngine_MapLoaded( CodeSegDefinition aLoadedEntry, MapFile aMapFile )
        {
            OnCollectionCreated( aMapFile );
        }

        private void SymbolEngine_Observer( SymbianUtils.AsyncReaderBase.TEvent aEvent, SymbianUtils.AsyncReaderBase aSender )
        {
            System.Diagnostics.Debug.Assert( aSender.Tag is SymbolFileEngine );
            SymbolFileEngine engine = (SymbolFileEngine) aSender.Tag;
            //
            switch( aEvent )
            {
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingStarted:
                OnParsingStarted( engine.SymbolFileName );
                break;
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingProgress:
                OnParsingProgress( engine.SymbolFileName, aSender.Progress );
                break;
            case SymbianUtils.AsyncReaderBase.TEvent.EReadingComplete:
                OnParsingCompleted( engine.SymbolFileName );
                break;
            }
        }
        #endregion

        #region Internal methods
        #endregion

        #region Data members
        private readonly MapFileEngineCollection iEngineMap;
        private readonly SymbolFileEngineCollection iEngineSymbol;
        #endregion
    }
}