sdis1819-t7g05

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Arrays;

/**

 * BackupTask

 */

public class BackupTask implements Runnable {

    private static final int MAX_CHUNK_SIZE = 64000; // 64KBytes

    private static final String CRLF = Integer.toHexString(0xD) + Integer.toHexString(0xA);

    private String filePath;

    private String version;

    private int replicationDeg;

    private InetAddress MDBaddress;

    private int MDBport;

    private Peer peer;

    BackupTask(String pathname, int replicationDeg, String version, Peer peer) {

        this.filePath = pathname;

        this.version = version;

        this.replicationDeg = replicationDeg;

        this.MDBaddress = peer.getMDBaddress();

        this.MDBport = peer.getMDBport();

        this.peer = peer;

    }

    @Override

    public void run() {

        File file = new File(this.filePath);

        try {

            BackupFile backupFile;

            FileInputStream stream = new FileInputStream(file);

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

            stream.read(data);

            stream.close();

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

            String fileId = BackupFile.generateFileId(this.filePath, file.lastModified());

            DatagramSocket socket = new DatagramSocket();

            long interval;

            backupFile = new BackupFile(this.filePath, this.replicationDeg);

            int i;

            for (i = 0; i < data.length / MAX_CHUNK_SIZE; i++) {

                chunks.add(new Chunk(backupFile, i, Arrays.copyOfRange(data, i * MAX_CHUNK_SIZE, (i + 1) * MAX_CHUNK_SIZE)));

                backupFile.addChunk(i, new Chunk(backupFile, i, Arrays.copyOfRange(data, i * MAX_CHUNK_SIZE, (i + 1) * MAX_CHUNK_SIZE)));

            }

            chunks.add(new Chunk(backupFile, i, Arrays.copyOfRange(data, i * MAX_CHUNK_SIZE, data.length)));

            backupFile.addChunk(i, new Chunk(backupFile, i, Arrays.copyOfRange(data, i * MAX_CHUNK_SIZE, data.length)));

            this.peer.addToFileMap(backupFile.getPathname(), backupFile);

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

                interval = 1000;

                byte[] chunk = chunks.get(i).getData();

                String message = "PUTCHUNK " + version + " " + peer.getSenderId() + " " + fileId + " " + i + " "

                        + this.replicationDeg + " " + CRLF + CRLF;

                byte[] packetData = new byte[message.getBytes().length + chunk.length];

                System.arraycopy(message.getBytes(), 0, packetData, 0, message.getBytes().length);

                System.arraycopy(chunk, 0, packetData, message.getBytes().length, chunk.length);

                DatagramPacket packet = new DatagramPacket(packetData, packetData.length, MDBaddress, MDBport);

                while (interval <= 31000) { //31 = 1+2+4+8+16

                    this.peer.print("sending PUTCHUNK message");

                    socket.send(packet);

                    Thread.sleep(interval);

                    if (this.peer.repDegMap.containsKey(fileId) && this.peer.repDegMap.get(fileId).get(i) >= this.replicationDeg)

                        break;

                    interval *= 2;

                }

                if(interval > 31000) {

                        this.peer.print("Couldn't achieve the desired replication degree.");

                        this.peer.fileMap.remove(this.filePath);

                        return;

                }

            }

            socket.close();

            this.peer.print("BACKUP protocol finished");

        } catch (IOException | NoSuchAlgorithmException | InterruptedException e) {

            e.printStackTrace();

        }

    }

}