sdis1819-t7g06

package Protocols;

import Message.*;

import Peers.Peer;

import Storage.Chunk;

import Storage.ChunksManager;

import java.io.*;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.List;

import static Global.Globals.MAX_TRIES;

public class BackUpProtocol implements Runnable {

    int repDegree;

    Peer peer;

    String filepath;

    ChunksManager chunks;

    public BackUpProtocol(Peer peer, int repDegree, String filepath) throws IOException {

        this.repDegree = repDegree;

        this.peer = peer;

        this.filepath = filepath;

        this.chunks = new ChunksManager(filepath, repDegree, peer.getId());

    }

    String calculateFileId(Peer peer, String filepath) throws NoSuchAlgorithmException, IOException {

        String[] split = filepath.split("\\.");

        String ext = split[split.length - 1];

        Path path = Paths.get(filepath);

        BasicFileAttributes metadata = Files.readAttributes(path, BasicFileAttributes.class);

        FileInputStream in = new FileInputStream(filepath);

        byte[] info = new byte[(int) metadata.size()];

        in.read(info);

        String sha = peer.getStorage().createFileID(filepath, metadata, info);

        return sha;

    }

    ArrayList<Message> constructMessages(List<Chunk> list, String fileID) {

        ArrayList<Message> messages = new ArrayList<Message>();

        for (Chunk i : list) {

            Message msg = new PutChunkMsg(MessageType.PUTCHUNK, peer.getVersionProtocol(), peer.getId(), fileID, i.getId(), repDegree, i.getInfo());

            messages.add(msg);

        }

        return messages;

    }

    @Override

    public void run() {

        try {

            String id = calculateFileId(peer, filepath);

            String[] name = filepath.split("/");

            peer.getControl().getBackedUpFiles().put(name[name.length - 1], id);

            ArrayList<Message> messages = constructMessages(chunks.getChunks(), id);

            int i = 1;

            int sleep = 500;

            do {

                sleep *= 2;

                //send putchunks

                if (i > MAX_TRIES) {

                    System.out.println("MAX TRIES ARCHIEVED!");

                    return;

                }

                for (Message k : messages) {

                    peer.getMdb_channel().send(k);

                }

                i++;

            } while (confirmMessage(messages, sleep));

        } catch (Exception e) {

            e.printStackTrace();

        }

        System.out.println("Backup over");

    }

    boolean confirmMessage(ArrayList<Message> messages, int sleep) {

        try {

            Thread.sleep(sleep);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        try {

            for (Message i : messages) {

                String key = i.getChunkNo() + ";" + i.getFileID();

                Integer value = peer.getControl().getStoredMessages().get(key);

                if (value == null) {

                    return true;

                }

                if (i.getRepDegree() >= value) {

                    messages.remove(i);

                    continue;

                }

                return true;

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return false;

    }

}