// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.orsup.nonpublic;

import org.litesoft.orsup.base.*;

public abstract class AbstractRowSourcePOQueryIterator<T extends PersistentObject> extends AbstractPOQueryIterator<T>
{
    private PersistenceHelperRowSource mRowSource;
    private RowAcceptor mRowAcceptor = RowAcceptor.NULL;
    private Class mKeyFilterClass = null;
    private int mPrimaryKeyIndex = 0;

    protected AbstractRowSourcePOQueryIterator( MetaDataForPOinternalExtension pMetaDataForPO, Finder pFinder, POQueryFilter pQueryFilter, PersistenceHelperRowSource pRowSource )
    {
        super( pMetaDataForPO, pFinder, determinePOInstanceQueryFilter( pQueryFilter ) );
        mRowSource = PersistenceHelperRowSource.NULL.deNull( pRowSource );
        try
        {
            if ( pQueryFilter != null )
            {
                switch ( pQueryFilter.getType() )
                {
                    case NoneAcceptable:
                        releasePOsource();
                        POQueryFilter.LOGGER.trace.log( "ALL ", getMD(), " POs filtered out by ", //
                                                        pQueryFilter.getClass() );
                        return;
                    case PotentialFilteringByKey:
                        Integer zPrimaryKeyIndex = mMetaDataForPO.getPrimaryKeyPersistingAccessorSCDsIndex();
                        if ( zPrimaryKeyIndex != null )
                        {
                            mRowAcceptor = new AbstractRowSourcePOQueryIterator.IdRowAcceptor( (POKeyQueryFilter) pQueryFilter, zPrimaryKeyIndex );
                            mKeyFilterClass = pQueryFilter.getClass();
                            mPrimaryKeyIndex = zPrimaryKeyIndex;
                        }
                        break;
                    default:
                        break;
                }
            }
            preFetchPO();
        }
        catch ( RuntimeException e )
        {
            releaseResources();
            throw e;
        }
    }

    private static POInstanceQueryFilter determinePOInstanceQueryFilter( POQueryFilter pQueryFilter )
    {
        if ( pQueryFilter != null )
        {
            switch ( pQueryFilter.getType() )
            {
                case NoneAcceptable:
                    return POInstanceQueryFilter.NONE_ACCEPTABLE;
                case AllAcceptable:
                    break;
                case PotentialFilteringByInstance:
                    return (POInstanceQueryFilter) pQueryFilter;
                case PotentialFilteringByKey:
                    break;
                default:
                    // Note: this is an error so that resources do NOT need to be cleaned up!
                    throw new Error( "Combo of '" + pQueryFilter.getType() + "' and " + pQueryFilter.getClass() );
            }
        }
        return null;
    }

    @Override
    protected void preparePOsource()
    {
        mRowSource = mRowSource.prepareForGetNextRow();
    }

    @Override
    protected T LLfetchPO()
    {
        for ( Object[] row; null != (row = mRowSource.getNextRow()); )
        {
            if ( mRowAcceptor.isRowAcceptable( row ) )
            {
                //noinspection unchecked
                return (T) mMetaDataForPO.createPO( mFinder, row );
            }
            POQueryFilter.LOGGER.trace.log( getMD(), " PO w/ ID ", row[mPrimaryKeyIndex], " filtered out by ", mKeyFilterClass );
        }
        return null;
    }

    @Override
    protected void releasePOsource()
    {
        mRowSource.dispose();
        mRowSource = PersistenceHelperRowSource.NULL.INSTANCE;
    }

    private static class RowAcceptor
    {
        public static final RowAcceptor NULL = new RowAcceptor();

        public boolean isRowAcceptable( Object[] pRow )
        {
            return true;
        }
    }

    private static class IdRowAcceptor extends RowAcceptor
    {
        private POKeyQueryFilter mPOKeyQueryFilter;
        private int mPrimaryKeyIndex;

        public IdRowAcceptor( POKeyQueryFilter pPOKeyQueryFilter, int pPrimaryKeyIndex )
        {
            mPOKeyQueryFilter = pPOKeyQueryFilter;
            mPrimaryKeyIndex = pPrimaryKeyIndex;
        }

        @Override
        public boolean isRowAcceptable( Object[] pRow )
        {
            return mPOKeyQueryFilter.isPO_KeyAcceptable( pRow[mPrimaryKeyIndex] );
        }
    }
}