//#define SHOW_EACH_LINE

/*

* 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.Utilities;

using SymbianParserLib.RegExTranslators;

using SymbianParserLib.BaseStructures;

using SymbianParserLib.ValueStores;

namespace SymbianParserLib.Elements

{

    public class ParserLine : ParserElementBaseWithValueStore, IEnumerable<ParserField>

    {

        #region Enumerations

        public enum TLineType

        {

            ELineTypeSimpleStringMatch = 0,

            ELineTypeSymbianFormatString,

            ELineTypeRegEx

        }

        [Flags]

        internal enum TLineFlags

        {

            ELineFlagNone = 0,

            ELineFlagDequeueIfComplete = 1,

            ELineFlagNeverConsumesLine = 2

        }

        #endregion

        #region Static constructors

        public static ParserLine New( string aText )

        {

            ParserLine self = new ParserLine( TLineType.ELineTypeSimpleStringMatch );

            self.OriginalValue = ParserUtils.RemoveLineEndings( aText );

            return self;

        }

        public static ParserLine NewSymFormat( string aFormat )

        {

            // First check with cache

            ParserLine self = RegExTranslatorManager.PreCachedCompiledEntry( aFormat );

            if ( self == null )

            {

                // Wasn't cached so we need to parse and create a new entry

                self = new ParserLine( TLineType.ELineTypeSymbianFormatString );

                self.OriginalValue = aFormat;

                //

                RegExTranslatorManager.CompileToRegularExpression( self );

            }

            //

            return self;

        }

        public static ParserLine NewRegEx( string aRegEx )

        {

            throw new NotSupportedException();

        }

        internal static ParserLine NewCopy( ParserLine aLine )

        {

            ParserLine ret = new ParserLine( aLine );

            return ret;

        }

        #endregion

        #region Constructors

        private ParserLine( TLineType aLineType )

        {

            iLineType = aLineType;

        }

        private ParserLine( ParserLine aLine )

        {

            iLineType = aLine.LineType;

            iOriginalValue = aLine.OriginalValue;

            iFinalValue = new StringBuilder( aLine.FinalValue );

            iFlags = aLine.iFlags;

            foreach ( ParserField templateField in aLine )

            {

                ParserField copy = new ParserField( templateField );

                Add( copy );

            }

            CreateRegEx();

        }

        #endregion

        #region API

        public void Add( ParserField aField )

        {

            aField.Parent = this;

            aField.DisableWhenComplete = this.DisableWhenComplete;

            iFields.Add( aField );

        }

        internal void Finalise()

        {

            if ( Count != 0 )

            {

                FinalValue = OriginalValue;

                // Fixup the final string to be a new "dynamically" generated regular expression. Work

                // backwards since we adjust the string by index and therefore we must not affect earlier

                // indexes when forming the replacement.

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

                {

                    ParserField field = this[ i ];

                    //

                    string regex = field.FormatSpecifier.RegularExpressionString;

                    int origPos = field.FormatSpecifier.OriginalLocation;

                    int origLen = field.FormatSpecifier.OriginalLength;

                    iFinalValue.Remove( origPos, origLen );

                    iFinalValue.Insert( origPos, regex );

                }

                CreateRegEx();

            }

        }

        #endregion

        #region Properties

        public int Count

        {

            get { return iFields.Count; }

        }

        public ParserField this[ int aIndex ]

        {

            get { return iFields[ aIndex ]; }

        }

        public ParserParagraph Paragraph

        {

            get

            {

                ParserParagraph ret = null;

                //

                if ( Parent != null && Parent is ParserParagraph )

                {

                    ret = Parent as ParserParagraph;

                }

                //

                return ret;

            }

        }

        public bool DequeueIfComplete

        {

            get { return ( iFlags & TLineFlags.ELineFlagDequeueIfComplete ) == TLineFlags.ELineFlagDequeueIfComplete; }

            set

            {

                if ( value )

                {

                    iFlags |= TLineFlags.ELineFlagDequeueIfComplete;

                }

                else

                {

                    iFlags &= ~TLineFlags.ELineFlagDequeueIfComplete;

                }

            }

        }

        public bool NeverConsumesLine

        {

            get { return ( iFlags & TLineFlags.ELineFlagNeverConsumesLine ) == TLineFlags.ELineFlagNeverConsumesLine; }

            set

            {

                if ( value )

                {

                    iFlags |= TLineFlags.ELineFlagNeverConsumesLine;

                }

                else

                {

                    iFlags &= ~TLineFlags.ELineFlagNeverConsumesLine;

                }

            }

        }

        public string OriginalValue

        {

            get { return iOriginalValue; }

            set { iOriginalValue = value; }

        }

        public TLineType LineType

        {

            get { return iLineType; }

        }

        internal string FinalValue

        {

            get { return FinalValueBuilder.ToString(); }

            set { iFinalValue = new StringBuilder( value ); }

        }

        internal StringBuilder FinalValueBuilder

        {

            get { return iFinalValue; }

            set { iFinalValue = value; }

        }

        #endregion

        #region From ParserElementBase

        internal override ParserResponse Offer( ref string aLine )

        {

            ParserResponse ret = new ParserResponse();

            //

            if ( iLineType == TLineType.ELineTypeSimpleStringMatch )

            {

                bool match = ( aLine.Contains( OriginalValue ) );

                if ( match )

                {

#if SHOW_EACH_LINE

                    System.Diagnostics.Debug.WriteLine( aLine );

#endif

                    ret = new ParserResponse( ParserResponse.TResponseType.EResponseTypeHandled );

                }

            }

            else if ( iLineType == TLineType.ELineTypeSymbianFormatString )

            {

                if ( iFinalRegEx != null )

                {

                    Match m = iFinalRegEx.Match( aLine );

                    bool match = m.Success;

                    if ( match )

                    {

#if SHOW_EACH_LINE

                        System.Diagnostics.Debug.WriteLine( aLine );

#endif

                        GroupCollection groups = m.Groups;

                        ExtractValues( groups );

                        ret = new ParserResponse( ParserResponse.TResponseType.EResponseTypeHandled );

                    }

                }

            }

            // Update completion - will trigger observers

            IsComplete = ret.WasHandled;

            if ( IsComplete )

            {

                // Dequeue the line from parent paragraph if it is

                // complete and so adorned

                if ( DequeueIfComplete )

                {

                    Paragraph.Remove( this );

                }

                // If this object never consumes the input string, then

                // instead throw a nonconsuming exception, and the engine

                // will re-offer it to all objects

                if ( NeverConsumesLine )

                {

                    ret = new ParserResponse( ParserResponse.TResponseType.EResponseTypeHandledByRequiresReProcessing );

                }

            }

            return ret;

        }

        internal override void OnDisableWhenComplete()

        {

            base.OnDisableWhenComplete();

            //

            foreach( ParserField f in iFields )

            {

                f.DisableWhenComplete = this.DisableWhenComplete;

            }

        }

        internal override void OnNeverEnding()

        {

            base.OnNeverEnding();

            //

            foreach ( ParserField f in iFields )

            {

                f.IsNeverEnding = this.IsNeverEnding;

            }

        }

        #endregion

        #region From ParserElementBaseWithValueStore

        public override void SetTargetObject()

        {

            base.SetTargetObject();

            foreach ( ParserField field in this )

            {

                field.SetTargetObject();

            }

        }

        internal override void SetTargetProperty( object aPropertyObject, string aPropertyName, int aIndex )

        {

            if ( aIndex == ParserElementBaseWithValueStore.KGloballyApplicable )

            {

                // Applicable to all

                iValueStore = new ValueStore();

                iValueStore.SetTargetProperty( aPropertyObject, aPropertyName );

            }

            else

            {

                // Specific to a field

                if ( aIndex < 0 || aIndex >= Count )

                {

                    throw new ArgumentOutOfRangeException( "aIndex" );

                }

                this[ aIndex ].SetTargetProperty( aPropertyObject, aPropertyName );

            }

        }

        #endregion

        #region Internal methods

        private void CreateRegEx()

        {

            iFinalRegEx = new Regex( FinalValue, RegexOptions.Singleline );

        }

        private void ExtractValues( GroupCollection aGroups )

        {

            for ( int i = 1; i < aGroups.Count; i++ )

            {

                Group group = aGroups[ i ];

                if ( group.Success )

                {

                    int pos = group.Index;

                    string value = group.Value;

                    //

                    if ( i <= Count )

                    {

                        ParserField field = this[ i - 1 ];

                        field.ExtractValue( group );

                    }

                }

            }

        }

        #endregion

        #region Internal constants

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return base.ToString();

        }

        #endregion

        #region From IEnumerable<ParserField>

        public IEnumerator<ParserField> GetEnumerator()

        {

            foreach ( ParserField field in iFields )

            {

                yield return field;

            }

        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            foreach ( ParserField field in iFields )

            {

                yield return field;

            }

        }

        #endregion

        #region Data members

        private readonly TLineType iLineType;

        private string iOriginalValue = string.Empty;

        private StringBuilder iFinalValue = new StringBuilder();

        private Regex iFinalRegEx = null;

        private TLineFlags iFlags = TLineFlags.ELineFlagNone;

        private List<ParserField> iFields = new List<ParserField>();

        #endregion

    }

}