SDIS1819-T2G01

import java.rmi.registry.Registry;

import java.rmi.registry.LocateRegistry;

import java.rmi.RemoteException;

import java.rmi.server.UnicastRemoteObject;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ScheduledThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.Executors;

import java.util.concurrent.CopyOnWriteArrayList;;

import java.util.ArrayList;

import java.util.List;

import java.util.Comparator;

import java.util.HashSet;

import java.util.Collections;

import java.io.*;

import java.net.DatagramPacket;

import java.nio.file.*;

//Server class essentially a Peer

public class Server implements PeerInterface {

    // Unique peer id

    public String id;

    // Size controls

    public static final int DEFAULT_MAX_SIZE = 1000000000;

    public int limit;

    public int used;

    // Thread Pool

    public static ScheduledThreadPoolExecutor pool;

    // Sockets

    public static Socket MC;

    public static Socket MDB;

    public static Socket MDR;

    // State Backup

    public boolean doingBackUp;

    public String file;

    public int replications;

    // State Restore

    public boolean restoring;

    public AtomicBoolean waitRestoreReply = new AtomicBoolean(false);

    public ConcurrentHashMap<String, Chunk> recoveredChunks = new ConcurrentHashMap<String, Chunk>(); // ChunkNo -> Chunk

    // Service Management Information

    public ConcurrentHashMap<String, Chunk> chunks = new ConcurrentHashMap<String, Chunk>(); // fileId-ChunkNo

                                                                                             // -> Chunk

    public ConcurrentHashMap<String, String> files = new ConcurrentHashMap<String, String>(); // fileId -> // file name

    // Empty Constructor

    public Server() {

    }

    // Simplified Constructor(Default values)

    public Server(String id) throws IOException {

        this.used = 0;

        this.id = id;

        this.limit = DEFAULT_MAX_SIZE;

        this.setupSockets();

        this.loadLocal();

        this.setupDirectory();

    }

    // Full constructor

    public Server(String id, int portMC, String addressMC, int portMDB, String addressMDB, int portMDR,

            String addressMDR) throws IOException {

        this.used = 0;

        this.id = id;

        this.limit = DEFAULT_MAX_SIZE;

        this.setupSockets(portMC, addressMC, portMDB, addressMDB, portMDR, addressMDR);

        this.loadLocal();

        this.setupDirectory();

    }

    // Backup Protocol

    public void backup(String path, int replications) throws RemoteException {

        // TODO is file backed up already?

        // Start backup

        this.doingBackUp = true;

        // Extract file name

        int index = path.lastIndexOf("\\");

        String fileName = path.substring(index + 1);

        // Generate Hash

        // TODO dont use just file name for hashing(multiple file versions with same

        // name problem)

        String fileId = FileManager.hash(fileName);

        // Add to file list

        this.files.put(fileId, fileName);

        try {

            // Get file bytes

            byte[] bytes = FileManager.readFile(path);

            // Get file in chunks

            byte[][] chunks = FileManager.split(bytes);

            // Send each chunk

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

                // Base receive time of 1 second

                int receiveTime = 1000;

                // PUTCHUNK tries

                for (int j = 0; j < 5; j++) {

                    // Prepare message

                    Message msg = new Message(Message.MessageType.PUTCHUNK, id, fileId, i, replications, chunks[i]);

                    // Pack in datagram

                    DatagramPacket packet = msg.packit(MDB.address, MDB.port);

                    // Send message

                    MDB.socket.send(packet);

                    // Wait for replies and check Replication level

                    this.replications = 0;

                    this.file = fileId;

                    Thread.sleep(receiveTime);

                    if (this.replications >= replications) {

                        break;

                    }

                    // Double receive time

                    receiveTime *= 2;

                }

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        // Terminate backup

        this.doingBackUp = false;

    }

    // Restore Protocol

    public void restore(String path) throws RemoteException {

        this.restoring = true;

        // File name

        int index = path.lastIndexOf("\\");

        String fileName = path.substring(index + 1);

        // Generate Hash

        // TODO dont use just file name for hashing(multiple file versions with same

        // name problem)

        String fileId = FileManager.hash(fileName);

        // Find in list of backed up

        String name = this.files.get(fileId);

        // File not backed up yet, just return

        if (name == null) {

            return;

        }

        try {

            // Get byte count (probably better than actually fetching the bytes array)

            File file = new File(path);

            int bytes = (int) file.length();

            // How many chunks to expect

            int chunks = 1 + bytes / FileManager.chunkSize;

            // Reset list of Chunks recovered

            this.recoveredChunks.clear();

            // Request chunks

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

                // Prepare message

                Message msg = new Message(Message.MessageType.GETCHUNK, id, fileId, i, 0, new byte[0]);

                // Pack in datagram

                DatagramPacket packet = msg.packit(MC.address, MC.port);

                // Send message

                MC.socket.send(packet);

                // Wait for response

                this.waitRestoreReply.set(true);

                while (this.waitRestoreReply.get()) {

                }

            }

            //Get simple list from recovered chunks

            List<Chunk> list = new ArrayList<Chunk>(this.recoveredChunks.values());

            // Sort chunks

            Collections.sort(list, new Comparator<Chunk>() {

                @Override

                public int compare(Chunk p1, Chunk p2) {

                    return p1.chunkN - p2.chunkN; // Ascending

                }

            });

            // Pack chunks

            byte[][] allBytes = new byte[list.size()][];

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

                allBytes[i] = list.get(i).bytes;

            }

            // Merge chunks

            byte[] fileBytes = FileManager.merge(allBytes);

            // Save file

            Path current = Paths.get("");

            String place = current.toAbsolutePath().toString() + "\\peer" + id + "\\restored\\" + fileName;

            try (FileOutputStream stream = new FileOutputStream(place)) {

                stream.write(fileBytes);

                stream.close();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        this.restoring = false;

    }

    // Delete chunks associated to this file

    public void delete(String path) throws RemoteException {

        // File name

        int index = path.lastIndexOf("\\");

        String fileName = path.substring(index + 1);

        // Generate Hash

        // TODO dont use just file name for hashing(multiple file versions with same

        // name problem)

        String fileId = FileManager.hash(fileName);

        try {

            // Prepare message

            Message msg = new Message(Message.MessageType.DELETE, id, fileId, 0, 0, new byte[0]);

            // Pack in datagram

            DatagramPacket packet = msg.packit(MC.address, MC.port);

            // Send message

            MC.socket.send(packet);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public void reclaim(int memory) throws RemoteException {

        // Memory can't be lower than 0

        if (memory < 0) {

            return;

        }

        // Assign new limit

        limit = memory;

        try {

            // Check need to delete chunks

            // Going to delete by order in the map

            while (used > limit) {

                // Pick an entry

                Map.Entry<String, Chunk> entry = chunks.entrySet().iterator().next();

                // Remove from used space

                used -= entry.getValue().bytes.length;

                // Prepare message

                Message msg = new Message(Message.MessageType.REMOVED, id, entry.getValue().fileId,

                        entry.getValue().chunkN, 0, new byte[0]);

                // Pack in datagram

                DatagramPacket packet = msg.packit(MC.address, MC.port);

                // Send message

                MC.socket.send(packet);

                // Remove from map

                chunks.remove(entry.getKey());

                // Remove from file system

                Path current = Paths.get("");

                String place = current.toAbsolutePath().toString() + "\\peer" + id + "\\backup\\" + entry.getValue().fileId + "\\chk" + entry.getValue().chunkN + ".chk";

                File toDelete = new File(place);

                toDelete.delete();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public void state() throws RemoteException {

    }

    // Get information of previous peer life from file system

    public void loadLocal() {

        // Base path

        Path currentRelativePath = Paths.get("");

        String peerDir = currentRelativePath.toAbsolutePath().toString() + "\\peer" + id;

        // Backup path

        File file = new File(peerDir + "\\backup");

        // FileIds backed up

        File[] files = file.listFiles(File::isDirectory);

        // Peer didn't exist, just return

        if (files == null)

            return;

        // Each file directory

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

            // FileId

            String fileId = files[i].getName();

            // Get Chunks inside

            file = new File(peerDir + "\\backup" + "\\" + fileId);

            File[] chunks = file.listFiles();

            // No chunks, just return

            if (chunks == null)

                return;

            // Each chunk

            for (int j = 0; j < chunks.length; j++) {

                // Chunk name

                String chunkNo = chunks[j].getName();

                // Remove chk

                chunkNo = chunkNo.replaceAll("\\.", "");

                chunkNo = chunkNo.replaceAll("chk", "");

                try {

                    // Read bytes

                    byte[] bytes = Files.readAllBytes(chunks[j].toPath());

                    // Updated used bytes

                    used += bytes.length;

                    // Add to HashMap

                    this.chunks.put(fileId + "-" + chunkNo, new Chunk(fileId, Integer.parseInt(chunkNo), bytes, 0));

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

    }

    // Setup directory

    public void setupDirectory() {

        // Base path

        Path currentRelativePath = Paths.get("");

        String peerDir = currentRelativePath.toAbsolutePath().toString() + "\\peer" + id;

        // Backup path

        File file = new File(peerDir + "\\backup");

        file.mkdirs();

        // Backup path

        file = new File(peerDir + "\\restored");

        file.mkdirs();

    }

    // Default Socket Setup

    public void setupSockets() throws IOException {

        pool = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10000);

        MC = new Socket(this, Socket.Type.MC);

        pool.execute(MC);

        MDB = new Socket(this, Socket.Type.MDB);

        pool.execute(MDB);

        MDR = new Socket(this, Socket.Type.MDR);

        pool.execute(MDR);

    }

    // Specifc Socket Setup

    public void setupSockets(int portMC, String addressMC, int portMDB, String addressMDB, int portMDR,

            String addressMDR) throws IOException {

        pool = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10000);

        MC = new Socket(this, Socket.Type.MC, portMC, addressMC);

        pool.execute(MC);

        MDB = new Socket(this, Socket.Type.MDB, portMDB, addressMDB);

        pool.execute(MDB);

        MDR = new Socket(this, Socket.Type.MDR, portMDR, addressMDR);

        pool.execute(MDR);

    }

    public static void main(String args[]) {

        // TODO Arguments are not correct, need to receive all the specific socket

        // arguments too, version and server(RMI)

        // Check arguments

        if (args.length < 1) {

            System.err.println("Invalid number of arguments");

            return;

        }

        try {

            // Create Server

            Server obj = new Server(args[0]);

            // Bind the server as a registry

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

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

            // TODO Get registry what port?

            Registry registry = LocateRegistry.getRegistry();

            registry.bind(args[0], stub);

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

        } catch (Exception e) {

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

            e.printStackTrace();

        }

    }

}