sdis1819-t7g05

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.net.InetAddress;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.concurrent.ConcurrentHashMap;

/**

 * Peer

 */

public class Peer extends Thread implements TestAppRemote {

    private int serverId;

    private String serviceAccessPoint;

    private int storageCapacity = 100000000; //100MB

    private int storageUsed = 0;

    //HashMap for all the chunks being backed up by this peer

    public ConcurrentHashMap<String, BackupFile> chunksMap = new ConcurrentHashMap<>();

    //HashMap for all the chunks retrieved to restore a file

    public ConcurrentHashMap<String, RestoreFile> restoreMap = new ConcurrentHashMap<>();

    //HashMap for all files asked to be deleted

    public ConcurrentHashMap<String, DeleteFile> deleteMap = new ConcurrentHashMap<>();

    //HashMap for all perceived replication degrees in the network

    public ConcurrentHashMap<String, ConcurrentHashMap<Integer, Integer>> repDegMap = new ConcurrentHashMap<>();

    //HashMap for all files backed up in the network

    public ConcurrentHashMap<String, BackupFile> fileMap = new ConcurrentHashMap<>();

    private InetAddress MDRaddress;

    private int MDRport;

    private InetAddress MDBaddress;

    private int MDBport;

    private InetAddress MCaddress;

    private int MCport;

    public static void main(String[] args) throws NumberFormatException, IOException {

        if(!parseInputs(args))

            return;

        Peer peer = new Peer(args[0], args[1], args[2], args[3]);

        Peer obj = peer;

        TestAppRemote stub = (TestAppRemote) UnicastRemoteObject.exportObject(obj, 0);

        // Bind the remote object's stub in the registry

        Registry registry = LocateRegistry.getRegistry();

        registry.rebind(peer.getServiceAccessPoint(), stub);

    }

    public Peer(String serverId, String MC, String MDB, String MDR)

            throws NumberFormatException, IOException {

        this.serverId = Integer.parseInt(serverId);

        this.serviceAccessPoint = serverId;

        String[] MCinfo = MC.split("_");

        this.MCaddress = InetAddress.getByName(MCinfo[0]);

        this.MCport = Integer.parseInt(MCinfo[1]);

        MCListener mcListener = new MCListener(InetAddress.getByName(MCinfo[0]), Integer.parseInt(MCinfo[1]),

                this.serverId, this);

        new Thread(mcListener).start();

        String[] MDBinfo = MDB.split("_");

        this.MDBaddress = InetAddress.getByName(MDBinfo[0]);

        this.MDBport = Integer.parseInt(MDBinfo[1]);

        MDBListener mdbListener = new MDBListener(InetAddress.getByName(MDBinfo[0]), Integer.parseInt(MDBinfo[1]),

                this.serverId, InetAddress.getByName(MCinfo[0]), Integer.parseInt(MCinfo[1]), this);

        new Thread(mdbListener).start();

        String[] MDRinfo = MDR.split("_");

        this.MDRaddress = InetAddress.getByName(MDRinfo[0]);

        this.MDRport = Integer.parseInt(MDRinfo[1]);

        MDRListener mdrListener = new MDRListener(InetAddress.getByName(MDRinfo[0]), Integer.parseInt(MDRinfo[1]),

                this.serverId, InetAddress.getByName(MCinfo[0]), Integer.parseInt(MCinfo[1]), this);

        new Thread(mdrListener).start();

        fillChunksMap();

        File dir = new File("Peer-" + this.getSenderId() + File.separator + "Backups");

        dir.mkdirs();

    }

    // Saves the chunk under the correct directory: "Chunks\FILE_ID\CHUNK_ID"

    public void saveChunk(Chunk chunk) throws IOException {

        // Create the directory if needed

        File dir = new File(chunk.getDir());

        dir.mkdirs();

        FileOutputStream outputStream = new FileOutputStream(chunk.getPath());

        outputStream.write(chunk.getData());

        outputStream.close();

    }

    // Get current storage usage in Bytes

    public long getCurrentStorageSize(File dir) {

        File[] files = dir.listFiles();

        int count = files.length;

        long length = 0;

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

            if (files[i].isFile()) {

                length += files[i].length();

            } else {

                length += getCurrentStorageSize(files[i]);

            }

        }

        return length;

    }

    private static boolean parseInputs(String[] args) {

        try {

            Integer.parseInt(args[0]);

        } catch (NumberFormatException e) {

            System.out.println("Invalid arguments!: serverId must be a valid int");

            return false;

        }

        String[] MCinfo = args[1].split("_");

        if (MCinfo.length != 2) {

            System.out.println("Invalid arguments!: MC name must be of the format <ip_address>_<port>");

            return false;

        }

        try {

            InetAddress.getByName(MCinfo[0]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MC IP address must be a valid IP");

            return false;

        }

        try {

            Integer.parseInt(MCinfo[1]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MC socket must be valid");

            return false;

        }

        String[] MDBinfo = args[2].split("_");

        if (MDBinfo.length != 2) {

            System.out.println("Invalid arguments!: MDB name must be of the format <ip_address>_<port>");

            return false;

        }

        try {

            InetAddress.getByName(MDBinfo[0]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MDB IP address must be a valid IP");

            return false;

        }

        try {

            Integer.parseInt(MDBinfo[1]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MDB socket must be valid");

            return false;

        }

        String[] MDRinfo = args[3].split("_");

        if (MDRinfo.length != 2) {

            System.out.println("Invalid arguments!: MDR name must be of the format <ip_address>_<port>");

            return false;

        }

        try {

            InetAddress.getByName(MDRinfo[0]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MDR IP address must be a valid IP");

            return false;

        }

        try {

            Integer.parseInt(MDRinfo[1]);

        } catch (Exception e) {

            System.out.println("Invalid arguments!: MDR socket must be valid");

            return false;

        }

        return true;

    }

    @Override

    public void backup(String pathname, int replicationDeg, boolean enhanced) throws RemoteException {

        print("starting BACKUP protocol");

        if (enhanced) {

            new Thread(new BackupTask(pathname, replicationDeg, "2.0", this)).start();

        } else {

            new Thread(new BackupTask(pathname, replicationDeg, "1.0", this)).start();

        }

    }

    @Override

    public void restore(String pathname, boolean enhanced) throws RemoteException {

        print("starting RESTORE protocol");

        if (enhanced) {

            new Thread(new RestoreTask(pathname, "2.0", this)).start();

        } else {

            new Thread(new RestoreTask(pathname, "1.0", this)).start();

        }        

    }

    @Override

    public void delete(String pathname, boolean enhanced) throws RemoteException {

        print("starting DELETE protocol");

        if (enhanced) {

            new Thread(new DeleteTask(pathname, "2.0", this)).start();

        } else {

            new Thread(new DeleteTask(pathname, "1.0", this)).start();

        }

    }

    @Override

    public void reclaim(int diskspace) throws RemoteException {

        print("starting RECLAIM protocol");

        new Thread(new ReclaimTask(diskspace, this)).start();

    }

    @Override

    public void state() throws RemoteException {

        print("starting STATE protocol");

        new Thread(new StateTask(this)).start();

    }

    @Override

    public void chunk(String fileId, byte[] chunk) throws RemoteException {

        this.print("Enhanced CHUNK protocol started");

        this.restoreMap.get(fileId).getChunks().add(chunk);

        this.print("Enhanced CHUNK protocol finished");

    }

    public String getServiceAccessPoint() {

        return this.serviceAccessPoint;

    }

    public void print(String message) {

        System.out.println("[PEER-" + this.serverId + "-Service] " + message);

    }

    public int getSenderId() {

        return this.serverId;

    }

    public InetAddress getMDBaddress() {

        return this.MDBaddress;

    }

    public int getMDBport() {

        return this.MDBport;

    }

    public InetAddress getMDRaddress() {

        return this.MDRaddress;

    }

    public int getMDRport() {

        return this.MDRport;

    }

    public InetAddress getMCaddress() {

        return this.MCaddress;

    }

    public int getMCport() {

        return this.MCport;

    }

    public ConcurrentHashMap<String, BackupFile> getFileMap() {

                return this.fileMap;

    }

    public void addToFileMap(String key, BackupFile file){

        this.fileMap.put(key, file);

    }

    private void fillChunksMap() throws IOException {

        File peerDir = new File("Peer-"+this.serverId+File.separator+"Chunks");

        peerDir.mkdirs();

        for (File file : peerDir.listFiles()) {

            BackupFile backupFile = new BackupFile(file.getName());

            for (File chunk : file.listFiles()) {

                FileInputStream stream = new FileInputStream(chunk);

                byte[] data = new byte[(int)chunk.length()];

                stream.read(data);

                backupFile.addChunk(Integer.parseInt(chunk.getName()), new Chunk(backupFile, Integer.parseInt(chunk.getName()), data));

                this.addStorage(data.length);

                stream.close();

            }

            this.chunksMap.put(file.getName(), backupFile);

        }

    }

    public long addStorage(long size) {

        this.storageUsed += size;

        if(this.storageUsed > this.storageCapacity)

                print("Storage overload!");

        return this.storageUsed;

    }

    public long removeStorage(long size) {

        this.storageUsed -= size;

        if(this.storageUsed < 0)

                print("Negative storage...");

        return this.storageUsed;

    }

    public int getStorageUsed() {

        return this.storageUsed;

    }

    public int getStorageCapacity() {

        return this.storageCapacity;

    }

    public void setStorageCapacity(int cap) {

        this.storageCapacity = cap;

    }

}