sdis1819-t7g06

package Storage;

import Peers.Peer;

import java.io.*;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.attribute.UserPrincipal;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.HashMap;

import java.util.List;

public class FileSystem implements Serializable {

    private final Peer peer;

    private int maxSize;

    private int inUse = 0;

    private int peerID;

    private String base;

    public FileSystem(int maxSize, String directory, int peerID, Peer peer) {

        this.maxSize = maxSize;

        this.peerID = peerID;

        this.base = directory + peerID;

        this.peer = peer;

        createDir();

    }

    public int availableSpace() {

        return maxSize - inUse;

    }

    public void setSpace(int inc) {

        maxSize = inc;

    }

    public int getInUse() {

        return inUse;

    }

    public String createFileID(String filepath, BasicFileAttributes attr, byte[] info) throws NoSuchAlgorithmException {

        String id = "";

        String[] fileName = filepath.split("/");

        try {

            Path path = Paths.get(filepath);

            UserPrincipal name = Files.getOwner(path);

            id += name.toString();

            byte[] sh = new byte[(int) attr.size() / 3];

            System.arraycopy(sh, 0, info, 0, (int) attr.size() / 3);

            id += attr.fileKey() + fileName[fileName.length - 1] + (new String(sh));

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

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

        byte[] result = mDigest.digest(id.getBytes());

        StringBuffer hexString = new StringBuffer();

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

            hexString.append(Integer.toHexString(0xFF & result[i]));

        }

        return hexString.toString();

    }

    public void saveFile(String file, byte[] info) throws Exception {

        if(info.length > availableSpace())

            throw new Exception("file is huge......... NO space");

        File nfile = new File(base + "/restored/" + file);

        System.out.println(info.length);

        try {

            if (nfile.createNewFile()) {

                FileOutputStream writer = new FileOutputStream(base + "/restored/" + file);

                writer.write(info, 0, info.length);

                inUse -= info.length;

                writer.close();

            } else {

                System.out.println("Fail creating file");

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public boolean saveChunk(Chunk chunk, String fileId) {

        if (chunk.getInfo().length > availableSpace())

            return false;

        try {

            File dir = new File(base + "/" + "backup/" + fileId);

            File nfile = new File(base + "/" + "backup/" + fileId + "/" + chunk.getId());

            dir.mkdir();

            if (nfile.createNewFile()) {

                FileOutputStream writer = new FileOutputStream(nfile);

                writer.write(chunk.getInfo(), 0, chunk.getInfo().length);

                writer.close();

                inUse += chunk.getInfo().length;

                return true;

            } else {

                System.out.println("Fail creating file");

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return false;

    }

    public HashMap<String, byte[]> getChunks(String fileId) {

        HashMap<String, byte[]> chunksInfo = new HashMap<>();

        String name;

        String dir = base + "/backup/" + fileId;

        File[] files = new File(dir).listFiles();

        try {

            for (File abc : files) {

                if (!abc.isDirectory()) {

                    name = abc.getName();

                    FileInputStream in = new FileInputStream(dir + "/" + name);

                    byte[] info = in.readAllBytes();

                    chunksInfo.put(name, info);

                }

            }

        } catch (Exception e) {

        //    e.printStackTrace();

        }

        return chunksInfo;

    }

    private void createDir() {

        Path pathres = Paths.get(base + "/restored");

        Path pathchunks = Paths.get(base + "/backup");

        try {

            Files.createDirectories(pathres);

            Files.createDirectory(pathchunks);

        } catch (IOException e) {

           // e.printStackTrace();

        }

    }

    public void delete(String fileID) {

        try {

            String dir = base + "/backup/" + fileID;

            File l = new File(dir);

            System.out.println(dir);

            if (l.isDirectory()) {

                File[] file = l.listFiles();

                for (File i : file) {

                    this.inUse -= i.length();

                    i.delete();

                }

                l.delete();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public boolean reclaimSpace(int reclaimed) {

        if(reclaimed >= inUse ) {

            maxSize = reclaimed;

            return true;

        }

        else{

           try{

               peer.getControl().reduceChunks( inUse - reclaimed);

               return true;

           }catch (Exception e){

               e.printStackTrace();

           }

           return false;

        }

    }

}