using System;
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 abstract class AbstractWrappableStringableHandler : AbstractStringableHandler
    {
        protected readonly Type mBaseNativeType;
        protected readonly string mBaseWoxType;
        protected readonly Type mWrappedNativeType;
        protected readonly string mWrappedWoxType;

        protected AbstractWrappableStringableHandler( Type pBaseNativeType, string pBaseWoxType, Type pWrappedNativeType )
        {
            mBaseNativeType = pBaseNativeType;
            mBaseWoxType = pBaseWoxType;
            mWrappedNativeType = pWrappedNativeType;
            mWrappedWoxType = pBaseWoxType + "Wrapper";
        }

        public override string[] GetForReadObjectWoxTypeNames()
        {
            return GetForParseFieldValueWoxTypeNames();
        }

        public override Type GetNativeTypeFor( WoxHandlers pWoxHandlers, string pWoxType )
        {
            if ( mWrappedWoxType.Equals( pWoxType ) || mBaseWoxType.Equals( pWoxType ) )
            {
                return mBaseNativeType;
            }
            throw new ApplicationException( "No Native Type for Wox Type: " + pWoxType );
        }

        public override string GetWoxTypeFor( WoxHandlers pWoxHandlers, Type pType, FieldInfo pField, bool pJustType )
        {
            if ( mWrappedNativeType.Equals( pType ) )
            {
                return pJustType ? mWrappedWoxType : mBaseWoxType;
            }
            if ( mBaseNativeType.Equals( pType ) )
            {
                return mBaseWoxType;
            }
            throw new ApplicationException( "No Wox Type for Native Type: " + pType );
        }

        public override bool WillReadObjectForWoxType( string pWoxType )
        {
            return WillParseFieldValueForWoxType( pWoxType );
        }

        public override bool IsFor( Type pType )
        {
            return mWrappedNativeType.IsAssignableFrom( pType );
        }

        public override string[] GetForParseFieldValueWoxTypeNames()
        {
            return new[] {mBaseWoxType, mWrappedWoxType};
        }

        public override bool WillParseFieldValueForWoxType( string pWoxType )
        {
            return mBaseWoxType.Equals( pWoxType ) || mWrappedWoxType.Equals( pWoxType );
        }

        public override bool WillFieldValueNeverHaveAnySpaces()
        {
            return true;
        }

        public override object CreateArrayFor( Type pFieldElementType, string[] pValues )
        {
            Type zComponentType;
            if ( pFieldElementType == null )
            {
                zComponentType = AnyNullIndicators( pValues ) ? mWrappedNativeType : mBaseNativeType;
            }
            else if ( mBaseNativeType.Equals( pFieldElementType ) )
            {
                zComponentType = mBaseNativeType;
            }
            else if ( mWrappedNativeType.Equals( pFieldElementType ) )
            {
                zComponentType = mWrappedNativeType;
            }
            else
            {
                throw new ApplicationException( "Not Supported Field Native Type: " + pFieldElementType );
            }
            Array zArray = Array.CreateInstance( zComponentType, pValues.Length );
            for ( int i = 0; i < pValues.Length; i++ )
            {
                zArray.SetValue( CreateInstance( pValues[i] ), i );
            }
            return zArray;
        }

        private static bool AnyNullIndicators( string[] pValues )
        {
            foreach ( var zValue in pValues )
            {
                if ( Serial.NULL.Equals( zValue ) )
                {
                    return true;
                }
            }
            return false;
        }

        protected override object CreateInstance( string pValue )
        {
            if ( string.IsNullOrEmpty( pValue ) || Serial.NULL.Equals( pValue ) )
            {
                return null;
            }
            return NonNullValueParse( pValue );
        }

        protected override string Stringify( object pObject )
        {
            return (pObject == null) ? Serial.NULL : NonNullValueToString( pObject );
        }

        abstract protected object NonNullValueParse( string pValue );

        protected virtual string NonNullValueToString( object pObject )
        {
            return pObject.ToString();
        }
    }
}