/*
* 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.BaseStructures;
using SymbianParserLib.Elements;
using SymbianParserLib.Elements.SubFields;

namespace SymbianParserLib.ValueStores
{
    public class ValueStore
    {
        #region Enumerations
        internal enum TValueStoreType
        {
            EValueStoreTypeProperty = 0,
            EValueStoreTypeMethod,
            EValueStoreTypeStoreInternally
        }
        #endregion

        #region Constructors
        public ValueStore()
        {
        }
        #endregion

        #region API
        public void SetTargetProperty( object aPropertyObject, string aPropertyName )
        {
            iValueStore = aPropertyObject;
            iValueStoreType = TValueStoreType.EValueStoreTypeProperty;
            iValueStoreMemberName = aPropertyName;
            //
        }

        public void SetTargetMethod( object aMethodObject, string aMethodName, params TValueStoreMethodArguments[] aArgs )
        {
            iValueStore = aMethodObject;
            iValueStoreType = TValueStoreType.EValueStoreTypeMethod;
            iValueStoreMemberName = aMethodName;
            //
            iMethodArgumentSpecifier = aArgs;
        }
        #endregion

        #region Internal API
        internal void SetValue( ParserFieldFormatSpecifier aFieldFormatSpecifier, ParserFieldFormatValue aFieldFormatValue )
        {
            CheckForValidValueStore();
            //
            if ( iValueStoreType == TValueStoreType.EValueStoreTypeProperty )
            {
                // Store value to user-supplied property within object
                Binder binder = null;
                Type typeInfo = iValueStore.GetType();
                PropertyInfo propInfo = typeInfo.GetProperty( iValueStoreMemberName, PropertyBindingFlags );
                if ( propInfo == null )
                {
                    throw new MissingMemberException( "A property called: \"" + iValueStoreMemberName + "\" was not found within object: " + iValueStore.ToString() );
                }
                //
                Type propType = propInfo.PropertyType;
                object[] args = PrepareMethodArgument( aFieldFormatValue.Value, propType );
                typeInfo.InvokeMember( iValueStoreMemberName, PropertyBindingFlags, binder, iValueStore, args );
            }
            else if ( iValueStoreType == TValueStoreType.EValueStoreTypeMethod )
            {
                object[] args = null;
                //
                try
                {
                    // Store value to user-supplied method
                    Binder binder = null;

                    // Build arguments
                    Type valueTypeInfo = aFieldFormatValue.Value.GetType();
                    TValueStoreMethodArguments[] argumentSpecification = BuildMethodArgumentSpecification( valueTypeInfo, iValueStore, iValueStoreMemberName );
                    args = BuildCustomFunctionArguments( argumentSpecification, aFieldFormatSpecifier, aFieldFormatValue );
                    
                    // Sanity check number of arguments for method implementation actually agrees with our run-time generated
                    // object array of parameters.
                    Type valueStoreTypeInfo = iValueStore.GetType();
                    MethodInfo methodInfo = valueStoreTypeInfo.GetMethod( iValueStoreMemberName, MethodBindingFlags );
                    ParameterInfo[] methodParams = methodInfo.GetParameters();
                    if ( args.Length != methodParams.Length )
                    {
                        throw new MissingMethodException( "Argument specification doesn't align with method implementation" );
                    }
                    else
                    {
                        valueStoreTypeInfo.InvokeMember( iValueStoreMemberName, MethodBindingFlags, binder, iValueStore, args );
                    }
                }
                catch ( Exception exception )
                {
                    if ( exception is TargetInvocationException || 
                         exception is MissingMethodException || 
                         exception is MissingMemberException || 
                         exception is AmbiguousMatchException )
                    {
                        StringBuilder funcDetails = new StringBuilder();
                        funcDetails.Append( iValueStoreMemberName + "( " );
                        //
                        int count = ( args != null ) ? args.Length : 0;
                        for ( int i = 0; i < count; i++ )
                        {
                            object arg = args[ i ];
                            string argTypeName = ( arg != null ) ? arg.GetType().ToString() : "null";
                            funcDetails.Append( argTypeName );
                            //
                            if ( i < count - 1 )
                            {
                                funcDetails.Append( ", " );
                            }
                        }
                        //
                        funcDetails.Append( " )" );
                        System.Diagnostics.Debug.WriteLine( "Failed to invoke method: " + funcDetails.ToString() );
                    }
                    else
                    {
                        throw exception;
                    }
                }
            }
            else if ( iValueStoreType == TValueStoreType.EValueStoreTypeStoreInternally )
            {
                // Store it in the value store and the client can extract it via the public properties...
                iValueStore = aFieldFormatValue.Value;
            }
        }
        #endregion

        #region Properties
        public bool IsInt
        {
            get
            {
                bool ret = IsDynamicAndOfType( typeof( int ) );
                return ret;
            }
        }

        public bool IsUint
        {
            get
            {
                bool ret = IsDynamicAndOfType( typeof( uint ) );
                return ret;
            }
        }

        public bool IsString
        {
            get
            {
                bool ret = IsDynamicAndOfType( typeof( string ) );
                return ret;
            }
        }

        public int AsInt
        {
            get
            {
                int ret = 0;
                //
                if ( IsInt )
                {
                    ret = (int) iValueStore;
                }
                //
                return ret;
            }
        }

        public uint AsUint
        {
            get
            {
                uint ret = 0;
                //
                if ( IsUint )
                {
                    ret = (uint) iValueStore;
                }
                //
                return ret;
            }
        }

        public string AsString
        {
            get
            {
                string ret = string.Empty;
                //
                if ( IsString )
                {
                    ret = (string) iValueStore;
                }
                //
                return ret;
            }
        }

        internal TValueStoreType ValueStoreType
        {
            get
            {
                return iValueStoreType;
            }
        }

        internal BindingFlags MethodBindingFlags
        {
            get
            {
                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod;
                return bindingFlags;
            }
        }

        internal BindingFlags PropertyBindingFlags
        {
            get
            {
                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty;
                return bindingFlags;
            }
        }
        #endregion

        #region Internal methods
        private bool IsDynamicAndOfType( Type aExpectedType )
        {
            bool ret = false;
            //
            object vs = iValueStore;
            TValueStoreType vsType = ValueStoreType;
            if ( vs != null && vsType == TValueStoreType.EValueStoreTypeStoreInternally )
            {
                Type typeInfo = vs.GetType();
                ret = ( typeInfo == aExpectedType );
            }
            //
            return ret;
        }

        private void CheckForValidValueStore()
        {
            if ( iValueStoreType == TValueStoreType.EValueStoreTypeProperty ||
                 iValueStoreType == TValueStoreType.EValueStoreTypeMethod )
            {
                if ( iValueStore == null )
                {
                    throw new Exception( "Missing value store" );
                }
            }
        }

        private object[] PrepareMethodArgument( object aValue, Type aExpectedPropertyType )
        {
            // If we're calling a property where the expected property type doesn't match the value
            // we have been asked to use (for example, a property expects an enumerator, but we are given
            // a uint or int) then we must convert from the value type to the expected property type.
            object[] ret = { aValue };
            Type valueType = aValue.GetType();
            //
            if ( aExpectedPropertyType != valueType )
            {
                // Get a type converter to perform the operation. Note that some of the built-in type
                // converters are very "dumb" in that they only convert from strings to numbers (and vice
                // versa). This doesn't help us when we need to convert from e.g. a uint to a long.
                TypeConverter conv = TypeDescriptor.GetConverter( aExpectedPropertyType );
                if ( conv == null )
                {
                    throw new NotSupportedException( "No type converter exists to convert between " + valueType.ToString() + " and " + aExpectedPropertyType.ToString() );
                }
                else if ( conv.CanConvertFrom( valueType ) )
                {
                    object converted = conv.ConvertFrom( aValue );
                    ret = new object[] { converted };
                }
                else
                {
                    // Might be one of the built-in type converters that only works
                    // with strings. Convert the value to a string and try once more
                    string asString = aValue.ToString();
                    try
                    {
                        object converted = conv.ConvertFrom( asString );
                        ret = new object[] { converted };
                    }
                    catch ( NotSupportedException )
                    {
                        throw new NotSupportedException( "No type converter exists to convert between " + valueType.ToString() + " and " + aExpectedPropertyType.ToString() );
                    }
                }
            }
            //
            return ret;
        }

        private TValueStoreMethodArguments[] BuildMethodArgumentSpecification( Type aValueTypeInfo, object aObject, string aMethodName )
        {
            List<TValueStoreMethodArguments> args = new List<TValueStoreMethodArguments>();
            //
            if ( iMethodArgumentSpecifier == null )
            {
                iMethodArgumentSpecifier = new TValueStoreMethodArguments[] { TValueStoreMethodArguments.EValueStoreMethodArgumentCalculateAtRuntime };
            }
            //
            bool done = false;
            int count = iMethodArgumentSpecifier.Length;
            for( int i=0; i<count && !done; i++ )
            {
                TValueStoreMethodArguments argType = iMethodArgumentSpecifier[ i ];
                switch ( argType )
                {
                default:
                    args.Add( argType );
                    break;
                case TValueStoreMethodArguments.EValueStoreMethodArgumentCalculateAtRuntime:
                    args.Clear();
                    BuildRuntimeGeneratedArgumentList( aValueTypeInfo, aObject, aMethodName, ref args );
                    done = true;
                    break;
                }
            }
            //
            return args.ToArray();
        }

        private void BuildRuntimeGeneratedArgumentList( Type aValueTypeInfo, object aObject, string aMethodName, ref List<TValueStoreMethodArguments> aArgs )
        {
            Type typeInfo = aObject.GetType();
            MethodInfo methodInfo = typeInfo.GetMethod( aMethodName, MethodBindingFlags );
            if ( methodInfo == null )
            {
                throw new MissingMemberException( "Method: " + aMethodName + " was not found within object: " + aObject.ToString() );
            }
            ParameterInfo[] methodParams = methodInfo.GetParameters();

            // Check if the parameters include an explicit request for a ParserFieldName object
            // If so, we'll not send the "argument name as string" since the client has
            // explicitly requested it as an object...
            bool requestingArgNameAsObject = false;
            foreach ( ParameterInfo info in methodParams )
            {
                if ( info.ParameterType == typeof( ParserFieldName ) )
                {
                    requestingArgNameAsObject = true;
                    break;
                }
            }

            // Second pass to build real list...
            foreach ( ParameterInfo info in methodParams )
            {
                Type paramType = info.ParameterType;
                //
                if ( paramType == typeof( ParserFieldName ) )
                {
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentNameAsObject );
                }
                else if ( paramType == typeof( ParserField ) )
                {
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentField );
                }
                else if ( paramType == typeof( ParserLine ) )
                {
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentLine );
                }
                else if ( paramType == typeof( ParserParagraph ) )
                {
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentParagraph );
                }
                else if ( paramType == typeof( string ) && !requestingArgNameAsObject )
                {
                    // Best guess - if the first argument of the method is actually
                    // a string-based "value" argument (rather than field name argument) then we'll
                    // pass the parameter out of order - hence the "name as object" approach used
                    // above, which let's us accurately infer type...
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentNameAsString );
                }
                else if ( paramType == aValueTypeInfo )
                {
                    aArgs.Add( TValueStoreMethodArguments.EValueStoreMethodArgumentValue );
                }
            }
        }

        private object[] BuildCustomFunctionArguments( TValueStoreMethodArguments[] aArgumentSpecification, ParserFieldFormatSpecifier aFieldFormatSpecifier, ParserFieldFormatValue aFieldFormatValue )
        {

            List<object> args = new List<object>();
            //
            foreach ( TValueStoreMethodArguments argType in aArgumentSpecification )
            {
                if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentNameAsString )
                {
                    args.Add( aFieldFormatSpecifier.Name.ToString() );
                }
                else if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentNameAsObject )
                {
                    args.Add( aFieldFormatSpecifier.Name );
                }
                else if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentValue )
                {
                    args.Add( aFieldFormatValue.Value );
                }
                else if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentParagraph )
                {
                    ParserParagraph para = null;
                    //
                    if ( aFieldFormatSpecifier.Field.Parent != null && aFieldFormatSpecifier.Field.Parent is ParserLine )
                    {
                        ParserLine line = (ParserLine) aFieldFormatSpecifier.Field.Parent;
                        if ( line.Parent != null && line.Parent is ParserParagraph )
                        {
                            para = (ParserParagraph) line.Parent;
                        }
                    }
                    //
                    args.Add( para );
                }
                else if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentLine )
                {
                    ParserLine line = null;
                    //
                    if ( aFieldFormatSpecifier.Field.Parent != null && aFieldFormatSpecifier.Field.Parent is ParserLine )
                    {
                        line = (ParserLine) aFieldFormatSpecifier.Field.Parent;
                    }
                    //
                    args.Add( line );
                }
                else if ( argType == TValueStoreMethodArguments.EValueStoreMethodArgumentField )
                {
                    args.Add( aFieldFormatSpecifier.Field );
                }
                else
                {
                    System.Diagnostics.Debug.Assert( false, "Argument specification contains unresolved runtime reference" );
                }
            }
            //
            return args.ToArray();
        }
        #endregion

        #region Internal constants
        #endregion

        #region From System.Object
        public override string ToString()
        {
            return base.ToString();
        }
        #endregion

        #region Data members
        // Common members
        private object iValueStore = null;
        private string iValueStoreMemberName = string.Empty;
        private TValueStoreType iValueStoreType = TValueStoreType.EValueStoreTypeStoreInternally;

        // Method-specific members
        private TValueStoreMethodArguments[] iMethodArgumentSpecifier = null;
        #endregion
    }
}