package org.litesoft.boviews.podataproviders.support;

import org.litesoft.bo.attributes.*;
import org.litesoft.bo.change.*;
import org.litesoft.bo.views.*;
import org.litesoft.bo.views.communication.*;
import org.litesoft.bo.views.server.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.exceptions.*;
import org.litesoft.commonfoundation.iterators.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;

import org.litesoft.commonfoundation.typeutils.Objects;
import java.util.*;

public class PoServerVoDataProvider<T extends IViewObject> extends AbstractServerRequestRowOrRowsVoDataProvider<T>
{
    public static final WhereClauseFactory WCF = WhereClauseFactory.INSTANCE;

    private static final String VO_ID_ATTRIBUTE_NAME = "ID";

    protected MetaDataForPO mPOMetaData = null;
    protected AttributeAccessorSCD<PersistentObject<?>> mPrimaryKeyASCD;
    protected POrecordVersion mPOrecordVersion = POrecordVersion.INSTANCE;

    @SuppressWarnings({"UnusedDeclaration"})
    public PoServerVoDataProvider( VoMetaData<T> pVOMetaData, MetaDataForPO pPOMetaData )
    {
        super( pVOMetaData );
        mPOMetaData = pPOMetaData;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public PoServerVoDataProvider( VoMetaData<T> pVOMetaData, MetaDataStore pMetaDataStore )
    {
        super( pVOMetaData );
        String zType = Strings.noEmpty( mVOMetaData.getDerivedFromRegisteredObjectType() );
        if ( zType == null )
        {
            throw new PersistenceException( "ViewObject '" + pVOMetaData.getObjectName() + "' does not indicate Derived From!" );
        }
        if ( null == (mPOMetaData = pMetaDataStore.getMetaDataOptionallyByIdentifier( zType )) )
        {
            mPOMetaData = pMetaDataStore.getMetaDataRequired( zType );
        }
    }

    @Override
    protected void LLinitialize()
    {
        super.LLinitialize();

        AttributeAccessorSCD<PersistentObject<?>>[] zSCDs = mPOMetaData.getKeySet().getKeyAttributeAccessorSCDs();
        if ( zSCDs.length != 1 )
        {
            throw new PersistenceException( "POs w/ Multiple Primary Keys or no Primary Key are not supported" + this );
        }
        Class<?> zVoIDtype = mVOMetaData.getVoAttribute( VO_ID_ATTRIBUTE_NAME ).getType().getType();
        Class zPoIDtype = (mPrimaryKeyASCD = zSCDs[0]).getColumnType();
        if ( !zPoIDtype.equals( zVoIDtype ) )
        {
            throw new PersistenceException( "Mismatched column types VO: " + zVoIDtype + " != " + zPoIDtype + " :PO" + this );
        }
        String zRecordVersionAttributeName = mPOMetaData.getRecordVersionAttributeName();
        if ( Strings.isNotNullOrEmpty( zRecordVersionAttributeName ) )
        {
            mPOrecordVersion = new POrecordVersionImpl( zRecordVersionAttributeName );
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    protected void assertMatchingVOsALL( Integer pMaxToReturn, SSMap[] pORed_ANDFilters )
    {
        if ( pMaxToReturn != null )
        {
            throw new IllegalStateException( "MaxToReturn not supported for: " + getVOMetaData().getViewObjectClass().getSimpleName() );
        }
        if ( (pORed_ANDFilters != null) && (pORed_ANDFilters.length != 0) )
        {
            throw new IllegalStateException( "Only auto filtering supported for: " + getVOMetaData().getViewObjectClass().getSimpleName() );
        }
    }

    public T createView( PersistentObject pPO, boolean pOnlyQueryAttributes )
    {
        return (pPO != null) ? LLcreateView( pPO, pOnlyQueryAttributes, false ) : null;
    }

    public T LLcreateView( PersistentObject pPO, boolean pOnlyQueryAttributes, boolean pExtraFlag )
    {
        T zVO = mVOMetaData.createViewObject( false, null );

        zVO.setRecordVersion( mPOrecordVersion.get( pPO ) );

        zVO.setAttributeValue( VO_ID_ATTRIBUTE_NAME, mPrimaryKeyASCD.getValueOnPO( pPO ) );

        updateView( zVO, pPO, pOnlyQueryAttributes, pExtraFlag );

        zVO.initialize();
        return zVO;
    }

    @SuppressWarnings({"UnusedParameters"})
    public void updateView( T pVO, PersistentObject pPO, boolean pOnlyQueryAttributes, boolean pExtraFlag )
    {
        String[] zAttributeNames = mVOMetaData.getAttributeNames();
        for ( String zAttributeName : zAttributeNames )
        {
            VoAttribute<T> zAttribute = mVOMetaData.getVoAttribute( zAttributeName );
            if ( zAttribute.isQueryViewAttribute() || !pOnlyQueryAttributes )
            {
                String zPath = zAttribute.getDerivedFromAttributePath();
                if ( Strings.isNotNullOrEmpty( zPath ) )
                {
                    Object zValueOnPO = getDottedAttributeValue( pPO, zPath );
                    pVO.setAttributeValue( zAttributeName, zValueOnPO );
                }
            }
        }
    }

    public void updatePO( PersistentObject pPO, T pMember )
    {
        String[] zAttributeNames = mVOMetaData.getAttributeNames();
        for ( String zAttributeName : zAttributeNames )
        {
            VoAttribute<T> zAttribute = mVOMetaData.getVoAttribute( zAttributeName );
            String zPath = zAttribute.getDerivedFromAttributePath();
            if ( Strings.isNotNullOrEmpty( zPath ) )
            {
                Mutability zMutability = zAttribute.getMutability();
                if ( Mutability.RW.equals( zMutability ) || (pPO.isNew() && Mutability.AddOnly.equals( zMutability )) )
                {
                    setDottedAttributeValue( pPO, zPath, pMember.getAttributeValue( zAttributeName ) );
                }
            }
        }
    }

    public PersistentObject getAndUpdatePO( Transaction pTransaction, T pMember )
    {
        PersistentObject zPO = getTransactionPO( pTransaction, pMember );
        updatePO( zPO, pMember );
        return zPO;
    }

    public PersistentObject getTransactionPO( Transaction pTransaction, T pMember )
    {
        return pMember.isNew() ? createNewPO( pTransaction, pMember ) : getUpdatableExistingPO( pTransaction, pMember );
    }

    public PersistentObject getUpdatableExistingPO( Transaction pTransaction, T pMember )
    {
        PersistentObject zPO = getExistingPO( pTransaction, pMember );
        if ( zPO == null )
        {
            throw new ConcurrentPOModificationException( "No Persisted data for '" + pMember + "', it may have been deleted" );
        }
        if ( !Objects.areNonArraysEqual( pMember.getRecordVersion(), mPOrecordVersion.get( zPO ) ) )
        {
            throw new ConcurrentPOModificationException( "Persisted data for '" + pMember + "' has been updated, please refresh and try again" );
        }
        return zPO;
    }

    public PersistentObject getExistingPO( Finder pFinder, T pMember )
    {
        return findPO( pFinder, pMember.getID() );
    }

    @SuppressWarnings({"UnusedParameters"})
    public PersistentObject createNewPO( Transaction pTransaction, T pMember )
    {
        return mPOMetaData.createNew( pTransaction );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public PersistentObject getPO( Object pDBValueForPrimaryKey )
    {
        return findPO( DataStoreLocator.get().getUnfilteredFinder(), pDBValueForPrimaryKey );
    }

    @SuppressWarnings({"UnnecessaryLocalVariable"})
    public PersistentObject findPO( Finder pFinder, Object pDBValueForPrimaryKey )
    {
        PersistentObjectUniqueKey zPOUK = new UniqueKeySingle( mPrimaryKeyASCD, pDBValueForPrimaryKey );
        PersistentObject zPO = pFinder.findOne( mPOMetaData.getPOregistrationName(), zPOUK );
        return zPO;
    }

    /**
     * Get a single VO based on an ObejctURL
     *
     * @param pObjectURL if null, null will be return
     *
     * @return single VO found (matches), or null if not found (or pObjectURL is null)
     *
     * @throws PersistenceException if there was an underlying exception!
     */
    @Override
    public T getVOby( ObjectURL pObjectURL )
            throws PersistenceException
    {
        if ( pObjectURL != null )
        {
            if ( !mVOMetaData.getObjectName().equals( pObjectURL.getObjectName() ) )
            {
                throw new PersistenceException( "Unacceptable ObjectName: " + pObjectURL.getObjectName() + this );
            }
            ObjectUniqueKey zObjectUniqueKey = pObjectURL.getObjectUniqueKey();
            if ( !zObjectUniqueKey.isForNewObject() )
            {
                return createVObyURLkey( zObjectUniqueKey );
            }
        }
        return null;
    }

    protected T createVObyURLkey( ObjectUniqueKey pObjectUniqueKey )
    {
        PersistentObject zPO = findPO( DataStoreLocator.get().getUnfilteredFinder(), pObjectUniqueKey.getParsedID() );

        return createView( zPO, false );
    }

    /**
     * Get all Matching VO(s) with the supplied URLs.
     *
     * @param pObjectURLs the URLs for the VOs to fetch.
     *
     * @return a SizedIterator, if the rows found are <= pMaxToReturn then the size indicated will match the rows returned by iterating, otherwise, the state of the iterator is unspecified.
     *
     * @throws PersistenceException if there was an underlying exception!
     */
    @Override
    public SizedIterator<T> getMatchingVOs( ObjectURL... pObjectURLs )
            throws PersistenceException
    {
        if ( pObjectURLs != null )
        {
            List<Object> zKeys = new ArrayList<Object>();
            for ( ObjectURL zURL : pObjectURLs )
            {
                if ( zURL != null )
                {
                    if ( !mVOMetaData.getObjectName().equals( zURL.getObjectName() ) )
                    {
                        throw new PersistenceException( "Unacceptable ObjectName: " + zURL.getObjectName() + this );
                    }
                    ObjectUniqueKey zObjectUniqueKey = zURL.getObjectUniqueKey();
                    if ( !zObjectUniqueKey.isForNewObject() )
                    {
                        zKeys.add( zObjectUniqueKey.getParsedID() );
                    }
                }
            }
            if ( !zKeys.isEmpty() )
            {
                POQueryIterator zPOs = findAllCursored( DataStoreLocator.get().getUnfilteredFinder(), augment_getMatchingVOs( WCF.isAnyFrom( mPrimaryKeyASCD, zKeys ) ), null );
                return new SizedIterator<T>( new PoToVoIterator<T>( false, zPOs ) );
            }
        }
        return new SizedIterator<T>( new PoToVoIterator<T>( false, Iterators.empty() ) );
    }

    /**
     * Get all Matching VO(s) by the supplied criteria (Not to exceed the pMaxToReturn).
     *
     * @param pMaxToReturn     if ! null, then if there are more then the pMaxToReturn that match, return none, but indicate how many would have been returned.
     * @param pORed_ANDFilters - OR the criteria of each map, where each map is the ANDing of the attribute values (Note: if No Maps are given then return ALL)
     *
     * @return a SizedIterator, if the rows found are <= pMaxToReturn then the size indicated will match the rows returned by iterating, otherwise, the state of the iterator is unspecified.
     *
     * @throws PersistenceException if there was an underlying exception!
     */
    @Override
    public SizedIterator<T> getMatchingVOs( Integer pMaxToReturn, SSMap... pORed_ANDFilters )
            throws PersistenceException
    {
        boolean zOnlyQueryAttributes = getMatchingVOsOnlyQueryAttributesFlag();
        UnfilteringFinder zFinder = DataStoreLocator.get().getUnfilteredFinder();

        WhereClause zWhereClause = createWhereClauseSupport( zFinder ).createWhereClause( pORed_ANDFilters );

        POQueryIterator zPOs = findAllCursored( zFinder, augment_getMatchingVOs( zWhereClause ), augment_getMatchingVOs( (OrderBy) null ) );

        if ( pMaxToReturn == null )
        {
            return new SizedIterator<T>( new PoToVoIterator<T>( zOnlyQueryAttributes, zPOs ) );
        }
        List<PersistentObject> zList = new ArrayList<PersistentObject>();
        for ( int max = pMaxToReturn; zPOs.hasNext(); zList.add( zPOs.next() ) )
        {
            if ( --max < 0 )
            {
                zPOs.dispose();
                return new SizedIterator<T>( zFinder.count( mPOMetaData.getPOregistrationName(), zWhereClause ) );
            }
        }
        zPOs.dispose();
        return new SizedIterator<T>( new PoToVoIterator<T>( zOnlyQueryAttributes, zList.iterator() ) );
    }

    protected WhereClauseSupport createWhereClauseSupport( UnfilteringFinder pFinder )
    {
        return new WhereClauseSupport( pFinder, mPOMetaData, mVOMetaData );
    }

    protected boolean getMatchingVOsOnlyQueryAttributesFlag()
    {
        return true;
    }

    protected OrderBy augment_getMatchingVOs( OrderBy pOrderBy )
    {
        return pOrderBy;
    }

    protected WhereClause augment_getMatchingVOs( WhereClause pWhereClause )
    {
        return pWhereClause;
    }

    protected POQueryIterator findAllCursored( UnfilteringFinder pFinder, WhereClause pWhereClause, OrderBy pOrderBy )
    {
        return pFinder.findAllCursored( mPOMetaData.getPOregistrationName(), pWhereClause, pOrderBy );
    }

    protected class PoToVoIterator<VO> extends Iterators.AbstractReadOnly<VO>
    {
        private boolean mOnlyQueryAttributes;
        private Iterator mIterator;

        public PoToVoIterator( boolean pOnlyQueryAttributes, Iterator pIterator )
        {
            mOnlyQueryAttributes = pOnlyQueryAttributes;
            mIterator = pIterator;
        }

        @SuppressWarnings({"unchecked"}) @Override
        public VO next()
        {
            return (VO) createView( (PersistentObject) mIterator.next(), mOnlyQueryAttributes );
        }

        @Override
        public boolean hasNext()
        {
            return mIterator.hasNext();
        }

        @Override
        public void dispose()
        {
            if ( mIterator instanceof Disposable )
            {
                ((Disposable) mIterator).dispose();
            }
        }
    }

    protected void setDottedAttributeValue( PersistentObject pPO, String pPath, Object pAttributeValue )
    {
        for ( int zDotAt; -1 != (zDotAt = pPath.indexOf( '.' )); pPath = pPath.substring( zDotAt + 1 ) )
        {
            String zAttributeName = pPath.substring( 0, zDotAt );

            pPO = getToOne( pPO, zAttributeName );
        }
        setAttributeValue( pPO, pPath, pAttributeValue );
    }

    protected PersistentObject getToOne( PersistentObject pPO, String pAttributeName )
    {
        Object zValue = getAttributeValue( pPO, pAttributeName );
        if ( zValue instanceof PersistentObject )
        {
            return (PersistentObject) zValue;
        }
        throw new PersistenceException( "Invalid ToOne Attribute '" + pAttributeName + "' requested on PO: " + pPO );
    }

    protected Object getDottedAttributeValue( PersistentObject pPO, String pPath )
    {
        for ( int zDotAt; -1 != (zDotAt = pPath.indexOf( '.' )); pPath = pPath.substring( zDotAt + 1 ) )
        {
            String zAttributeName = pPath.substring( 0, zDotAt );

            Object zValue = getAttributeValue( pPO, zAttributeName );
            if ( !(zValue instanceof PersistentObject) )
            {
                if ( zValue != null )
                {
                    LOGGER.error.log( "Invalid ToOne Attribute '", zAttributeName, "' requested on PO: " + pPO );
                }
                return null;
            }
            pPO = (PersistentObject) zValue;
        }
        return getAttributeValue( pPO, pPath );
    }

    @SuppressWarnings({"unchecked"})
    protected void setAttributeValue( PersistentObject pPO, String pAttributeName, Object pAttributeValue )
    {
        AttributeAccessorSCD zASCD = pPO.getMetaDataForPO().getAccessorSCDrequired( pAttributeName );
        Mutability zMutability = zASCD.getMutability();
        if ( Mutability.RW.equals( zMutability ) || (pPO.isNew() && Mutability.AddOnly.equals( zMutability )) )
        {
            if ( !pPO.isNew() || !zASCD.isRequired() || (pAttributeValue != null) )
            {
                zASCD.setValueOnPO( pPO, pAttributeValue );
            }
        }
    }

    @SuppressWarnings({"unchecked"})
    protected Object getAttributeValue( PersistentObject pPO, String pAttributeName )
    {
        AttributeAccessorSCD zASCD = pPO.getMetaDataForPO().getAccessorSCDoptional( pAttributeName );
        if ( zASCD != null )
        {
            return zASCD.getValueOnPO( pPO );
        }
        LOGGER.error.log( "Invalid Attribute '", pAttributeName, "' requested on PO: " + pPO );
        return null;
    }

    /**
     * ACIDly update the Backing Persistence Engine (DB?) with rows from the pTransactionSet.
     *
     * @param pTransactionSet  !null
     * @param pReturnOnSuccess the SCresult will contain a VO (of type T) (which may be null) entry for each VO originally in the pTransactionSet whose original ObjectURL matches the entry in this array (dups allowed).
     *
     * @return a Relatively complex object that is used to manage Caches.
     *
     * @throws PersistenceException if there was an underlying exception!
     */
    @Override
    public SCresult requestCommit( TransactionSet pTransactionSet, ObjectURL... pReturnOnSuccess )
            throws PersistenceException
    {
        SCresult rv = new SCresult();

        Map<ObjectURL, VoPoPair> zURLsToSaved = new HashMap<ObjectURL, VoPoPair>();

        Set<ViewObject> zMembers = ValidateTransactionSet( pTransactionSet );
        if ( !zMembers.isEmpty() )
        {
            Transaction zTransaction = DataStoreLocator.get().getUnfilteredFinder().createUnaugmentedTransaction();

            try
            {
                prepopulateTransaction( zTransaction, zMembers );
                for ( ViewObject<?> zMember : zMembers )
                {
                    if ( zMember instanceof Precommitable )
                    {
                        ((Precommitable) zMember).aboutToCommit();
                    }
                    PersistentObject zPO = getAndUpdatePO( zTransaction, zMember, //
                                                           mVOMetaData.getObjectName().equals( zMember.getObjectName() ) ? //
                                                           this : getNotUsDataProvider( zMember ) );
                    zURLsToSaved.put( zMember.getObjectURL(), new VoPoPair( zMember, zPO ) );
                }
                commit( zTransaction );
            }
            catch ( ConcurrentPOModificationException e )
            {
                return VOSC.result( e.getMessage() );
            }

            for ( ViewObject<?> zVO : zMembers )
            {
                committedVO( zVO, zURLsToSaved.get( zVO.getObjectURL() ) );
            }

            pTransactionSet.clear();
        }
        ArrayList<T> zRequestedBack = new ArrayList<T>();
        if ( pReturnOnSuccess != null )
        {
            for ( ObjectURL zObjectURL : pReturnOnSuccess )
            {
                zRequestedBack.add( createViewForCommitReturn( false, zURLsToSaved.get( zObjectURL ) ) );
            }
        }

        return rv.setSCresponse( new VOSCresponseRows( new ImmutableArrayList<T>( zRequestedBack ) ) );
    }

    protected void commit( Transaction pTransaction )
    {
        pTransaction.commit();
    }

    @SuppressWarnings({"unchecked"})
    private PersistentObject getAndUpdatePO( Transaction pTransaction, ViewObject<?> zMember, PoServerVoDataProvider pDataProvider )
    {
        return pDataProvider.getAndUpdatePO( pTransaction, zMember );
    }

    private void prepopulateTransaction( Transaction pTransaction, Collection<ViewObject> pMembers )
    {
        List<ViewObject> zNotUs = new ArrayList<ViewObject>();
        List<Object> zOurKeys = new ArrayList<Object>();

        for ( ViewObject zMember : pMembers )
        {
            if ( !zMember.isNew() )
            {
                if ( mVOMetaData.getObjectName().equals( zMember.getObjectName() ) )
                {
                    zOurKeys.add( zMember.getID() );
                }
                else
                {
                    zNotUs.add( zMember );
                }
            }
        }
        if ( !zOurKeys.isEmpty() )
        {
            pTransaction.findAll( mPOMetaData.getPOregistrationName(), WCF.isAnyFrom( mPrimaryKeyASCD, zOurKeys ) );
        }
        if ( !zNotUs.isEmpty() )
        {
            getNotUsDataProvider( zNotUs.get( 0 ) ).prepopulateTransaction( pTransaction, zNotUs );
        }
    }

    @SuppressWarnings({"unchecked", "UnusedDeclaration"})
    protected <VoType extends IViewObject> PoServerVoDataProvider<VoType> getNotUsDataProvider( Class<VoType> pViewObjectClass )
    {
        return (PoServerVoDataProvider<VoType>) getNotUsDataProvider( pViewObjectClass.getName() );
    }

    protected PoServerVoDataProvider getNotUsDataProvider( ViewObject pViewObject )
    {
        return getNotUsDataProvider( pViewObject.getClass().getName() );
    }

    private PoServerVoDataProvider getNotUsDataProvider( String pObjectName )
    {
        ServerVoDataProvider<IViewObject> zDataProvider = getServerVoDataProviderMap().get( pObjectName );
        if ( !(zDataProvider instanceof PoServerVoDataProvider) )
        {
            throw new PersistenceException( "TransactionSet contained a VO '" + pObjectName + "' not currently supported by a PoServerVoDataProvider" );
        }
        return (PoServerVoDataProvider) zDataProvider;
    }

    protected Set<ViewObject> ValidateTransactionSet( TransactionSet pTransactionSet )
    {
        Set<ViewObject> zMembers = pTransactionSet.getAllMembers();

        for ( ViewObject zMember : zMembers )
        {
            if ( validateMember( zMember ) )
            {
                return zMembers;
            }
        }
        throw new PersistenceException( "Base View: " + mVOMetaData.getObjectName() + " not in TransactionSet" );
    }

    protected boolean validateMember( ViewObject pMember )
    {
        return pMember.getObjectName().equals( mVOMetaData.getObjectName() );
    }

    protected T createViewForCommitReturn( boolean pOnlyQueryAttributes, VoPoPair pVoPoPair )
    {
        if ( pVoPoPair != null )
        {
            if ( validateMember( pVoPoPair.getVO() ) )
            {
                return createView( pVoPoPair.getPO(), pOnlyQueryAttributes );
            }
        }
        return null;
    }

    private void committedVO( ViewObject<?> pVO, VoPoPair pVoPoPair )
    {
        pVO.committed( getID( pVoPoPair ) );
    }

    private Object getID( VoPoPair pVoPoPair )
    {
        return (pVoPoPair != null) ? TypeConverter.to_Long( getAttributeValue( pVoPoPair.getPO(), VO_ID_ATTRIBUTE_NAME ) ) : null;
    }

    protected static class POrecordVersion
    {
        public static final POrecordVersion INSTANCE = new POrecordVersion();

        public Long get( PersistentObject pPO )
        {
            return null;
        }
    }

    private static class POrecordVersionImpl extends POrecordVersion
    {
        private String mRecordVersionAttributeName;

        private POrecordVersionImpl( String pRecordVersionAttributeName )
        {
            mRecordVersionAttributeName = pRecordVersionAttributeName;
        }

        @Override
        public Long get( PersistentObject pPO )
        {
            return TypeConverter.to_Long( pPO.getAttributeValue( mRecordVersionAttributeName ) );
        }
    }

    @Override
    public String toString()
    {
        return " (" + getClass().getSimpleName() + ": " + mVOMetaData.getObjectName() + " <-> " + mPOMetaData.getIdentifierName() + ")";
    }

    protected static class VoPoPair
    {
        private ViewObject<?> mVO;
        private PersistentObject mPO;

        public VoPoPair( ViewObject<?> pVO, PersistentObject pPO )
        {
            mVO = pVO;
            mPO = pPO;
        }

        public ViewObject<?> getVO()
        {
            return mVO;
        }

        public PersistentObject getPO()
        {
            return mPO;
        }
    }
}