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 ListHandler : AbstractHandler, WoxGenericsHandler
    {
        public static readonly ListHandler INSTANCE = new ListHandler();

        public const String WOX_TYPE = "list";

        private const string GENERIC_WOX_TYPE_NAME_STARTS_WITH = WOX_TYPE + "<";

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

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

        protected ListHandler()
        {
        }

        #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 (ArrayList);
            }
            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 (ArrayList).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 );

                ArrayList zList = ReadObjects( pWoxReader, zSubtree );

                Type zNativeType = GetNativeTypeFor( pWoxHandlers, zWoxTypeName );

                if ( typeof (ArrayList).Equals( zNativeType ) )
                {
                    return zList;
                }

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

                MethodInfo zMethodInfo = zGenericList.GetType().GetMethod( "Add" );
                //populate the List with the elements
                for ( int i = 0; i < zList.Count; i++ )
                {
                    Object[] args = {zList[i]};
                    zMethodInfo.Invoke( zGenericList, args );
                }
                return zGenericList;
            }
            catch ( Exception e )
            {
                throw new ApplicationException( "List 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 List or an ArrayList, so, we simply get the underlying array
            MethodInfo zMethodInfo = zType.GetMethod( "ToArray", new Type[0] );
            var zArray = (Array) zMethodInfo.Invoke( pObject, null ); // null == NO Params

            int zLength = zArray.GetLength( 0 ); // 0 == 1st Dimension!

            if ( zLength != 0 )
            {
                pWriter.WriteAttributeString( Serial.ID, pWoxWriter.CreateIDfor( pObject ) );

                foreach ( object zEntry in zArray )
                {
                    pWoxWriter.Write( zEntry, pField, pWriter, pJustType );
                }
            }
            pWriter.WriteEndElement();
        }

        #endregion
    }
}