using System;
using System.Collections;
using System.Reflection;

/// <header>
/// <wox>
///     <version>1.0</version>
///     <author>Carlos R. Jaimez Gonzalez</author>
///     <author>Simon M. Lucas</author>
///     <site>http://woxserializer.sourceforge.net/</site>
/// </wox>
/// <wox>
///     <version>1.5</version>
///     <author>Steven M Lewis</author>
/// </wox>
/// <wox>
///     <version>2.0</version>
///     <author>George A Smith</author>
///     <svn>http://woxserializer.sourceforge.net/</svn>
///     <note>XML form for vs 2 is more compact and therefor incompatible with vs 1</note>
/// </wox>
/// </header>

namespace wox.serial
{
    public class MapHandler : AbstractHandler, WoxGenericsHandler
    {
        public static readonly MapHandler INSTANCE = new MapHandler();

        public const String WOX_TYPE = "map";

        private const string GENERIC_WOX_TYPE_NAME_STARTS_WITH = WOX_TYPE + "<";

        private const string GENERIC_NATIVE_TYPE_NAME_STARTS_WITH = "System.Collections.Generic.Dictionary";

        private static readonly string NON_GENERIC_NATIVE_TYPE_NAME = typeof (Hashtable).ToString();

        protected MapHandler()
        {
        }

        #region WoxStartsWithHandler Members

        public bool IsFor( string pTypeName )
        {
            return NON_GENERIC_NATIVE_TYPE_NAME.Equals( pTypeName ) || //
                   pTypeName.StartsWith( GENERIC_NATIVE_TYPE_NAME_STARTS_WITH );
        }

        public string GetGenericsNativeBaseTypeFor( WoxHandlers pWoxHandlers, string pWoxBaseType )
        {
            return GenericsBaseTypeFor( pWoxBaseType, "Wox", WOX_TYPE, "Native", GENERIC_NATIVE_TYPE_NAME_STARTS_WITH );
        }

        public string GetGenericsWoxBaseTypeFor( WoxHandlers pWoxHandlers, string pNativeBaseType )
        {
            return GenericsBaseTypeFor( pNativeBaseType, "Native", GENERIC_NATIVE_TYPE_NAME_STARTS_WITH, "Wox", WOX_TYPE );
        }

        public override string[] GetForReadObjectWoxTypeNames()
        {
            return null; // Ask Us
        }

        public override Type GetNativeTypeFor( WoxHandlers pWoxHandlers, string pWoxType )
        {
            if ( WOX_TYPE.Equals( pWoxType ) )
            {
                return typeof (Hashtable);
            }
            if ( pWoxType.StartsWith( GENERIC_WOX_TYPE_NAME_STARTS_WITH ) )
            {
                Type zType = CommonNativeType( pWoxHandlers, pWoxType );
                if ( zType != null )
                {
                    return zType;
                }
            }
            throw new ApplicationException( "No Native Type for Wox Type: " + pWoxType );
        }

        public override string GetWoxTypeFor( WoxHandlers pWoxHandlers, Type pType, FieldInfo pField, bool pJustType )
        {
            if ( typeof (Hashtable).Equals( pType ) )
            {
                return WOX_TYPE;
            }
            if ( pType.ToString().StartsWith( GENERIC_NATIVE_TYPE_NAME_STARTS_WITH ) )
            {
                return CommonWoxType( pWoxHandlers, pType, pField, pJustType );
            }
            throw new ApplicationException( "No Wox Type for Native Type: " + pType );
        }

        public override bool WillReadObjectForWoxType( string pWoxType )
        {
            return WOX_TYPE.Equals( pWoxType ) || pWoxType.StartsWith( GENERIC_WOX_TYPE_NAME_STARTS_WITH );
        }

        public override object ReadObject( WoxHandlers pWoxHandlers, WoxReader pWoxReader, XMLreader pReader )
        {
            XMLreader zSubtree = pReader.CreateSubtreeReader();
            zSubtree.ReadStartElement(); //position the cursor to our element

            try
            {
                string zWoxTypeName = zSubtree.GetAttribute( Serial.TYPE );

                Type zNativeType = GetNativeTypeFor( pWoxHandlers, zWoxTypeName );

                object zDictionary = Util.CreateInstance( zNativeType, zWoxTypeName );

                MethodInfo zMethodInfo = zDictionary.GetType().GetMethod( "Add" );

                while ( zSubtree.ReadStartElement() )
                {
                    // currently at the "entry"
                    //position the cursor in the KEY object
                    zSubtree.ReadStartElement();
                    Object zKey = pWoxReader.Read( zSubtree );

                    //position the cursor in the VALUE object
                    zSubtree.ReadStartElement();
                    Object zValue = pWoxReader.Read( zSubtree );

                    //Add the key and the value to the Dictionary
                    Object[] args = {zKey, zValue};
                    zMethodInfo.Invoke( zDictionary, args );
                }

                return zDictionary;
            }
            catch ( Exception e )
            {
                throw new ApplicationException( "Map Handler Read Object Exception is: " + e.Message, e );
            }
            finally
            {
                Consume( zSubtree );
            }
        }

        public override void WriteObject( WoxHandlers pWoxHandlers, WoxWriter pWoxWriter, object pObject, FieldInfo pField, XMLwriter pWriter,
                                          bool pJustType )
        {
            Type zType = pObject.GetType();
            string zWoxTypeName = CommonWoxType( pWoxHandlers, zType, pField, pJustType );

            pWriter.WriteStartElement( Serial.OBJECT );
            pWriter.WriteAttributeString( Serial.TYPE, zWoxTypeName );

            //we already know it is either a Generic Dictionary or a Hashtable, so, we can simply Enumerate over the entries.
            MethodInfo zMethodInfo = zType.GetMethod( "GetEnumerator" );
            IDictionaryEnumerator zEnumerator = (IDictionaryEnumerator) zMethodInfo.Invoke( pObject, null ); // null == NO Params

            if ( zEnumerator.MoveNext() )
            {
                pWriter.WriteAttributeString( Serial.ID, pWoxWriter.CreateIDfor( pObject ) );

                do
                {
                    pWriter.WriteStartElement( Serial.OBJECT );
                    pWriter.WriteAttributeString( Serial.TYPE, Serial.MAP_ENTRY );
                    pWoxWriter.Write( zEnumerator.Key, pField, pWriter, pJustType );
                    pWoxWriter.Write( zEnumerator.Value, pField, pWriter, pJustType );
                    pWriter.WriteEndElement();
                }
                while ( zEnumerator.MoveNext() );
            }

            pWriter.WriteEndElement();
        }

        #endregion
    }
}