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

import java.util.*;

import org.litesoft.db.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;

public abstract class AbstractFinder extends AbstractORFacilitatorCarrier implements Finder
{
    protected final Logger mLogger;
    protected final boolean mIncludingImmortalInactives;
    protected final POQueryFilterFactory mPOQueryFilterFactory; // nullable

    protected AbstractFinder( ORFacilitatorInternalExtension pCommonSupport, Logger pLogger, boolean pIncludingImmortalInactives, POQueryFilterFactory pPOQueryFilterFactory )
    {
        super( pCommonSupport );
        mLogger = pLogger;
        mIncludingImmortalInactives = pIncludingImmortalInactives;
        mPOQueryFilterFactory = pPOQueryFilterFactory;
    }

    @Override
    public final POQueryFilterFactory getPOQueryFilterFactory()
    {
        return mPOQueryFilterFactory;
    }

    @Override
    public MetaDataForPO getMetaDataOptionallyByIdentifier( String pIdentifierName )
    {
        return getMetaDataStore().getMetaDataOptionallyByIdentifier( pIdentifierName );
    }

    @Override
    public final MetaDataForPO[] getAllMetaDataForPOs()
    {
        return getMetaDataStore().getAllMetaDataForPOs();
    }

    @Override
    public final MetaDataForPO getMetaDataOptional( String pPersistedObjectRegistrationName )
    {
        return getMetaDataStore().getMetaDataOptional( pPersistedObjectRegistrationName );
    }

    @Override
    public final MetaDataForPO getMetaDataOptional( Class<? extends PersistentObject> pPersistedObjectClass )
    {
        return getMetaDataStore().getMetaDataOptional( pPersistedObjectClass );
    }

    @Override
    public final MetaDataForPO getMetaDataRequired( String pPersistedObjectRegistrationName )
    {
        return getMetaDataStore().getMetaDataRequired( pPersistedObjectRegistrationName );
    }

    @Override
    public final MetaDataForPO getMetaDataRequired( Class<? extends PersistentObject> pPersistedObjectClass )
    {
        return getMetaDataStore().getMetaDataRequired( pPersistedObjectClass );
    }

    @Override
    public final boolean isIncludingImmortalInactives()
    {
        return mIncludingImmortalInactives;
    }

    @Override
    public Transaction createTransaction()
    {
        return getTransactionFactory().createTransaction( this, true );
    }

    protected final POQueryFilter createPOQueryFilter( MetaDataForPO pMetaDataForPO )
    {
        if ( (mPOQueryFilterFactory == null) )
        {
            return null;
        }
        RuntimeException zRTE;
        AbstractLogger zLogger;
        try
        {
            return mPOQueryFilterFactory.createFilter( pMetaDataForPO );
        }
        catch ( SecurityException e )
        {
            zRTE = e;
            zLogger = mLogger.info;
        }
        catch ( RuntimeException e )
        {
            zRTE = e;
            zLogger = mLogger.error;
        }
        zLogger.log( zRTE, "CreateFilter exception on ", pMetaDataForPO, " w/ factory", mPOQueryFilterFactory.getClass() );
        return POInstanceQueryFilter.NONE_ACCEPTABLE;
    }

    protected final POQueryIterator<?> LLfindAllCursored( String pPersistedObjectRegistrationName, //
                                                          WhereClause pSelectionWhereClause, OrderBy pOrderBy )
            throws DBException
    {
        MetaDataForPOinternalExtension metaDataForPO = getRequiredMetaDataForPO( pPersistedObjectRegistrationName );
        POQueryFilter zQueryFilter = createPOQueryFilter( metaDataForPO );
        boolean zIncludingImmortalInactives = isIncludingImmortalInactives();
        return helperFindAllCursored( metaDataForPO, zQueryFilter, zIncludingImmortalInactives, pSelectionWhereClause, pOrderBy );
    }

    protected final POQueryIterator<?> helperFindAllCursored( MetaDataForPOinternalExtension pMetaDataForPO, POQueryFilter pQueryFilter, boolean pIncludingImmortalInactives, WhereClause pSelectionWhereClause, OrderBy pOrderBy )
    {
        ORPersistenceHelper helper = (ORPersistenceHelper) getPersistenceHelper();
        return helper.findAllCursored( this, pQueryFilter, //
                                       pIncludingImmortalInactives, pMetaDataForPO, //
                                       pSelectionWhereClause, pOrderBy );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                              - Persisted Object Class Name (getClass().getName())
     * @param pSelectionWhereClause - null means all
     * @param pOrderBy              - null means order immaterial
     * @param pOffset               - Rows to Skip (< 0 treated as 0)
     * @param pLimit                - Max Rows to return (< 1 treated as 1)
     *
     * @return !Null Mutable List
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final List<PersistentObject<?>> findSubset( String pPersistedObjectRegistrationName, WhereClause pSelectionWhereClause, OrderBy pOrderBy, //
                                                       long pOffset, int pLimit )
            throws DBException
    {
        ORPersistenceHelper helper = (ORPersistenceHelper) getPersistenceHelper();
        MetaDataForPOinternalExtension metaDataForPO = getRequiredMetaDataForPO( pPersistedObjectRegistrationName );
        POQueryIterator<?> iterator = helper.findSubset( this, isIncludingImmortalInactives(), metaDataForPO, //
                                                         pSelectionWhereClause, pOrderBy, //
                                                         (pOffset < 0) ? 0L : pOffset, //
                                                         (pLimit < 1) ? 1 : pLimit );
        return listIt( iterator );
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pSelectionWhereClause - null means all
     * @param pOrderBy              - null means order immaterial
     * @param pOffset               - Rows to Skip (< 0 treated as 0)
     * @param pLimit                - Max Rows to return (< 1 treated as 1)
     *
     * @return !Null Mutable List
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"}) @Override
    public final <T extends PersistentObject> List<T> findSubset( Class<T> pPersistedObjectClass, WhereClause pSelectionWhereClause, OrderBy pOrderBy, long pOffset, int pLimit )
            throws DBException
    {
        return (List<T>) findSubset( pPersistedObjectClass.getName(), pSelectionWhereClause, pOrderBy, pOffset, pLimit );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                              - Persisted Object Class Name (getClass().getName())
     * @param pSelectionWhereClause - null means all
     * @param pOrderBy              - null means order immaterial
     *
     * @return !Null Mutable List
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final List<PersistentObject<?>> findAll( String pPersistedObjectRegistrationName, WhereClause pSelectionWhereClause, OrderBy pOrderBy )
            throws DBException
    {
        return listIt( LLfindAllCursored( pPersistedObjectRegistrationName, pSelectionWhereClause, pOrderBy ) );
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pSelectionWhereClause - null means all
     * @param pOrderBy              - null means order immaterial
     *
     * @return !Null Mutable List
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"}) @Override
    public final <T extends PersistentObject> List<T> findAll( Class<T> pPersistedObjectClass, WhereClause pSelectionWhereClause, OrderBy pOrderBy )
            throws DBException
    {
        return (List<T>) findAll( pPersistedObjectClass.getName(), pSelectionWhereClause, pOrderBy );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                              - Persisted Object Class Name (getClass().getName())
     * @param pSelectionWhereClause - null means all
     *
     * @return !Null Mutable List, order indeterminate
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final List<PersistentObject<?>> findAll( String pPersistedObjectRegistrationName, WhereClause pSelectionWhereClause )
            throws DBException
    {
        return findAll( pPersistedObjectRegistrationName, pSelectionWhereClause, null );
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pSelectionWhereClause - null means all
     *
     * @return !Null Mutable List, order indeterminate
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final <T extends PersistentObject> List<T> findAll( Class<T> pPersistedObjectClass, WhereClause pSelectionWhereClause )
            throws DBException
    {
        return findAll( pPersistedObjectClass, pSelectionWhereClause, null );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                 - Persisted Object Class Name (getClass().getName())
     * @param pKeys    - null or empty means none
     * @param pOrderBy - null means order immaterial
     *
     * @return !Null Mutable List
     *
     * @throws UnsupportedOperationException - if the PO type does not have a "single" key
     * @throws DBException                   - other Exception regarding the OR layer
     */
    @Override
    public final List<PersistentObject<?>> findAllByKeys( String pPersistedObjectRegistrationName, Collection pKeys, OrderBy pOrderBy )
            throws UnsupportedOperationException, DBException
    {
        MetaDataForPO metaDataForPO = getRequiredMetaDataForPO( pPersistedObjectRegistrationName );
        SimpleColumnDefinition zKeyCD = getKeyCD( metaDataForPO, ", so can't findAllByKeys" );
        POQueryIterator<?> zPOQueryIterator;
        if ( (pKeys == null) || pKeys.isEmpty() )
        {
            zPOQueryIterator = POQueryIterator.INSTANCE;
        }
        else
        {
            zPOQueryIterator = LLfindAllCursored( pPersistedObjectRegistrationName, WhereClauseFactory.INSTANCE.isAnyFrom( zKeyCD, pKeys ), pOrderBy );
        }
        return listIt( zPOQueryIterator );
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pKeys                 - null or empty means none
     * @param pOrderBy              - null means order immaterial
     *
     * @return !Null Mutable List
     *
     * @throws UnsupportedOperationException - if the PO type does not have a "single" key
     * @throws DBException                   - other Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"}) @Override
    public final <T extends PersistentObject> List<T> findAllByKeys( Class<T> pPersistedObjectClass, Collection pKeys, OrderBy pOrderBy )
            throws UnsupportedOperationException, DBException
    {
        return (List<T>) findAllByKeys( pPersistedObjectClass.getName(), pKeys, pOrderBy );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *              - Persisted Object Class Name (getClass().getName())
     * @param pKeys - null or empty means none
     *
     * @return !Null Mutable List, order indeterminate
     *
     * @throws UnsupportedOperationException - if the PO type does not have a "single" key
     * @throws DBException                   - other Exception regarding the OR layer
     */
    @Override
    public final List<PersistentObject<?>> findAllByKeys( String pPersistedObjectRegistrationName, Collection pKeys )
            throws UnsupportedOperationException, DBException
    {
        return findAllByKeys( pPersistedObjectRegistrationName, pKeys, null );
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pKeys                 - null or empty means none
     *
     * @return !Null Mutable List, order indeterminate
     *
     * @throws UnsupportedOperationException - if the PO type does not have a "single" key
     * @throws DBException                   - other Exception regarding the OR layer
     */
    @Override
    public final <T extends PersistentObject> List<T> findAllByKeys( Class<T> pPersistedObjectClass, Collection pKeys )
            throws UnsupportedOperationException, DBException
    {
        return findAllByKeys( pPersistedObjectClass, pKeys, null );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                              - Persisted Object Class Name (getClass().getName())
     * @param pSelectionWhereClause - null means all, which will only succeed if the table only has one entry
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final PersistentObject<?> findOne( String pPersistedObjectRegistrationName, WhereClause pSelectionWhereClause )
            throws DBException
    {
        POQueryIterator<?> it = LLfindAllCursored( pPersistedObjectRegistrationName, pSelectionWhereClause, null );
        try
        {
            if ( !it.hasNext() )
            {
                return null;
            }
            PersistentObject<?> first = it.next();
            if ( it.hasNext() )
            {
                throw new DisplayableDBException( "findOnePOfoundN", pPersistedObjectRegistrationName );
            }
            return first;
        }
        finally
        {
            it.releaseResources();
        }
    }

    /**
     * @param pPersistedObjectClass - Persisted Object Class (getClass())
     * @param pSelectionWhereClause - null means all, which will only succeed if the table only has one entry
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"}) @Override
    public final <T extends PersistentObject> T findOne( Class<T> pPersistedObjectClass, WhereClause pSelectionWhereClause )
            throws DBException
    {
        return (T) findOne( pPersistedObjectClass.getName(), pSelectionWhereClause );
    }

    /**
     * @param pPersistedObjectRegistrationName
     *                                   - Persisted Object Class Name (getClass().getName())
     * @param pPersistentObjectUniqueKey - !Null
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final PersistentObject<?> findOne( String pPersistedObjectRegistrationName, PersistentObjectUniqueKey pPersistentObjectUniqueKey )
            throws DBException
    {
        FindOneCacheResult zResult = checkCacheFindOne( pPersistedObjectRegistrationName, //
                                                        pPersistentObjectUniqueKey );
        if ( zResult != null )
        {
            return zResult.getOne();
        }
        return findOne( pPersistedObjectRegistrationName, pPersistentObjectUniqueKey.convertToWC() );
    }

    /**
     * @param pPersistedObjectClass      - Persisted Object Class (getClass())
     * @param pPersistentObjectUniqueKey - !Null
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"}) @Override
    public final <T extends PersistentObject> T findOne( Class<T> pPersistedObjectClass, PersistentObjectUniqueKey pPersistentObjectUniqueKey )
            throws DBException
    {
        return (T) findOne( pPersistedObjectClass.getName(), pPersistentObjectUniqueKey );
    }

    /**
     * @param pPersistentObjectURL - !Null
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final PersistentObject<?> findOne( PersistentObjectURL pPersistentObjectURL )
            throws DBException
    {
        return findOne( pPersistentObjectURL.getPersistedObjectRegistrationName(), pPersistentObjectURL.getPersistentObjectUniqueKey() );
    }

    /**
     * Convenience alternative to findOne(PersistentObjectURL) as we will seem to need to do this
     * conversion more and more.
     *
     * @param pPersistentObjectURL - !Null - a string suitable for translation into a PersistentObjectURL
     *
     * @return Null if not Found
     *
     * @throws DBException              - Exception regarding the OR layer
     * @throws IllegalArgumentException - if the string cannot be parsed and the PO reference or the Key is invalid
     */
    @Override
    public final PersistentObject<?> findOne( String pPersistentObjectURL )
            throws DBException, IllegalArgumentException
    {
        return findOne( createPersistentObjectURLfrom( pPersistentObjectURL ) );
    }

    /**
     * @param pObjectHandle - !Null
     *
     * @return Null if not Found
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public final PersistentObject<?> findOne( ObjectHandle pObjectHandle )
            throws DBException
    {
        return findOne( pObjectHandle.getPersistentObjectURL() );
    }

    protected final List<PersistentObject<?>> listIt( POQueryIterator<?> pIt )
    {
        try
        {
            List<PersistentObject<?>> pos = new ArrayList<PersistentObject<?>>();
            while ( pIt.hasNext() )
            {
                pos.add( pIt.next() );
            }
            return pos;
        }
        finally
        {
            pIt.releaseResources();
        }
    }

    /**
     * @return null indicates that this Cache can not help, !null indicates that it has answered the request
     */
    protected FindOneCacheResult checkCacheFindOne( String pPersistedObjectRegistrationName, //
                                                    PersistentObjectUniqueKey pPersistentObjectUniqueKey )
            throws DBException
    {
        return null;
    }
}