/*

* 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.Collections.Generic;

using System.Text;

using SymbianUtils.Strings;

namespace SymbianUtils.XRef

{

    public class XRefIdentiferExtractor

    {

        #region Constructors

        public XRefIdentiferExtractor( string aFunction )

        {

            iIdentifiers = ExtractSearchableElements( aFunction );

        }

        #endregion

        #region Properties

        public List<XRefIdentifer> Identifiers

        {

            get { return iIdentifiers; }

        }

        #endregion

        #region Internal methods

        private static bool ContainsParameters( string aText )

        {

            // Search initiall for '(' - if that is found, then

            // we should also find a closing bracket.

            bool parameters = false;

            int openingBracketPos = aText.IndexOf( "(" );

            //

            if ( openingBracketPos > 0 )

            {

                // Should also be a closing bracket and it should

                // appear after the opening bracket

                int closingBracketPos = aText.LastIndexOf( ")" );

                parameters = ( closingBracketPos > openingBracketPos );

            }

            //

            return parameters;

        }

        private static string ExtractParameters( ref string aText )

        {

            const string KOperatorChevronText = "operator <<";

            // DoAppendFormatList<TDes16, (int)2>(T1&, const T3&, std::__va_list, T2*)

            // DoAppendFormatList<TDes16, (int)2>(T1&, TBuf<(int)256>, std::__va_list, T2*)

            // Method<TDes16>::Wibble( something )

            // Method::Wibble( RPointerArray<HBufC> )

            // RTest::operator ()(int, int, const unsigned short*)

            // TDesC16::Left(int) const

            // CObjectCon::AtL(int) const

            // User::Panic(const TDesC16&, int)

            // operator <<(RWriteStream&, const unsigned char&)

            // Handle special case of "operator <<" confusing matters

            string workingText = aText;

            int operatorOpeningChevronPos = aText.IndexOf( KOperatorChevronText );

            if ( operatorOpeningChevronPos >= 0 )

            {

                aText = aText.Substring( 0, operatorOpeningChevronPos + KOperatorChevronText.Length );

                workingText = workingText.Substring( operatorOpeningChevronPos + KOperatorChevronText.Length );

            }

            else

            {

                aText = string.Empty;

            }

            string ret = string.Empty;

            //

            int closingPos = 0;

            int openingPos = 0;

            int templatePos = 0;

            //

            while ( openingPos >= 0 )

            {

                if ( templatePos >= 0 )

                    templatePos = workingText.IndexOf( "<", templatePos );

                openingPos = workingText.IndexOf( "(", openingPos );

                if ( templatePos >= 0 && templatePos < openingPos )

                {

                    // Template region appears before the next bracket. Skip

                    // over all characters until we hit the end of the template

                    // section

                    int endingPos = templatePos;

                    StringParsingUtils.SkipToEndOfSection( ref workingText, ref endingPos, '<', '>' );

                    if ( endingPos < 0 )

                    {

                        // Matching closing brace was never found - dealing with operator << ?

                        templatePos = -1;

                    }

                    else

                    {

                        // Something like DoAppendFormatList<TDes16, (int)2>(T1&, const T3&, std::__va_list, T2*) ???

                        templatePos = endingPos;

                        openingPos = endingPos;

                    }

                }

                else if ( openingPos >= 0 )

                {

                    // Skipped over any template nonsense. Work backward from the end 

                    // in order to locate start of parameters.

                    closingPos = workingText.LastIndexOf( ')' );

                    openingPos = closingPos;

                    StringParsingUtils.SkipToBeginningOfSection( ref workingText, ref openingPos, '(', ')' );

                    string parameters = workingText.Substring( openingPos + 1, ( closingPos - openingPos ) - 1 ).Trim();

                    ret = parameters;

                    workingText = workingText.Substring( 0, openingPos + 1 ) + workingText.Substring( closingPos );

                    aText = aText + workingText;

                    break;

                }

            }

            //

            return ret;

        }

        private static void SplitParameters( string aParams, ref List<string> aEntries )

        {

            /*

             * TPtrC16::TPtrC16(const unsigned short*) 

             * TPtrC16::TPtrC16(const TDesC16&) 

             * UserHal::MemoryInfo(TDes8&) 

             * RHandleBase::Close() 

             * TBufCBase16::Copy(const TDesC16&, int) 

             * CBufFlat::NewL(int) 

             * TBufCBase16::TBufCBase16() 

             * CServer2::RunL() 

             * CServer2::StartL(const TDesC16&) 

             * CServer2::DoCancel() 

             * CServer2::RunError(int) 

             * CServer2::DoConnect(const RMessage2&) 

             * CServer2::CServer2__sub_object(int, CServer2::TServerType) 

             */

            string paramType;

            while ( aParams.Length > 0 )

            {

                int commaPos = aParams.IndexOf( "," );

                //

                paramType = aParams;

                if ( commaPos > 0 )

                {

                    paramType = aParams.Substring( 0, commaPos ).Trim();

                    if ( commaPos < aParams.Length )

                        aParams = aParams.Substring( commaPos + 1 ).Trim();

                    else

                        aParams = string.Empty;

                }

                else

                {

                    // Everything was consumed

                    aParams = string.Empty;

                }

                // Add it

                aEntries.Add( paramType );

            }

        }

        private static string[] IdentifyFurtherClassAndMethodInformation( string aEntry )

        {

            string[] classAndMethodData = aEntry.Split( new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries );

            return classAndMethodData;

        }

        private static List<XRefIdentifer> ExtractSearchableElements( string aFunction )

        {

            List<string> workingData = new List<string>();

            // See if this entry contains parameter data?

            if ( ContainsParameters( aFunction ) )

            {

                // This call modifies aFunction so that the parameters are removed

                string parameters = ExtractParameters( ref aFunction );

                // Now we get the individual parameter elements from the arguments

                SplitParameters( parameters, ref workingData );

            }

            // Extract class & method names if present

            string[] classAndMethodData = aFunction.Split( new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries );

            if ( classAndMethodData.Length > 0 )

            {

                foreach ( string identifiedEntry in classAndMethodData )

                {

                    workingData.Add( identifiedEntry );

                }

            }

            else

            {

                // Not a class & method - so just take the entire text as a 

                // global function name

                workingData.Add( aFunction );

            }

            // Recursively check for any more class types, e.g. in the following entry:

            //

            // CServer2::CServer2__sub_object(int, CServer2::TServerType) 

            //

            // We also need to extract CServer2 and TServerType as individual elements

            for ( int i = workingData.Count - 1; i >= 0; i-- )

            {

                string entry = workingData[ i ];

                string[] furtherSplit = IdentifyFurtherClassAndMethodInformation( entry );

                if ( furtherSplit != null && furtherSplit.Length > 1 )

                {

                    foreach ( string furtherEntry in furtherSplit )

                    {

                        workingData.Add( furtherEntry );

                    }

                    // Remove defunct entry

                    workingData.RemoveAt( i );

                }

            }

            // Clean up phase

            List<string> cleanedEntries = new List<string>();

            foreach ( string identifiedEntry in workingData )

            {

                string entry = identifiedEntry;

                // Now go through the identified entries and ensure they don't include

                // any pointer (*), reference (&) or bracketry.

                int pos = entry.IndexOfAny( new char[] { '*', '+', '&', '[', ']', '<', '>', '(', ')' } );

                if ( pos >= 0 )

                {

                    entry = entry.Substring( 0, pos );

                }

                // Strip any reserved keywords

                if ( entry.Length > 0 )

                {

                    entry = entry.Replace( "const", string.Empty );

                    entry = entry.Replace( "static", string.Empty );

                    entry = entry.Replace( "public", string.Empty );

                    entry = entry.Replace( "protected", string.Empty );

                    entry = entry.Replace( "private", string.Empty );

                    entry = entry.Replace( "__sub_object", string.Empty );

                    //

                    if ( !cleanedEntries.Contains( entry ) )

                    {

                        cleanedEntries.Add( entry.Trim() );

                    }

                }

            }

            // Convert to XRefIdentifiers

            List<XRefIdentifer> finalEntries = new List<XRefIdentifer>();

            foreach ( string cleanedEntry in cleanedEntries )

            {

                XRefIdentifer item = new XRefIdentifer( cleanedEntry );

                finalEntries.Add( item );

            }

            //

            return finalEntries;

        }

        #endregion

        #region Data members

        private readonly List<XRefIdentifer> iIdentifiers;

        #endregion

    }

}