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

namespace SymbolLib.Sources.Map.Engine
{
    internal class MapFileEngineCollection : GenericSymbolEngine
    {
        #region Delegates & Events
        public event AsyncReaderBase.Observer Observer;
        #endregion

        #region Constructors & destructor
        internal MapFileEngineCollection( ITracer aTracer )
            : base( aTracer )
        {
            iCodeSegResolver = new CodeSegResolver( aTracer );
            iCodeSegParser = new CodeSegDefinitionParser( iCodeSegResolver );
        }
        #endregion

        #region API
        public static TFileType IsSupported( string aFileName )
        {
            TFileType ret = TFileType.EFileNotSupported;
            //
            try
            {
                using ( StreamReader reader = new StreamReader( aFileName ) )
                {
                    const int maxLines = 100;
                    //
                    bool foundHeader = false;
                    bool foundBody = false;
                    //
                    int lineCounter = 0;
                    string line = reader.ReadLine();
                    while ( line != null && !( foundHeader && foundBody ) && lineCounter < maxLines )
                    {
                        if ( line.StartsWith( "ARM Linker, RVCT" ) )
                        {
                            foundHeader = true;
                        }
                        else if ( line.Contains( "Symbol Name" ) && line.Contains( "Value" ) && line.Contains( "Object" ) && line.Contains( "Section" ) )
                        {
                            foundBody = true;
                        }

                        line = reader.ReadLine();
                        ++lineCounter;
                    }
                    //
                    if ( foundBody && foundHeader )
                    {
                        ret = TFileType.EFileMap;
                    }
                }
            }
            catch ( Exception )
            {
            }
            //
            return ret;
        }

        public MapFileEngine LoadFromFile( string aMapFileName, TSynchronicity aSynchronicity )
        {
            // Check if already exists
            MapFileEngine engine = null;
            //
            lock ( this )
            {
                engine = FindByMapFileName( aMapFileName );
                if ( engine != null )
                {
                    iFiles.Remove( engine );
                }

                engine = new MapFileEngine( this );
                engine.Observer += new AsyncReaderBase.Observer( MapEngine_ObserverProxy );
                engine.LoadFromFile( aMapFileName, aSynchronicity );
                iFiles.Add( engine );
            }

            return engine;
        }

        public bool Load( CodeSegDefinition aDefinition, TSynchronicity aSynchronicity )
        {
            bool ret = false;
            //
            if ( string.IsNullOrEmpty( aDefinition.MapFileName ) || !aDefinition.MapFileExists )
            {
            }
            else
            {
                // First pass - try to find map engine that matches the specified
                // PC file name. 
                string mapFileName = aDefinition.MapFileName;
                if ( aDefinition.MapFileExists )
                {
                    System.Diagnostics.Debug.WriteLine( "   LOAD {M}: " + aDefinition.ToString() );

                    MapFileEngine engine = FindByMapFileName( mapFileName );
                    if ( engine != null )
                    {
                        engine.Load( aDefinition );
                        ret = true;
                    }
                    else
                    {
                        // Map file engine doesn't exist for the specified code segment.
                        // Can we load it from file?
                        engine = LoadFromFile( aDefinition.MapFileName, aSynchronicity );
                        if ( engine != null )
                        {
                            engine.Load( aDefinition );
                            ret = true;
                        }
                    }
                }
            }
            //
            return ret;
        }

        public bool Unload( CodeSegDefinition aDefinition )
        {
            bool ret = false;
            //
            foreach ( MapFileEngine engine in iFiles )
            {
                if ( engine.Unload( aDefinition ) )
                {
                    ret = true;
                    break;
                }
            }
            //
            return ret;
        }

        public void UnloadAll()
        {
            foreach ( MapFileEngine engine in iFiles )
            {
                engine.UnloadAll();
            }
        }

        public bool IsLoaded( CodeSegDefinition aDefinition )
        {
            bool ret = false;
            //
            foreach ( MapFileEngine engine in iFiles )
            {
                if ( engine.IsLoaded( aDefinition ) )
                {
                    ret = true;
                    break;
                }
            }
            //
            return ret;
        }

        public string MapFileName( int aIndex )
        {
            return iFiles[ aIndex ].MapFileName;
        }
        #endregion

        #region Properties
        public int MapFileCount
        {
            get { return iFiles.Count; }
        }

        public CodeSegResolver CodeSegResolver
        {
            get { return iCodeSegResolver; }
        }

        public CodeSegDefinitionParser CodeSegParser
        {
            get { return iCodeSegParser; }
        }

        public GenericSymbolEngine MapFileEngineAt( int aIndex )
        {
            return iFiles[ aIndex ];
        }

        public string[] BinaryFileNames
        {
            get
            {
                List<string> fileNames = new List<string>( iFiles.Count );
                //
                foreach ( MapFileEngine engine in iFiles )
                {
                    // Map files only contain symbols for one binary
                    fileNames.Add( engine[ 0 ].HostBinaryFileName );
                }
                //
                return fileNames.ToArray();
            }
        }

        public string[] MapFileNames
        {
            get
            {
                List<string> fileNames = new List<string>( iFiles.Count );
                //
                foreach ( MapFileEngine engine in iFiles )
                {
                    fileNames.Add( engine.MapFileName );
                }
                //
                return fileNames.ToArray();
            }
        }
        #endregion

        #region From GenericSymbolEngine
        public override void Reset()
        {
            iFiles.Clear();
            iCodeSegResolver.Clear();
        }

        public override bool IsLoaded( string aFileName )
        {
            MapFileEngine engine = FindByMapFileName( aFileName );
            return engine != null;
        }

        public override bool IsReady
        {
            get
            {
                int readyCount = 0;
                //
                foreach ( MapFileEngine engine in iFiles )
                {
                    if ( engine.IsReady )
                    {
                        ++readyCount;
                    }
                }
                //
                return ( readyCount == iFiles.Count );
            }
        }

        public override GenericSymbolCollection this[ int aIndex ]
        {
            get
            {
                // Map files contain only a single symbol collection;
                GenericSymbolCollection ret = iFiles[ aIndex ][ 0 ];
                return ret;
            }
        }

        public override AddressRange Range
        {
            get
            {
                AddressRange ret = new AddressRange();
                //
                foreach ( MapFileEngine engine in iFiles )
                {
                    ret.Update( engine.Range );
                }
                //
                return ret;
            }
        }

        internal override void UnloadUntagged()
        {
        }
        #endregion

        #region From IGenericSymbolCollectionStatisticsInterface
        public override int NumberOfCollections
        {
            get
            {
                // Map files contain only a single symbol collection
                int count = iFiles.Count;
                return count;
            }
        }
        #endregion

        #region Event handlers
        private void MapEngine_ObserverProxy( SymbianUtils.AsyncReaderBase.TEvent aEvent, SymbianUtils.AsyncReaderBase aSender )
        {
            if ( Observer != null )
            {
                Observer( aEvent, aSender );
            }
        }
        #endregion

        #region Internal methods
        private MapFileEngine FindByMapFileName( string aFileName )
        {
            MapFileEngine ret = null;
            //
            foreach ( MapFileEngine engine in iFiles )
            {
                if ( engine.MapFileName.ToLower() == aFileName.ToLower() )
                {
                    ret = engine;
                    break;
                }
            }
            //
            return ret;
        }
        #endregion

        #region Data members
        private readonly CodeSegResolver iCodeSegResolver;
        private readonly CodeSegDefinitionParser iCodeSegParser;
        private List<MapFileEngine> iFiles = new List<MapFileEngine>();
        #endregion
    }
}