package wox.serial;

import java.lang.reflect.*;
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 abstract class AbstractHandler implements WoxHandler
{
    public static final String[] EMPTY_STRING_ARRAY = new String[0];

    @Override
    public String[] getForParseFieldValueWoxTypeNames()
    {
        return EMPTY_STRING_ARRAY;
    }

    @Override
    public boolean willParseFieldValueForWoxType( String pWoxType )
    {
        return false;
    }

    @Override
    public Object parseFieldValue( String pFieldValue )
    {
        throw new ApplicationException( "Parse Field Value not supported by " + getClass().getSimpleName() );
    }

    @Override
    public String createFieldValue( Object pFieldValue )
    {
        return null;
    }

    @Override
    public boolean willFieldValueNeverHaveAnySpaces()
    {
        return false;
    }

    @Override
    public Object createArrayFor( Class pFieldElementType, String[] pValues )
    {
        throw new ApplicationException( "Create Array For not supported by " + getClass().getSimpleName() );
    }

    @Override
    public Object getNonNullDefaultValue()
    {
        return null;
    }

    @Override
    public boolean supportsJustTypeWriting()
    {
        return false;
    }

    protected void consume( XMLreader pReader )
    {
        while ( pReader.readStartElement() )
        {
            // consume Subtree
        }
    }

    protected Field getField( WoxHandlers pWoxHandlers, Field[] pFields, String pName )
    {
        for ( Field zField : pFields )
        {
            if ( pWoxHandlers.customWoxFieldNameNormalizer( zField.getName() ).equals( pName ) )
            {
                return zField;
            }
        }
        return null;
    }

    protected static Field[] getFields( Class pType )
    {
        List<Field> holder = new ArrayList<Field>();
        accumulateFields( pType, holder );
        return holder.toArray( new Field[holder.size()] );
    }

    protected static void accumulateFields( Class pType, List<Field> pFields )
    {
        while ( pType != Object.class )
        {
            Field[] fields = pType.getDeclaredFields(); // BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
            for ( Field zField : fields )
            {
                // added SLewis skip fields marked as not serialized
                int zModifiers = zField.getModifiers();
                if ( !Modifier.isTransient( zModifiers ) && !Modifier.isStatic( zModifiers ) )
                {
                    pFields.add( zField );
                }
            }
            pType = pType.getSuperclass();
        }
    }

    protected void processFields( WoxHandlers pWoxHandlers, WoxReader pWoxReader, XMLreader pReader, Class pType, Object pInstance )
    {
        Field[] zFields = getFields( pType );

        while ( pReader.readStartElement() )
        {
            XMLreader zSubtree = pReader.createSubtreeReader();
            zSubtree.readStartElement(); //position the cursor to our element

            String zFieldName = pReader.getAttribute( Serial.NAME );

            try
            {
                Field zField = getField( pWoxHandlers, zFields, zFieldName );
                if ( zField == null )
                {
                    throw new ApplicationException( "No Field" );
                }
                fieldRead( pWoxHandlers, pWoxReader, pReader, pType, zFieldName, zField, pInstance );
            }
            catch ( Exception e )
            {
                throw new ApplicationException( "ProcessingFields for (" + pType + "." + zFieldName + " on " + pInstance + ") Read Exception is: " + e.getMessage(), e );
            }
            finally
            {
                consume( zSubtree );
            }
        }
    }

    protected void processFields( WoxHandlers pWoxHandlers, WoxWriter pWoxWriter, XMLwriter pWriter, boolean pJustType, Class pType, Object pInstance )
    {
        Field[] zFields = getFields( pType );

        for ( Field zField : zFields )
        {
            String zFieldName = zField.getName();
            if ( !zFieldName.startsWith( "this$" ) )
            {
                try
                {
                    zField.setAccessible( true );
                    Object zFieldValue = zField.get( pInstance );
                    if ( pJustType || (zFieldValue != null) ) // do not send null fields
                    {
                        fieldWrite( pWoxHandlers, pWoxWriter, pWriter, pJustType, pType, zFieldName, zField, pInstance, zFieldValue );
                    }
                }
                catch ( Exception e )
                {
                    throw new ApplicationException( "ProcessingFields for (" + pType + "." + zFieldName + " on " + pInstance + ") Write Exception is: " + e.getMessage(), e );
                    // Shouldn't we at least comment on what went wrong; pWriter.addContent(new Comment(e.toString()));
                }
            }
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    protected void fieldWrite( WoxHandlers pWoxHandlers, WoxWriter pWoxWriter, XMLwriter pWriter, boolean pJustType, Class pObjectType, String pFieldName, Field pField, Object pObjectInstance, Object pFieldValue )
    {
        Class zType = pField.getType();

        WoxHandler zHandler = pWoxHandlers.getNativeHandler( zType );

        if ( !pJustType )
        {
            Object zDefaultValue = zHandler.getNonNullDefaultValue();
            if ( (zDefaultValue != null) && zDefaultValue.equals( pFieldValue ) )
            {
                return;
            }
        }

        pWriter.writeStartElement( Serial.FIELD );
        pWriter.writeAttributeString( Serial.NAME, pWoxHandlers.customWoxFieldNameNormalizer( pFieldName ) );

        if ( pJustType )
        {
            pWriter.writeAttributeString( Serial.TYPE, zHandler.getWoxTypeFor( pWoxHandlers, zType, pField, pJustType ) );
            if ( zType.isArray() ) // Special Case for Arrays
            {
                Class zElementType = zType.getComponentType();
                String zElementWoxType = commonWoxType( pWoxHandlers, zElementType, pField, pJustType );
                pWriter.writeAttributeString( Serial.ELEMENT_TYPE, zElementWoxType );
            }
        }
        else
        {
            String zValue = zType.isEnum() ? pFieldValue.toString() : zHandler.createFieldValue( pFieldValue );

            if ( zValue != null )
            {
                pWriter.writeAttributeString( Serial.TYPE, zHandler.getWoxTypeFor( pWoxHandlers, zType, pField, pJustType ) );
                // Since we don't write nulls, and a "" will read as null, then we should assume a read of null is a ""
                pWriter.writeAttributeString( Serial.VALUE, zValue );
            }
            else
            {
                pWoxWriter.write( pFieldValue, pField, pWriter, false );
            }
        }

        pWriter.writeEndElement();
    }

    @SuppressWarnings({"UnusedDeclaration"})
    protected void fieldRead( WoxHandlers pWoxHandlers, WoxReader pWoxReader, XMLreader pReader, Class pObjectType, String pFieldName, Field pField, Object pObjectInstance )
    {
        Object zValue;
        String zWoxType = pReader.getAttribute( Serial.TYPE );
        if ( zWoxType == null )
        {
            // No TYPE == Sub Object
            zValue = pWoxReader.read( advanceToFirstChild( pReader ) );
        }
        else
        {
            Class zType = pField.getType();
            // Since we don't write nulls, and a "" will read as null, then we should assume a read of null is a ""
            String zFieldValue = pReader.getAttribute( Serial.VALUE );
            if ( zFieldValue == null )
            {
                zFieldValue = "";
            }
            if ( zType.isEnum() )
            {
                //noinspection unchecked
                zValue = Enum.valueOf( zType, zFieldValue );
            }
            else
            {
                WoxHandler zHandler = pWoxHandlers.getWoxFieldHandler( zWoxType );
                zValue = zHandler.parseFieldValue( zFieldValue );
            }
        }
        try
        {
            pField.setAccessible( true );
            pField.set( pObjectInstance, zValue );
        }
        catch ( IllegalAccessException e )
        {
            throw new RuntimeException( e );
        }
    }

    protected static XMLreader advanceToFirstChild( XMLreader pReader )
    {
        if ( pReader.readStartElement() )
        {
            return pReader;
        }
        throw new ApplicationException( "Expected Child Element NOT Found" );
    }

    protected ArrayList readObjects( WoxReader pWoxReader, XMLreader pSubtree )
    {
        ArrayList<Object> zList = new ArrayList<Object>();
        while ( pSubtree.readStartElement() )
        {
            Object zChild = pWoxReader.read( pSubtree );
            zList.add( zChild );
        }
        return zList;
    }

    protected static Type[] getGenericTypes( Field pField )
    {
        if ( pField != null )
        {
            Type zType = pField.getGenericType();
            if ( zType instanceof ParameterizedType )
            {
                return getGenericTypes( (ParameterizedType) zType );
            }
        }
        return null;
    }

    protected static Type[] getGenericTypes( ParameterizedType pType )
    {
        if ( pType != null )
        {
            Type[] zArguments = pType.getActualTypeArguments();
            if ( (zArguments != null) && (zArguments.length != 0) )
            {
                return zArguments;
            }
        }
        return null;
    }

    protected static String commonWoxType( WoxHandlers pWoxHandlers, Class pNativeType, Field pField, boolean pJustType )
    {
        return innerCommonWoxType( pWoxHandlers, pNativeType, getGenericTypes( pField ), pJustType );
    }

    private static String innerCommonWoxType( WoxHandlers pWoxHandlers, Class pNativeType, Type[] pGenericTypes, boolean pJustType )
    {
        if ( pNativeType.isArray() )
        {
            return innerCommonWoxType( pWoxHandlers, pNativeType.getComponentType(), pGenericTypes, pJustType ) + "[]";
        }

        if ( pGenericTypes == null )
        {
            WoxHandler zHandler = pWoxHandlers.getNativeHandler( pNativeType );

            if ( zHandler instanceof WoxDefaultHandler )
            {
                if ( pNativeType.equals( Object.class ) )
                {
                    return Serial.WOX_TYPE_OBJECT;
                }
                // Unless we re-map the type, ASSUME that the Wox Type is actually the Native (Java) Type (Package and all)!
                return pWoxHandlers.customNativeTypeToWoxType( pNativeType.getName() );
            }

            return zHandler.getWoxTypeFor( pWoxHandlers, pNativeType, null, pJustType );
        }

        StringBuilder zWoxType = new StringBuilder( innerCommonWoxType( pWoxHandlers, pNativeType, null, pJustType ) );

        char zPrepend = '<';

        for ( Type zArgument : pGenericTypes )
        {
            zWoxType.append( zPrepend );
            zPrepend = ',';
            if ( zArgument instanceof Class )
            {
                zWoxType.append( innerCommonWoxType( pWoxHandlers, (Class) zArgument, null, pJustType ) );
                continue;
            }
            if ( zArgument instanceof ParameterizedType )
            {
                ParameterizedType zType = (ParameterizedType) zArgument;
                Type zRawType = zType.getRawType();
                if ( zRawType instanceof Class )
                {
                    zWoxType.append( innerCommonWoxType( pWoxHandlers, (Class) zRawType, getGenericTypes( zType ), pJustType ) );
                    continue;
                }
                System.out.println( "PT: " + zArgument.getClass().getName() + ": " + zArgument );
                System.out.println( "  Raw: " + zRawType );
            }
            else
            {
                System.out.println( "!PT: " + zArgument.getClass().getName() + ": " + zArgument );
            }
            zWoxType.append( Serial.WOX_TYPE_OBJECT );
        }

        return zWoxType.append( '>' ).toString();
    }

    protected static Class commonNativeType( WoxHandlers pWoxHandlers, String pWoxType )
    {
        if ( pWoxType.endsWith( "[]" ) )
        {
            String zWoxType = pWoxType.substring( 0, pWoxType.length() - 2 );
            Class zType = commonNativeType( pWoxHandlers, zWoxType );
            if ( zType == null )
            {
                throw new NullPointerException( "No (Array) Native Type for Wox Type: " + zWoxType );
            }
            return Array.newInstance( zType, 0 ).getClass();
        }

        // Since Java "ignores" Generics at Runtime, we can simply strip them off!
        if ( pWoxType.endsWith( ">" ) )
        {
            int zAt = pWoxType.indexOf( '<' );

            if ( zAt == -1 )
            {
                throw new ApplicationException( "Bad Generics Form: " + pWoxType );
            }
            pWoxType = pWoxType.substring( 0, zAt );
        }

        WoxHandler zHandler = pWoxHandlers.getWoxHandler( pWoxType );

        if ( zHandler instanceof WoxDefaultHandler )
        {
            if ( Serial.WOX_TYPE_OBJECT.equals( pWoxType ) )
            {
                return Object.class;
            }
            // Unless we re-map the type, ASSUME that the Wox Type is actually the Native (Java) Type (Package and all)!
            return Util.resolveType( pWoxHandlers.customWoxTypeToNativeType( pWoxType ) );
        }

        return zHandler.getNativeTypeFor( pWoxHandlers, pWoxType );
    }
}