package com.megatim.module.compression.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.model.enums.CompressionLevel;
import net.lingala.zip4j.model.enums.EncryptionMethod;
import com.megatim.module.compression.ifaces.CompressionFace;
import java.util.Arrays;
import net.lingala.zip4j.exception.ZipException;
import net.lingala.zip4j.model.enums.CompressionMethod;

/**
 * Classe implementant l'algorithme Zip4J
 *
 * @author derteuffel
 *
 */
public class JavaZipZip4Impl implements CompressionFace {

    public void zipFile(File sourceFile, File destinationFolder, int splitLength) throws ZipException {
        ZipParameters zipParameters = new ZipParameters();
        zipParameters.setCompressionMethod(CompressionMethod.DEFLATE);
        zipParameters.setCompressionLevel(CompressionLevel.NORMAL);

        ZipFile zipFile = new ZipFile(new File(destinationFolder.getAbsolutePath(), removeExtension(sourceFile.getName()) + ".zip"));

        // Create the split zip file from a single file
        zipFile.createSplitZipFile(Arrays.asList(sourceFile), zipParameters, true, splitLength * 1024 * 1024);

    }

    public void mergeSplitFiles(File mainZip, File destinationDir, String outputName) throws ZipException {
        // Create a ZipFile instance for the first part
        ZipFile zipFile = new ZipFile(mainZip);
        File mergedZipFile = new File(destinationDir, outputName);

        // Merge the split files into a single ZIP file
        zipFile.mergeSplitFiles(mergedZipFile);
    }

    public File zipFile(File fichierAZipper) throws IOException {
        // TODO Auto-generated method stub

        ZipFile zipFile = new ZipFile(removeExtension(fichierAZipper.getPath()) + ".zip");
        zipFile.addFile(new File(fichierAZipper.getPath()));

        // return new File(removeExtension(fichierAZipper.getPath()) + ".zip");
        return zipFile.getFile();
    }

    public File zipFile(File fichierAZipper, File destination) throws IOException {
        // TODO Auto-generated method stub

        ZipFile zipFile = new ZipFile(new File(destination.getPath(), removeExtension(fichierAZipper.getName()) + ".zip"));
        zipFile.addFile(fichierAZipper);

        return zipFile.getFile();
    }

    public File zipRepository(File repertoireAZipper, File destination) throws IOException {
        // TODO Auto-generated method stub

        ZipFile zipFile = new ZipFile(new File(destination.getPath(), removeExtension(repertoireAZipper.getName()) + ".zip"));
        zipFile.addFolder(repertoireAZipper);

        return zipFile.getFile();
    }

    public File zipFile(File fichierAZipper, File repertoireDestination, String password) throws IOException {
        String sourceFile = fichierAZipper.getAbsolutePath();

        ZipParameters zipParameters = new ZipParameters();

        zipParameters.setEncryptFiles(true);

        zipParameters.setCompressionLevel(CompressionLevel.HIGHER);

        zipParameters.setEncryptionMethod(EncryptionMethod.AES);
        File fileToAdd = new File(sourceFile);

        if (!fileToAdd.exists()) {

            fileToAdd.createNewFile();

        }
        ZipFile zipFile = new ZipFile(new File(repertoireDestination.getPath(), removeExtension(fichierAZipper.getName()) + ".zip"), password.toCharArray());
        zipFile.addFile(fichierAZipper, zipParameters);

        zipFile.close();

        return zipFile.getFile();
    }

    // Zip directory
    public File zipRepository(File repertoireAZipper) throws IOException {
        // TODO Auto-generated method stub

        new ZipFile(removeExtension(repertoireAZipper.getPath()) + ".zip").addFolder(new File(repertoireAZipper.getPath()));

        return new File(removeExtension(repertoireAZipper.getPath()) + ".zip");
    }

    // Dezipper un fichier zipper
    public void unZipFile(File fichierZipper, File repertoireSorti) throws IOException {
        // TODO Auto-generated method stub

        new ZipFile(removeExtension(fichierZipper.getPath()) + ".zip").extractAll(repertoireSorti.getPath());

    }

    // Dezipper un repertoir 
    public void unZipRepository(File repertoireZipper, File repertoireSorti) throws IOException {
        // TODO Auto-generated method stub

        new ZipFile(removeExtension(repertoireZipper.getPath()) + ".zip").extractAll(repertoireSorti.getPath());

    }

    public void addFile(File fichier, File zipFile) throws Exception {
        // TODO Auto-generated method stub

        if (zipFile.createNewFile()) {

            System.out.println("Zip file created");

        } else {

            System.out.println("Zip file already exist");

        }

        new ZipFile(zipFile.getPath()).addFile(new File(fichier.getPath()));

    }

    // Add repository to existed zip file
    public void addRepository(File repository, File zipFile) throws Exception {
        // TODO Auto-generated method stub

        if (zipFile.createNewFile()) {

            System.out.println("Zip file created");

        } else {

            System.out.println("Zip file already exist");

        }

        new ZipFile(zipFile.getPath()).addFolder(new File(repository.getPath()));

    }

    // Zip file with password
    public File zipFile(File fichierAZipper, String password) throws Exception {
        // TODO Auto-generated method stub

        String sourceFile = fichierAZipper.getAbsolutePath();

        ZipParameters zipParameters = new ZipParameters();

        zipParameters.setEncryptFiles(true);

        zipParameters.setCompressionLevel(CompressionLevel.HIGHER);

        zipParameters.setEncryptionMethod(EncryptionMethod.AES);
        File fileToAdd = new File(sourceFile);

        if (!fileToAdd.exists()) {

            fileToAdd.createNewFile();

        }

        ZipFile zipFile = new ZipFile(removeExtension(fileToAdd.getPath()) + ".zip", password.toCharArray());

        zipFile.addFile(fileToAdd, zipParameters);

        zipFile.close();

        return new File(removeExtension(fileToAdd.getPath()) + ".zip");
    }

    // Zip directory with passwor
    public File zipRepository(File repertoireAZipper, String password) throws Exception {
        // TODO Auto-generated method stub

        String sourceFile = repertoireAZipper.getAbsolutePath();

        ZipParameters zipParameters = new ZipParameters();

        zipParameters.setEncryptFiles(true);

        zipParameters.setCompressionLevel(CompressionLevel.HIGHER);

        zipParameters.setEncryptionMethod(EncryptionMethod.AES);

        File fileToAdd = new File(sourceFile);

        if (!fileToAdd.exists()) {

            fileToAdd.mkdirs();

        }

        ZipFile zipFile = new ZipFile(removeExtension(fileToAdd.getPath()) + ".zip", password.toCharArray());

        zipFile.addFolder(fileToAdd, zipParameters);

        zipFile.close();

        return new File(removeExtension(fileToAdd.getPath()) + ".zip");

    }

    // dezippage d'un fichier zipper
    public void unZipFile(File fichierZipper, File repertoireSorti, String password) throws Exception {
        // TODO Auto-generated method stub

        String sourceFile = repertoireSorti.getAbsolutePath();

        File outFile = new File(sourceFile);

        // Check if directory exist
        if (!outFile.exists()) {

            outFile.mkdirs();

        }

        // Initialize zip file reader to prepare extraction
        ZipFile zipFile = new ZipFile(fichierZipper.getPath(), password.toCharArray());

        zipFile.extractAll(outFile.getPath());

        // Close the reader
        zipFile.close();

    }

    // Dezipper un repertoire
    public void unZipRepository(File repertoireZipper, File repertoireSorti, String password) throws Exception {
        // TODO Auto-generated method stub

        String sourceFile = repertoireSorti.getAbsolutePath();

        File outFile = new File(sourceFile);

        // Check if directory exist
        if (!outFile.exists()) {

            outFile.mkdirs();

        }

        // Initialize zip file reader to prepare extraction
        ZipFile zipFile = new ZipFile(repertoireZipper.getPath(), password.toCharArray());

        zipFile.extractAll(outFile.getPath());

        // Close the reader
        zipFile.close();

    }

    public void addFile(File fichier, File zipFile, String password) throws Exception {
        // TODO Auto-generated method stub

        // Test d'existance du repertoire de destination
        if (zipFile.createNewFile()) {

            System.out.println("Zip file created");

        } else {

            System.out.println("Zip file already exist");

        }

        ZipParameters zipParameters = new ZipParameters();

        zipParameters.setEncryptFiles(true);

        zipParameters.setCompressionLevel(CompressionLevel.HIGHER);

        zipParameters.setEncryptionMethod(EncryptionMethod.AES);

        //Ajouter le fichier dans le fichier zipper et association du mot de passe
        new ZipFile(zipFile.getPath(), password.toCharArray()).addFile(new File(fichier.getPath()), zipParameters);

    }

    public void addRepository(File repository, File zipFile, String password) throws Exception {
        // TODO Auto-generated method stub

        //Test d'existance du repertoire de destination
        if (zipFile.createNewFile()) {

            System.out.println("Zip file created");

        } else {

            System.out.println("Zip file already exist");

        }

        ZipParameters zipParameters = new ZipParameters();

        zipParameters.setEncryptFiles(true);

        zipParameters.setCompressionLevel(CompressionLevel.HIGHER);

        zipParameters.setEncryptionMethod(EncryptionMethod.AES);

        //Ajouter le repertoire dans le fichier zipper et association du mot de passe
        new ZipFile(zipFile.getPath(), password.toCharArray()).addFolder(new File(repository.getPath()), zipParameters);

    }

    // Remove extension before zip file
    public static String removeExtension(String s) {

        String separator = System.getProperty("file.separator");

        String filename;

        // Remove the path upto the filename.
        /*
		 * int lastSeparatorIndex = s.lastIndexOf(separator); if (lastSeparatorIndex ==
		 * -1) { filename = s; } else { filename = s.substring(lastSeparatorIndex + 1);
		 * }
         */
        // Remove the extension.
        int extensionIndex = s.lastIndexOf(".");

        if (extensionIndex == -1) {
            return s;
        }

        return s.substring(0, extensionIndex);
    }

    // create directory and check if there are many contained files
    private static void zipFile(File fileToZip, String fileName, ZipOutputStream zipOut) throws IOException {

        if (fileToZip.isHidden()) {

            return;

        }

        if (fileToZip.isDirectory()) {

            if (fileName.endsWith("/")) {

                zipOut.putNextEntry(new ZipEntry(fileName));

                zipOut.closeEntry();

            } else {

                zipOut.putNextEntry(new ZipEntry(fileName + "/"));

                zipOut.closeEntry();

            }
            File[] children = fileToZip.listFiles();

            for (File childFile : children) {

                zipFile(childFile, fileName + "/" + childFile.getName(), zipOut);

            }

            return;

        }

        FileInputStream fis = new FileInputStream(fileToZip);

        ZipEntry zipEntry = new ZipEntry(fileName);

        zipOut.putNextEntry(zipEntry);

        byte[] bytes = new byte[1024];

        int length;

        while ((length = fis.read(bytes)) >= 0) {

            zipOut.write(bytes, 0, length);

        }

        fis.close();
    }

    // Create new file after unzip
    public static File newFile(File destinationDir, ZipEntry zipEntry) throws IOException {

        File destFile = new File(destinationDir, zipEntry.getName());

        String destDirPath = destinationDir.getCanonicalPath();

        String destFilePath = destFile.getCanonicalPath();

        if (!destFilePath.startsWith(destDirPath + File.separator)) {

            throw new IOException("Entry is outside of the target dir: " + zipEntry.getName());

        }

        return destFile;
    }
}