import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

public class FileTracker {
    /*
    ** Local fields
     */
    private ServerSocket ftSocket;
    private boolean isServerOn = true;
    private Hashtable<String, ArrayList<FileInstance>> records = new Hashtable<>();
    private HashMap<INETAddr, Score> board = new HashMap<>();


    public FileTracker() {
        try {
            ftSocket = new ServerSocket(3333);
        } catch(IOException ioe) {
            System.out.println("Cannot create server socket on port 3333...");
            System.exit(-1);
        }

        while (isServerOn) {
            try {
                Socket peerSock = ftSocket.accept();
                PeerServiceThread peerThread = new PeerServiceThread(peerSock);
                peerThread.start();
            } catch(IOException ioe) {
                System.out.println("Exception on accepting");
                ioe.printStackTrace();
            }
        }

        try {
            ftSocket.close();
            System.out.println("FileTracker stopped");
        } catch(IOException ioe) {
            System.out.println("Error found on closing server socket");
            System.exit(-1);
        }
    }

    private void initRecords() {
        ArrayList<FileInstance> a1 = new ArrayList<>();
        a1.add(new FileInstance("pdf", 258, "07/02/2018", "192.168.0.5", 7777));
        a1.add(new FileInstance("txt", 3, "17/03/2018", "192.168.1.5", 8741));
        records.put("Exam", a1);

        ArrayList<FileInstance> a2 = new ArrayList<>();
        a2.add(new FileInstance("jpeg", 1258, "07/02/2018", "192.168.120.5", 7777));
        a2.add(new FileInstance("txt", 12343, "17/03/2018", "192.168.120.5", 7777));
        records.put("nu", a2);

        ArrayList<FileInstance> a3 = new ArrayList<>();
        a3.add(new FileInstance("pdf", 128, "07/02/2018", "95.5.0.5", 3333));
        records.put("OS-Solutions-Final", a3);
    }

    private String recordsLookup() {
        Set<String> keys = records.keySet();
        String rsp = "";
        for (String key : keys) {
            rsp += key + ":";
            for (int i = 0; i < records.get(key).size(); ++i) {
                if (i != 0) rsp += "->";
                rsp += records.get(key).get(i).getFileType() + ", " +
                        records.get(key).get(i).getFileSize() + ", " +
                        records.get(key).get(i).getLastModifiedDate() + "," +
                        records.get(key).get(i).getIpAddr() + ":" +
                        records.get(key).get(i).getPortNum();
            }
            rsp += "\n";
        }
        return rsp;
    }

    private String boardLookup() {
        String rsp = "";
        for (INETAddr key : board.keySet()) {
            rsp += key.getIpAddr() + ":" + key.getPort() + "-" + board.get(key).getNumOfUploads() + "/"
                    + board.get(key).getNumOfRequests() + "\n";
        }
        return rsp;
    }




    public static void main(String argsp[]) throws Exception {
        new FileTracker();
    }


    /*
    **  Additional classes
     */

    /*  Peer handler threaded class */
    class PeerServiceThread extends Thread {
        private Socket  pSocket;
        private int port;

        public PeerServiceThread() {
            super();
        }

        PeerServiceThread(Socket s) {
            pSocket = s;
        }

        public void run() {
            BufferedReader in = null;
            DataOutputStream out = null;
            System.out.println("Connected peer addr - " + pSocket.getInetAddress().getHostAddress());

            try {
                in = new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
                out = new DataOutputStream(pSocket.getOutputStream());
                while (true) {
                    String req = in.readLine();
                    String[] params = req.split(":");
                    System.out.println(req);

                    if (params[0].equals("HELLO")) {
                        out.writeBytes("HI\r\n");
                        out.flush();
                        String filesReq = in.readLine();
                        if (filesReq.length() == 0) {
                            out.writeBytes("NOT ACCEPTED\r\n");
                            out.flush();
                            return;
                        } else {
                            int port = 0;
                            String[] files = filesReq.split("\\|");
                            for (int i = 0; i < files.length; ++i) {
                                String[] fileAttr = files[i].split(",");
                                port = Integer.parseInt(fileAttr[4]);
                                this.port = port;
                                if (records.get(fileAttr[0]) != null) {
                                    records.get(fileAttr[0]).add(
                                            new FileInstance(
                                                    fileAttr[1],
                                                    Integer.parseInt(fileAttr[2]),
                                                    fileAttr[3],
                                                    pSocket.getInetAddress().getHostAddress(),
                                                    Integer.parseInt(fileAttr[4])));
                                } else {
                                    ArrayList<FileInstance> al = new ArrayList<>();
                                    al.add(new FileInstance(
                                            fileAttr[1],
                                            Integer.parseInt(fileAttr[2]),
                                            fileAttr[3],
                                            pSocket.getInetAddress().getHostAddress(),
                                            Integer.parseInt(fileAttr[4])));
                                    records.put(fileAttr[0], al);
                                }
                            }
                            out.writeBytes("ACCEPTED\r\n");
                            out.flush();
                            if (!board.containsKey(new INETAddr(pSocket.getInetAddress().getHostAddress(), port))) {
                                board.put(new INETAddr(pSocket.getInetAddress().getHostAddress(), port), new Score());
                            }
                        }
                    }

                    if (params[0].equals("SEARCH")) {
                        Set<String> keys = records.keySet();
                        String rsp = "FOUND: ";
                        String fileName = params[1].substring(1);
                        int x, y, p;
                        for (String key : keys) {
                            if (key.equals(fileName)) {
                                for (int i = 0; i < records.get(key).size(); ++i) {
                                    if (i != 0) rsp += "->";
                                    y =  board.get(new INETAddr(records.get(key).get(i).getIpAddr(),
                                            records.get(key).get(i).getPortNum())).getNumOfUploads();
                                    p = board.get(new INETAddr(records.get(key).get(i).getIpAddr(),
                                            records.get(key).get(i).getPortNum())).getNumOfRequests();
                                    if (p == 0)
                                        x = 0;
                                    else
                                        x = y / p;
                                    rsp += records.get(key).get(i).getFileType() + ", " +
                                            records.get(key).get(i).getFileSize() + ", " +
                                            records.get(key).get(i).getLastModifiedDate() + ", " +
                                            records.get(key).get(i).getIpAddr() + ":" +
                                            records.get(key).get(i).getPortNum() + ", " + x + "%";


                                }

                            }
                        }
                        if (rsp.equals("FOUND: ")) {
                            rsp = "NOT FOUND";
                        }
                        out.writeBytes(rsp + "\r\n");
                        out.flush();
                    }

                    if (params[0].equals("SCORE")) {
                        Score old = board.get(new INETAddr(params[1], Integer.parseInt(params[2])));
                        old.setNumOfRequests(old.getNumOfRequests() + 1);
                        old.setNumOfUploads(old.getNumOfUploads() + Integer.parseInt(params[3]));
                        board.put(new INETAddr(params[1], Integer.parseInt(params[2])), old);
                        System.out.println(boardLookup());
                    }

                    if (params[0].equals("BYE")) {
                        Iterator<Map.Entry<String, ArrayList<FileInstance>>> it = records.entrySet().iterator();

                        while (it.hasNext()) {
                            Map.Entry<String, ArrayList<FileInstance>> entry = it.next();

                            Iterator<FileInstance> fit = entry.getValue().iterator();
                            while (fit.hasNext()) {
                                FileInstance f = fit.next();
                                if (f.getIpAddr().equals(pSocket.getInetAddress().getHostAddress())
                                        && f.getPortNum() == port) {
                                    fit.remove();
                                }
                            }

                            // Remove entry if key is null or equals 0.
                            if (entry.getValue().size() == 0) {
                                it.remove();
                            }
                        }
                        System.out.println(recordsLookup());

                    }

                }
            } catch(Exception e) {
                System.out.println(pSocket.getInetAddress().getHostAddress() + "Peer has been disconnected");
            }
            finally {
                try {
                    in.close();
                    out.close();
                    pSocket.close();
                    System.out.println(pSocket.getInetAddress().getHostAddress() + "Peer was kicked from the service");
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }

    }


    /*  Class for storing the file information in records hashtable: value  */
    class INETAddr {
        public String getIpAddr() {
            return ipAddr;
        }

        public int getPort() {
            return port;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ipAddr.hashCode();
            result = prime * result + port;
            return result;
        }

        @Override
        public boolean equals(Object obj) {

            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            INETAddr other = (INETAddr) obj;
            if (!ipAddr.equals(other.ipAddr))
                return false;
            if (port != other.port)
                return false;
            return true;
        }

        private String ipAddr;
        private int port;

        public INETAddr(String ipAddr, int port) {
            this.ipAddr = ipAddr;
            this.port = port;
        }

    }

    class Score {
        private int numOfUploads;

        public int getNumOfUploads() {
            return numOfUploads;
        }

        public void setNumOfUploads(int numOfUploads) {
            this.numOfUploads = numOfUploads;
        }

        public int getNumOfRequests() {
            return numOfRequests;
        }

        public void setNumOfRequests(int numOfRequests) {
            this.numOfRequests = numOfRequests;
        }

        private int numOfRequests;

        public Score() {
            this.numOfUploads = 0;
            this.numOfRequests = 0;
        }
    }

    class FileInstance {
        private String  fileType;

        public String getFileType() {
            return fileType;
        }

        public int getFileSize() {
            return fileSize;
        }

        public String getLastModifiedDate() {
            return lastModifiedDate;
        }

        public String getIpAddr() {
            return ipAddr;
        }

        public int getPortNum() {
            return portNum;
        }

        private int     fileSize;
        private String  lastModifiedDate;
        private String  ipAddr;
        private int     portNum;

        public FileInstance(String fileType, int fileSize, String lastModifiedDate, String ipAddr, int portNum) {
            this.fileType           = fileType;
            this.fileSize           = fileSize;
            this.lastModifiedDate   = lastModifiedDate;
            this.ipAddr             = ipAddr;
            this.portNum            = portNum;
        }
    }

}