sdis1819-t2g03

package chunk;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

@SuppressWarnings("serial")

public class FileManager implements Serializable {

        private ConcurrentMap<String, FileManager> fileRepository;

        private ConcurrentMap<String, ConcurrentMap<Integer, Chunk>> chunkRepository;

        public FileManager() {

                fileRepository = new ConcurrentHashMap<>();

                chunkRepository = new ConcurrentHashMap<>();

        }

        private String fileID;

        private String pathName;

        private String fileName;

        private int numChunks;

        private int wantedReplication;

        private HashMap<String, Chunk> chunkMap;

        public FileManager( File file, String fileID, int replicationDegree, HashMap<String, Chunk> chunksInfo ) {

                this.fileID = fileID;

                this.fileName = file.getName();

                this.pathName = file.getPath();

                this.numChunks = chunksInfo.size();

                this.wantedReplication = replicationDegree;

                this.chunkMap = chunksInfo;

        }

        synchronized public static FileManager loadDatabase(File file) throws ClassNotFoundException {

                FileManager db = null;

                try {

                        final ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));

                        db = (FileManager) inputStream.readObject();

                        inputStream.close();

                } catch (final IOException pE) {

                        pE.printStackTrace();

                }

                return db;

        }

        public void addFile( String pathName, FileManager fileInfo ) {

                fileRepository.put(pathName, fileInfo);

        }

        public void removeFile( String pathName ) {

                fileRepository.remove(pathName);

        }

        public FileManager getFileInformation( String pathName)

        {

                return fileRepository.get( pathName);

        }

        public void addChunk( Chunk chunk )

        {

                String fileID = chunk.getFileID();

                int chunkNo = chunk.getChunkNo();

                ConcurrentMap<Integer, Chunk> fileChunks;

                fileChunks = chunkRepository.getOrDefault(fileID, new ConcurrentHashMap<>());

                fileChunks.putIfAbsent(chunkNo, chunk);

                chunkRepository.putIfAbsent(fileID, fileChunks);

        }

        public Chunk getChunkInformation( String fileID, int chunkNo )

        {

                Map<Integer, Chunk> fileChunks = chunkRepository.get(fileID);

                return fileChunks != null ? fileChunks.get(chunkNo) : null;

        }

        public void deleteChunk( String fileID, int chunkNo)

        {

                if (!chunkRepository.containsKey(fileID))

                        return;

                chunkRepository.get(fileID).remove(chunkNo);

        }

        public void deleteFileBackedUp( String fileID)

        {

                if (!chunkRepository.containsKey( fileID))

                        return;

                chunkRepository.remove(fileID);

        }

        public Integer getRecognizedReplication(String fileID, int chunkNo)

        {

                int ret;

                try

                {

                        ret = chunkRepository.get(fileID).get(chunkNo).getNumChunks();

                } catch (NullPointerException e) {

                        return null;

                }

                return ret;

        }

        // Getters e Setters

        public boolean chunkExists(String fileID) {

                return chunkRepository.containsKey(fileID);

        }

        public ConcurrentMap<String, FileManager> getFileRepository() {

                return fileRepository;

        }

        public void setFileRepository(ConcurrentMap<String, FileManager> fileRepository) {

                this.fileRepository = fileRepository;

        }

        public ConcurrentMap<String, ConcurrentMap<Integer, Chunk>> getChunkRepository() {

                return chunkRepository;

        }

        public void setChunkRepository(ConcurrentMap<String, ConcurrentMap<Integer, Chunk>> chunkRepository) {

                this.chunkRepository = chunkRepository;

        }

        public String getPathName() {

                return pathName;

        }

        public void setPathName(String pathName) {

                this.pathName = pathName;

        }

        public HashMap<String, Chunk> getChunkMap() {

                return chunkMap;

        }

        public void setChunkMap(HashMap<String, Chunk> chunkMap) {

                this.chunkMap = chunkMap;

        }

        public void setFileID(String fileID) {

                this.fileID = fileID;

        }

        public void setFileName(String fileName) {

                this.fileName = fileName;

        }

        public void setNumChunks(int numChunks) {

                this.numChunks = numChunks;

        }

        public void setWantedReplication(int wantedReplication) {

                this.wantedReplication = wantedReplication;

        }

        public Set<Integer> getFileChunksKey(String fileID) {

                return chunkRepository.get(fileID).keySet();

        }

        public String getFileID() {

                return fileID;

        }

        public int getNumChunks() {

                return numChunks;

        }

        public String getPathname() {

                return pathName;

        }

        public String getFileName() {

                return fileName;

        }

        public int getWantedReplication() {

                return wantedReplication;

        }

        public HashMap<String, Chunk> getChunks() {

                return chunkMap;

        }

        public int getNumChunks(String pathname) {

                return fileRepository.get(pathname).getNumChunks();

        }

}