package free.utils.zip;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.zip.Deflater;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * Utilitaire de compression/decompression au format ZIP
 * @author ****
 * @version 1.0
 */
public class ZipUtils {
	public final static int NO_COMPRESSION = Deflater.NO_COMPRESSION;
	public final static int BEST_COMPRESSION = Deflater.BEST_COMPRESSION;
	public final static int DEFAULT_COMPRESSION = Deflater.DEFAULT_COMPRESSION;

	/**
	 * Compression d'un ensemble de fichiers
	 * @param src Les fichiers à compresser
	 * @param zipFile L'archive ZIP à créer
	 * @param compressionLevel Le niveau de compression
	 * @throws IOException
	 */
	public static void compress(File[] src, File zipFile, int compressionLevel) throws IOException {
		ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(zipFile));
		zout.setMethod(ZipOutputStream.DEFLATED);
		zout.setLevel(compressionLevel);

		for(int i=0; i<src.length; i++) {
			addToZipFile(src[i], zout, zipFile.getPath());
		}

		zout.finish();
		zout.close();
	}

	/**
	 * Compression d'un ensemble de fichiers
	 * @param src Les fichiers à compresser
	 * @param zipFile L'archive ZIP à créer
	 * @throws IOException
	 */
	public static void compress(File[] src, File zipFile) throws IOException {
		compress(src, zipFile, DEFAULT_COMPRESSION);
	}

	/**
	 * Compression d'un ensemble de fichiers présents dans un répertoire (inclut les sous-répertoires également)
	 * @param dir Le répertoire contenant les fichiers à compresser
	 * @param zipFile L'archive ZIP à créer
	 * @param compressionLevel Le niveau de compression
	 * @throws IOException
	 */
	public static void compress(String dir, File zipFile, int compressionLevel) throws IOException {
		ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(zipFile));
		zout.setMethod(ZipOutputStream.DEFLATED);
		zout.setLevel(compressionLevel);

		addToZipFile(dir, zout, zipFile.getPath());

		zout.finish();
		zout.close();
	}

	/**
	 * Compression d'un ensemble de fichiers présents dans un répertoire (inclut les sous-répertoires également)
	 * @param dir Le répertoire contenant les fichiers à compresser
	 * @param zipFile L'archive ZIP à créer
	 * @throws IOException
	 */
	public static void compress(String dir, File zipFile) throws IOException {
		compress(dir, zipFile, DEFAULT_COMPRESSION);
	}

	/**
	 * Ajoute l'ensemble des fichiers d'un répertoire dans un flux ZIP
	 * @param dir Le répertoire contenant les fichiers à compresser
	 * @param zout Le flux ZIP, non null
	 * @param zipPath Le chemin du fichier ZIP
	 * @throws IOException
	 */
	private static void addToZipFile(String dir, ZipOutputStream zout, String zipPath) throws IOException {
		File dirFile = new File(dir);
		String files[] = dirFile.list();

		for(int i=0; i<files.length; i++) {
			File src = new File(dirFile + File.separator + files[i]);

			if (src.getPath().equals(zipPath)) {
				continue;
			}

			if (src.isDirectory()) {
				addDirToZip(src, zout);
				addToZipFile(src.getPath(), zout, zipPath);
			} else {
				addFileToZip(src, zout);
			}
		}
	}

	/**
	 * Ajoute un fichier ou un répertoire dans un flux ZIP
	 * @param src Le fichier ou repertoire à compresser
	 * @param zout Le flux ZIP, non null
	 * @param zipPath Le chemin du fichier ZIP
	 * @throws IOException
	 */
	private static void addToZipFile(File src, ZipOutputStream zout, String zipPath) throws IOException {
		if (src.getPath().equals(zipPath)) {
			return;
		}

		if (src.isDirectory()) {
			addDirToZip(src, zout);
			addToZipFile(src.getPath(), zout, zipPath);
		} else {
			addFileToZip(src, zout);
		}
	}

	/**
	 * Ajoute un répertoire dans un flux ZIP
	 * @param src Le fichier à compresser
	 * @param zout Le flux ZIP, non null
	 * @throws IOException
	 */
	private static void addDirToZip(File src, ZipOutputStream zout) throws IOException {
		ZipEntry entry = new ZipEntry(src.getPath() + File.separator);
		entry.setTime(src.lastModified());
		zout.putNextEntry(entry);
		zout.closeEntry();
		zout.flush();
	}

	/**
	 * Ajoute un fichier dans un flux ZIP
	 * @param src Le fichier à compresser
	 * @param zout Le flux ZIP, non null
	 * @throws IOException
	 */
	private static void addFileToZip(File src, ZipOutputStream zout) throws IOException {
		FileInputStream fin = new FileInputStream(src);
		ZipEntry entry = new ZipEntry(src.getPath());
		entry.setTime(src.lastModified());
		zout.putNextEntry(entry);

		byte[] data = new byte[4096];
		int lu = -1;

		while((lu = fin.read(data)) != -1) {
			zout.write(data, 0, lu);
		}

		zout.closeEntry();
		zout.flush();
		fin.close();
	}

	/**
	 * Decompression d'une archive ZIP vers un répertoire
	 * @param zipFile L'archive ZIP à decompresser
	 * @param dirDest Le repertoire où décompresser l'archive ZIP
	 * @throws IOException
	 */
	public static void decompress(File zipFile, String dirDest) throws IOException {
		ZipInputStream zin = new ZipInputStream(new FileInputStream(zipFile));
		FileOutputStream fout = null;
		ZipEntry entry = null;

		if (!dirDest.endsWith(File.separator)) {
			dirDest = dirDest + File.separator;
		}

		while ((entry = zin.getNextEntry()) != null) {
			File file = new File(dirDest + entry.getName());

			if (file.getParentFile() != null && !file.getParentFile().exists()) {
				file.getParentFile().mkdirs();
			}

			if (entry.isDirectory() || entry.getName().endsWith(File.separator)) {
				file.mkdir();
			} else {
				fout = new FileOutputStream(file);

				byte[] data = new byte[4096];
				int lu = -1;

				while ((lu = zin.read(data)) != -1) {
					fout.write(data, 0, lu);
				}

				fout.flush();
				fout.close();
			}
		}

		zin.close();
	}
}