package org.litesoft.orsup.base;

import org.litesoft.bo.attributes.*;
import org.litesoft.util.*;

import java.sql.*;

public abstract class AttributeAccessorSCD<Owner extends PersistentObject> extends SupplimentedSCD
{
    public static final AttributeAccessorSCD[] EMPTY_ARRAY = new AttributeAccessorSCD[0];

    public AttributeAccessorSCD( String pName, String pColumnName, boolean pRequired, AttributeMetaData pAMD )
    {
        super( pName, pColumnName, pRequired, pAMD );
    }

    public Object getDefault()
    {
        return null;
    }

    public void clrValueOnPO( Owner pPO )
    {
        setValueOnPO( pPO, null );
    }

    abstract public Object getValueOnPO( Owner pPO );

    abstract public void setValueOnPO( Owner pPO, Object pValue );

    abstract public Object db_getValueOnPO( Owner pPO );

    abstract public void db_setValueOnPO( Owner pPO, Object pValue );

    public void onSuccessfulCommit( Owner pPO, boolean pWasCommitted )
    {
    }

    public Object convertToAppropriateColumnType( Object pValue )
    {
        return convertToTargetType( pValue, getColumnType() );
    }

    private static Object convertToTargetType( Object pValue, Class<?> pTargetType )
    {
        // check first to see if we need to do a conversion
        if ( pValue == null || (pTargetType.isAssignableFrom( pValue.getClass() )) )
        {
            return pValue;
        }

        if ( pTargetType == String.class )
        {
            return pValue.toString();
        }
        if ( (pTargetType == Boolean.class) || (pTargetType == Boolean.TYPE) )
        {
            return to_Boolean( pValue );
        }
        if ( (pTargetType == Long.class) || (pTargetType == Long.TYPE) )
        {
            return to_Long( pValue );
        }
        if ( (pTargetType == Integer.class) || (pTargetType == Integer.TYPE) )
        {
            return to_Integer( pValue );
        }
        if ( (pTargetType == Short.class) || (pTargetType == Short.TYPE) )
        {
            return to_Short( pValue );
        }
        if ( (pTargetType == Double.class) || (pTargetType == Double.TYPE) )
        {
            return to_Double( pValue );
        }
        if ( (pTargetType == Float.class) || (pTargetType == Float.TYPE) )
        {
            return to_Float( pValue );
        }
        if ( pTargetType == Timestamp.class )
        {
            return to_Timestamp( pValue );
        }
        if ( pTargetType == Time.class )
        {
            return to_SqlTime( pValue );
        }
        if ( pTargetType == java.util.Date.class || pTargetType == java.sql.Date.class )
        {
            return to_UtilDate( pValue );
        }

        throw new IllegalArgumentException(
                "unexpected value; expected: " + pTargetType + " but got: " + Utils.classNameOf( pValue ) );
    }

    public static AttributeAccessorSCD[] append( AttributeAccessorSCD[] pOrig, AttributeAccessorSCD pNew )
    {
        if ( pNew == null )
        {
            return pOrig;
        }
        if ( Utils.isNullOrEmpty( pOrig ) )
        {
            return new AttributeAccessorSCD[]{pNew};
        }
        AttributeAccessorSCD[] newArray = new AttributeAccessorSCD[pOrig.length + 1];
        System.arraycopy( pOrig, 0, newArray, 0, pOrig.length );
        newArray[pOrig.length] = pNew;
        return newArray;
    }

    /**
     * Intended mainly for cleaning up after junit tests that might dynamically insert attributes
     */
    public static AttributeAccessorSCD[] remove( AttributeAccessorSCD[] pOrig,
                                                 AttributeAccessorSCD pToRemove )
    {
        if ( (pToRemove != null) && !Utils.isNullOrEmpty( pOrig ) )
        {
            for ( int i = 0; i < pOrig.length; i++ )
            {
                if ( pToRemove.getName().equals( pOrig[i].getName() ) )
                {
                    return remove( pOrig, i );
                }
            }
        }
        return pOrig;
    }

    private static AttributeAccessorSCD[] remove( AttributeAccessorSCD[] pOrig, int pToRemove )
    {
        AttributeAccessorSCD[] newArray = new AttributeAccessorSCD[pOrig.length - 1];
        int zDst = 0;
        for ( int zSrc = 0; zSrc < pOrig.length; zSrc++ )
        {
            if ( zSrc != pToRemove )
            {
                newArray[zDst++] = pOrig[zSrc];
            }
        }
        return newArray;
    }
}