package org.litesoft.aokeyhole.persist;

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

import org.litesoft.util.*;

public class PersistableFile implements PersistableProxy
{
    public static final String SUFFIX_OLD = ".previous";
    public static final String SUFFIX_NEW = ".tmpNew";

    private File mFile;
    private String mName;
    private boolean mReadOnly;
    private static final String TIMESTAMP_PREVIOUS = "TimestampPrevious";

    public PersistableFile( String pFileName )
            throws IOException
    {
        mFile = new File( pFileName );

        if ( !mFile.exists() || mFile.isDirectory() )
        {
            throw new FileNotFoundException( pFileName + " Not a File" );
        }
        if ( !mFile.canRead() )
        {
            throw new IOException( pFileName + " Not Readable" );
        }
        mName = cleanName( mFile.getName() );
        mReadOnly = !mFile.canWrite();
        if ( mName.length() == 0 )
        {
            throw new IOException( pFileName + " does NOT appear to have a File 'Name'" );
        }
    }

    private String cleanName( String pName )
    {
        pName += '.';
        return pName.substring( 0, pName.indexOf( '.' ) );
    }

    public String getName()
    {
        return mName;
    }

    public boolean isReadOnly()
    {
        return mReadOnly;
    }

    public String[] loadLines()
            throws IOException
    {
        BufferedReader reader = new BufferedReader( new FileReader( mFile ) );

        List<String> lines = new ArrayList<String>();

        boolean ok = false;
        try
        {
            for ( String line; null != (line = reader.readLine()); )
            {
                lines.add( line );
            }
            ok = true;
        }
        finally
        {
            if ( !ok )
            {
                try
                {
                    reader.close();
                }
                catch ( IOException ignore )
                {
                    // Have to eat this because Java provides no mechanism to release the file resources that does NOT throw an exception
                }
            }
        }
        reader.close();

        return lines.toArray( new String[lines.size()] );
    }

    public void saveLines( String[] pLines )
            throws IOException
    {
        String fPath = mFile.getPath();
        File newFile = new File( fPath + SUFFIX_NEW );
        File oldFile = new File( fPath + timestamp() + SUFFIX_OLD );

        writeLines( newFile, pLines );
        roll( newFile, mFile, oldFile );
    }

    private String timestamp()
    {
        return System.getProperty( TIMESTAMP_PREVIOUS ) == null ? //
               "" : // 
               "." + new SimpleDateFormat( "yyyyMMddHHmmss" ).format( Utils.getCurrentTimestamp() );
    }

    private void writeLines( File pFile, String[] pLines )
            throws IOException
    {
        BufferedWriter writer = new BufferedWriter( new FileWriter( pFile ) );

        boolean ok = false;
        try
        {
            if ( pLines != null )
            {
                for ( String line : pLines )
                {
                    if ( line != null )
                    {
                        writer.write( line );
                        writer.newLine();
                    }
                }
            }
            ok = true;
        }
        finally
        {
            if ( !ok )
            {
                try
                {
                    writer.close();
                }
                catch ( IOException ignore )
                {
                    // Have to eat this because Java provides no mechanism to release the file resources that does NOT throw an exception
                }
            }
        }
        writer.close();
    }

    private void roll( File pNewFile, File pCurFile, File pOldFile )
            throws IOException
    {
        if ( pCurFile.exists() )
        {
            if ( pOldFile.exists() )
            {
                remove( pOldFile );
            }
            rename( pCurFile, pOldFile );
        }
        rename( pNewFile, pCurFile );
    }

    private void rename( File pFileFrom, File pFileTo )
            throws IOException
    {
        if ( pFileFrom.exists() )
        {
            if ( !pFileFrom.renameTo( pFileTo ) )
            {
                throw new IOException( "Unable to rename (" + pFileFrom.getPath() + ") to: " + pFileTo.getPath() );
            }
        }
    }

    private void remove( File pFileToDel )
            throws IOException
    {
        if ( pFileToDel.exists() )
        {
            if ( !pFileToDel.delete() )
            {
                throw new IOException( "Unable to remove/delete: " + pFileToDel.getPath() );
            }
        }
    }
}