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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.server.file.*;
import org.litesoft.util.*;

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

public class TempDirImageAccessor implements ImageAccessor {
    private URLconstructor mURLconstructor;
    private File mExistingImage;
    private FileNameParts mParts;

    private TempDirImageAccessor( URLconstructor pURLconstructor, File pExistingImage, FileNameParts pParts ) {
        Confirm.isNotNull( "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();
    }

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

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

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

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

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

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

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

    /**
     * @return Actual Width or 0 if not set (or set to 0)
     */
    @Override
    public int getImageWidth() {
        return ConstrainTo.notNull( mParts.getImageWidth() );
    }

    /**
     * @return Actual Height or 0 if not set (or set to 0)
     */
    @Override
    public int getImageHeight() {
        return ConstrainTo.notNull( mParts.getImageHeight() );
    }

    /**
     * @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 ( !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
     */
    @Override
    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() {
            @Override
            public boolean accept( File dir, String name ) {
                return name.startsWith( zFileNamePrefix ) && name.contains( zUniquePortionMustBeInFileName );
            }
        } );
        if ( Currently.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( Directories.temp() );
    }

    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 ) );
        }

        @Override
        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;
            }
        }

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

        @Override
        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;
        }
    }
}