/* $Id: BinaryFileManager.java,v 1.9 2006/01/12 15:13:08 psionides Exp $ */
   package net.sourceforge.jdbdump.dump;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.util.zip.GZIPInputStream;
  import java.util.zip.GZIPOutputStream;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipFile;
  import java.util.zip.ZipOutputStream;
  
  import org.apache.log4j.Logger;
  
  /***
   * An implementation of DumpFileManager which saves dump objects in binary (serialized) form.
   * 
   * @see DumpFileManager
   * @author jsuder
   */
  
  public class BinaryFileManager implements DumpFileManager {
  
  	/*** A log4j logger for this class. */
  	private static Logger logger = Logger.getLogger(BinaryFileManager.class);
  
  	/***
  	 * Saves a backup of the database represented in the dump object into the specified file.
  	 * First it saves the database structure which is already contained in the Dump, then
  	 * uses the Dump to download all the data, table by table, record by record, and saves it
  	 * into the file as soon as it's downloaded.
  	 * 
  	 * @param dump a database dump created using DatabaseConnector.dump() method
  	 * @param file a file in which the backup will be stored
  	 * @param compress compression method used to compress the file (zip, gzip or none)
  	 */
  
  	public void exportDump(Dump dump, File file, CompressionMethod compress) {
  		ObjectOutputStream output;
  
  		try {
  			if (compress == CompressionMethod.ZIP) {
  				// create a zip file with one *.bin file inside
  				ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(file));
  				String zippedName = file.getName().substring(0, file.getName().lastIndexOf('.')) + ".bin";
  				zip.putNextEntry(new ZipEntry(zippedName));
  				output = new ObjectOutputStream(zip);
  			} else if (compress == CompressionMethod.GZIP) {
  				// create a gzip file
  				GZIPOutputStream gzip = new GZIPOutputStream(new FileOutputStream(file));
  				output = new ObjectOutputStream(gzip);
  			} else {
  				// use no compression, just save the file as it is
  				output = new ObjectOutputStream(new FileOutputStream(file));
  			}
  		} catch (Exception e) {
  			logger.error("Error while creating an ouput stream to the backup file: " + e);
  			e.printStackTrace();
  			return;
  		}
  
  		try {
  			// save the table structure into the file
  			output.writeObject(dump);
  		} catch (IOException e) {
  			logger.error("Error while saving the dump structure into the backup file: " + e);
  			e.printStackTrace();
  			return;
  		}
  		
  		// then save data for all the tables
  		for (Table table : dump.getTables()) {
  			logger.info("Downloading data from table " + table.getName());
  			try {
  				table.initializeData();
  				int count = 0;
  				while (true) {
  					String[] line = table.getDataLine();
  					output.writeObject(line);
  					if (count == 100) {
  						// reset the stream from time to time
  						// that releases the previously written lines from memory
  						output.reset();
  						count = 0;
  					}
  					count++;
  					if (line == null) {
  						// null line marks the end of that table's data
  						break;
  					}
  				}
  			} catch (Exception e) {
  				logger.error("Error while saving data from table " + table.getName() + ": " + e);
  				e.printStackTrace();
  				return;
 			}
 		}
 		
 		try {
 			output.close();
 		} catch (IOException e) {
 			logger.warn("Couldn't close output file.");
 		}
 	}
 
 	/***
 	 * Loads the database structure as a Dump object from the specified file.
 	 * <br />
 	 * This method doesn't load any data (i.e. table records) from the file yet. Data should be
 	 * loaded by DatabaseConnector.restore() when the dump returned by this function is passed to
 	 * it. The dump stores a reference to the input stream from this file to be able to read the data
 	 * later; when it is no longer needed, it should be closed by calling closeFileReader() on the
 	 * Dump (but that shouldn't be called until all data is read in DatabaseConnector.restore()).
 	 * 
 	 * @param file a file from which the backup should be read
 	 * @param compress compression method used to decompress the file (zip, gzip or none)
 	 * @return a database dump that can be uploaded using DatabaseConnector.restore() method
 	 */
 
 	public Dump importDump(File file, CompressionMethod compress) { 
 		ObjectInputStream input;
 		
 		try {
 			if (compress == CompressionMethod.ZIP) {
 				ZipFile zipFile = new ZipFile(file);
 				ZipEntry entry = zipFile.entries().nextElement();
 				InputStream compressedFile = zipFile.getInputStream(entry);
 				input = new ObjectInputStream(compressedFile);
 			} else if (compress == CompressionMethod.GZIP) {
 				GZIPInputStream gzip = new GZIPInputStream(new FileInputStream(file));
 				input = new ObjectInputStream(gzip);
 			} else { // no compression
 				input = new ObjectInputStream(new FileInputStream(file));
 			}
 
 			// read the serialized Dump
 			Dump dump = (Dump) input.readObject();
 			
 			// set the reference used later to download data
 			dump.setFileReader(input);
 
 			return dump;
 		} catch (Exception e) {
 			logger.error("An exception occured during import - dump file couldn't be read: " + e);
 			e.printStackTrace();
 			return null;
 		}
 	}
 }