sdis1819-t2g03

package server;

import protocols.BackupChunk;

import protocols.DeleteChunk;

import sockets.Socket;

import sockets.MultiCastSocket;

import sockets.MDBSocket;

import sockets.MDRSocket;

import sockets.Socket.SocketType;

import utils.Utils;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.*;

import chunk.*;

import handlers.Handler;

import handlers.Message;

public class Peer implements InitiatorPeer {

        private int id;

        private Handler handler;

        private ScheduledExecutorService agent;

        private Map<SocketType, Socket> sockets;

        private FolderManager folderManager;

        private FileManager fileManager;

        private Chunk peerInformation;

        private MultiCastSocket mc;

        private MDRSocket mdr;

        private MDBSocket mdb;

        public Peer(int id, String[] MC, String[] MDB, String[] MDR) throws IOException, ClassNotFoundException {

                this.id = id;

                folderManager = new FolderManager(this, 8000000);     //8000000 = size of maximum memory (8MB)

                fileManager = folderManager.getDatabase();

                String mcAddr = MC[0];

                String mcPort = MC[1];

                String mdbAddr = MDB[0];

                String mdbPort =  MDB[1];

                String mdrAddr = MDR[0];

                String mdrPort = MDR[1];

                mc= new MultiCastSocket(this, mcAddr, mcPort);

                mdb= new MDBSocket(this, mdbAddr, mdbPort);

                mdr= new MDRSocket(this, mdrAddr, mdrPort);

                new Thread(mc).start();

                new Thread(mdb).start();

                new Thread(mdr).start();

                sockets = new HashMap<>();

                sockets.put(SocketType.MC, mc);

                sockets.put(SocketType.MDB, mdb);

                sockets.put(SocketType.MDR, mdr);

                peerInformation = new Chunk();

                handler = new Handler(this);

                new Thread(handler).start();

                agent = new ScheduledThreadPoolExecutor(10);

                System.out.println("Peer " + id + " is alive!");

        }

        public static void main(String args[]) {

                String[] mc = args[1].split(":");

                String[] mdb = args[2].split(":");

                String[] mdr = args[3].split(":");

                System.setProperty("java.net.preferIPv4Stack", "true"); // Flag needed for systems that use IPv6 by default

                try {

                        Peer peer = new Peer(Integer.parseInt(args[0]), mc, mdb, mdr);

                        InitiatorPeer initiatorPeer = (InitiatorPeer) UnicastRemoteObject.exportObject(peer, 0);

                        Registry registry = LocateRegistry.getRegistry();

                        registry.rebind(args[0], initiatorPeer);

                        System.out.println("Peer ready!");

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

        public int getID() {

                return id;

        }

        public Socket getSocket(SocketType socketType) {

                return sockets.get(socketType);

        }

        public String getPath(String path) {

                String pathname;

                if(path == "chunks")

                        pathname = folderManager.getChunksPath();

                else

                        pathname = "";

                return pathname;

        }

        public void sendLateMsg(SocketType type, Message msg, long delay, TimeUnit unit) {

                agent.schedule(() -> {

                        try {

                                sendMsg(type, msg);

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                }, delay, unit);

        }

        public void sendMsg(SocketType socketType, Message msg) throws IOException {

                System.out.println("S:  " + msg.toString());

                sockets.get(socketType).sendMsg(msg.getBytes());

        }

        public void pushMsgHandler(byte[] data, int length) throws IOException {

                handler.pushMessage(data, length);

        }

        public void addFileToFileManager(String pathName, FileManager fileInfo) {

                fileManager.addFile(pathName, fileInfo);

        }

        public void addChunkToFileManager(Chunk chunkInfo) {

                fileManager.addChunk(chunkInfo);

        }

        public void deleteFileFromFileManager(String pathName) {

                fileManager.removeFile(pathName);

        }

        public FileManager getFile(String pathName) {

                return fileManager.getFileInformation(pathName);

        }

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

                return folderManager.loadChunk(fileID, chunkNo);

        }

        public Chunk getPeerInformation() {

                return peerInformation;

        }

        public FileManager getDatabase() {

                return fileManager;

        }

        public FolderManager getSystemManager() {

                return folderManager;

        }

        @Override

        public String backup(File file, int replicationDegree) {

                agent.execute(new BackupChunk(Utils.VERSION, file, replicationDegree, this));

                return "backup command ok";

        }

        @Override

        public void restore(String pathname) {

                return;

        }

        @Override

        public void delete(String pathname) {

                agent.execute(new DeleteChunk("1.0", pathname, this));

        }

        @Override

        public void reclaim(int space) {

        }

        @Override

        public void state() {

        }

}