import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import java.io.*;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static javax.tools.ToolProvider.getSystemJavaCompiler;

public class Annihilate {
    static final String PAYLOAD_CLASS_NAME = "Destroyer";

    static final String PAYLOAD_COMPILATION_UNIT =
            "import java.io.File;\n" +
                    "\n" +
                    "public class %s {\n" +
                    "\n" +
                    "    public static void main(String[] args) {\n" +
                    "        for (String path : args) {\n" +
                    "            System.out.println(\"Deleting file: \" + path);\n" +
                    "            if (new File(path).delete())\n" +
                    "                System.out.println(\"Deleted\");\n" +
                    "            else System.out.println(\"Failed to delete\");\n" +
                    "        }\n" +
                    "    }\n" +
                    "}\n";

    static class JavaSourceFromString extends SimpleJavaFileObject {
        final String code;

        JavaSourceFromString(String name, String code) {
            super(URI.create("string:///" + name.replace('.', File.separatorChar) + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }

    static class Tuple2<U, V> {
        public Tuple2(U first, V second) {
            this.first = first;
            this.second = second;
        }

        public U getFirst() {
            return first;
        }

        public V getSecond() {
            return second;
        }

        private final U first;
        private final V second;

    }

    static class DestroyerProcessBuilder {
        private final String classFilePath;
        private File outFile;
        private File errFile;


        public DestroyerProcessBuilder(String classFilePath) {
            this.classFilePath = classFilePath;
        }

        public DestroyerProcessBuilder outputStream(File outFile) {
            this.outFile = outFile;
            return this;
        }

        public DestroyerProcessBuilder errorStream(File errFile) {
            this.errFile = errFile;
            return this;
        }

        public ProcessBuilder build() {
            ProcessBuilder pb = new ProcessBuilder("java", classFilePath,
                    "Annihilate.class",
                    "Annihilate$DestroyerProcessBuilder.class",
                    "Annihilate$JavaSourceFromString.class",
                    "Annihilate$Tuple2.class");
            if (outFile != null)
                pb.redirectOutput(outFile);
            if (errFile != null)
                pb.redirectError(errFile);
            return pb;
        }
    }

    public static void main(String[] args) {
        compileSources(Arrays.asList(
                new Tuple2<>(PAYLOAD_CLASS_NAME, String.format(PAYLOAD_COMPILATION_UNIT, PAYLOAD_CLASS_NAME)))
        );
        try {
            System.out.println("Trying to load the class: " + PAYLOAD_CLASS_NAME);
            Class<Destroyer> destroyer = (Class<Destroyer>) Class.forName(PAYLOAD_CLASS_NAME);
            ProcessBuilder processBuilder = new DestroyerProcessBuilder(PAYLOAD_CLASS_NAME)
                    .outputStream(path("output").toFile())
                    .errorStream(path("error").toFile())
                    .build();
            processBuilder.start();
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }


    static void compile(String... paths) {
        JavaCompiler javaCompiler = getSystemJavaCompiler();
        List<JavaSourceFromString> compilationUnits = Arrays.stream(paths)
                .map(path -> new Tuple2<>(classNameFromPath(path), read(Paths.get(path))))
                .filter(namePathPair -> namePathPair.getFirst().isPresent())
                .map(namePathPair -> new JavaSourceFromString(namePathPair.getFirst().get(), namePathPair.getSecond()))
                .collect(Collectors.toList());

        if (compile0(compilationUnits, javaCompiler)) {
            System.out.println("Compilation Successful");
        } else {
            System.out.println("Compilation Failed");
        }
    }

    static void compileSources(List<Tuple2<String, String>> nameSourcePairs) {
        JavaCompiler javaCompiler = getSystemJavaCompiler();
        List<JavaSourceFromString> compilationUnits = nameSourcePairs.stream()
                .map(namePathPair -> new JavaSourceFromString(namePathPair.getFirst(), namePathPair.getSecond()))
                .collect(Collectors.toList());
        if (compile0(compilationUnits, javaCompiler)) {
            System.out.println("Compilation Successful");
        } else {
            System.out.println("Compilation Failed");
        }
    }

    static Optional<String> classNameFromPath(String path) {
        if (path != null && path.endsWith(".java")) {
            int sep = path.lastIndexOf(File.separator);
            int dot = path.lastIndexOf('.');
            if (sep < dot) {
                String candidateName = path.substring(sep + 1, dot).trim();
                if (!candidateName.isEmpty()) {
                    return Optional.of(candidateName);
                }
            }
        }
        return Optional.empty();
    }

    static Boolean compile0(Collection<? extends JavaFileObject> compilationUnits, JavaCompiler compiler) {
        JavaCompiler.CompilationTask task = compiler.getTask(null, null, null, null, null, compilationUnits);
        return task.call();
    }

    static void write(Path path, String data) {
        try (PrintWriter pw = new PrintWriter(path.toFile())) {
            pw.print(data);
            pw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    static String read(Path path) {
        StringBuilder data = new StringBuilder();
        try (BufferedReader br = Files.newBufferedReader(path)) {
            String line = null;
            while ((line = br.readLine()) != null) {
                data.append(line).append("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return data.toString();
    }

    static Path path(String... components) {
        return Paths.get(System.getProperty("user.dir"), components);
    }
}