using System;
using System.Collections.Generic;

/// <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 WoxHandlers
    {
        private readonly Dictionary<string, WoxHandler> mWoxTypeReadObjectHandlers = new Dictionary<string, WoxHandler>();
        private readonly List<WoxHandler> mAskEachInTurnWoxTypeReadObjectHandlers = new List<WoxHandler>();

        private readonly Dictionary<string, WoxHandler> mWoxTypeParseFieldValueHandlers = new Dictionary<string, WoxHandler>();
        private readonly List<WoxHandler> mAskEachInTurnWoxTypeParseFieldValueHandlers = new List<WoxHandler>();

        // NativeType Handlers
        private readonly List<WoxIsAHandler> mIsAHandlers = new List<WoxIsAHandler>();
        private readonly List<WoxGenericsHandler> mGenericsHandlers = new List<WoxGenericsHandler>();
        private readonly Dictionary<string, WoxTypeHandler> mTypeHandlers = new Dictionary<string, WoxTypeHandler>();

        // Mappers
        private readonly List<WoxTypeMapper> mTypeMappers = new List<WoxTypeMapper>();
        private readonly List<WoxFieldNameMapper> mFieldNameMappers = new List<WoxFieldNameMapper>();

        public WoxHandlers()
        {
            // Note: As they are Inserted, they are actually checked from the Bottom Up!

            AddIsAHandler( DefaultObjectHandler.INSTANCE ); // Needs to be FIRST (so will be checked LAST)!

            AddIsAHandler( GuidHandler.INSTANCE );

            AddIsAHandler( ArrayHandler.INSTANCE );

            AddIsAHandler( WOXdateHandler.INSTANCE );

            AddIsAHandler( WOXcharHandler.INSTANCE );

            AddIsAHandler( WOXdecimalHandler.INSTANCE );

            AddIsAHandler( WOXfloatHandler.INSTANCE );
            AddIsAHandler( WOXdoubleHandler.INSTANCE );

            AddIsAHandler( WOXbyteHandler.INSTANCE );
            AddIsAHandler( WOXshortHandler.INSTANCE );
            AddIsAHandler( WOXintHandler.INSTANCE );
            AddIsAHandler( WOXlongHandler.INSTANCE );

            AddIsAHandler( WOXbooleanHandler.INSTANCE );

            AddIsAHandler( WOXstringHandler.INSTANCE );

            AddGenericsHandler( ListHandler.INSTANCE );

            AddGenericsHandler( MapHandler.INSTANCE );
        }

        public string CustomNativeTypeToWoxType( string pNativeType )
        {
            foreach ( WoxTypeMapper zMapper in mTypeMappers )
            {
                String zWoxType = zMapper.GetWoxTypeFor( pNativeType );
                if ( zWoxType != null )
                {
                    return zWoxType;
                }
            }
            // Assume no translation: WoxType == NativeType (Namespace/Package and all!)
            return pNativeType;
        }

        public string CustomWoxTypeToNativeType( string pWoxType )
        {
            foreach ( WoxTypeMapper zMapper in mTypeMappers )
            {
                String zNativeType = zMapper.GetNativeTypeFor( pWoxType );
                if ( zNativeType != null )
                {
                    return zNativeType;
                }
            }
            // Assume no translation: NativeType == WoxType (Namespace/Package and all!)
            return pWoxType;
        }

        public void AddTypeMapper( WoxTypeMapper pWoxMapper )
        {
            if ( pWoxMapper != null )
            {
                mTypeMappers.Add( pWoxMapper );
            }
        }

        public string CustomWoxFieldNameNormalizer( string pNativeFieldName )
        {
            foreach (WoxFieldNameMapper zMapper in mFieldNameMappers)
            {
                String zWoxFieldName = zMapper.GetWoxFieldNameFor( pNativeFieldName );
                if (zWoxFieldName != null)
                {
                    return zWoxFieldName;
                }
            }
            // Assume no translation: Native == Wox
            return pNativeFieldName;
        }

        public void AddWoxFieldNameMapper(WoxFieldNameMapper pWoxMapper)
        {
            if ( pWoxMapper != null )
            {
                mFieldNameMappers.Add( pWoxMapper );
            }
        }

        public void AddTypeHandler( WoxTypeHandler pWoxHandler )
        {
            if ( pWoxHandler != null )
            {
                AddWoxHandlerForWoxType( pWoxHandler );
                string[] zForTypeNames = pWoxHandler.GetForNativeTypeNames();
                if ( zForTypeNames != null )
                {
                    foreach ( string zTypeName in zForTypeNames )
                    {
                        if ( !String.IsNullOrEmpty( zTypeName ) )
                        {
                            mTypeHandlers[zTypeName] = pWoxHandler;
                        }
                    }
                }
            }
        }

        public void AddGenericsHandler( WoxGenericsHandler pWoxHandler )
        {
            if ( pWoxHandler != null )
            {
                AddWoxHandlerForWoxType( pWoxHandler );
                mGenericsHandlers.Insert( 0, pWoxHandler );
            }
        }

        public void AddIsAHandler( WoxIsAHandler pWoxHandler )
        {
            if ( pWoxHandler != null )
            {
                AddWoxHandlerForWoxType( pWoxHandler );
                mIsAHandlers.Insert( 0, pWoxHandler );
            }
        }

        private void AddWoxHandlerForWoxType( WoxHandler pWoxHandler )
        {
            string[] zForReadObjectWoxTypeNames = pWoxHandler.GetForReadObjectWoxTypeNames();
            if ( zForReadObjectWoxTypeNames == null )
            {
                mAskEachInTurnWoxTypeReadObjectHandlers.Insert( 0, pWoxHandler );
            }
            else
            {
                foreach ( string zTypeName in zForReadObjectWoxTypeNames )
                {
                    if ( !String.IsNullOrEmpty( zTypeName ) )
                    {
                        mWoxTypeReadObjectHandlers[zTypeName] = pWoxHandler;
                    }
                }
                if ( pWoxHandler is WoxTypeAskUsHandler )
                {
                    mAskEachInTurnWoxTypeReadObjectHandlers.Insert( 0, pWoxHandler );
                }
            }

            string[] zForParseFieldValueWoxTypeNames = pWoxHandler.GetForParseFieldValueWoxTypeNames();
            if ( zForParseFieldValueWoxTypeNames == null )
            {
                mAskEachInTurnWoxTypeParseFieldValueHandlers.Insert( 0, pWoxHandler );
            }
            else
            {
                foreach ( string zTypeName in zForParseFieldValueWoxTypeNames )
                {
                    if ( !String.IsNullOrEmpty( zTypeName ) )
                    {
                        mWoxTypeParseFieldValueHandlers[zTypeName] = pWoxHandler;
                    }
                }
                if ( pWoxHandler is WoxTypeAskUsHandler )
                {
                    mAskEachInTurnWoxTypeParseFieldValueHandlers.Insert( 0, pWoxHandler );
                }
            }
        }

        public WoxHandler GetNativeHandler( Type pNativeType )
        {
            if ( pNativeType != null )
            {
                string zTypename = pNativeType.ToString();
                WoxTypeHandler rv;
                if ( mTypeHandlers.TryGetValue( zTypename, out rv ) )
                {
                    return rv;
                }
                if ( mGenericsHandlers.Count != 0 )
                {
                    foreach ( WoxGenericsHandler zStartsWithHandler in mGenericsHandlers )
                    {
                        if ( zStartsWithHandler.IsFor( zTypename ) )
                        {
                            return zStartsWithHandler;
                        }
                    }
                }
                foreach ( WoxIsAHandler zIsAHandler in mIsAHandlers )
                {
                    if ( zIsAHandler.IsFor( pNativeType ) )
                    {
                        return zIsAHandler;
                    }
                }
            }
            return null;
        }

        public WoxHandler GetWoxHandler( String pWoxType )
        {
            if ( pWoxType != null )
            {
                WoxHandler rv;
                if ( mWoxTypeReadObjectHandlers.TryGetValue( pWoxType, out rv ) )
                {
                    return rv;
                }
                foreach ( WoxHandler zHandler in mAskEachInTurnWoxTypeReadObjectHandlers )
                {
                    if ( zHandler.WillReadObjectForWoxType( pWoxType ) )
                    {
                        return zHandler;
                    }
                }
            }
            return null;
        }

        public WoxHandler GetWoxFieldHandler( String pWoxType )
        {
            if ( pWoxType != null )
            {
                WoxHandler rv;
                if ( mWoxTypeParseFieldValueHandlers.TryGetValue( pWoxType, out rv ) )
                {
                    return rv;
                }
                foreach ( WoxHandler zHandler in mAskEachInTurnWoxTypeParseFieldValueHandlers )
                {
                    if ( zHandler.WillParseFieldValueForWoxType( pWoxType ) )
                    {
                        return zHandler;
                    }
                }
            }
            return null;
        }
    }
}