package org.litesoft.textfiledirectory;

import org.litesoft.commonfoundation.annotations.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;

import org.litesoft.commonfoundation.typeutils.Objects;
import java.util.*;

public class TextFileDirectoryMemory extends AbstractTextFileDirectory
{
    public static final String DEFAULT_DIRECTORY = "TheOne";

    private final Map<String, TextFile> mFiles = new HashMap<String, TextFile>();
    private final String mDirectory;
    private boolean mExists;

    public TextFileDirectoryMemory( String pDirectory, boolean pExists )
    {
        mDirectory = Strings.assertNotNullNotEmpty( "Directory", pDirectory );
        mExists = pExists;
    }

    public TextFileDirectoryMemory( String pDirectory )
    {
        this( pDirectory, true );
    }

    public TextFileDirectoryMemory( boolean pExists )
    {
        this( DEFAULT_DIRECTORY, pExists );
    }

    public TextFileDirectoryMemory()
    {
        this( true );
    }

    @Override
    public String getDirectoryPath()
    {
        return mDirectory;
    }

    @Override
    public boolean exists()
    {
        return mExists;
    }

    @Override
    public String[] getFiles( String... pExtensions )
    {
        String[] zExtensions = preprocessExtensions( pExtensions );
        if ( mFiles.isEmpty() )
        {
            return Strings.EMPTY_ARRAY;
        }
        if ( zExtensions.length == 0 )
        {
            return mFiles.keySet().toArray( new String[mFiles.size()] );
        }
        List<String> zFound = new ArrayList<String>( mFiles.size() );
        for ( String zFileName : mFiles.keySet() )
        {
            if ( endsWithOneOf( zFileName, zExtensions ) )
            {
                zFound.add( zFileName );
            }
        }
        Collections.sort( zFound );
        return zFound.toArray( new String[zFound.size()] );
    }

    private boolean endsWithOneOf( String pFileName, String[] pExtensions )
    {
        for ( String zExtension : pExtensions )
        {
            if ( pFileName.endsWith( zExtension ) )
            {
                return true;
            }
        }
        return false;
    }

    @Override
    public TextFile load( @NotNull String pFileName )
            throws FileDoesNotExists
    {
        return mFiles.get( assertExists( Strings.assertNotNullNotEmpty( "FileName", pFileName ) ) );
    }

    @Override
    public void create( @NotNull TextFile pFile )
            throws FileAlreadyExists
    {
        write( assertNotExist( getFile( pFile ) ), pFile );
    }

    @Override
    public void update( @NotNull TextFile pFile )
            throws FileDoesNotExists
    {
        write( assertExists( getFile( pFile ) ), pFile );
    }

    @Override
    public void delete( @NotNull TextFile pFile )
            throws FileDoesNotExists
    {
        LLdelete( getFile( pFile ) );
    }

    @Override
    public void delete( @NotNull String pFileName )
            throws FileDoesNotExists
    {
        LLdelete( Strings.assertNotNullNotEmpty( "FileName", pFileName ) );
    }

    private void write( String pFileName, TextFile pTextFile )
    {
        mFiles.put( pFileName, pTextFile );
        mExists = true;
    }

    private void LLdelete( String pFileName )
    {
        mFiles.remove( assertExists( pFileName ) );
        mExists = true;
    }

    private String assertExists( String pFileName )
    {
        assertExists( mFiles.containsKey( pFileName ), pFileName );
        return pFileName;
    }

    private String assertNotExist( String pFileName )
    {
        assertNotExists( mFiles.containsKey( pFileName ), pFileName );
        return pFileName;
    }

    private String getFile( TextFile pFile )
    {
        return Objects.assertNotNull( "File", pFile ).getFileName();
    }
}