sdis1819-t7g07

package utils;

import java.io.*;

import java.nio.charset.StandardCharsets;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.attribute.BasicFileAttributes;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class FileController implements Serializable {

    private String messageType;

    private String version;

    private int senderId; //id of the server that has sent the message

    private String fileId; //metadata of file

    private byte[] body;

    private String hashedFileId; //hashed string with SHA256

    private String chunkNo; //together with the FileId specifies a chunk in the file.

    private String replicationDeg; //up to 9

    private int fileSize;

    private File file;

    private FileInputStream fileStream;

    public FileController(String m, String v, int s, String f, String r) throws IOException {

        this.messageType = m;

        this.version = v;

        this.senderId = s;

        this.fileId = f;

        this.replicationDeg = r;

    }

    public FileController(String[] receivedArray, byte[] bodyByteArray){

        String headerMsg = receivedArray[0];

        String[] headerTokens = headerMsg.split("\\s+");

        this.messageType = headerTokens[0];

        this.version = headerTokens[1];

        this.chunkNo = headerTokens[4];

        this.hashedFileId = headerTokens[3];

        if(headerTokens.length >= 6)

            this.replicationDeg = headerTokens[5];

        else

            this.replicationDeg = "";

        this.senderId = Integer.parseInt(headerTokens[2]);

        this.body = bodyByteArray;

        this.fileId = null;

    }

    public String getFileMetadata(String f) throws IOException {

        Path file = FileSystems.getDefault().getPath("test", f);

        BasicFileAttributes attr = Files.readAttributes(file, BasicFileAttributes.class);

        return f + "-" + attr.lastModifiedTime() + "-" + attr.creationTime();

    }

    public String getFileName(){

        return this.fileId;

    }

    public void saveToDisk(int senderId, String chunckNo) throws IOException {

        System.out.println("saving to disk...  ||  Sender ID: " + senderId + "  ||  ChunkNo: " + chunkNo);

        File storage = new File("storage");

        // if the directory does not exist, create it

        if (!storage.exists()) {

            System.out.println("creating directory to store chunks: " + storage.getName());

            boolean result = false;

            try{

                storage.mkdir();

                result = true;

            }

            catch(SecurityException se){

                //handle it

            }

            if(result) {

                System.out.println("Storage Directory created");

            }

        }

        //directory for backup

        File backup = new File ("storage/Backup");

        // if the directory does not exist, create it

        if (!backup.exists()) {

            System.out.println("creating directory to store chunks: " + backup.getName());

            boolean result = false;

            try{

                backup.mkdir();

                result = true;

            }

            catch(SecurityException se){

                //handle it

            }

            if(result) {

                System.out.println("Backup Directory created");

            }

        }

        //directory for peerid

        File peerId = new File ("storage/Backup/Peer" + senderId);

        // if the directory does not exist, create it

        if (!peerId.exists()) {

            System.out.println("creating directory to store chunks: " + peerId.getName());

            boolean result = false;

            try{

                peerId.mkdir();

                result = true;

            }

            catch(SecurityException se){

                //handle it

            }

            if(result) {

                System.out.println("PeerId Directory created");

            }

        }

        //directory for hashed file id

        //System.out.println(this.hashedFileId);

        File hashedDir = new File("storage/Backup/Peer" + senderId + "/"+ this.hashedFileId);

        // if the directory does not exist, create it

        if (!hashedDir.exists()) {

            System.out.println("creating directory to store chunks: " + hashedDir.getName());

            boolean result = false;

            try{

                hashedDir.mkdir();

                result = true;

            }

            catch(SecurityException se){

                //handle it

            }

            if(result) {

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

            }

        }

        //now store the chunck

        File chunk = new File("storage/Backup/Peer" + senderId + "/"+ this.hashedFileId + "/" + chunckNo);

        FileOutputStream fos = new FileOutputStream(chunk);

        fos.write(this.body);

        fos.close();

    }

    public void hashFileId() throws NoSuchAlgorithmException, IOException { //reference https://www.baeldung.com/sha-256-hashing-java

        //add a little more info to hash this fileId;

        String fileIdWithMetadata = getFileMetadata(this.fileId);

        if(!Utils.hashDatabase.containsKey(this.fileId)){

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

            byte[] encodedhash = digest.digest(

                    fileIdWithMetadata.getBytes(StandardCharsets.UTF_8));

            String hexHash = Utils.encodeHexString(encodedhash);

            this.hashedFileId = hexHash;

            Utils.hashDatabase.put(this.fileId,hexHash);

        }

        else this.hashedFileId = Utils.hashDatabase.get(this.fileId);

    }

    public void openStream() throws FileNotFoundException {

        this.file = new File("test/" + getFileName());

        this.fileStream = new FileInputStream(this.file);

        this.fileSize = ((int) this.file.length());

    }

    public byte[] header(int chunkNo){

        String header = "";

        switch(messageType){

            case "BACKUP":

                header = messageType + " " + version + " " + senderId + " " + hashedFileId + " " + chunkNo + " " + replicationDeg + "\r\n\r\n";

                break;

            case "RESTORE":

                header = messageType + " " + version + " " + senderId + " " + hashedFileId + " " + chunkNo + "\r\n\r\n";

                break;

        }

        byte[] buffer = header.getBytes();

        return buffer;

    }

    public int getSenderId() {

        return senderId;

    }

    public String getHashedFileId() {

        return hashedFileId;

    }

    public int getSize() {

        return fileSize;

    }

    public FileInputStream getFileStream(){

        return fileStream;

    }

    public String getReplicationDeg(){

        return replicationDeg;

    }

    public String getChunkNo() {

        return chunkNo;

    }

    public String getVersion() {

        return this.version;

    }

    public byte[] getBody(){

        return body;

    }

}