/**
 * A component of a library for 
 * <a href="http://www.geog.leeds.ac.uk/people/a.turner/src/andyt/java/projects/GENESIS/">GENESIS</a>
 * Copyright (C) 2008
 * <a href="http://www.geog.leeds.ac.uk/people/a.turner/">Andy Turner</a>,
 * <a href="http://www.leeds.ac.uk/">University of Leeds</a>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
package uk.ac.leeds.ccg.andyt.projects.genesis.utilities;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;

/**
 * An <code>abstract class</code> to be extended by classes that are required to 
 * handle runtime errors such as <code>java.lang.OutOfMemroyError</code>.
 * <ul>
 * <li>Developed for <a href="http://www.ncess.ac.uk/moses">MoSeS</a>.</li>
 * <li>Copyright (C) 2006 
 * <a href="http://www.geog.leeds.ac.uk/people/a.turner/">Andy Turner</a>,
 * <a href="http://www.leeds.ac.uk//">University of Leeds</a>.</li>
 * </ul>
 * @author <a href="http://www.geog.leeds.ac.uk/people/a.turner/">Andy Turner</a>
 * @version 1.0.0, 2008-10-10
 */
public abstract class ErrorHandler
        implements Serializable {
    
    private static final long serialVersionUID = 1L;
    
    /**
     * Directory for swapping data to.
     */
    private File directory;
    
    /**
     * A <code>HashMap</code> storing <code>class.getName()</code> as <code>keys</code> and
     * the numbers of caches swapped of that <code>class</code> as <code>values</code>.
     */
    private HashMap numberOfCachesSwappedAsFilesHashMap;
    
    /**
     * Reserve memory. This is to be cleared when dealing with <code>OutOfMemoryErrors</code>.
     */
    private transient int[] memoryReserve;
    //public transient int[] memoryReserve;
    
    /**
     * Initialises <code>this.memoryReserve</code> as an <code>int[]</code> of length size.
     * @param size The length that <code>this.memoryReserve</code> is initialised as.
     */
    public final void initMemoryReserve( int size ) {
        //log( "initMemoryReserve( " + size + " )" );
        this.memoryReserve = new int[ size ];
        Arrays.fill( this.memoryReserve, Integer.MIN_VALUE );
        System.gc();
    }
    
    /**
     * Initialises memoryReserve as an array of size 3000000.
     * Enough memory is needed for swapping data to <code>this.directory</code>
     */
    public final void initMemoryReserve() {
        initMemoryReserve( 3000000 );
    }
    
    /**
     * Clears memoryReserve by setting it to null and calling the garbage
     * collector.
     */
    public final void clearMemoryReserve() {
        //System.gc();
        //log(Runtime.getRuntime().freeMemory());
        this.memoryReserve = null;
        System.gc();
        //log(Runtime.getRuntime().freeMemory());
    }
    
    /**
     * If <code>aHashSetSerializable.isEmpty()</code> this does nothing and returns null.
     * Otherwise <code>aHashSetSerializable</code> is swapped to a <code>File</code>
     * which is returned.
     */
    protected File swapToFile(
            HashSet _HashSet ) {
        //throws IOException {
        if ( _HashSet.isEmpty() ) {
            return null;
        } else {
            String type = _HashSet.getClass().getName();
            if ( true ) {
                Iterator aHashSetSerializableIterator = _HashSet.iterator();
                type += aHashSetSerializableIterator.next().getClass().getName();
            }
            int numberOfCachesSwappedAsFiles = ( Integer ) this.numberOfCachesSwappedAsFilesHashMap.get( type );
            numberOfCachesSwappedAsFiles ++;
            this.numberOfCachesSwappedAsFilesHashMap.put( type, numberOfCachesSwappedAsFiles );
            File aFile = FileCreator.createNewFile(
                    this.directory,
                    type + Integer.toString( numberOfCachesSwappedAsFiles ) );
            try {
                ObjectOutputStream aObjectOutputStream = new ObjectOutputStream(
                        new BufferedOutputStream(
                        new FileOutputStream( aFile ) ) );
                aObjectOutputStream.writeObject( _HashSet );
                aObjectOutputStream.flush();
                aObjectOutputStream.close();
            } catch ( IOException aIOException ) {
                aIOException.printStackTrace();
                //throw ioe0;
            }
            return aFile;
        }
    }
    
    /**
     * If <code>aHashMap.isEmpty()</code> this does nothing and returns null.
     * Otherwise <code>aHashMap</code> is swapped to a <code>File</code>
     * which is returned.
     */
    protected File swapToFile(
            HashMap aHashMap ) {
        //throws IOException {
        if ( aHashMap.isEmpty() ) {
            return null;
        } else {
            String type = aHashMap.getClass().getName();
            if ( true ) {
                Iterator aHashMapKeySetIterator = aHashMap.keySet().iterator();
                type += aHashMapKeySetIterator.next().getClass().getName();
                Iterator aHashMapValuesIterator = aHashMap.values().iterator();
                type += aHashMapValuesIterator.next().getClass().getName();
            }
            int numberOfCachesSwappedAsFiles = ( Integer ) this.numberOfCachesSwappedAsFilesHashMap.get( type );
            numberOfCachesSwappedAsFiles ++;
            this.numberOfCachesSwappedAsFilesHashMap.put( type, numberOfCachesSwappedAsFiles );
            File aFile = FileCreator.createNewFile(
                    this.directory,
                    type + Integer.toString( numberOfCachesSwappedAsFiles ) );
            try {
                ObjectOutputStream aObjectOutputStream = new ObjectOutputStream(
                        new BufferedOutputStream(
                        new FileOutputStream( aFile ) ) );
                aObjectOutputStream.writeObject( aHashMap );
                aObjectOutputStream.flush();
                aObjectOutputStream.close();
            } catch ( IOException aIOException ) {
                aIOException.printStackTrace();
                //throw ioe0;
            }
            return aFile;
        }
    }
    
    /**
     * A method to write this instance to Files located in this.directory.
     * @param handleOutOfMemoryError
     *   If true then OutOfMemoryErrors are caught, swap operations are initiated,
     *     then the method is re-called.
     *   If false then OutOfMemoryErrors are caught and thrown.
     */
    public final File writeToFile(
            boolean handleOutOfMemoryError )
            throws IOException {
        try {
            return writeToFile();
        } catch ( OutOfMemoryError oome0 ) {
            if ( handleOutOfMemoryError ) {
                return writeToFile( handleOutOfMemoryError );
            } else {
                throw oome0;
            }
        }
    }
    
    /**
     * A method to write this instance to a File located in the directory returned by
     * getDirectory().
     */
    protected File writeToFile() throws IOException {
            // Write out this.
            String filename = this.getClass().getName();
            File file = new File(
                    getDirectory(),
                    filename + ".thisFile" );
            //System.out.println("Writing out to " + file.toURL().toString() );
            ObjectOutputStream aObjectOutputStream = new ObjectOutputStream(
                    new BufferedOutputStream(
                    new FileOutputStream( file ) ) );
            aObjectOutputStream.writeObject( this );
            aObjectOutputStream.flush();
            aObjectOutputStream.close();
            return file;
    }
    
    /**
     * A method to write this instance to a File located in the directory returned by
     * getDirectory().
     * @param objectToWrite The object to be written
     */
    protected void writeToFile( 
            Object objectToWrite,
            File aFileToWriteTo )
            throws IOException {
            ObjectOutputStream aObjectOutputStream = new ObjectOutputStream(
                    new BufferedOutputStream(
                    new FileOutputStream( aFileToWriteTo ) ) );
            aObjectOutputStream.writeObject( objectToWrite );
            aObjectOutputStream.flush();
            aObjectOutputStream.close();
    }
    
    /**
     * Loads an <code>Object</code> from aFile <code>File</code>.
     * @param aFile The <code>File</code> from which the <code>Object</code is loaded.
     * @return The loaded <code>Object</code or <code>null</code.
     */
    protected final Object loadObject( File aFile ) {
        ObjectInputStream aObjectInputStream = null;
        try {
            aObjectInputStream = new ObjectInputStream(
                    new BufferedInputStream(
                    new FileInputStream( aFile ) ) );
        } catch ( Exception aException ) {
            if ( aObjectInputStream != null ) {
                try {
                    aObjectInputStream.close();
                } catch ( Exception bException ) {
                    aException.printStackTrace();
                }
            }
            //return null;
        } catch ( Error aError ) {
            if ( aObjectInputStream != null ) {
                try {
                    aObjectInputStream.close();
                } catch ( Exception aException ) {
                    aError.printStackTrace();
                }
            }
        }
        return loadObject( aObjectInputStream );
    }
    
    /**
     * Loads an <code>Object</code> from aObjectInputStream <code>ObjectInputStream</code>.
     * @param aObjectInputStream The <code>ObjectInputStream</code> from which the <code>Object</code is loaded.
     * @return The loaded <code>Object</code or <code>null</code.
     */
    protected final Object loadObject(
            ObjectInputStream aObjectInputStream ) {
        Object result = null;
        try {
            result = aObjectInputStream.readObject();
            aObjectInputStream.close();
        } catch ( Exception aException ) {
            aException.printStackTrace();
        }
        return result;
    }
    
    /**
     * @return <code>this.directory</code>
     */
    public final File getDirectory() {
        return this.directory;
    }
    
    /**
     * Sets <code>this.directory</code> to <code>directory</code>.
     * N.B. No checks are done on <code>directory</code> to ensure it is viable for use.
     */
    protected final void setDirectory( File directory ) {
        this.directory = directory;
    }
    
    /**
     * @return <code>this.memoryReserve</code>
     */
    protected final int[] getMemoryReserve() {
        return this.memoryReserve;
    }
    
    /**
     * Sets <code>this.memoryReserve</code> to <code>memoryReserve</code>.
     */
    protected final void setMemoryReserve( int[] memoryReserve ) {
        this.memoryReserve = memoryReserve;
    }
    
    /**
     * @return <code>this.numberOfCachesSwappedAsFilesHashMap</code>
     */
    protected final HashMap getNumberOfCachesSwappedAsFilesHashMap() {
        return this.numberOfCachesSwappedAsFilesHashMap;
    }
    
    /**
     * Sets <code>this.numberOfCachesSwappedAsFilesHashMap</code> to <code>numberOfCachesSwappedAsFilesHashMap</code>.
     */
    protected final void setNumberOfCachesSwappedAsFilesHashMap( HashMap numberOfCachesSwappedAsFilesHashMap ) {
        this.numberOfCachesSwappedAsFilesHashMap = numberOfCachesSwappedAsFilesHashMap;
    }
    
}