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

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

import org.litesoft.core.typeutils.*;
import org.litesoft.util.*;

public class TempDirImageAccessor implements ImageAccessor
{
    public static final Integer ZERO = 0;

    private URLconstructor mURLconstructor;
    private File mExistingImage;
    private FileNameParts mParts;

    private TempDirImageAccessor( URLconstructor pURLconstructor, File pExistingImage, FileNameParts pParts )
    {
        Objects.assertNotNull( "URLconstructor", mURLconstructor = pURLconstructor );
        mExistingImage = pExistingImage;
        mParts = pParts;
    }

    public TempDirImageAccessor( URLconstructor pURLconstructor, File pExistingImage )
    {
        this( pURLconstructor, pExistingImage, FileNameParts.createFromFileName( pExistingImage.getName() ) );
    }

    public TempDirImageAccessor( URLconstructor pURLconstructor, //
                                 String pPrefix, String pExtraInfo, //
                                 int pImageWidth, int pImageHeight, //
                                 String pImageEncoding )
    {
        this( pURLconstructor, null, new FileNameParts( pPrefix, pExtraInfo, //
                                                        pImageWidth, pImageHeight, //
                                                        pImageEncoding ) );
    }

    public static void deleteByOpaqueStoredImageKey( String pOpaqueStoredImageKey )
    {
        File zFile = new File( tempDirectory(), pOpaqueStoredImageKey );
        zFile.delete();
    }

    public String getURL()
    {
        return mURLconstructor.createURL( mParts );
    }

    public String getOpaqueStoredImageKey()
            throws IllegalStateException
    {
        if ( !isReadable() )
        {
            throw new IllegalStateException( "Image Not Readable" );
        }
        return mExistingImage.getName();
    }

    public boolean isReadable()
    {
        return (mExistingImage != null);
    }

    public boolean isWritable()
    {
        return (mExistingImage == null);
    }

    /**
     * @return Whatever was set (null possible)
     */
    public String getPrefix()
    {
        return mParts.getPrefix();
    }

    /**
     * @return Whatever was set (null possible)
     */
    public String getImageEncoding()
    {
        return mParts.getImageEncoding();
    }

    /**
     * @return Actual Size or 0 if not readable
     */
    public int getImageSizeInBytes()
    {
        return (mExistingImage == null) ? 0 : (int) mExistingImage.length();
    }

    /**
     * @return Actual Width or 0 if not set (or set to 0)
     */
    public int getImageWidth()
    {
        return Objects.deNull( mParts.getImageWidth(), ZERO );
    }

    /**
     * @return Actual Height or 0 if not set (or set to 0)
     */
    public int getImageHeight()
    {
        return Objects.deNull( mParts.getImageHeight(), ZERO );
    }

    /**
     * @return !null
     *
     * @throws IllegalStateException    - if not Readable
     * @throws MissingResourceException - if resource not found
     * @throws IOException              - any other IOException
     */
    public InputStream readOpen()
            throws IllegalStateException, MissingResourceException, IOException
    {
        if ( !isReadable() )
        {
            throw new IllegalStateException( "Not Readable: No Image written" );
        }
        try
        {
            return new FileInputStream( mExistingImage );
        }
        catch ( FileNotFoundException e )
        {
            MissingResourceException zException = new MissingResourceException( e.getMessage(),
                                                                                TempDirImageAccessor.class.getName(),
                                                                                "Not Found" );
            zException.initCause( e );
            throw zException;
        }
    }

    /**
     * @return !null
     *
     * @throws UnsupportedOperationException - if not Writable (ie already written)
     * @throws IllegalStateException         - if something required for writing is missing
     * @throws IOException                   - any other IOException
     */
    public OutputStream writeOpen()
            throws UnsupportedOperationException, IllegalStateException, IOException
    {
        if ( !isWritable() )
        {
            throw new UnsupportedOperationException( "Not Writable" );
        }
        File zFile = mParts.createFileAt( tempDirectory() );
        zFile.deleteOnExit();
        return new MyOutputStream( zFile );
    }

    public static TempDirImageAccessor findBy( URLconstructor pURLconstructor, //
                                               String pPrefix, String pExtraInfo, String pUniquingPortion )
    {
        final String zFileNamePrefix = new FileNameParts( pPrefix, pExtraInfo ).createFileNamePrefix();
        final String zUniquePortionMustBeInFileName =
                FileNameParts.delineateUniquingPortion( pUniquingPortion );

        File[] zFiles = tempDirectory().listFiles( new FilenameFilter()
        {
            public boolean accept( File dir, String name )
            {
                return name.startsWith( zFileNamePrefix ) && name.contains( zUniquePortionMustBeInFileName );
            }
        } );
        if ( Utils.isNullOrEmpty( zFiles ) )
        {
            return null;
        }
        if ( zFiles.length > 1 )
        {
            throw new IllegalStateException( "Multiple Files found starting w/ '" + zFileNamePrefix +
                                             "', and containing '" + zUniquePortionMustBeInFileName + "'" );
        }
        return new TempDirImageAccessor( pURLconstructor, zFiles[0] );
    }

    private static File tempDirectory()
    {
        return new File( Utils.tempDirectory() );
    }

    private class MyOutputStream extends OutputStream
    {
        private File mFile;
        private OutputStream mOS;
        private int mSizeInBytes = 0;

        public MyOutputStream( File pFile )
                throws FileNotFoundException
        {
            mFile = pFile;
            mOS = new BufferedOutputStream( new FileOutputStream( pFile ) );
        }

        public void write( int b )
                throws IOException
        {
            if ( ++mSizeInBytes < 0 )
            {
                throw new IOException( "Image is too large for Web Content." );
            }
            try
            {
                mOS.write( b );
            }
            catch ( IOException e )
            {
                cleanUp();
                throw e;
            }
        }

        public void flush()
                throws IOException
        {
            try
            {
                if ( mOS != null )
                {
                    mOS.flush();
                }
            }
            catch ( IOException e )
            {
                cleanUp();
                throw e;
            }
        }

        public void close()
                throws IOException
        {
            try
            {
                if ( mOS != null )
                {
                    OutputStream zOS = mOS;
                    mOS = null;
                    zOS.close();
                }
            }
            catch ( IOException e )
            {
                cleanUp();
                throw e;
            }

            mExistingImage = mFile;
        }

        private void cleanUp()
        {
            Utils.dispose( mOS );
            mOS = null;
            try
            {
                if ( mFile != null )
                {
                    mFile.delete();
                }
            }
            catch ( Exception e )
            {
                // Whatever
            }
            mFile = null;
        }
    }
}