import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.management.ManagementFactory;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

import static java.nio.file.StandardWatchEventKinds.*;

public class WatchDog implements Launcher {

    private static Logger LOGGER = LoggerFactory.getLogger(WatchDog.class);
    public static final String ENV_KEY_TARGET = "WATCH_DOG_TARGET";
    private final Launcher launcher;

    public WatchDog(Launcher launcher) {
        this.launcher = launcher;
    }

    @Override
    public void launch(String[] args) {
        if (!startWatchDog()) {
            launcher.launch(args);
        }
    }

    private static boolean startWatchDog() {
        String target = System.getenv(ENV_KEY_TARGET);
        if (null == target) {
            LOGGER.debug("Do not have target for watch dog, launch directly");
            return false;
        }
        LOGGER.debug("Watch dog is watching " + target + " ...");
        watch(target);
        return true;
    }

    private static void watch(String target) {
        try {
            int thisProcessId = Integer.valueOf(ManagementFactory.getRuntimeMXBean().getName().split("@")[0]);
            String thisProcessCommand = getProcessCommand(thisProcessId);
            Process subProcess = launchWithoutWatchDog(thisProcessCommand);
            final WatchService watchService = FileSystems.getDefault().newWatchService();
            try {
                Path targetPath = Paths.get(target);
                Files.walkFileTree(targetPath, new SimpleFileVisitor<Path>(){
                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                        dir.register(watchService, ENTRY_MODIFY, ENTRY_DELETE, ENTRY_CREATE);
                        return super.preVisitDirectory(dir, attrs);
                    }
                });
                while (true) {
                    WatchKey key = watchService.take();
                    key.pollEvents();
                    key.reset();
                    while (null != (key = watchService.poll())) {
                        key.pollEvents();
                        key.reset();
                    }
                    subProcess.destroy();
                    subProcess = launchWithoutWatchDog(thisProcessCommand);
                }
            } finally {
                watchService.close();
            }
        } catch (Throwable e) {
            throw new RuntimeException("Failed to watch " + target, e);
        }
    }

    private static String getProcessCommand(int processId) {
        String command = "pargs -l " + processId;
        try {
            Process process = Runtime.getRuntime().exec(command);
            process.waitFor();
            return readAll(process.getInputStream());
        } catch (Throwable e) {
            throw new RuntimeException("Failed to execute " + command, e);
        }
    }

    private static String readAll(InputStream inputStream) throws IOException {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder result = new StringBuilder();
            String line;
            while (null != (line = reader.readLine())) {
                result.append(line);
            }
            return result.toString();
        } finally {
            inputStream.close();
        }
    }

    private static Process launchWithoutWatchDog(String command) {
        try {
            LOGGER.info("Launch: " + command);
            ProcessBuilder processBuilder = new ProcessBuilder();
            processBuilder.command(command.replace("'", "").split(" "));
            processBuilder.environment().remove(ENV_KEY_TARGET);
            processBuilder.inheritIO();
            return processBuilder.start();
        } catch (Throwable e) {
            throw new RuntimeException("Failed to launch without watch dog: " + command, e);
        }
    }
}

public interface Launcher {

    public void launch(String[] args);
}