SDIS1819-T2G01

import java.io.*;

import java.nio.file.*;

import java.security.*;

import java.nio.charset.*;

public class FileManager {

    public static int chunkSize = 64000;

    // Save byte array chunk to path

    public static void saveChunk(byte[] bytes, String path, int chunkN) throws FileNotFoundException, IOException {

        String fileName = path + Integer.toString(chunkN);

        try (FileOutputStream stream = new FileOutputStream(fileName)) {

            stream.write(bytes);

        }

    }

    // Hash a string with SHA256

    public static String hash(String input) {

        try {

            byte[] bytes = digestHashing(input);

            return bytesToHex(bytes);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

    // Use MessageDigest to hash in bytes

    private static byte[] digestHashing(String input) throws NoSuchAlgorithmException {

        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        return digest.digest(input.getBytes(StandardCharsets.UTF_8));

    }

    // Use bytes from MessageDigest to a String

    private static String bytesToHex(byte[] hash) {

        StringBuffer hexString = new StringBuffer();

        for (int i = 0; i < hash.length; i++) {

            String hex = Integer.toHexString(0xff & hash[i]);

            if (hex.length() == 1)

                hexString.append('0');

            hexString.append(hex);

        }

        return hexString.toString();

    }

    // Delete directory and files

    public static void deleteDir(File file) {

        File[] contents = file.listFiles();

        if (contents != null) {

            for (File f : contents) {

                if (!Files.isSymbolicLink(f.toPath())) {

                    deleteDir(f);

                }

            }

        }

        file.delete();

    }

    // Read all bytes of file(generic use)

    public static byte[] readFile(String path) {

        Path filePath = Paths.get(path);

        byte[] bytes = null;

        try {

            bytes = Files.readAllBytes(filePath);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return bytes;

    }

    // Split file in chunks

    public static byte[][] split(byte[] fileBytes) {

        // Number of chunks needed is always integer division plus 1 which may be

        // partially used or empty

        int nChunks = 1 + fileBytes.length / chunkSize;

        // Total bytes

        int bytes = fileBytes.length;

        int rBytes = 0;

        // Chunks seperated

        byte[][] chunks = new byte[nChunks][];

        for (int i = 0; i < nChunks; i++) {

            // Calculate proper size

            int sizeToCopy = chunkSize;

            if (bytes < sizeToCopy)

                sizeToCopy = bytes;

            // Chunk with proper size

            chunks[i] = new byte[sizeToCopy];

            // Copy to chunk

            System.arraycopy(fileBytes, rBytes, chunks[i], 0, sizeToCopy);

            // Remove form total bytes

            bytes -= sizeToCopy;

            rBytes += sizeToCopy;

        }

        return chunks;

    }

    // Merge chunks into single byte array

    public static byte[] merge(byte[][] chunks) throws IOException {

        // Total bytes

        int tBytes = 0;

        for (int i = 0; i < chunks.length; i++) {

            tBytes += chunks[i].length;

        }

        byte[] mergedFile = new byte[tBytes];

        // Written bytes count

        int nBytes = 0;

        // Write bytes

        for (int i = 0; i < chunks.length; i++) {

            System.arraycopy(chunks[i], 0, mergedFile, nBytes, chunks[i].length);

            nBytes += chunks[i].length;

        }

        return mergedFile;

    }

    // Test main for split and merge file

    public static void main(String[] args) {

        String fileName = args[0];

        Path filePath = Paths.get(fileName);

        byte[] fileBytes = null;

        try {

            fileBytes = Files.readAllBytes(filePath);

        } catch (Exception e) {

            e.printStackTrace();

        }

        byte[][] chunks = split(fileBytes);

        try {

            fileBytes = merge(chunks);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}