sdis1819-t2g11

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.InetAddress;

import java.nio.file.*;

import java.rmi.AlreadyBoundException;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.concurrent.ConcurrentHashMap;

import javax.print.DocFlavor.STRING;

import java.net.MulticastSocket;

import java.util.ArrayList;

public class Peer implements RMInterface {

    private static MC mc;

    private static MDB mdb;

    private static MDR mdr;

    private static int peerId;

    private static String protocolVersion;

    private static ChannelsInfo cInfo;

    private static String accessPoint;

    private static PeersInfo peersInfo;

    public Peer() {

        try {

            FileInputStream fileIn = new FileInputStream("./peer" + peerId + "/memory.ser");

            ObjectInputStream in = new ObjectInputStream(fileIn);

            peersInfo = (PeersInfo) in.readObject();

            in.close();

            fileIn.close();

        } catch (Exception e) {

            System.out.println("Create new PeersInfo");

            peersInfo = new PeersInfo(peerId);

        }

    }

    public static void main(String[] args) {

        try {

            accessPoint = args[2];

            protocolVersion = args[0];

            try {

                peerId = Integer.parseInt(args[1]);

            } catch (NumberFormatException e) {

                peerId = 0;

            }

            setRMI();

            parseArgs(args);

            System.err.println("Peer ready");

        } catch (Exception e) {

            System.err.println("Peer exception: " + e.toString());

            e.printStackTrace();

        }

    }

    public static void parseArgs(String[] args) {

        try {

            cInfo = new ChannelsInfo();

            cInfo.MCa = InetAddress.getByName(args[3]);

            cInfo.MCp = Integer.parseInt(args[4]);

            cInfo.MDBa = InetAddress.getByName(args[5]);

            cInfo.MDBp = Integer.parseInt(args[6]);

            cInfo.MDRa = InetAddress.getByName(args[7]);

            cInfo.MDRp = Integer.parseInt(args[8]);

            cInfo.socketMC = new MulticastSocket(cInfo.MCp);

            cInfo.socketMDB = new MulticastSocket(cInfo.MDBp);

            cInfo.socketMDR = new MulticastSocket(cInfo.MDRp);

            cInfo.socketMC.joinGroup(cInfo.MCa);

            cInfo.socketMDB.joinGroup(cInfo.MDBa);

            cInfo.socketMDR.joinGroup(cInfo.MDRa);

            mc = new MC(peersInfo, cInfo, peerId, cInfo.MCa, cInfo.MCp);

            mdb = new MDB(peersInfo, cInfo, peerId, cInfo.MDBa, cInfo.MDBp);

            mdr = new MDR(peersInfo, cInfo, peerId, cInfo.MDRa, cInfo.MDRp);

            mc.start();

            mdb.start();

            mdr.start();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    private static void setRMI() {

        try {

            Peer peer = new Peer();

            RMInterface stub = (RMInterface) UnicastRemoteObject.exportObject(peer, 0);

            try {

                Registry registry = LocateRegistry.createRegistry(1099);

                registry.rebind(accessPoint, stub);

            } catch (Exception e) {

                Registry registry = LocateRegistry.getRegistry();

                registry.rebind(accessPoint, stub);

            }

        } catch (RemoteException e) {

            e.printStackTrace();

        }

    }

    public byte[] createMessage(String protocol, String version, int senderId, String fileId, String[] args,

            byte[] body) {

        String msg = "";

        msg = protocol + " " + version + " " + senderId + " " + fileId + " ";

        for (String arg : args) {

            msg += arg + " ";

        }

        msg += "\r\n\r\n";

        ByteArrayOutputStream append = new ByteArrayOutputStream();

        try {

            append.write(msg.getBytes());

            if (body != null)

                append.write(body);

        } catch (IOException e) {

            e.printStackTrace();

        }

        return append.toByteArray();

    }

    public static void serialize_storage(PeersInfo info, int peerid) {

        try {

            String path = "./peer" + peerid + "/";

            File file = new File(path);

            file.mkdirs();

            file = new File(path + "memory.ser");

            FileOutputStream fileIn = new FileOutputStream(file);

            ObjectOutputStream in = new ObjectOutputStream(fileIn);

            in.writeObject(info);

            in.close();

            fileIn.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public Integer getUsedStorage() {

        if (peersInfo.spaceUsedOnDisk.get(peerId) == null)

            return 0;

        else

            return peersInfo.spaceUsedOnDisk.get(peerId);

    }

    public Integer getMaxStorage() {

        return peersInfo.getMaxStorage();

    }

    private boolean hasFreeSpace(Integer size) {

        return getUsedStorage() + size > getMaxStorage();

    }

    @Override

    public void backupFile(String path, int repDegree) throws Exception {

        System.out.println("Entra no Backup");

        File fileRead = new File(path);

        if (!fileRead.exists()) {

            throw new Exception("[ERROR] Couldn't locate file");

        }

        FilesInfo file = new FilesInfo(peerId, path, repDegree);

        String key = file.getFileID() + ":" + path;

        peersInfo.files.put(key, file.getChunks().size());

        for (int i = 0; i < file.getChunks().size(); i++) {

            Chunk currChunk = file.getChunks().get(i);

            System.out.println("CURRRRORIGINAL->" + currChunk.getReplicationDegree());

            String id = "";

            id = currChunk.getFileID() + ":" + currChunk.getChunkNo();

            peersInfo.storage.put(id, currChunk);

            String[] args = new String[2];

            args[0] = String.valueOf(currChunk.getChunkNo());

            args[1] = String.valueOf(repDegree);

            System.out.println("CURR PASSADAAOS peers->" + repDegree);

            byte[] msg = createMessage("PUTCHUNK", protocolVersion, peerId, file.getFileID(), args,

                    currChunk.getData());

            try {

                int time = 1000;

                int counter = 1;

                Message mensagem = new Message(msg, msg.length);

                cInfo.send(mensagem, cInfo.socketMDB, cInfo.MDBa, cInfo.MDBp);

                int NoStored = peersInfo.getStorage().get(id).getCurrReplicationDegree();

                int chunkReplicationDegree = peersInfo.getStorage().get(id).getReplicationDegree();

                System.out.println("Chunk" + currChunk.getChunkNo());

                System.out

                        .println("CurrReplicationDegree->" + peersInfo.getStorage().get(id).getCurrReplicationDegree());

                System.out.println("ReplicationDegree->" + peersInfo.getStorage().get(id).getReplicationDegree());

                while (counter < 5) {

                    Thread.sleep(time);

                    NoStored = peersInfo.getStorage().get(id).getCurrReplicationDegree();

                    chunkReplicationDegree = peersInfo.getStorage().get(id).getReplicationDegree();

                    System.out.println(

                            "CurrReplicationDegree->" + peersInfo.getStorage().get(id).getCurrReplicationDegree());

                    System.out.println("ReplicationDegree->" + peersInfo.getStorage().get(id).getReplicationDegree());

                    if (NoStored < chunkReplicationDegree) {

                        cInfo.send(mensagem, cInfo.socketMDB, cInfo.MDBa, cInfo.MDBp);

                        time = 2 * time;

                        counter++;

                    } else {

                        counter = 5;

                    }

                }

            } catch (Exception e) {

            }

        }

    }

    @Override

    public void backupEnhFile(String path, int repDegree) throws Exception {

        System.out.println("Entra no Backup");

        File fileRead = new File(path);

        if (!fileRead.exists()) {

            throw new Exception("[ERROR] Couldn't locate file");

        }

        FilesInfo file = new FilesInfo(peerId, path, repDegree);

        String key = file.getFileID() + ":" + path;

        peersInfo.files.put(key, file.getChunks().size());

        for (int i = 0; i < file.getChunks().size(); i++) {

            Chunk currChunk = file.getChunks().get(i);

            System.out.println("CURRRRORIGINAL->" + currChunk.getReplicationDegree());

            // por no hashmap

            String id = "";

            id = currChunk.getFileID() + ":" + currChunk.getChunkNo();

            peersInfo.storage.put(id, currChunk);

            String[] args = new String[2];

            args[0] = String.valueOf(currChunk.getChunkNo());

            args[1] = String.valueOf(repDegree);

            System.out.println("CURRPASSADAAOS peers->" + repDegree);

            byte[] msg = createMessage("PUTCHUNK", protocolVersion, peerId, file.getFileID(), args,

                    currChunk.getData());

            try {

                int time = 1000;

                int counter = 1;

                Message mensagem = new Message(msg, msg.length);

                cInfo.send(mensagem, cInfo.socketMDB, cInfo.MDBa, cInfo.MDBp);

                int NoStored = peersInfo.getStorage().get(id).getCurrReplicationDegree();

                int chunkReplicationDegree = peersInfo.getStorage().get(id).getReplicationDegree();

                System.out.println("Chunk" + currChunk.getChunkNo());

                System.out

                        .println("CurrReplicationDegree->" + peersInfo.getStorage().get(id).getCurrReplicationDegree());

                System.out.println("ReplicationDegree" + peersInfo.getStorage().get(id).getReplicationDegree());

                while (counter < 5) {

                    Thread.sleep(time);

                    NoStored = peersInfo.getStorage().get(id).getCurrReplicationDegree();

                    chunkReplicationDegree = peersInfo.getStorage().get(id).getReplicationDegree();

                    System.out.println(

                            "CurrReplicationDegree->" + peersInfo.getStorage().get(id).getCurrReplicationDegree());

                    System.out.println("ReplicationDegree->" + peersInfo.getStorage().get(id).getReplicationDegree());

                    if (NoStored < chunkReplicationDegree) {

                        cInfo.send(mensagem, cInfo.socketMDB, cInfo.MDBa, cInfo.MDBp);

                        time = 2 * time;

                        counter++;

                    } else {

                        counter = 5;

                    }

                }

            } catch (Exception e) {

            }

        }

    }

    @Override

    public void restoreFile(String path) throws RemoteException {

        System.out.println("Entra no restore");

        for (ConcurrentHashMap.Entry<String, Chunk> entry : peersInfo.storage.entrySet()) {

            String key = entry.getKey().toString();

            Chunk value = entry.getValue();

            System.out.println("File id e No: " + key);

        }

        File fileRead = new File(path);

        FilesInfo file = new FilesInfo(peerId, path, 2);

        for (int i = 0; i < file.getChunks().size(); i++) {

            Chunk currChunk = file.getChunks().get(i);

            String id = "";

            id = currChunk.getFileID() + ":" + currChunk.getChunkNo();

            String[] args = new String[1];

            args[0] = String.valueOf(currChunk.getChunkNo());

            byte[] msg = createMessage("GETCHUNK", protocolVersion, peerId, file.getFileID(), args, null);

            try {

                int time = 1000;

                int counter = 1;

                Message mensagem = new Message(msg, msg.length);

                mensagem.setMessageType(Message.MessageType.GETCHUNK);

                mensagem.setProtocolVersion(protocolVersion);

                mensagem.setSenderId(peerId);

                mensagem.setFileID(file.getFileID());

                cInfo.send(mensagem, cInfo.socketMC, cInfo.MCa, cInfo.MCp);

                Thread.sleep(400);

            } catch (Exception e) {

                System.out.println("[ERROR] Exception in sending <GETCHUNK> message");

                e.printStackTrace();

            }

        }

    }

    @Override

    public void deleteFile(String path) throws RemoteException {

        System.out.println("entra no delete");

        FilesInfo fileInfo = new FilesInfo(peerId, path, 1);

        System.out.println("[FILEID]: " + fileInfo.getFileID());

        System.out.println("[PATH]: " + path);

        String[] args = new String[0]; // no args

        byte[] msg = createMessage("DELETE", protocolVersion, peerId, fileInfo.getFileID(), args, null);

        try {

            Message mensagem = new Message(msg, msg.length);

            cInfo.send(mensagem, cInfo.socketMC, cInfo.MCa, cInfo.MCp);

        } catch (Exception e) {

            System.out.println("[ERROR] Exception in sending <DELETE> message");

            e.printStackTrace();

        }

        try {

            Files.deleteIfExists(fileInfo.getFile().toPath());

            System.out.println("[INFO] File deleted successfully");

        } catch (NoSuchFileException x) {

            System.err.format("%s: no such" + " file or directory%n", fileInfo.getFile().toPath());

        } catch (DirectoryNotEmptyException x) {

            System.err.format("%s not empty%n", fileInfo.getFile().toPath());

        } catch (IOException x) {

            System.err.println(x);

        }

    }

    @Override

    public void reclaim(int size) throws RemoteException {

        // Ir a storage

        System.out.println("______________________");

        System.out.println("Entra no Reclaim");

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

        for (ConcurrentHashMap.Entry<String, Chunk> entry : peersInfo.storage.entrySet()) {

            String key = entry.getKey().toString();

            Chunk currChunk = entry.getValue();

            if (currChunk.getPeersId().contains(peerId)) {

                chunksOnDisk.add(currChunk);

                System.out.println("File id e No: " + key);

                // significa que o peer a guardou no sistema

            }

        }

        System.out.println("Espaço usado até agora->" + Integer.toString(peersInfo.getSpaceUsedOnDisk().get(peerId)));

        int i = 0;

        while (peersInfo.getSpaceUsedOnDisk().get(peerId) > size) {

            if (i < chunksOnDisk.size()) {

                Chunk chunkToDelete = chunksOnDisk.get(i);

                int space = peersInfo.getSpaceUsedOnDisk().get(peerId);

                peersInfo.spaceUsedOnDisk.replace(peerId, space - chunkToDelete.getData().length);

                deleteFiles(chunkToDelete);

                String[] args = new String[1]; // no args

                args[0] = Integer.toString(chunkToDelete.getChunkNo());

                byte[] msg = createMessage("REMOVED", protocolVersion, peerId, chunkToDelete.getFileID(), args, null);

                try {

                    Message mensagem = new Message(msg, msg.length);

                    cInfo.send(mensagem, cInfo.socketMC, cInfo.MCa, cInfo.MCp);

                    Thread.sleep(2000);

                } catch (Exception e) {

                    System.out.println("[ERROR] Exception in sending <REMOVED> message");

                    e.printStackTrace();

                }

                i++;

            }

        }

    }

    public void deleteFiles(Chunk chunktoDelete) throws RemoteException {

        // removes each chunk

        Path path = Paths.get("./peer" + peerId + "/" + "backup/" + chunktoDelete.getFileID() + "/chk"

                + Integer.toString(chunktoDelete.getChunkNo()) + ".chunk");

        try {

            Files.deleteIfExists(path);

        } catch (IOException e) {

            System.err.println("[ERROR] Could not delete chunk folder");

            e.printStackTrace();

        }

        // removes directory from FileSystem

        Path pathfileID = Paths.get("./peer" + peerId + "/" + "backup/" + chunktoDelete.getFileID() + "/chk"

                + Integer.toString(chunktoDelete.getChunkNo()) + ".chunk");

        try {

            Files.deleteIfExists(pathfileID);

        } catch (IOException e) {

            System.err.println("[ERROR] Could not delete chunk");

            e.printStackTrace();

        }

    }

    @Override

    public String state() throws RemoteException {

        StringBuilder stateString = new StringBuilder();

        stateString.append("\n============ CURRENT PEER STATE ============\n\n");

        stateString.append("Files whose backup was initiated by this peer:\n");

        for (ConcurrentHashMap.Entry<String, Integer> entry : peersInfo.getFiles().entrySet()) {

            Integer numberOfChunks = entry.getValue();

            String[] entrySplit = entry.getKey().split(":");

            String fileID = entrySplit[0];

            String fileName = entrySplit[1];

            stateString.append("\t\tFile Pathname = " + fileName + " | fileID = " + fileID + "\n");

        }

        stateString.append("\nChunks stored in this peer:\n");

        for (ConcurrentHashMap.Entry<String, Chunk> entry : peersInfo.storage.entrySet()) {

            String key = entry.getKey().toString();

            Chunk chunk = entry.getValue();

            ArrayList<Integer> chunkSavedOnPeers = chunk.getPeersId();

            for (Integer savedOnPeer : chunkSavedOnPeers) {

                if (savedOnPeer == peerId) {

                    stateString.append("\t\tChunk id: " + chunk.getChunkNo() + " | Chunk size (KB): "

                            + chunk.getData().length / 1000 + " | Perceived replication degree:\n");

                }

            }

        }

        stateString.append("\nMax storage capacity (KB): " + getMaxStorage() / 1000 + "\n");

        stateString.append("Current amount of storage used (KB): " + getUsedStorage() / 1000 + "\n");

        return stateString.toString();

    }

}