sdis1819-t7g06

package Peers;

import Message.*;

import Storage.Chunk;

import java.io.Serializable;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentSkipListSet;

import java.util.concurrent.TimeUnit;

public class Control implements Serializable {

    // chunkNo + fileid, nº of stored

    ConcurrentHashMap<String, Integer> storedMessages = new ConcurrentHashMap<>();

    //i have saved

    ConcurrentHashMap<String, Chunk> repDegrees = new ConcurrentHashMap<>();

    ConcurrentHashMap<String, ConcurrentSkipListSet<Chunk>> restoredChunks = new ConcurrentHashMap<>();

    ConcurrentHashMap<String, String> backedUpFiles = new ConcurrentHashMap<>();

    private Peer peer;

    Control(Peer peer) {

        this.peer = peer;

    }

    public void putchunkControl(Message message) {

        if (message.getSenderId() == peer.getId())

            return;

        try {

            Integer a = storedMessages.get(message.getChunkNo().toString() + ";" + message.getFileID());

            if (a == null)

                a = 0;

            if (a < message.getRepDegree()) {

                Chunk c = new Chunk(message.getChunkNo(), message.getBody(), message.getSenderId(), message.getFileID(),

                        message.getRepDegree());

                if (!peer.getStorage().saveChunk(new Chunk(message.getChunkNo(), message.getBody(),

                        message.getSenderId(), message.getFileID(), message.getRepDegree()), message.getFileID()))

                    return;

                repDegrees.put(message.getChunkNo().toString() + ";" + message.getFileID(), c);

                Message answer = new StoredMsg(message.getVersion(), peer.getId(), message.getFileID(), message.getChunkNo());

                peer.getMc_channel().send(answer);

            } else return;

        } catch (Exception e) {

         //   e.printStackTrace();

        }

    }

    public void getchunkControl(Message message) {

        if (message.getSenderId() == peer.getId()) {

            return;

        }

        HashMap<String, byte[]> chunksInfo = peer.getStorage().getChunks(message.getFileID());

        Set<String> key = chunksInfo.keySet();

        for (String i : key) {

            peer.getThreadPool().schedule(() -> {

                    Message ms = new ChunkMsg(message.getVersion(), peer.getId(), message.getFileID(),

                            Integer.parseInt(i), chunksInfo.get(i));

                    Chunk tmp = new Chunk(Integer.parseInt(i), chunksInfo.get(i), peer.getId(), message.getFileID());

                    if (!receivedChunk(message.getFileID(), tmp)) {

                        peer.getMdr_channel().send(ms);

                    }

            }, (long) (Math.random() * 400), TimeUnit.MILLISECONDS);

        }

    }

    public void chunkControl(Message message) {

        if (message.getSenderId() == peer.getId())

            return;

        try {

            Chunk c = new Chunk(message.getChunkNo(), message.getBody(), message.getSenderId(), message.getFileID());

            if (!receivedChunk(message.getFileID(), c)) {

                if (restoredChunks.get(message.getFileID()) != null) {

                    ConcurrentSkipListSet<Chunk> a = restoredChunks.get(message.getFileID());

                    a.add(c);

                    restoredChunks.put(message.getFileID(), a);

                } else {

                    ConcurrentSkipListSet<Chunk> b = new ConcurrentSkipListSet<Chunk>();

                    b.add(c);

                    restoredChunks.put(message.getFileID(), b);

                }

            }

        } catch (Exception e) {

            //e.printStackTrace();

        }

    }

    public void removedControl(Message message) {

    }

    public void deleteControl(Message message) {

        peer.getStorage().delete(message.getFileID());

        storedMessages.remove(message.getFileID());

        repDegrees.remove(message.getFileID());

    }

    public void storedControl(Message message) {

        if (message.getSenderId() == peer.getId()) {

            return;

        }

        String key = message.getChunkNo().toString() + ";" + message.getFileID();

        if (storedMessages.contains(key)) {

            Integer value = storedMessages.remove(key);

            storedMessages.put(message.getChunkNo().toString() + ";" + message.getFileID(), value + 1);

        } else {

            storedMessages.put(key, 1);

        }

    }

    public ConcurrentHashMap<String, Integer> getStoredMessages() {

        return storedMessages;

    }

    public ConcurrentHashMap<String, ConcurrentSkipListSet<Chunk>> getRestoredChunks() {

        return restoredChunks;

    }

    private boolean receivedChunk(String fileId, Chunk chunkNo) {

        if (restoredChunks.get(fileId) != null)

            return restoredChunks.get(fileId).contains(chunkNo);

        else

            return false;

    }

    public void reduceChunks(long reclaimed) {

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

        Chunk tmpChunk;

        int lowestRep = 1;

        for (Chunk i : repDegrees.values()) {

            if (i.getRepDegree() >= lowestRep && i.getRepDegree() > 1) {

                lowestRep = i.getId();

                tmpChunk = i;

                if (i.getInfo().length >= reclaimed)

                    tmpChunks.add(i);

            }

        }

    }

    public ConcurrentHashMap<String, String> getBackedUpFiles() {

        return backedUpFiles;

    }

}