package org.litesoft.filesinksource;

import org.litesoft.util.*;

import java.io.*;

public class FileSystemFileSinkAndSourceFactory extends FileSinkAndSourceFactory
{
    public static final String HANDLE_PREFIX = "F@";

    private String mDirectoryPath;

    public FileSystemFileSinkAndSourceFactory( String pDirectoryPath )
    {
        mDirectoryPath = pDirectoryPath.replace( '\\', '/' );
    }

    @Override
    protected FileSink LLcreateFileSink( String pName )
            throws IOException
    {
        return new OurFileSink( mDirectoryPath, pName );
    }

    @Override
    public FileSource createFileSource( String pOpaqueHandle )
            throws IOException
    {
        return new OurFileSource( mDirectoryPath, pOpaqueHandle );
    }

    private static class OurFileSink extends AbstractFileSink
    {
        private String mDirectoryPath;

        private OurFileSink( String pDirectoryPath, String pDesiredFileName )
        {
            super( pDesiredFileName );
            mDirectoryPath = pDirectoryPath;
        }

        public String put( InputStream pInputStream ) throws IOException
        {
            final File zFile = getAvailableName( pInputStream ); // Will close pInputStream if problem
            Utils.copy( pInputStream, new OutputStreamFactory() // closes pInputStream 
            {
                public OutputStream createOutputStream()
                        throws IOException
                {
                    return new FileOutputStream( zFile );
                }
            } );
            return new OpaqueHandle( mDirectoryPath, zFile.getName(), mDesiredFileName ).toString();
        }

        /**
         * Note: Closes pInputStream if Exception
         */
        private File getAvailableName( InputStream pInputStream )
                throws IOException
        {
            try
            {
                File zFile = getAvailableName( "" );
                for ( int i = 2; zFile == null; i++ )
                {
                    zFile = getAvailableName( "-" + i );
                }
                return zFile;
            }
            catch ( IOException e )
            {
                Utils.dispose( pInputStream );
                throw e;
            }
            catch ( RuntimeException e )
            {
                Utils.dispose( pInputStream );
                throw e;
            }
        }

        private File getAvailableName( String pSuffix )
                throws IOException
        {
            File zFile = new File( mDirectoryPath, mDesiredFileName + pSuffix );
            return zFile.createNewFile() ? zFile : null;
        }
    }

    private static class OurFileSource extends AbstractFileSource
    {
        private String mDirectoryPath;

        private OurFileSource( String pDirectoryPath, String pOpaqueHandle )
        {
            super( pOpaqueHandle );
            mDirectoryPath = pDirectoryPath;
        }

        public FileSourceInfo get() throws IOException
        {
            OpaqueHandle zHandle = OpaqueHandle.parse( mOpaqueHandle );
            if ( (zHandle != null) && mDirectoryPath.equals( zHandle.getDirectoryPath() ) )
            {
                File zFile = new File( mDirectoryPath, zHandle.getLocalName() );
                if ( zFile.isFile() )
                {
                    return new OurFileSourceInfo( zFile, zHandle.getDesiredFileName() );
                }
                throw new FileNotFoundException( mOpaqueHandle + ": " + zFile );
            }
            throw new IllegalArgumentException( "OpaqueHandle? '" + mOpaqueHandle + "'" );
        }
    }

    private static class OurFileSourceInfo extends AbstractFileSourceInfo
    {
        private File mFile;

        private OurFileSourceInfo( File pFile, String pDesiredFileName )
        {
            super( pDesiredFileName );
            mFile = pFile;
        }

        public long getSize()
        {
            return mFile.length();
        }

        @Override
        public InputStream getInputStream()
                throws IOException
        {
            return new FileInputStream( mFile );
        }
    }

    private static class OpaqueHandle extends AbstractOpaqueHandle
    {
        public static OpaqueHandle parse( String pOpaqueHandleToString )
        {
            String[] zParts = parse( HANDLE_PREFIX, pOpaqueHandleToString );
            return (zParts != null) ? parseOpaquePart( zParts[0], zParts[1] ) : null;
        }

        private static OpaqueHandle parseOpaquePart( String pOpaquePart, String pDesiredFileName )
        {
            int slashAt = pOpaquePart.lastIndexOf( '/' );
            if ( slashAt != -1 )
            {
                String zDirectoryPath = pOpaquePart.substring( 0, slashAt ).trim();
                String zLocalName = Utils.noEmpty( pOpaquePart.substring( slashAt + 1 ) );
                if ( zLocalName != null )
                {
                    return new OpaqueHandle( zDirectoryPath, zLocalName, pDesiredFileName );
                }
            }
            return null;
        }

        @Override
        public String toString()
        {
            return toString( HANDLE_PREFIX, mDirectoryPath + "/" + mLocalName );
        }

        private String mDirectoryPath, mLocalName;

        public OpaqueHandle( String pDirectoryPath, String pLocalName, String pDesiredFileName )
        {
            super( pDesiredFileName );
            mDirectoryPath = pDirectoryPath;
            mLocalName = pLocalName;
        }

        public String getDirectoryPath()
        {
            return mDirectoryPath;
        }

        public String getLocalName()
        {
            return mLocalName;
        }
    }
}