/*

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

using System.ComponentModel;

using SymbianParserLib.Enums;

using SymbianParserLib.ValueStores;

using SymbianParserLib.Elements.SubFields;

namespace SymbianParserLib.BaseStructures

{

    public abstract class ParserElementBaseWithValueStore : ParserElementBase

    {

        #region Constructors

        protected ParserElementBaseWithValueStore()

            : this( string.Empty )

        {

        }

        protected ParserElementBaseWithValueStore( string aName )

            : base( aName )

        {

        }

        #endregion

        #region Abstract API

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

        internal virtual void SetValue( ParserFieldFormatSpecifier aFormat, ParserFieldFormatValue aValue )

        {

            ValueStore vs = GetValueStore( this );

            if ( vs == null )

            {

                // Make a new "store internally" value store

                iValueStore = new ValueStore();

                vs = iValueStore;

            }

            //

            vs.SetValue( aFormat, aValue );

        }

        #endregion

        #region API

        public virtual void SetTargetObject()

        {

            iValueStore = new ValueStore();

        }

        public virtual void SetTargetProperty( object aPropertyObject, string aPropertyName )

        {

            SetTargetProperty( aPropertyObject, aPropertyName, KGloballyApplicable );

        }

        public virtual void SetTargetProperties( object aPropertyObjects, params string[] aPropertyNames )

        {

            if ( aPropertyObjects == null )

            {

                throw new ArgumentException( "Property object cannot be null" );

            }

            int count = aPropertyNames.Length;

            if ( count == 0 )

            {

                throw new ArgumentException( "Property name array must not be empty" );

            }

            for ( int i = 0; i < count; i++ )

            {

                string propName = aPropertyNames[ i ];

                if ( propName.Length == 0 )

                {

                    throw new ArgumentException( "Property name is invalid" );

                }

                SetTargetProperty( aPropertyObjects, propName, i );

            }

        }

        public virtual void SetTargetProperties( object[] aPropertyObjects, params string[] aPropertyNames )

        {

            if ( aPropertyObjects.Length == 0 || aPropertyNames.Length == 0 || aPropertyObjects.Length != aPropertyNames.Length )

            {

                throw new ArgumentException( "Property object/names are invalid" );

            }

            //

            int count = aPropertyNames.Length;

            for ( int i = 0; i < count; i++ )

            {

                object obj = aPropertyObjects[ i ];

                if ( obj == null )

                {

                    throw new ArgumentException( "Property object cannot be null" );

                }

                string propName = aPropertyNames[ i ];

                if ( propName.Length == 0 )

                {

                    throw new ArgumentException( "Property name is invalid" );

                }

                SetTargetProperty( obj, propName, i );

            }

        }

        public virtual void SetTargetMethod( object aMethodObject, string aMethodName )

        {

            SetTargetMethod( aMethodObject, aMethodName, TValueStoreMethodArguments.EValueStoreMethodArgumentCalculateAtRuntime );

        }

        public virtual void SetTargetMethod( object aMethodObject, string aMethodName, params TValueStoreMethodArguments[] aMethodArgs )

        {

            // Check that the args are okay.

            foreach ( TValueStoreMethodArguments argType in aMethodArgs )

            {

                if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentCalculateAtRuntime )

                {

                    if ( aMethodArgs.Length != 1 )

                    {

                        throw new ArgumentException( "Method arguments must contain only a single entry when using \'calculate at runtime\' approach" );

                    }

                }

            }

            iValueStore = new ValueStore();

            iValueStore.SetTargetMethod( aMethodObject, aMethodName, aMethodArgs );

        }

        #endregion

        #region Properties

        public bool IsInt

        {

            get

            {

                bool ret = ( iValueStore != null ) && iValueStore.IsInt;

                return ret;

            }

        }

        public bool IsUint

        {

            get

            {

                bool ret = ( iValueStore != null ) && iValueStore.IsUint;

                return ret;

            }

        }

        public bool IsString

        {

            get

            {

                bool ret = ( iValueStore != null ) && iValueStore.IsString;

                return ret;

            }

        }

        public int AsInt

        {

            get

            {

                int ret = 0;

                //

                if ( IsInt )

                {

                    ret = iValueStore.AsInt;

                }

                //

                return ret;

            }

        }

        public uint AsUint

        {

            get

            {

                uint ret = 0;

                //

                if ( IsUint )

                {

                    ret = iValueStore.AsUint;

                }

                //

                return ret;

            }

        }

        public string AsString

        {

            get

            {

                string ret = string.Empty;

                //

                if ( IsString )

                {

                    ret = iValueStore.AsString;

                }

                //

                return ret;

            }

        }

        #endregion

        #region Internal methods

        #endregion

        #region Internal static methods

        private static ValueStore GetValueStore( ParserElementBase aElement )

        {

            ValueStore ret = null;

            //

            if ( aElement is ParserElementBaseWithValueStore )

            {

                ParserElementBaseWithValueStore element = (ParserElementBaseWithValueStore) aElement;

                if ( element.iValueStore != null )

                {

                    ret = element.iValueStore;

                }

                else if ( element.Parent != null )

                {

                    ret = GetValueStore( element.Parent );

                }

            }

            //

            return ret;

        }

        #endregion

        #region Internal constant

        protected const int KGloballyApplicable = -1;

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return base.Name;

        }

        #endregion

        #region Data members

        protected ValueStore iValueStore = null;

        #endregion

    }

}