/*

* Copyright (c) 2004-2008 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.Generic;

using System.Text;

using System.Text.RegularExpressions;

using SymbianStructuresLib.Debug.Symbols;

using SymbianSymbolLib.SourceManagement.Source;

using SymbianSymbolLib.SourceManagement.Provisioning;

using SymbianUtils.FileTypes;

using SymbianUtils;

namespace SLPluginObey.Reader

{

    internal class ObeyFileReader : AsyncTextFileReader

    {

        #region Delegates & events

        public delegate void ObyEntryHandler( ObeyFileReader aReader, string aHost, string aDevice );

        public event ObyEntryHandler EntryRead;

        #endregion

        #region Constructors

        public ObeyFileReader( string aFileName )

            : base( aFileName )

        {

            // We should identify what kind of prefix to apply to all the (host) file name

            // entries that we read from the OBY file.

            //

            // For example, the OBY might say:

            //

            //  \epoc32\release\ARMV5\urel\somebinary.dll    "..."

            //

            // We must work out where that '\epoc32' directory is relative to, and then

            // use this as the basis of the prefix to apply to every line we read

            // from the OBY itself.

            //

            // Pre-conditions:

            //  * We will only ever look on the host drive that contains the actual OBY file.

            //

            // Algorithm:

            //

            // 1) We will search up the directory tree, starting at the directory containing the OBY

            //    and check whether it contains an \epoc32\ subdirectory. 

            // 2) If an \epoc32 subdirectory exists, then this is our prefix.

            // 3) If no such subdirectory exists, then we pop a level from the directory (i.e. move to parent)

            //    and try again.

            // 4) Eventually, we'll end up with [OBY drive letter]:\epoc32\ - at this point, even if

            //    the specified directory does not exist, we'll just give up.

            //

            // Fail safe

            iRootPathToApplyToAllHostFileNames = Path.GetPathRoot( base.FileName );

            try

            {

                DirectoryInfo dirInfo = new DirectoryInfo( Path.GetDirectoryName( aFileName ) );

                while( dirInfo.Exists )

                {

                    string path = Path.Combine( dirInfo.FullName, KStandardEpoc32Path );

                    if ( Directory.Exists( path ) )

                    {

                        iRootPathToApplyToAllHostFileNames = dirInfo.FullName;

                        break;

                    }

                    else

                    {

                        dirInfo = new DirectoryInfo( dirInfo.Parent.FullName );

                    }

                }

            }

            catch

            {

            }

        }

        #endregion

        #region API

        public void Read( TSynchronicity aSynchronicity )

        {

            base.StartRead( aSynchronicity );

        }

        #endregion

        #region Properties

        #endregion

        #region From AsyncTextFileReader

        protected override void HandleFilteredLine( string aLine )

        {

            Match m = KMapParserRegex.Match( aLine );

            if ( m.Success )

            {

                GroupCollection groups = m.Groups;

                string type = groups[ "Type" ].Value;

                string host = groups[ "Host" ].Value;

                string device = groups[ "Device" ].Value;

                // Fix up names

                try

                {

                    if ( type != "ROFS_HEADER" )

                    {

                        host = CombineWithHostDrive( host );

                        device = CombineWithDeviceDrive( device );

                        if ( EntryRead != null )

                        {

                            EntryRead( this, host, device );

                        }

                    }

                }

                catch ( Exception )

                {

                    base.Trace( "WARNING: exception when trying to parse OBY line: [{0}], file: [{1}]", aLine, base.FileName );

                }

            }

        }

        #endregion

        #region Internal constants

        public static readonly Regex KMapParserRegex = new Regex(

             @"(?<Type>.+)\=(\x22|)(?<Host>.+?)(\x22|)(?:\s+)\x22(?<Device>.+)\x22",

           RegexOptions.CultureInvariant

           | RegexOptions.IgnorePatternWhitespace

           | RegexOptions.Compiled

           );

        private const string KStandardEpoc32Path = @"epoc32\";

        #endregion

        #region Internal methods

        private string CombineWithHostDrive( string aFileAndPath )

        {

            string fileName = aFileAndPath.Trim();

            if ( fileName.StartsWith( @"\" ) )

            {

                fileName = fileName.Substring( 1 );

            }

            string ret = Path.Combine( iRootPathToApplyToAllHostFileNames, fileName );

            return ret;

        }

        private string CombineWithDeviceDrive( string aFileAndPath )

        {

            string ret = Path.Combine( @"Z:\", aFileAndPath );

            return ret;

        }

        #endregion

        #region Data members

        private readonly string iRootPathToApplyToAllHostFileNames;

        #endregion

    }

}