/*

* 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 System.Text.RegularExpressions;

using System.Reflection;

using SymbianParserLib.Enums;

namespace SymbianParserLib.RegExTranslators

{

    internal class RegExTranslatorExtractionInfo

    {

        #region Constructors

        public RegExTranslatorExtractionInfo( string aLine, int aStartPos )

        {

            iMatch = KRegEx.Match( aLine, aStartPos );

        }

        #endregion

        #region API

        #endregion

        #region Constants

        public const int KNoWidthSpecified = -1;

        #endregion

        #region Properties

        public bool Success

        {

            get { return Match.Success; }

        }

        public Match Match

        {

            get { return iMatch; }

        }

        public char ValueTypeChar

        {

            get

            {

                char ret = '\0';

                //

                if ( iMatch.Success )

                {

                    Group gpType = iMatch.Groups[ KGroupTypeChar ];

                    if ( gpType.Success )

                    {

                        string type = gpType.Value.ToUpper();

                        ret = type[ 0 ];

                    }

                }

                //

                return ret;

            }

        }

        public TParserValueType ValueType

        {

            get

            {

                TParserValueType ret = TParserValueType.EValueTypeUnknown;

                //

                if ( iMatch.Success )

                {

                    char typeChar = ValueTypeChar;

                    switch ( typeChar )

                    {

                    case 'U':

                        ret = TParserValueType.EValueTypeUint32;

                        break;

                    case 'S':

                        ret = TParserValueType.EValueTypeString;

                        break;

                    case 'D':

                        ret = TParserValueType.EValueTypeInt32;

                        break;

                    case 'X':

                        if ( IsLong )

                        {

                            ret = TParserValueType.EValueTypeUint64;

                        }

                        else

                        {

                            ret = TParserValueType.EValueTypeUint32;

                        }

                        break;

                    default:

                        break;

                    }

                }

                //

                return ret;

            }

        }

        public string ValuePrefix

        {

            get

            {

                string ret = string.Empty;

                //

                if ( iMatch.Success )

                {

                    Group gpValuePrefix = iMatch.Groups[ KGroupValuePrefix ];

                    if ( gpValuePrefix.Success )

                    {

                        ret = gpValuePrefix.Value;

                    }

                }

                //

                return ret;

            }

        }

        public bool IsValuePrefixHex

        {

            get

            {

                string prefix = ValuePrefix;

                bool ret = ( prefix == KValuePrefixHex1 || prefix == KValuePrefixHex2 );

                return ret;

            }

        }

        public int NumberBase

        {

            get

            {

                int ret = 0;

                //

                if ( iMatch.Success )

                {

                    if ( ValueType != TParserValueType.EValueTypeString )

                    {

                        char typeChar = ValueTypeChar;

                        switch ( typeChar )

                        {

                            case 'U':

                            case 'D':

                                ret = KNumberBaseDecimal;

                                break;

                            case 'X':

                                ret = KNumberBaseHexadecimal;

                                break;

                            default:

                                break;

                        }

                    }

                }

                //

                return ret;

            }

        }

        public bool IsLong

        {

            get

            {

                // The 'long' (L) specifier gets shoehorned into the width group

                bool ret = false;

                //

                if ( iMatch.Success )

                {

                    Group gpWidth = iMatch.Groups[ KGroupWidth ];

                    if ( gpWidth.Success )

                    {

                        string val = gpWidth.Value.Trim().ToUpper();

                        ret = ( val == "L" );

                    }

                }

                //

                return ret;

            }

        }

        public int Width

        {

            get

            {

                int ret = KNoWidthSpecified;

                //

                if ( iMatch.Success )

                {

                    Group gpWidth = iMatch.Groups[ KGroupWidth ];

                    if ( gpWidth.Success )

                    {

                        string val = gpWidth.Value.Trim();

                        if ( val.Length != 0 )

                        {

                            Match m = KNumericNumberRegex.Match( val );

                            if ( m.Success )

                            {

                                ret = System.Convert.ToInt32( m.Value );

                            }

                        }

                    }

                }

                //

                return ret;

            }

        }

        public int CapturePos

        {

            get

            {

                Group gpPercent = Match.Groups[ KGroupPercent ];

                int pos = gpPercent.Index;

                return pos;

            }

        }

        public int CaptureLength

        {

            get

            {

                // [StartPos] ..... [% Pos] .... [EndPos]

                //                  <------------------->       = what we return

                int startPos = Match.Index;

                int length = Match.Length;

                int endPos = startPos + length;

                int percentPos = CapturePos;

                int ret = ( endPos - percentPos );

                return ret;

            }

        }

        public string Name

        {

            get

            {

                string ret = string.Empty;

                //

                if ( Success )

                {

                    Group propertyName = Match.Groups[ KGroupPropertyName ];

                    ret = propertyName.Value.Trim();

                }

                //

                return ret;

            }

        }

        public string PadChar

        {

            get

            {

                string ret = string.Empty;

                //

                if ( Success )

                {

                    Group pad = Match.Groups[ KGroupPadChar ];

                    ret = pad.Value.Trim();

                }

                //

                return ret;

            }

        }

        #endregion

        #region Internal methods

        #endregion

        #region Internal constants

        private const string KGroupValuePrefix = "ValuePrefix";

        private const string KGroupPropertyName = "PropertyName";

        private const string KGroupPadChar = "PadChar";

        private const string KGroupWidth = "Width";

        private const string KGroupTypeChar = "TypeChar";

        private const string KGroupPercent = "Percent";

        private const string KValuePrefixHex1 = "0x";

        private const string KValuePrefixHex2 = "x";

        private const int KNumberBaseDecimal = 10;

        private const int KNumberBaseHexadecimal = 16;

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return base.ToString();

        }

        #endregion

        #region Data members

        /// <summary>

        ///  Regular expression built for C# on: Tue, May 20, 2008, 12:54:34 PM

        ///  Using Expresso Version: 3.0.2766, http://www.ultrapico.com

        ///  

        ///  A description of the regular expression:

        ///  

        ///  [PropertyName]: A named capture group. [(?:\w+\s*)+?], zero or one repetitions

        ///      Match expression but don't capture it. [\w+\s*], one or more repetitions, as few as possible

        ///          \w+\s*

        ///              Alphanumeric, one or more repetitions

        ///              Whitespace, any number of repetitions

        ///  Comment: Property name, essentially captures words separated by whitespace

        ///  Match expression but don't capture it. [\s*]

        ///      Whitespace, any number of repetitions

        ///  Comment: More whitespace

        ///  Match expression but don't capture it. [-], zero or one repetitions

        ///      -

        ///  Comment: Ignore any leading minus char

        ///  Match expression but don't capture it. [\s*]

        ///      Whitespace, any number of repetitions

        ///  Comment: More whitespace

        ///  Comment: Next parse and discard any optional assignment prefix - such a ";" or "="

        ///  Match expression but don't capture it. [\s*]

        ///      Whitespace, any number of repetitions

        ///  Match expression but don't capture it. [=|\x3A], zero or one repetitions

        ///      Select from 2 alternatives

        ///          =

        ///          Hex 3A

        ///  Match expression but don't capture it. [\s*]

        ///      Whitespace, any number of repetitions

        ///  [ValuePrefix]: A named capture group. [0x|x], zero or one repetitions

        ///      Select from 2 alternatives

        ///          0x

        ///              0x

        ///          x

        ///  Match expression but don't capture it. [%{1}]

        ///      %, exactly 1 repetitions

        ///  [PadChar]: A named capture group. [(?:0| )?]

        ///      Match expression but don't capture it. [0| ], zero or one repetitions

        ///          Select from 2 alternatives

        ///              0

        ///              NULL

        ///  [Width]: A named capture group. [(?:[0-9]?|l)]

        ///      Match expression but don't capture it. [[0-9]?|l]

        ///          Select from 2 alternatives

        ///              Any character in this class: [0-9], zero or one repetitions

        ///              l

        ///  [TypeChar]: A named capture group. [d|D|x|X|u|U|s|S]

        ///      Select from 8 alternatives

        ///          dDxXuUsS

        ///  

        ///

        /// </summary>

        private static readonly Regex KRegEx = new Regex(

              "(?<PropertyName>(?:\\w+\\s*)+?)? # Property name, essentiall" +

              "y captures words separated by whitespace\r\n(?:\\s*) # More wh" +

              "itespace\r\n(?:-)? # Ignore any leading minus char\r\n(?:\\s*) #" +

              " More whitespace\r\n\r\n# Next parse and discard any optional as" +

              "signment prefix - such a \";\" or \"=\"\r\n(?:\\s*)(?:=|\\x3A)" +

              "?(?:\\s*) \r\n\r\n(?<ValuePrefix>0x|x)?(?<Percent>%{1})\r\n\r\n(?<PadChar>(?" +

              ":0| )?)(?<Width>(?:[0-9]?|l))(?<TypeChar>d|D|x|X|u|U|s|S|i|I)",

            RegexOptions.CultureInvariant

            | RegexOptions.IgnorePatternWhitespace

            | RegexOptions.Compiled

            );

        private static readonly Regex KNumericNumberRegex = new Regex( @"[0-9]", RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled );

        private readonly Match iMatch;

        #endregion

    }

}