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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.orsup.base.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.util.*;

public abstract class AbstractLazyLoadToMany<Owner extends PersistentObjectImpl, Them extends PersistentObjectImpl> extends AbstractLazyLoadTo<Owner, Them>
{
    protected MetaDataForPO mThierMetaData;
    private final OrderBy mOrderBy;
    private List<Them> mValue = null;
    private ModificationAccessableArrayList<Them> mMutableValueToGiveOut = null;
    private boolean mMutated = false;

    public AbstractLazyLoadToMany( Owner pOwner, AbstractAttributeAccessorSCDtoMany<Owner, Them> pSCDtoMany )
    {
        super( pOwner, pSCDtoMany );
        mThierMetaData = getPOMetaDataRequired( pSCDtoMany.getToThemName() );
        mOrderBy = createOrderBy( pSCDtoMany );
    }

    public boolean isMutated()
    {
        return mMutated;
    }

    private void setValue( List<Them> pNewThems )
    {
        mValue = (pNewThems instanceof ArrayList) ? pNewThems : new ArrayList<Them>( pNewThems );
        loadedListMutated();
    }

    @Override
    protected void releaseLoadeds()
    {
        mValue.clear();
        mValue = null;
        mMutableValueToGiveOut = null;
        mMutated = false;
    }

    private void loadedListMutated()
    {
        mMutableValueToGiveOut = null;
        mMutated = true;
    }

    public List<Them> getValue()
    {
        loadValue();
        if ( (mMutableValueToGiveOut == null) || mMutableValueToGiveOut.isModified() )
        {
            mMutableValueToGiveOut = new ModificationAccessableArrayList<Them>( mValue ); // copy it
        }
        return mMutableValueToGiveOut;
    }

    @Override
    public void revertToNotLoaded()
    {
        super.revertToNotLoaded();
        clearAdded();
        clearRemoved();
    }

    private OrderBy createOrderBy( AbstractAttributeAccessorSCDtoMany<Owner, Them> pSCDtoMany )
    {
        String orderby = Strings.noEmpty( pSCDtoMany.getOrderByAttribute() );
        if ( orderby != null )
        {
            return BuilderMetaDataAwareOrderBy.create( mThierMetaData, orderby );
        }
        if ( null != (orderby = Strings.noEmpty( mThierMetaData.getDefaultOrderByAttributeName() )) )
        {
            return BuilderMetaDataAwareOrderBy.create( mThierMetaData, orderby );
        }
        OrderBy zOrderBy = null;
        AttributeAccessorKeySet keySet = mThierMetaData.getKeySet();
        if ( keySet != null )
        {
            AttributeAccessorSCD[] keys = keySet.getKeyAttributeAccessorSCDs();
            if ( (keys != null) && (keys.length != 0) )
            {
                int i = keys.length - 1;
                zOrderBy = new OrderBy( keys[i] );
                while ( --i >= 0 )
                {
                    zOrderBy = new OrderBy( keys[i], zOrderBy );
                }
            }
        }
        return zOrderBy;
    }

    abstract protected Object getLoadingWhereClauseIsEqualValue();

    public abstract AbstractAttributeAccessorSCDtoMany<Owner, Them> getSCDtoMany();

    @Override
    public final String getAttributeName()
    {
        return getSCDtoMany().getName();
    }

    @Override
    protected final boolean isThemDependantOnUs()
    {
        return getSCDtoMany().isThemDependantOnUs();
    }

    protected WhereClause createLoadingWhereClause()
    {
        String backReference = getSCDtoMany().getBackReference();
        Object value = getLoadingWhereClauseIsEqualValue();
        AttributeAccessorSCD scd = mThierMetaData.getAccessorSCDrequired( backReference );
        return WhereClauseFactory.INSTANCE.isEqual( scd, value );
    }

    /**
     * @param pNewThems Nullable and may actually be no changes
     */
    public void setValues( List<Them> pNewThems )
    {
        loadValue(); // Since already added to loaded List
        if ( pNewThems == null )
        {
            pNewThems = new ArrayList<Them>();
        }
        List<Them> zCurThems = new ArrayList<Them>( mValue );
        for ( Them newThem : pNewThems )
        {
            if ( !zCurThems.remove( newThem ) ) // NEW newThem
            {
                addValue( newThem );
            }
        }
        for ( Them curThem : zCurThems )
        {
            removeValue( curThem );
        }
        setValue( pNewThems );
    }

    /**
     * @param pPO !null, but may already be in the list
     */
    public void addValue( Them pPO )
    {
        loadValue(); // Since already added to loaded List
        if ( LLaddValue( pPO ) )
        {
            getToOneLazyLoader( pPO ).backdoorSetValue( mOwner, getAttributeName() );
        }
    }

    /**
     * @param pPO !null , but might not be in the list
     */
    public void removeValue( Them pPO )
    {
        loadValue(); // Since already added to loaded List
        if ( LLremoveValue( pPO ) )
        {
            getToOneLazyLoader( pPO ).backdoorSetValue( null, getAttributeName() );
            if ( isThemDependantOnUs() )
            {
                pPO.requestDelete();
            }
        }
    }

    private AbstractLazyLoadToOne<Them, Owner> getToOneLazyLoader( Them pThem )
    {
        checkTransactions( pThem );
        String backReference = getSCDtoMany().getBackReference();
        pThem.getAttributeValue( backReference ); // Force them to LazyLoad
        AbstractAttributeAccessorSCDtoOne acdToOne = (AbstractAttributeAccessorSCDtoOne) mThierMetaData.getAccessorSCDrequired( backReference );
        //noinspection unchecked
        return acdToOne.getValueHolder( pThem );
    }

    /**
     * Already Lazy Loaded
     *
     * @param pPO !null, but may already be in the list
     *
     * @return true if added
     */
    private boolean LLaddValue( Them pPO )
    {
        boolean notInList = !mValue.contains( pPO );
        if ( notInList )
        {
            loadedListMutated();
            mValue.add( pPO );
        }
        return notInList;
    }

    /**
     * Already Lazy Loaded
     *
     * @param pPO !null , but might not be in the list
     *
     * @return true if removed
     */
    private boolean LLremoveValue( Them pPO )
    {
        boolean inList = mValue.remove( pPO );
        if ( inList )
        {
            loadedListMutated();
        }
        return inList;
    }

    private void loadValue()
    {
        if ( !mLoaded )
        {
            List<Them> zPOs;
            if ( mOwner.isNew() )
            {
                zPOs = new ArrayList<Them>();
            }
            else
            {
                String themName = mThierMetaData.getPOregistrationName();
                WhereClause whereClause = createLoadingWhereClause();
                List found = mOwner.getFinder().findAll( themName, whereClause, mOrderBy );
                //noinspection unchecked
                zPOs = (List<Them>) found;
            }
            applyAddedsAndRemoveds( zPOs );
            setValue( zPOs );
            mLoaded = true;
        }
    }

    private void clearRemoved()
    {
        if ( mRemoved != null )
        {
            mRemoved.clear();
            mRemoved = null;
        }
    }

    private void clearAdded()
    {
        if ( mAdded != null )
        {
            mAdded.clear();
            mAdded = null;
        }
    }

    private Set<Them> initAdded()
    {
        return (mAdded != null) ? mAdded : (mAdded = new HashSet<Them>());
    }

    private Set<Them> initRemoved()
    {
        return (mRemoved != null) ? mRemoved : (mRemoved = new HashSet<Them>());
    }

    private void applyAddedsAndRemoveds( List<Them> pPOs )
    {
        if ( (mAdded != null) || (mRemoved != null) )
        {
            initAdded();
            initRemoved();
            if ( !mAdded.isEmpty() || !mRemoved.isEmpty() )
            {
                for ( int i = pPOs.size(); --i >= 0; ) // Backwards for Safe Removal!
                {
                    Them zThem = pPOs.get( i );
                    if ( mRemoved.contains( zThem ) ) // Should remove?
                    {
                        mRemoved.remove( zThem );
                        pPOs.remove( i );
                        continue;
                    }
                    if ( mAdded.contains( zThem ) ) // Allready in the List?
                    {
                        mAdded.remove( zThem );
                    }
                }
                pPOs.addAll( mAdded );
            }
            clearAdded();
            clearRemoved();
        }
    }

    private Set<Them> mAdded = null;
    private Set<Them> mRemoved = null; //

    /**
     * May or may not be Already Lazy Loaded
     *
     * @param pPO !null
     */
    void backdoorAddValue( Them pPO )
    {
        if ( !mLoaded )
        {
            initAdded().add( pPO );
        }
        else if ( !mValue.contains( pPO ) )
        {
            loadedListMutated();
            mValue.add( pPO );
        }
    }

    /**
     * May or may not be Already Lazy Loaded
     *
     * @param pPO !null
     */
    void backdoorRemoveValue( Them pPO )
    {
        if ( !mLoaded )
        {
            if ( (mAdded == null) || !mAdded.remove( pPO ) )
            {
                initRemoved().add( pPO );
            }
        }
        else if ( mValue.remove( pPO ) ) // true if was removed
        {
            loadedListMutated();
        }
    }
}