package org.litesoft.filesinksource;

import org.litesoft.util.*;

import java.io.*;

public abstract class FileSinkAndSourceFactory
{
    public final FileSink createFileSink( String pName )
            throws IOException
    {
        if ( (pName.indexOf( '\\' ) != -1) || (pName.indexOf( '/' ) != -1) )
        {
            throw new IllegalArgumentException( "Invalid File Name, found Path Sep in: " + pName );
        }
        return LLcreateFileSink( pName );
    }

    protected abstract FileSink LLcreateFileSink( String pName )
            throws IOException;

    public abstract FileSource createFileSource( String pOpaqueHandle )
            throws IOException;

    private static FileSinkAndSourceFactory sInstance = Null.INSTANCE;

    public static FileSinkAndSourceFactory getInstance()
    {
        return sInstance;
    }

    public static void setInstance( FileSinkAndSourceFactory pInstance )
    {
        sInstance = (pInstance != null) ? pInstance : Null.INSTANCE;
    }

    public static class Null extends FileSinkAndSourceFactory
    {
        public static final FileSinkAndSourceFactory INSTANCE = new Null();

        private Null()
        {
        }

        @Override
        protected FileSink LLcreateFileSink( String pName )
                throws IOException
        {
            throw new RuntimeException( "Null" );
        }

        @Override
        public FileSource createFileSource( String pOpaqueHandle )
                throws IOException
        {
            throw new RuntimeException( "Null" );
        }
    }

    protected static abstract class AbstractFileSink implements FileSink
    {
        protected final String mDesiredFileName;

        protected AbstractFileSink( String pDesiredFileName )
        {
            mDesiredFileName = Utils.assertNotNullNotEmpty( "DesiredFileName", pDesiredFileName );
        }
    }

    protected static abstract class AbstractFileSource implements FileSource
    {
        protected final String mOpaqueHandle;

        protected AbstractFileSource( String pOpaqueHandle )
        {
            mOpaqueHandle = Utils.assertNotNullNotEmpty( "OpaqueHandle", pOpaqueHandle );
        }
    }

    protected static abstract class AbstractFileSourceInfo implements FileSourceInfo
    {
        private final String mDesiredFileName;

        protected AbstractFileSourceInfo( String pDesiredFileName )
        {
            mDesiredFileName = Utils.assertNotNullNotEmpty( "DesiredFileName", pDesiredFileName );
        }

        public String getName()
        {
            return mDesiredFileName;
        }

        public InputStream getInputStream()
                throws IOException
        {
            return null;
        }
    }

    protected static abstract class AbstractOpaqueHandle
    {
        protected final String mDesiredFileName;

        protected AbstractOpaqueHandle( String pDesiredFileName )
        {
            mDesiredFileName = Utils.assertNotNullNotEmpty( "DesiredFileName", pDesiredFileName );
        }

        public String getDesiredFileName()
        {
            return mDesiredFileName;
        }

        protected String toString( String pHandlePrefix, String pOpaquePart )
        {
            return pHandlePrefix + encode( pOpaquePart ) + "/" + mDesiredFileName;
        }

        /**
         * @return String pair - 1st = OpaquePart, 2nd = DesiredFileName
         */
        protected static String[] parse( String pHandlePrefix, String pOpaqueHandleToString )
        {
            if ( pOpaqueHandleToString.startsWith( pHandlePrefix ) )
            {
                String zRest = pOpaqueHandleToString.substring( pHandlePrefix.length() );
                int slashAt = zRest.lastIndexOf( '/' );
                if ( slashAt != -1 )
                {
                    String zOpaquePart = Utils.noEmpty( decode( zRest.substring( 0, slashAt ).trim() ) );
                    String zDesiredFileName = Utils.noEmpty( zRest.substring( slashAt + 1 ) );
                    if ( (zOpaquePart != null) && (zDesiredFileName != null) )
                    {
                        return new String[]{zOpaquePart, zDesiredFileName};
                    }
                }
            }
            return null;
        }

        private static String encode( String pRegularString )
        {
            byte[] zBytes;
            try
            {
                zBytes = pRegularString.getBytes( FileUtils.UTF_8 );
            }
            catch ( UnsupportedEncodingException e )
            {
                throw new RuntimeException( e );
            }
            return Utils.toHex( zBytes );
        }

        private static String decode( String pEncodedString )
        {
            byte[] zBytes = Utils.fromHex( pEncodedString );
            try
            {
                return new String( zBytes, FileUtils.UTF_8 );
            }
            catch ( UnsupportedEncodingException e )
            {
                throw new RuntimeException( e );
            }
        }
    }
}