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

import java.io.*;
import java.sql.*;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.core.util.*;
import org.litesoft.db.*;
import org.litesoft.logger.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.util.*;

public class Blob extends PersistentObjectImpl<Blob> implements SizeableStreamAccessor
{
    private static final Logger LOGGER = LoggerFactory.getLogger( Blob.class );

    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

    public static SimpleFromIdentifier from()
    {
        return MyMetaData.INSTANCE;
    }

    public Blob( Transaction pTransaction ) // Only used for New
    {
        super( MyMetaData.INSTANCE, pTransaction );
        mID = getNextSequenceNumber( getClass() );
        registerWithTransaction();
    }

    public Blob( ConstructionControl pConstructionControl )
    {
        super( MyMetaData.INSTANCE, CONSTRUCTION_CONTROL, pConstructionControl );
    }

    @Override
    protected void transactionDisposed()
    {
        if ( isStreamOpen() )
        {
            closeStream();
        }
        if ( isNew() && hasParts() )
        {
            removeParts( null );
        }
        super.transactionDisposed();
    }

    @Override
    public Serializable aboutToCommit( Timestamp pTransactionTimestamp )
    {
        if ( isStreamOpen() )
        {
            throw new IllegalStateException( "Blob Stream Not Closed" );
        }
        if ( !isDeleteRequested() && (getSizeInBytes() < 0) )
        {
            throw new IllegalStateException( "Blob with No Data" );
        }
        return super.aboutToCommit( pTransactionTimestamp );
    }

    @Override
    protected void justDeletedInTransaction( DBconnection pDBconnection )
    {
        if ( hasParts() )
        {
            removeParts( pDBconnection );
        }
        super.justDeletedInTransaction( pDBconnection );
    }

    public static final AttributeAccessorSCD CD_ID = new Blob.AttributeAccessor_ID();

    private Long mID = null;

    public Long getID()
    {
        return mID;
    }

    protected void LLsetID( Long pID )
    {
        verifyMutability( CD_ID, mID, pID );
        mID = pID;
    }

    private static class AttributeAccessor_ID extends AttributeAccessorSCDsimplePersistedReadOnly<Blob>
    {
        public AttributeAccessor_ID()
        {
            super( "ID", "id", true, _Long );
        }

        @Override
        public Object getValueOnPO( Blob pPO )
        {
            return pPO.getID();
        }

        @Override
        public void db_setValueOnPO( Blob pPO, Object pValue )
        {
            pPO.LLsetID( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_SizeInBytes = new AttributeAccessor_SizeInBytes();

    private Long mSizeInBytes;

    /**
     * From: SizeableStreamAccessor
     *
     * @return Actual Size or -1 if not readable
     */
    @Override
    public long getSizeInBytes()
    {
        return (mSizeInBytes == null) ? -1 : mSizeInBytes;
    }

    private void LLsetSizeInBytes( long pSizeInBytes )
    {
        verifyMutability( CD_SizeInBytes, mSizeInBytes, pSizeInBytes );
        mSizeInBytes = pSizeInBytes;
    }

    private void addBytes( int pBytesAdded )
    {
        mSizeInBytes = (mSizeInBytes == null) ? (long) pBytesAdded : mSizeInBytes + pBytesAdded;
    }

    private static class AttributeAccessor_SizeInBytes extends AttributeAccessorSCDsimplePersistedReadOnly<Blob>
    {
        public AttributeAccessor_SizeInBytes()
        {
            super( "SizeInBytes", "SizeInBytes", true, _Long );
        }

        @Override
        public Object getValueOnPO( Blob pPO )
        {
            return pPO.getSizeInBytes();
        }

        @Override
        public void db_setValueOnPO( Blob pPO, Object pValue )
        {
            pPO.LLsetSizeInBytes( to_long( pValue ) );
        }
    }

    public static class MyMetaData extends PersistentObjectImplMetaData<Blob>
    {
        public static final String OBJECT_NAME = "Blob";
        public static final String TABLE_NAME = "Blob";
        public static final MyMetaData INSTANCE = new MyMetaData();

        private MyMetaData()
        {
            super( MyMetaData.OBJECT_NAME, MyMetaData.TABLE_NAME, //
                   new AttributeAccessorKeySet( CD_ID ), //
                   CD_ID, CD_SizeInBytes );
        }

        @Override
        public Class getPOclass()
        {
            return Blob.class;
        }

        @Override
        public Blob createNew( Transaction pTransaction )
        {
            return new Blob( pTransaction );
        }

        @Override
        public Blob createPOfromFinder()
        {
            return new Blob( CONSTRUCTION_CONTROL );
        }

        @Override
        public String getDisplayValueFormat()
        {
            return "${ID}";
        }
    }

    protected boolean hasParts()
    {
        return (getSizeInBytes() > 0);
    }

    protected void closeStream()
    {
        if ( isStreamOpen() )
        {
            Exception ex;
            try
            {
                mStream.close();
                return;
            }
            catch ( RuntimeException e )
            {
                ex = e;
            }
            catch ( IOException e )
            {
                ex = e;
            }
            LOGGER.error.log( ex, "Blob.closeStream()" );
        }
    }

    protected boolean isStreamOpen()
    {
        return (mStream != null);
    }

    protected void removeParts( DBconnection pDBconnection )
    {
        WhereClause wc = WhereClauseFactory.INSTANCE.isEqual( Parts4Blobs.CD_BlobID, getID() );
        getFinder().getPersistenceHelper().deleteRows( pDBconnection, Parts4Blobs.MyMetaData.INSTANCE, wc );
    }

    @Override
    public boolean isReadable()
    {
        return (getSizeInBytes() >= 0) && !isStreamOpen();
    }

    @Override
    public boolean isWritable()
    {
        return (getSizeInBytes() < 0) && !isStreamOpen() && isNew();
    }

    /**
     * @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
    {
        if ( getSizeInBytes() < 0 )
        {
            throw new IllegalStateException( "Not Readable: No Data written" );
        }
        if ( isStreamOpen() )
        {
            throw new IllegalStateException( "Already Reading" );
        }
        InputStream zStream = (getSizeInBytes() == 0) ? new NoPartsInputStream() : new PartsInputStream();
        mStream = zStream;
        return zStream;
    }

    /**
     * @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 ( getSizeInBytes() >= 0 )
        {
            throw new UnsupportedOperationException( "Already Written" );
        }
        if ( isStreamOpen() )
        {
            throw new UnsupportedOperationException( "Already Writing" );
        }
        if ( !isNew() )
        {
            throw new IllegalStateException( "Not New!" );
        }
        OutputStream zStream = new PartsOutputStream();
        mStream = zStream;
        return zStream;
    }

    private Closeable mStream = null;

    private class NoPartsInputStream extends InputStream
    {
        @Override
        public int read()
                throws IOException
        {
            return -1;
        }

        @Override
        public void close()
                throws IOException
        {
            mStream = null;
            super.close();
        }
    }

    private static byte[] fromHex( String pHex )
    {
        String zHex = Strings.noEmpty( pHex );
        int bLen = zHex.length() / 2;
        if ( (bLen == 0) || ((bLen + bLen) != zHex.length()) )
        {
            throw new RuntimeException( "decode bad length: " + zHex.length() );
        }
        byte[] zBytes = new byte[bLen];
        int from = 0;
        for ( int i = 0; i < bLen; i++ )
        {
            int zByte = Hex.fromCharChecked( zHex.charAt( from++ ) ) << 4;
            zByte += Hex.fromCharChecked( zHex.charAt( from++ ) );
            zBytes[i] = (byte) zByte;
        }
        return zBytes;
    }

    private static String toHex( byte[] pBytes, int pOffset, int pCount )
    {
        StringBuilder sb = new StringBuilder( pCount + pCount );
        while ( pCount-- > 0 )
        {
            int zByte = (pBytes[pOffset++] & 0xFF);
            sb.append( Hex.toChar( zByte >> 4 ) );
            sb.append( Hex.toChar( zByte ) );
        }
        return sb.toString();
    }

    private class PartsInputStream extends InputStream
    {
        private POQueryIterator<Parts4Blobs> mIterator;
        private byte[] mBuffer = new byte[0];
        private int mNextReadOffset = 0;

        private int bufRead()
        {
            return (mBuffer[mNextReadOffset++] & 0xFF);
        }

        public PartsInputStream()
                throws IOException
        {
            WhereClause wc = WhereClauseFactory.INSTANCE.isEqual( Parts4Blobs.CD_BlobID, getID() );
            OrderBy zOrderBy = new OrderBy( Parts4Blobs.CD_Ordinal );
            try
            {
                mIterator = getNonTransactionalFinder().findAllCursored( Parts4Blobs.class, wc, zOrderBy );
            }
            catch ( RuntimeException e )
            {
                IOException zException = new IOException();
                zException.initCause( e );
                throw zException;
            }
        }

        @Override
        public int read()
                throws IOException
        {
            if ( mNextReadOffset < mBuffer.length )
            {
                return bufRead();
            }
            if ( mIterator != null )
            {
                try
                {
                    if ( mIterator.hasNext() )
                    {
                        String zHexed2kPart = mIterator.next().getHexed2kPart();
                        mBuffer = fromHex( zHexed2kPart );
                        mNextReadOffset = 0;
                        return bufRead();
                    }
                }
                catch ( RuntimeException e )
                {
                    releaseIterator();
                    IOException zException = new IOException();
                    zException.initCause( e );
                    throw zException;
                }
                releaseIterator();
            }
            return -1;
        }

        @Override
        public void close()
                throws IOException
        {
            releaseIterator();
            mStream = null;
            super.close();
        }

        private void releaseIterator()
        {
            if ( mIterator != null )
            {
                mIterator.releaseResources();
                mIterator = null;
            }
        }

        @Override
        protected void finalize()
                throws Throwable
        {
            releaseIterator();
            super.finalize();
        }
    }

    private class PartsOutputStream extends OutputStream
    {
        private static final int BUFFER_PER_TRANSACTION = 16 * 1024;

        private byte[] mBuffer = new byte[BUFFER_PER_TRANSACTION];
        private int mNextWriteOffset = 0;
        private int mNextOridinal = 0;

        private void bufWrite( int pByte )
        {
            mBuffer[mNextWriteOffset++] = (byte) pByte;
        }

        private void newBuffer()
        {
            mNextWriteOffset = 0;
        }

        @Override
        public void write( int b )
                throws IOException
        {
            if ( mNextWriteOffset >= mBuffer.length )
            {
                flush();
                newBuffer();
            }
            bufWrite( b );
        }

        @Override
        public void flush()
                throws IOException
        {
            if ( mNextWriteOffset != 0 )
            {
                Transaction zTrans = getFinder().createTransaction();
                int zReadOffset = 0;
                while ( (zReadOffset + Parts4Blobs.MAX_BYTES_PER_PART) <= mNextWriteOffset )
                {
                    new Parts4Blobs( zTrans, getID(), mNextOridinal++, //
                                     toHex( mBuffer, zReadOffset, Parts4Blobs.MAX_BYTES_PER_PART ) );
                    zReadOffset += Parts4Blobs.MAX_BYTES_PER_PART;
                }
                if ( zReadOffset < mNextWriteOffset )
                {
                    new Parts4Blobs( zTrans, getID(), mNextOridinal++, //
                                     toHex( mBuffer, zReadOffset, mNextWriteOffset - zReadOffset ) );
                }
                int zBytesAdded = mNextWriteOffset;
                newBuffer();
                try
                {
                    zTrans.commit();
                }
                catch ( RuntimeException e )
                {
                    IOException zException = new IOException();
                    zException.initCause( e );
                    throw zException;
                }
                addBytes( zBytesAdded );
            }
        }

        @Override
        public void close()
                throws IOException
        {
            if ( mBuffer != null )
            {
                mBuffer = null;
                mStream = null;
            }
            super.close();
        }
    }
}