/********************************************************************************
    * InternetCafe is a software solution that helps the management of Cybercafes
    * according with the ITALIAN DECREE LAW ON ANTI-TERROR MEASURES, 27 JULY 2005.
    * Copyright (C) 2006  Guido Angelo Ingenito
   
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU General Public License
    * as published by the Free Software Foundation; either version 2
    * of the License, or (at your option) any later version.
  
   * This program 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   *******************************************************************************/
  package base.backup;
  
  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.InputStream;
  import java.io.PrintStream;
  import java.util.Date;
  import java.util.Enumeration;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipFile;
  import java.util.zip.ZipInputStream;
  import java.util.zip.ZipOutputStream;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.apache.log4j.Logger;
  import org.w3c.dom.Document;
  
  import base.ConfigurationManager;
  import base.IdManager;
  
  public class BackupFactory {
  	private static final transient Logger logger = Logger
  			.getLogger(BackupFactory.class.getName());
  
  	public static Backup newBackup(String name, String description, Date date,
  			String dbLocationPath, String zipLocationPath) {
  		int id = IdManager.getInstance().getNextBackupId();
  
  		return new Backup(id, name, description, date, dbLocationPath,
  				zipLocationPath);
  	}
  
  	public static Backup newBackupFromZipArchive(File backupFile)
  			throws Exception {
  		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  
  		factory.setIgnoringComments(true);
  		factory.setValidating(false);
  		factory.setIgnoringElementContentWhitespace(true);
  
  		DocumentBuilder docBuilder = factory.newDocumentBuilder();
  		File unzipFolder = new File(backupFile.getParent(), backupFile
  				.getName().substring(0, backupFile.getName().lastIndexOf(".")));
  
  		unzipFolder.mkdir();
  		unZipFile(new ZipFile(backupFile), unzipFolder);
  
  		// Now we must retrieve the details file
  		File xmlDetailsFile = new File(unzipFolder,
  				ConfigurationManager.BACKUP_DETAILS_FILE);
  		Document document = docBuilder
  				.parse(new FileInputStream(xmlDetailsFile));
  		Backup backup = new Backup(document);
  
  		backup.setZipLocationPath(backupFile.getAbsolutePath());
  
  		return backup;
  	}
  
  	public static File createDetailsFile(Backup backup) throws Exception {
  		Document doc = DocumentBuilderFactory.newInstance()
  				.newDocumentBuilder().newDocument();
  
  		doc.appendChild(backup.toXml(doc));
  
  		String detailsfileName = ConfigurationManager.BACKUP_DETAILS_FILE;
  
  		if (!detailsfileName.endsWith(".xml")) {
  			detailsfileName += ".xml";
  		}
 
 		Transformer transformer = TransformerFactory.newInstance()
 				.newTransformer();
 		DOMSource source = new DOMSource(doc);
 		StreamResult streamResult = new StreamResult(new PrintStream(
 				detailsfileName));
 
 		transformer.transform(source, streamResult);
 
 		return new File(detailsfileName);
 	}
 
 	public static void backupToZipArchive(Backup backup) throws Exception {
 		// Create the ZIP file, will be rappresented by the backup's name
 		// followed by its id.
 		String outFilename = backup.getName() + backup.getId() + ".zip";
 		ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
 				new File(backup.getZipLocationPath(), outFilename)));
 
 		out.setComment(backup.getDescription());
 
 		// Link the db path to the current zip location
 		String dbFileName = backup.getDbLocationPath().substring(
 				backup.getDbLocationPath().lastIndexOf(File.separatorChar),
 				backup.getDbLocationPath().length());
 
 		backup.setDbLocationPath(new File(backup.getZipLocationPath(),
 				dbFileName).getAbsolutePath());
 
 		// We must create the backup's details file (xml)
 		File details = createDetailsFile(backup);
 
 		// We must zip it
 		zipFile(details, out);
 
 		// Lets delete the backup's details file (xml) it doesn't serve anymore
 		details.delete();
 
 		File resourcesFolder = new File(
 				ConfigurationManager.RESOURCES_DIRECTORY);
 
 		zipDirectory(resourcesFolder, out);
 
 		// Complete the ZIP file
 		out.close();
 	}
 
 	public static void zipDirectory(File file, ZipOutputStream out)
 			throws Exception {
 		String[] dirList = file.list();
 		byte[] readBuffer = new byte[1024];
 		int bytesIn = 0;
 
 		for (int i = 0; i < dirList.length; i++) {
 			File f = new File(file, dirList[i]);
 
 			if (f.isDirectory()) {
 				// if the File object is a directory, call this
 				// function again to add its content recursively
 				zipDirectory(f, out);
 
 				// loop again
 				continue;
 			}
 
 			// if we reached here, the File object f was not a directory
 			// create a FileInputStream on top of f
 			FileInputStream fis = new FileInputStream(f);
 
 			// create a new zip entry
 			ZipEntry zipEntry = new ZipEntry(f.getPath());
 
 			// place the zip entry in the ZipOutputStream object
 			out.putNextEntry(zipEntry);
 
 			// now write the content of the file to the ZipOutputStream
 			while ((bytesIn = fis.read(readBuffer)) != -1) {
 				out.write(readBuffer, 0, bytesIn);
 			}
 
 			// close the Stream
 			fis.close();
 		}
 	}
 
 	public static void zipFile(File file, ZipOutputStream out) throws Exception {
 		// Create a buffer for reading the file
 		byte[] buf = new byte[1024];
 
 		out.putNextEntry(new ZipEntry(file.getName()));
 
 		FileInputStream in = new FileInputStream(file);
 
 		// Transfer bytes from the file to the ZIP file
 		int len;
 
 		while ((len = in.read(buf)) > 0) {
 			out.write(buf, 0, len);
 		}
 
 		in.close();
 
 		// Complete the entry
 		out.closeEntry();
 	}
 
 	public static void unZipFile(ZipFile zipFile, File destinationDirectory)
 			throws Exception {
 		logger.debug("unZipFile: " + zipFile.getName()
 				+ " destination directory: " + destinationDirectory);
 
 		Enumeration enumeration = zipFile.entries();
 
 		while (enumeration.hasMoreElements()) {
 			ZipEntry zipEntry = (ZipEntry) enumeration.nextElement();
 
 			File file = new File(destinationDirectory.getCanonicalPath(),
 					zipEntry.getName().replaceFirst(".." + File.separatorChar,
 							""));
 
 			logger.debug("File: " + file);
 
 			if (zipEntry.isDirectory()) {
 				file.mkdirs();
 			} else {
 				InputStream is = zipFile.getInputStream(zipEntry);
 				BufferedInputStream bis = new BufferedInputStream(is);
 
 				if (file.getParent() != null) {
 					File dir = new File(file.getParent());
 
 					dir.mkdirs();
 				}
 
 				FileOutputStream fos = new FileOutputStream(file);
 				BufferedOutputStream bos = new BufferedOutputStream(fos);
 
 				int c;
 
 				while ((c = bis.read()) != -1) {
 					bos.write((byte) c);
 				}
 
 				bos.close();
 				fos.close();
 			}
 
 			logger.debug(" unzipped.");
 		}
 	}
 
 	public static void unzip(ZipInputStream zin, String zipEntry,
 			File destinationFolder) throws IOException {
 		System.out
 				.println("unzipping " + zipEntry + " to " + destinationFolder);
 
 		FileOutputStream out = new FileOutputStream(new File(destinationFolder,
 				new File(zipEntry).getName()));
 		byte[] b = new byte[1024];
 		int len = 0;
 
 		while ((len = zin.read(b)) != -1) {
 			out.write(b, 0, len);
 		}
 
 		out.close();
 	}
 
 	public static long fileSizeInKB(File file) {
 		long size = 0;
 
 		if (file.isDirectory()) {
 			File[] filelist = file.listFiles();
 
 			for (int i = 0; i < filelist.length; i++) {
 				if (filelist[i].isDirectory()) {
 					size += fileSizeInKB(filelist[i]);
 				} else {
 					size += filelist[i].length();
 				}
 			}
 		} else {
 			size += file.length();
 		}
 
 		return size / 1024;
 	}
 }