sdis1819-t2g03

package chunk;

import java.io.*;

import java.util.ArrayList;

import chunk.FileManager;

import server.Peer;

import utils.Utils;

import static java.util.Arrays.copyOfRange;

public class FolderManager {

        private static long maxMemory;

        private static long usedMemory;

        private Peer peer;

        private String path;

        private FileManager fileManager;

        private static int chunkSizeLimit;

        public FolderManager(Peer peer, long maxMemory) throws ClassNotFoundException {

                this.peer = peer;

                FolderManager.maxMemory = maxMemory;

                chunkSizeLimit = 64000;

                usedMemory = 0;

                path = "results/peer_" + peer.getID() + "/";

                File db = new File(path + "db");

                if (db.exists()) {

                        fileManager = FileManager.loadDatabase(db);

                } else {

                        fileManager = new FileManager();

                }

                makeDir(path + Utils.CHUNKS);

        }

        public static void makeDir(String name) {

                File file = new File(name);

                file.mkdirs();

        }

        public static ArrayList<Chunk> loadChunks(String path, int chunksNumber) throws IOException {

                ArrayList<Chunk> chunks = new ArrayList<>();

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

                        byte[] information = loadFile(new File(path + "/" + i));

                        Chunk chunk = new Chunk("", i, 1, information);

                        chunks.add(chunk);

                }

                return chunks;

        }

        synchronized public static boolean backupFile(String name, String path, byte[] information) throws IOException {

                if (getFreeMemory() < information.length) {

                        System.out.println("Without space to backup file");

                        return false;

                }

                FileOutputStream out;

                out = new FileOutputStream(path + "/" + name);

                out.write(information);

                out.close();

                return FolderManager.incrUsedMemory(information.length);

        }

        synchronized public static byte[] loadFile(File file) throws IOException {

                FileInputStream inStream;

                byte[] information;

                inStream = new FileInputStream(file);

                information = new byte[(int) file.length()];

                inStream.read(information);

                inStream.close();

                return information;

        }

        public static ArrayList<Chunk> fileSplit(byte[] fileInformation, String fileID, int replication) {

                ArrayList<Chunk> chunks;

                int numChunks;

                numChunks = fileInformation.length / chunkSizeLimit + 1;

                chunks = new ArrayList<>();

                for (int i = 0; i < numChunks; i++) 

                {

                        byte[] chunkinformation;

                        if (i == numChunks - 1) 

                        {

                                int leftOverBytes = fileInformation.length - (i * chunkSizeLimit);

                                chunkinformation = copyOfRange(fileInformation, i * chunkSizeLimit, i * chunkSizeLimit + leftOverBytes);

                        } 

                        else if (i == numChunks - 1 && fileInformation.length % chunkSizeLimit == 0) 

                        {

                                chunkinformation = new byte[0];

                        } 

                        else 

                        {

                                chunkinformation = copyOfRange(fileInformation, i * chunkSizeLimit, i * chunkSizeLimit + chunkSizeLimit);

                        }

                        Chunk chunk = new Chunk(fileID, i, replication, chunkinformation);

                        chunks.add(chunk);

                }

                return chunks;

        }

        public byte[] loadChunk(String fileID, int chunkNo) {

                byte[] chunkinformation = null;

                String chunkPath = getChunksPath() + fileID + "/" + chunkNo;

                try {

                        chunkinformation = loadFile(new File(chunkPath));

                } catch (IOException e) {

                        e.printStackTrace();

                }

                return chunkinformation;

        }

        public void deleteChunk(String fileID, int chunkNo) {

                String chunkPath = getChunksPath() + fileID + "/" + chunkNo;

                File file = new File(chunkPath);

                long chunkSize = file.length();

                file.delete();

                decUsedMemory(chunkSize);

                fileManager.deleteChunk(fileID, chunkNo);

        }

        private static void decUsedMemory(long n) {

                usedMemory -= n;

                if (usedMemory < 0) {

                        usedMemory = 0;

                        System.out.println("Used memory went below 0");

                }

        }

        private static boolean incrUsedMemory(long n) {

                if (usedMemory + n > maxMemory) {

                        System.out.println("Tried to surpass memory restrictions");

                        return false;

                }

                usedMemory += n;

                System.out.println("Used memory: " + usedMemory + " / " + maxMemory);

                return true;

        }

        // Getters and setters 

        public static long getMaxMemory() { return maxMemory; }

        public static void setMaxMemory(int maxMemory) { FolderManager.maxMemory = maxMemory; }

        public static long getUsedMemory() { return FolderManager.usedMemory; }

        public static long getFreeMemory() { return maxMemory - usedMemory; }

        public String getRootPath() { return path; }

        public String getChunksPath() { return path + Utils.CHUNKS; }

        public String getRestoresPath() { return path + Utils.RESTORES; }

        public FileManager getDatabase() { return fileManager; }

        public Peer getPeer() { return peer; }

        public void setPeer(Peer peer) { this.peer = peer; }

        public String getPath() { return path; }

        public void setPath(String path) { this.path = path; }

        public FileManager getFileManager() { return fileManager; }

        public void setFileManager(FileManager fileManager) { this.fileManager = fileManager; }

        public static int getChunkSizeLimit() {        return chunkSizeLimit; }

        public static void setChunkSizeLimit(int chunkSizeLimit) { FolderManager.chunkSizeLimit = chunkSizeLimit; }

        public static void setMaxMemory(long maxMemory) { FolderManager.maxMemory = maxMemory; }

        public static void setUsedMemory(long usedMemory) {        FolderManager.usedMemory = usedMemory; }

}