package wox.serial;

import org.litesoft.core.typeutils.Objects;
import java.util.*;

/**
 * Version: 1.0
 * Author: Carlos R. Jaimez Gonzalez
 * Author: Simon M. Lucas
 * Site: http://woxserializer.sourceforge.net/
 *
 * Version: 1.5
 * Author: Steven M Lewis
 *
 * Version: 2.0
 * Author: George Smith
 * SVN: http://svn.xp-dev.com/svn/WOX2/
 * Note: XML form for vs 2 is more compact and therefor incompatible with vs 1
 */

public class WoxHandlers
{
    private final Map<String, WoxHandler> mWoxTypeReadObjectHandlers = new HashMap<String, WoxHandler>();
    private final List<WoxHandler> mAskEachInTurnWoxTypeReadObjectHandlers = new ArrayList<WoxHandler>();

    private final Map<String, WoxHandler> mWoxTypeParseFieldValueHandlers = new HashMap<String, WoxHandler>();
    private final List<WoxHandler> mAskEachInTurnWoxTypeParseFieldValueHandlers = new ArrayList<WoxHandler>();

    // NativeType Handlers
    private final List<WoxIsAHandler> mIsAHandlers = new ArrayList<WoxIsAHandler>();
    private final List<WoxGenericsHandler> mGenericsHandlers = new ArrayList<WoxGenericsHandler>();
    private final Map<String, WoxTypeHandler> mTypeHandlers = new HashMap<String, WoxTypeHandler>();

    // Mappers
    private final List<WoxTypeMapper> mTypeMappers = new ArrayList<WoxTypeMapper>();
    private final List<WoxFieldNameMapper> mFieldNameMappers = new ArrayList<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( 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 );

        addIsAHandler( ListHandler.INSTANCE );

        addIsAHandler( MapHandler.INSTANCE );
    }

    public String customNativeTypeToWoxType( String pNativeType )
    {
        for ( WoxTypeMapper zMapper : 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 )
    {
        for ( WoxTypeMapper zMapper : 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 )
    {
        for ( WoxFieldNameMapper zMapper : 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 )
            {
                for ( String zTypeName : zForTypeNames )
                {
                    if ( !Util.isNullOrEmpty( zTypeName ) )
                    {
                        mTypeHandlers.put( zTypeName, pWoxHandler );
                    }
                }
            }
        }
    }

    public void addGenericsHandler( WoxGenericsHandler pWoxHandler )
    {
        if ( pWoxHandler != null )
        {
            addWoxHandlerForWoxType( pWoxHandler );
            mGenericsHandlers.add( 0, pWoxHandler );
        }
    }

    public void addIsAHandler( WoxIsAHandler pWoxHandler )
    {
        if ( pWoxHandler != null )
        {
            addWoxHandlerForWoxType( pWoxHandler );
            mIsAHandlers.add( 0, pWoxHandler );
        }
    }

    private void addWoxHandlerForWoxType( WoxHandler pWoxHandler )
    {
        String[] zForReadObjectWoxTypeNames = pWoxHandler.getForReadObjectWoxTypeNames();
        if ( zForReadObjectWoxTypeNames == null )
        {
            mAskEachInTurnWoxTypeReadObjectHandlers.add( 0, pWoxHandler );
        }
        else
        {
            for ( String zTypeName : zForReadObjectWoxTypeNames )
            {
                if ( !Util.isNullOrEmpty( zTypeName ) )
                {
                    mWoxTypeReadObjectHandlers.put( zTypeName, pWoxHandler );
                }
            }
            if ( pWoxHandler instanceof WoxTypeAskUsHandler )
            {
                mAskEachInTurnWoxTypeReadObjectHandlers.add( 0, pWoxHandler );
            }
        }

        String[] zForParseFieldValueWoxTypeNames = pWoxHandler.getForParseFieldValueWoxTypeNames();
        if ( zForParseFieldValueWoxTypeNames == null )
        {
            mAskEachInTurnWoxTypeParseFieldValueHandlers.add( 0, pWoxHandler );
        }
        else
        {
            for ( String zTypeName : zForParseFieldValueWoxTypeNames )
            {
                if ( !Util.isNullOrEmpty( zTypeName ) )
                {
                    mWoxTypeParseFieldValueHandlers.put( zTypeName, pWoxHandler );
                }
            }
            if ( pWoxHandler instanceof WoxTypeAskUsHandler )
            {
                mAskEachInTurnWoxTypeParseFieldValueHandlers.add( 0, pWoxHandler );
            }
        }
    }

    public WoxHandler getNativeHandler( Class pNativeType )
    {
        if ( pNativeType != null )
        {
            String zTypename = pNativeType.getName();
            WoxHandler rv = mTypeHandlers.get( zTypename );
            if ( rv != null )
            {
                return rv;
            }
            if ( mGenericsHandlers.size() != 0 )
            {
                for ( WoxGenericsHandler zStartsWithHandler : mGenericsHandlers )
                {
                    if ( zStartsWithHandler.isFor( zTypename ) )
                    {
                        return zStartsWithHandler;
                    }
                }
            }
            for ( WoxIsAHandler zIsAHandler : mIsAHandlers )
            {
                if ( zIsAHandler.isFor( pNativeType ) )
                {
                    return zIsAHandler;
                }
            }
        }
        return null;
    }

    public WoxHandler getWoxHandler( String pWoxType )
    {
        if ( pWoxType != null )
        {
            WoxHandler rv = mWoxTypeReadObjectHandlers.get( pWoxType );
            if ( rv != null )
            {
                return rv;
            }
            for ( WoxHandler zHandler : mAskEachInTurnWoxTypeReadObjectHandlers )
            {
                if ( zHandler.willReadObjectForWoxType( pWoxType ) )
                {
                    return zHandler;
                }
            }
        }
        return null;
    }

    public WoxHandler getWoxFieldHandler( String pWoxType )
    {
        if ( pWoxType != null )
        {
            WoxHandler rv = mWoxTypeParseFieldValueHandlers.get( pWoxType );
            if ( rv != null )
            {
                return rv;
            }
            for ( WoxHandler zHandler : mAskEachInTurnWoxTypeParseFieldValueHandlers )
            {
                if ( zHandler.willParseFieldValueForWoxType( pWoxType ) )
                {
                    return zHandler;
                }
            }
        }
        return null;
    }
}