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

import java.io.*;
import java.util.*;

import org.litesoft.orsup.base.*;
import org.litesoft.orsup.lazyload.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.util.*;

public class BlobHandler<Owner extends PersistentObjectImpl> extends AbstractLazyLoadToOne<Owner, Blob> implements SizeableStreamAccessor
{
    protected AttributeAccessorSCDtoBlob<Owner> mSCDtoOne;

    public BlobHandler( Owner pOwner, AttributeAccessorSCDtoBlob<Owner> pSCDtoOne )
    {
        super( pOwner, pSCDtoOne );
        mSCDtoOne = pSCDtoOne;
    }

    @Override
    public final AttributeAccessorSCDtoBlob<Owner> getSCDtoOne()
    {
        return mSCDtoOne;
    }

    @SuppressWarnings({"unchecked"})
    private Blob getBlob()
    {
        return mOwner.processLazyLoadAccess( this );
    }

    @SuppressWarnings({"unchecked"})
    private Blob createNewBlob()
    {
        Blob zBlob = new Blob( mOwner.getTransaction() );
        setBlob( zBlob );
        return zBlob;
    }

    @SuppressWarnings({"unchecked"})
    public void setBlob( Blob pBlob )
    {
        mOwner.processLazyLoadMutation( this, pBlob );
    }

    /**
     * @param pNewThem !null
     */
    public final Object extract_db_value( Blob pNewThem )
    {
        return LL_extract_db_value( pNewThem, null );
    }

    /**
     * @param pDBValue !null
     */
    @Override
    protected final PersistentObject<?> LL_loadValueWithNonNull( Object pDBValue )
    {
        //noinspection unchecked
        return mOwner.getFinder().findOne( Blob.class, new UniqueKeySingle( Blob.CD_ID, pDBValue ) );
    }

    @Override
    protected String getBackRefOnUnWire( String pBackRefAttributeNameOnNewThem )
    {
        return null;
    }

    /**
     * @param pNewThem !null
     */
    @Override
    protected final Object LL_extract_db_value( PersistentObjectImpl pNewThem, String pBackRefAttributeNameOnNewThem )
    {
        return pNewThem.getAttributeValue( Blob.CD_ID.getName() );
    }

    // SizeableStreamAccessor

    /**
     * @return Actual Size or -1 if not readable
     */
    @Override
    public long getSizeInBytes()
    {
        return isReadable() ? getBlob().getSizeInBytes() : -1;
    }

    @Override
    public boolean isReadable()
    {
        Blob zBlob = getBlob();
        return (zBlob != null) && zBlob.isReadable();
    }

    @Override
    public boolean isWritable()
    {
        if ( mOwner.getTransaction() != null )
        {
            Blob zBlob = getBlob();
            if ( (zBlob == null) || !zBlob.isStreamOpen() )
            {
                return true;
            }
        }
        return false;
    }

    /**
     * @return !null
     *
     * @throws IllegalStateException    - if not Readable
     * @throws MissingResourceException - if resource not found
     * @throws IOException              - any other IOException
     */
    @Override
    public InputStream readOpen()
            throws IllegalStateException, MissingResourceException, IOException
    {
        Blob zBlob = getBlob();
        if ( zBlob == null )
        {
            throw new IllegalStateException( "Not Readable: No Data ever written" );
        }
        return zBlob.readOpen();
    }

    /**
     * @return !null
     *
     * @throws UnsupportedOperationException - if not Writable (ie already written)
     * @throws IllegalStateException         - if something required for writing is missing
     * @throws IOException                   - any other IOException
     */
    @Override
    public OutputStream writeOpen()
            throws UnsupportedOperationException, IllegalStateException, IOException
    {
        if ( mOwner.getTransaction() == null )
        {
            throw new UnsupportedOperationException( "Not in a transaction" );
        }
        Blob zBlob = getBlob();
        if ( (zBlob != null) && zBlob.isStreamOpen() )
        {
            throw new UnsupportedOperationException( "Already Writing" );
        }
        return createNewBlob().writeOpen();
    }
}