package org.litesoft.textfiledirectory;

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

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 = Confirm.significant( "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( Confirm.significant( "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( Confirm.significant( "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 Confirm.isNotNull( "File", pFile ).getFileName();
    }
}