Java_2/src/main/java/de/joethei/hs/java2/praktikum/praktikum4/KlausurenServer.java

package de.joethei.hs.java2.praktikum.praktikum4;

import java.io.*;
import java.net.ServerSocket;
import java.util.*;
import java.util.concurrent.*;

public class KlausurenServer {

    private ConcurrentMap<String, TreeSet<Integer>> data = new ConcurrentHashMap<>();
    private ExecutorService executorService = Executors.newCachedThreadPool();
    private ServerSocket serverSocket;

    private static Map<String, CommandHandler> commands = new HashMap<>();
    Hallo Welt
    static Map<String, CommandHandler> getCommands() {
        return commands;
    }

    private boolean running;

    public KlausurenServer(int port) {
        load();

        commands.put("test", ((writer, args) -> writer.write("Hallo Welt")));
        commands.put("delall", (writer, args) -> {
           data.clear();
           save();
        });
        commands.put("put", (writer, args) -> {
            if (args.size() >= 3) {
                TreeSet<Integer> set = new TreeSet<>();
                for (int i = 2; i <= args.size() - 1; i++) {
                    try {
                        set.add(Integer.parseInt(args.get(i)));
                    } catch (NumberFormatException ex) {
                    }
                }
                writer.write("1 ");
                if (data.containsKey(args.get(1).toLowerCase())) {
                    writer.write(data.get(args.get(1).toLowerCase()).toString().replace('[', ' ').replace(']', ' ').replaceAll(" ", ""));
                }
                data.put(args.get(1).toLowerCase(), set);
                save();
            } else {
                writer.write("0");
            }
        });
        commands.put("getall", (writer, args) -> {
            if (!data.isEmpty()) {
                writer.write("1 ");
                ConcurrentMap<String, TreeSet<Integer>> set = new ConcurrentHashMap<>(data);
                Set<TreeSet<Integer>> result = new HashSet<>();

                set.forEach((key, value) -> set.forEach((s, integers) -> {
                    if(!value.equals(integers)) {
                        if (integers.containsAll(value))
                            set.remove(key);
                    }
                }));

                set.forEach((key, value) -> result.add(value));

                result.removeIf(TreeSet::isEmpty);

                writer.write(result.toString().substring(1, result.toString().length()-1).replace(" ", ""));
            } else {
                writer.write("0");
            }
        });
        commands.put("get", (writer, args) -> {
            if (args.size() == 2) {
                if (data.containsKey(args.get(1).toLowerCase())) {
                    writer.write("1 " + data.get(args.get(1).toLowerCase()).toString().replace('[', ' ').replace(']', ' ').replace(" ", ""));
                } else writer.write("0");
            } else writer.write("0");
        });
        commands.put("del", (writer, args) -> {
            if (args.size() == 2) {
                if (data.containsKey(args.get(1).toLowerCase())) {
                    writer.write("1 " + data.remove(args.get(1).toLowerCase()).toString().replace('[', ' ').replace(']', ' ').replace(" ", ""));
                    save();
                } else writer.write("0");
            } else writer.write("0");
        });
        commands.put("stop", ((writer, args) -> {
            writer.write("1");
            save();
            running = false;
        }));
        running = true;
        Runnable runnable = () -> {
            try {
                serverSocket = new ServerSocket(port);
                System.out.println("waiting for clients");
                while (running) {
                    executorService.submit(new ClientRunnable(serverSocket.accept()));
                }
                executorService.shutdown();
                try {
                    executorService.awaitTermination(1, TimeUnit.MINUTES);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }

                serverSocket.close();
                System.out.println("server shutdown");
                Thread.currentThread().interrupt();
            } catch (IOException e) {
                e.printStackTrace();
            }

        };
        Thread thread = new Thread(runnable);
        thread.start();
    }

    synchronized void load() {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(getClass().getClassLoader().getResource("praktikum4/data.txt").getFile());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try (BufferedReader br = new BufferedReader(Objects.requireNonNull(fileReader))) {
            for (String line = br.readLine(); line != null; line = br.readLine()) {
                TreeSet<Integer> set = new TreeSet<>();
                String[] array = line.split(":");
                for (int i = 1; i <= array.length - 1; i++) {
                    set.add(Integer.parseInt(array[i]));
                }
                data.put(array[0], set);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    synchronized void save() {
        FileOutputStream fileWriter;
        PrintWriter printWriter = null;
        try {
            fileWriter = new FileOutputStream(getClass().getClassLoader().getResource("praktikum4/data.txt").getFile());
            printWriter = new PrintWriter(fileWriter);

            for (Map.Entry<String, TreeSet<Integer>> entry : data.entrySet()) {
                StringBuilder tmp = new StringBuilder(entry.getKey());
                for (int integer : entry.getValue()) {
                    tmp.append(":").append(integer);
                }
                printWriter.println(tmp.toString());

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            assert printWriter != null;
            printWriter.close();


        }
    }

    public static void main(String[] args) {
        new KlausurenServer(Integer.parseInt(args[0]));
    }
}